diff --git a/src/bootsupport/include_modules.config b/src/bootsupport/include_modules.config
index 8544d90c..aa6c50f8 100644
--- a/src/bootsupport/include_modules.config
+++ b/src/bootsupport/include_modules.config
@@ -1,4 +1,5 @@
 
+#each entry - base module
 set bootsupport_modules [list\
     src/vendormodules cksum\
     src/vendormodules natsort\
@@ -30,11 +31,12 @@ set bootsupport_modules [list\
     modules punk::mix::commandset::scriptwrap\
     modules punk::overlay\
     modules punk::repo\
+    modules punk::encmime\
     modules punk::tdl\
     modules punk::winpath\
 ]
 
-
-#Don't include punk/mix/templates - recursive bootsupport problem!
+#each entry - base subpath
 set bootsupport_module_folders [list\
+    modules punk/mix/templates
 ]
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/mime-1.7.0.tm b/src/bootsupport/modules/mime-1.7.1.tm
similarity index 99%
rename from src/mixtemplates/layouts/basic/src/bootsupport/modules/mime-1.7.0.tm
rename to src/bootsupport/modules/mime-1.7.1.tm
index fa460769..b4b0d61d 100644
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/mime-1.7.0.tm
+++ b/src/bootsupport/modules/mime-1.7.1.tm
@@ -23,7 +23,7 @@
 # new string features and inline scan are used, requiring 8.3.
 package require Tcl 8.5
 
-package provide mime 1.7.0
+package provide mime 1.7.1
 package require tcl::chan::memchan
 
 
@@ -681,7 +681,7 @@ proc ::mime::parsepart {token} {
         }
 
          if {!$blankP && [string match *\r $line]} {
-             set line [string range $line 0 $x-2]]
+             set line [string range $line 0 $x-2]
              if {$x == 1} {
                  set blankP 1
              }
@@ -1340,12 +1340,19 @@ proc ::mime::getsize {token} {
 proc ::mime::getContentType token {
     variable $token
     upvar 0 $token state
-    set boundary {}
     set res $state(content)
+
+    set boundary {}
     foreach {k v} $state(params) {
-	set boundary $v
+        if {$k eq {boundary}} {
+	    set boundary $v
+	}
         append res ";\n              $k=\"$v\""
     }
+
+    # Save boundary separate from the params
+    set state(boundary) $boundary
+
     if {([string match multipart/* $state(content)]) \
         && ($boundary eq {})} {
         # we're doing everything in one pass...
@@ -1356,6 +1363,8 @@ proc ::mime::getContentType token {
         }
         set boundary "----- =_[string trim [base64 -mode encode -- $key]]"
 
+	set state(boundary) $boundary
+
         append res ";\n              boundary=\"$boundary\""
     }
     return $res
@@ -1397,7 +1406,7 @@ proc ::mime::getheader {token {key {}}} {
 	    lappend result MIME-Version $state(version)
             foreach lower $state(lowerL) mixed $state(mixedL) {
 		foreach value $header($lower) {
-		    lappend result $mixed $value 
+		    lappend result $mixed $value
 		}
             }
 	    set tencoding [getTransferEncoding $token]
@@ -1878,18 +1887,12 @@ proc ::mime::copymessageaux {token channel} {
 
     array set header $state(header)
 
-    set boundary {}
-
     set result {}
     foreach {mixed value} [getheader $token] {
 	puts $channel "$mixed: $value"
     }
 
-    foreach {k v} $state(params) {
-        if {$k eq {boundary}} {
-            set boundary $v
-        }
-    }
+    set boundary $state(boundary) ;# computed by `getheader`
 
     set converter {}
     set encoding {}
@@ -1916,17 +1919,6 @@ proc ::mime::copymessageaux {token channel} {
                 }
             }
         }
-    } elseif {([string match multipart/* $state(content)]) \
-        && ($boundary eq {})} {
-        # we're doing everything in one pass...
-        set key [clock seconds]$token[info hostname][array get state]
-        set seqno 8
-        while {[incr seqno -1] >= 0} {
-            set key [md5 -- $key]
-        }
-        set boundary "----- =_[string trim [base64 -mode encode -- $key]]"
-
-        puts $channel ";\n              boundary=\"$boundary\""
     }
 
     if {[info exists state(error)]} {
@@ -2072,7 +2064,7 @@ proc ::mime::copymessageaux {token channel} {
 #       token      The MIME token to parse.
 #
 # Results:
-#       The message. 
+#       The message.
 
 proc ::mime::buildmessage token {
     global errorCode errorInfo
diff --git a/src/bootsupport/modules/natsort-0.1.1.5.tm b/src/bootsupport/modules/natsort-0.1.1.5.tm
index 0dcf57e7..0e4260b8 100644
--- a/src/bootsupport/modules/natsort-0.1.1.5.tm
+++ b/src/bootsupport/modules/natsort-0.1.1.5.tm
@@ -238,8 +238,13 @@ namespace eval natsort {
 
     #considered using hex to make large numbers more compact for viewing in debug output - but it's not that much shorter and probably obscures more than it helps.
     proc hex2dec {largeHex} {
+        #todo - use punk::lib::hex2dec - (scan supports ll so can do larger hex values directly)
         set res 0
         set largeHex [string map [list _ ""] $largeHex]
+        if {[string length $largeHex] <=7} {
+            #scan can process up to FFFFFFF and does so quickly
+            return [scan $largeHex %x]
+        }
         foreach hexDigit [split $largeHex {}] {
             set new 0x$hexDigit
             set res [expr {16*$res + $new}]
@@ -249,6 +254,8 @@ namespace eval natsort {
     proc dec2hex {decimalNumber} {
         format %4.4llX $decimalNumber
     }
+
+    #punk::lib::trimzero
     proc trimzero {number} {
         set trimmed [string trimleft $number 0]
         if {[string length $trimmed] == 0} {
@@ -382,6 +389,7 @@ namespace eval natsort {
     }
 
     proc get_char_count {str char} {
+        #faster than lsearch on split for str of a few K
         expr {[string length $str]-[string length [string map [list $char {}] $str]]}
     }
     
diff --git a/src/vendormodules/overtype-1.5.0.tm b/src/bootsupport/modules/overtype-1.5.1.tm
similarity index 74%
rename from src/vendormodules/overtype-1.5.0.tm
rename to src/bootsupport/modules/overtype-1.5.1.tm
index f4e466f3..92f2464a 100644
--- a/src/vendormodules/overtype-1.5.0.tm
+++ b/src/bootsupport/modules/overtype-1.5.1.tm
@@ -7,23 +7,69 @@
 # (C) Julian Noble 2003-2023
 #
 # @@ Meta Begin
-# Application overtype 1.5.0
+# Application overtype 1.5.1
 # Meta platform     tcl
 # Meta license      BSD 
 # @@ Meta End
 
 
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin overtype_module_overtype 0 1.5.1]
+#[copyright "2024"]
+#[titledesc {overtype text layout - ansi aware}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {overtype text layout}]             [comment {-- Description at end of page heading --}] 
+#[require overtype]
+#[keywords module text ansi]
+#[description]
+#[para] -
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of overtype 
+#[subsection Concepts]
+#[para] -
+
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Requirements
-##e.g package require frobz
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by overtype 
+#[list_begin itemized]
+
+package require Tcl 8.6
 package require textutil
 package require punk::ansi  ;#required to detect, split, strip and calculate lengths
 package require punk::char  ;#box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+#*** !doctools
+#[item] [package {Tcl 8.6}]
+#[item] [package textutil]
+#[item] [package punk::ansi]
+#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
+#[item] [package punk::char]
+#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+
+# #package require frobz
+# #*** !doctools
+# #[item] [package {frobz}]
+
+#*** !doctools
+#[list_end]
+
 
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[section API]
+
 
 #Julian Noble <julian@precisium.com.au> - 2003 
 #Released under standard 'BSD license' conditions.
@@ -83,183 +129,69 @@ namespace eval overtype {
 }
 
 
-#candidate for zig/c implementation?
-proc overtype::stripansi {text} {
-    variable escape_terminals  ;#dict
-    variable ansi_2byte_codes_dict
-    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-        #\033 same as \x1b
-        return $text
-    }
-
-    set text [convert_g0 $text] 
-
-    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-    set inputlist [split $text ""]
-    set outputlist [list] 
-
-    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-
-    set in_escapesequence 0
-    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-    set i 0
-    foreach u $inputlist {
-        set v [lindex $inputlist $i+1]
-        set uv ${u}${v}
-        if {$in_escapesequence eq "2b"} {
-            #2nd byte - done.
-            set in_escapesequence 0
-        } elseif {$in_escapesequence != 0} {
-            set escseq [dict get $escape_terminals $in_escapesequence]
-            if {$u in $escseq} {
-                set in_escapesequence 0
-            } elseif {$uv in $escseq} {
-                set in_escapseequence 2b ;#flag next byte as last in sequence
-            }
-        } else {
-            #handle both 7-bit and 8-bit CSI and OSC
-            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-                set in_escapesequence CSI
-            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-                set in_escapesequence OSC
-            } elseif {$uv in $2bytecodes} {
-                #self-contained e.g terminal reset - don't pass through.
-                set in_escapesequence 2b
-            } else {
-                lappend outputlist $u
-            }
-        }
-        incr i
-    }
-    return [join $outputlist ""]
-}
-
-#review
-#todo - map other chars  to unicode equivs
-proc overtype::convert_g0 {text} {
-    #using not \033 inside to stop greediness - review how does it compare to ".*?"
-    set re {\033\(0[^\033]*\033\(B} 
-    set re2 {\033\(0(.*)\033\(B} ;#capturing
-    set parts [ta::_perlish_split $re $text]
-    set out ""
-    foreach {pt g} $parts {
-        append out $pt
-        if {$g ne ""} {
-            #puts --$g--
-            #box sample
-            #lqk
-            #x x
-            #mqj
-            #m = boxd_lur
-            #set map [list l \u250f k \u2513] ;#heavy
-            set map [list l \u250c q \u2500 k \u2510 x \u2502 m \u2514 j \u2518] ;#light
-
-            regexp $re2 $g _match contents
-            append out [string map $map $contents]
-        }
-    }
-    return $out
-}
-
-#todo - convert esc(0 graphics sequences to single char unicode equivalents e.g box drawing set
-# esc) ??
-proc overtype::stripansi_gx {text} {
-        #e.g "\033(0" - select VT100 graphics for character set G0
-        #e.g "\033(B" - reset 
-        #e.g "\033)0" - select VT100 graphics for character set G1
-        #e.g "\033)X" - where X is any char other than 0 to reset ??
-        return [convert_g0 $text]
-}
-
-
-#This shouldn't be called on text containing ansi codes!
-proc overtype::strip_nonprinting_ascii {str} {
-    #review - some single-byte 'control' chars have visual representations e.g ETX as heart
-    #It is currently used for screen display width calculations
-    #equivalent for various unicode combining chars etc?
-    set map [list\
-        \007 ""\
-        [format %c 0] ""\
-        [format %c 0x7f] ""\
-    ]
-    return [string map $map $str]
-}
-
-#length of text for printing characters only
-#review - unicode and other non-printing chars and combining sequences?
-#certain unicode chars are full-width (single char 2 columns wide) e.g see "Halfwdith and fullwidth forms" and ascii_fuillwidth blocks in punk::char::charset_names
-#review - is there an existing library or better method? print to a terminal and query cursor position?
-#Note this length calculation is only suitable for lines being appended to other strings if the line is pre-processed to account for backspace and carriage returns first
-#If the raw line is appended to another string without such processing - the backspaces & carriage returns can affect data prior to the start of the string. 
-proc overtype::printing_length {line} {
-    if {[string first \n $line] >= 0} {
-        error "line_print_length must not contain newline characters"
-    }
+#proc overtype::stripansi {text} {
+#    variable escape_terminals  ;#dict
+#    variable ansi_2byte_codes_dict
+#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
+#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
+#        #\033 same as \x1b
+#        return $text
+#    }
+#
+#    set text [convert_g0 $text] 
+#
+#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
+#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
+#    set inputlist [split $text ""]
+#    set outputlist [list] 
+#
+#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
+#
+#    set in_escapesequence 0
+#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
+#    set i 0
+#    foreach u $inputlist {
+#        set v [lindex $inputlist $i+1]
+#        set uv ${u}${v}
+#        if {$in_escapesequence eq "2b"} {
+#            #2nd byte - done.
+#            set in_escapesequence 0
+#        } elseif {$in_escapesequence != 0} {
+#            set escseq [dict get $escape_terminals $in_escapesequence]
+#            if {$u in $escseq} {
+#                set in_escapesequence 0
+#            } elseif {$uv in $escseq} {
+#                set in_escapseequence 2b ;#flag next byte as last in sequence
+#            }
+#        } else {
+#            #handle both 7-bit and 8-bit CSI and OSC
+#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
+#                set in_escapesequence CSI
+#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
+#                set in_escapesequence OSC
+#            } elseif {$uv in $2bytecodes} {
+#                #self-contained e.g terminal reset - don't pass through.
+#                set in_escapesequence 2b
+#            } else {
+#                lappend outputlist $u
+#            }
+#        }
+#        incr i
+#    }
+#    return [join $outputlist ""]
+#}
 
-    #review - 
-    set line [stripansi $line]
 
-    set line [strip_nonprinting_ascii $line] ;#only strip nonprinting after stripansi - some like BEL are part of ansi
-    #backspace 0x08 only erases* printing characters anyway - so presumably order of processing doesn't matter
-    #(* more correctly - moves cursor back)
-    #backspace will not move beyond a preceding newline - but we have disallowed newlines for this function already
-    #leading backspaces will eat into any string (even prompt in non-standard tclsh shell) that is prepended to the line
-    # - but for the purposes of overtype we wouldn't want that - so we strip it here in the length calculation and should strip leading backspaces in the actual data concatenation operations too.
-    #curiously - a backspace sequence at the end of a string also doesn't reduce the printing width - so we can also strip from RHS
 
-    #Note that backspace following a \t will only shorten the string by one (ie it doesn't move back the whole tab width like it does interactively in the terminal)
-    #for this reason - it would seem best to normalize the tabs to spaces prior to performing the backspace calculation - otherwise we won't account for the 'short' tabs it effectivley produces
-    #normalize tabs to an appropriate* width
-    #*todo - handle terminal/context where tabwidth != the default 8 spaces
-    set line [textutil::tabify::untabify2 $line]
 
-    set bs [format %c 0x08]
-    #set line [string map [list "\r${bs}" "\r"] $line] ;#backsp following a \r will have no effect
-    set line [string trim $line $bs]
-    set n 0
-
-    set chars [split $line ""] 
-    #build an output 
-    set idx 0
-    set outchars [list]
-    set outsizes [list]
-    foreach c $chars {
-        if {$c eq $bs} {
-            if {$idx > 0} {
-                incr idx -1
-            }
-        } elseif {$c eq "\r"} {
-            set idx 0
-        } else {
-            priv::printing_length_addchar $idx $c
-            incr idx
-        }
-    }
-    set line2 [join $outchars ""]
-    return [punk::char::string_width $line2]
-}
 
 proc overtype::string_columns {text} {
     if {[punk::ansi::ta::detect $text]} {
-        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with overtype::stripansi. Alternatively try overtype::printing_length"
+        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
     }
     return [punk::char::string_width $text]
 }
 
-namespace eval overtype::priv {
-    proc printing_length_addchar {i c} {
-        upvar outchars outc 
-        upvar outsizes outs
-        set nxt [llength $outc] 
-        if {$i < $nxt} {
-            lset outc $i $c
-        } else {
-            lappend outc $c
-        }
-    }
-}
 
 #string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
 proc overtype::left {args} {
@@ -299,13 +231,13 @@ proc overtype::left {args} {
     set overblock  [string map $norm $overblock]
 
     set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
+    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
     set overlines  [split $overblock \n]
 
     set outputlines [list]
     foreach undertext $underlines overtext $overlines {    
-        set undertext_printlen [printing_length $undertext]
-        set overlen [printing_length $overtext]
+        set undertext_printlen [punk::ansi::printing_length $undertext]
+        set overlen [punk::ansi::printing_length $overtext]
         set diff [expr {$overlen - $colwidth}]
 
         #review
@@ -387,46 +319,53 @@ proc overtype::centre {args} {
     set overblock  [string map $norm $overblock]
 
     set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
+    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
     set overlines  [split $overblock \n]
+    set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
 
     set outputlines [list]
     foreach undertext $underlines overtext $overlines {    
-        set olen [printing_length $overtext]
-        set ulen [printing_length $undertext]
+        #set olen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
         if {$ulen < $colwidth} {
             set udiff [expr {$colwidth - $ulen}]
             set undertext "$undertext[string repeat { } $udiff]"
         }
         #review
-        append overtext "\033\[0m"
+        #append overtext "\033\[0m"
 
-        set diff [expr {$colwidth - $olen}]
-        if {$diff > 0} {
+        set under_exposed [expr {$colwidth - $overblock_width}]
+        if {$under_exposed > 0} {
             #background block is wider
-            set half [expr {round(int($diff / 2))}]
-            if {[string match right [dict get $opts -bias]]} {
-                if {[expr {2 * $half}] < $diff} {
-                    incr half
+            if {$under_exposed % 2 == 0} {
+                #even left/right exposure
+                set left_exposed [expr {$under_exposed / 2}]
+            } else {
+                set beforehalf [expr {$under_exposed / 2}] ;#1 less than half due to integer division
+                if {[string tolower [dict get $opts -bias]] eq "left"} {
+                    set left_exposed $beforehalf
+                } else {
+                    #bias to the right
+                    set left_exposed [expr {$beforehalf + 1}]
                 }
             }
             
+            if 0 {
             set rhs [expr {$diff - $half - 1}]
             set lhs [expr {$half - 1}]
             set rhsoffset [expr {$rhs +1}]
-            if 0 {
             set a [string range $undertext 0 $lhs]
             set background [string range $undertext $lhs+1 end-$rhsoffset]
             set b [renderline -transparent $opt_transparent $background $overtext]
             set c [string range $undertext end-$rhs end]
             lappend outputlines $a$b$c
             }
-            lappend outputlines [renderline -start $lhs -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+            lappend outputlines [renderline -start $left_exposed -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
 
         } else {
             #overlay wider or equal
             set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {$diff < 0} {
+            if {$under_exposed < 0} {
                 #overlay is wider - trim if overflow not specified in opts
                 if {![dict get $opts -overflow]} {
                     #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
@@ -436,7 +375,7 @@ proc overtype::centre {args} {
                     }
                 }
             } else {
-                #widths match
+                #zero under_exposed - widths match
             }
             lappend outputlines $rendered
             #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
@@ -485,13 +424,13 @@ proc overtype::right {args} {
     set overblock  [string map $norm $overblock]
 
     set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
+    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
     set overlines  [split $overblock \n]
 
     set outputlines [list]
     foreach undertext $underlines overtext $overlines {    
-        set olen [printing_length $overtext]
-        set ulen [printing_length $undertext]
+        set olen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
         if {$ulen < $colwidth} {
             set udiff [expr {$colwidth - $ulen}]
             set undertext "$undertext[string repeat { } $udiff]"
@@ -547,7 +486,7 @@ namespace eval overtype::piper {
 interp alias "" piper_renderline "" overtype::piper::renderline 
 
 #-returnextra to enable returning of overflow and length
-# todo - use ta::detect to short-circuit processing and do simple string calcs as an optimisation?
+# todo - use punk::ansi::ta::detect to short-circuit processing and do simple string calcs as an optimisation?
 #review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
 #todo - review transparency issues with single/double width characters!
 proc overtype::renderline {args} {
@@ -905,9 +844,10 @@ namespace eval overtype::priv {
 
 
 # -- --- --- --- --- --- --- --- --- --- ---
+if 0 {
 namespace eval overtype::ta {
     namespace path ::overtype
-    #*based* on but not identical to:
+    # *based* on but not identical to:
     #https://github.com/perlancar/perl-Text-ANSI-Util/blob/master/lib/Text/ANSI/BaseUtil.pm
 
     #handle both 7-bit and 8-bit csi 
@@ -934,45 +874,28 @@ namespace eval overtype::ta {
 
     #detect any ansi escapes
     #review - only detect 'complete' codes - or just use the opening escapes for performance?
-    proc detect {text} {
-        variable re_ansi_detect
-        #variable re_csi_open
-        #variable re_esc_osc1
-        #variable re_esc_osc2
-        #todo - other escape sequences
-        #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
-        expr {[regexp $re_ansi_detect $text]}
-    }
+    #proc detect {text} {
+    #    variable re_ansi_detect
+    #    #variable re_csi_open
+    #    #variable re_esc_osc1
+    #    #variable re_esc_osc2
+    #    #todo - other escape sequences
+    #    #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
+    #    expr {[regexp $re_ansi_detect $text]}
+    #}
     #not in perl ta
-    proc detect_csi {text} {
-        variable re_csi_colour
-        expr {[regexp $re_csi_colour $text]}
-    }
+    #proc detect_csi {text} {
+    #    variable re_csi_colour
+    #    expr {[regexp $re_csi_colour $text]}
+    #}
     proc strip {text} {
-        tailcall stripansi $text
+        tailcall punk::ansi::stripansi $text
     }
     #note this is character length after stripping ansi codes - not the printing length
     proc length {text} {
-        string length [overtype::stripansi $text]
-    }
-    #todo - handle newlines
-    #not in perl ta
-    proc printing_length {text} {
-
+        string length [punk::ansi::stripansi $text]
     }
 
-    proc trunc {text width args} {
-
-    }
-
-    #not in perl ta
-    #returns just the plaintext portions in a list
-    proc split_at_codes {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        textutil::splitx $text "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-    }
     
     # -- --- --- --- --- --- 
     #Split $text to a list containing alternating ANSI color codes and text.
@@ -987,43 +910,41 @@ namespace eval overtype::ta {
     #ta_split_codes "\e[31ma\e[0mb" # => {""    "\e[31m"       "a"  "\e[0m", "b"}
     #ta_split_codes "\e[31m\e[0mb"  # => {""    "\e[31m\e[0m"  "b"}
     #
-    proc split_codes {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
-        return [_perlish_split $re $text]
-    }
-    #like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
-    proc split_codes_single {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-        return [_perlish_split $re $text]
-    }
-
-    #review - tcl greedy expressions may match multiple in one element
-    proc _perlish_split {re text} {
-        if {[string length $text] == 0} {
-            return {}
-        }
-        set list [list]
-        set start 0
-        while {[regexp -start $start -indices -- $re $text match]} {
-            lassign $match      matchStart matchEnd
-            lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
-            set start [expr {$matchEnd+1}]
-        }
-        lappend list [string range $text $start end]
-        return $list
-    }
-    proc _ws_split {text} {
-        regexp -all -inline {(?:\S+)|(?:\s+)} $text
-    }
-    # -- --- --- --- --- --- 
+    #proc split_codes {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
+    #    return [_perlish_split $re $text]
+    #}
+    ##like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
+    #proc split_codes_single {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
+    #    return [_perlish_split $re $text]
+    #}
+
+    ##review - tcl greedy expressions may match multiple in one element
+    #proc _perlish_split {re text} {
+    #    if {[string length $text] == 0} {
+    #        return {}
+    #    }
+    #    set list [list]
+    #    set start 0
+    #    while {[regexp -start $start -indices -- $re $text match]} {
+    #        lassign $match      matchStart matchEnd
+    #        lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
+    #        set start [expr {$matchEnd+1}]
+    #    }
+    #    lappend list [string range $text $start end]
+    #    return $list
+    #}
+    ## -- --- --- --- --- --- 
 
 }
+} ;# end if 0
 
 # -- --- --- --- --- --- --- --- --- --- ---
 namespace eval overtype {
@@ -1034,6 +955,9 @@ namespace eval overtype {
 ##  Ready   
 package provide overtype [namespace eval overtype {
     variable version
-    set version 1.5.0 
+    set version 1.5.1 
 }]
-return
\ No newline at end of file
+return
+
+#*** !doctools
+#[manpage_end]
diff --git a/src/bootsupport/modules/overtype-1.5.3.tm b/src/bootsupport/modules/overtype-1.5.3.tm
new file mode 100644
index 00000000..6b54a4ac
--- /dev/null
+++ b/src/bootsupport/modules/overtype-1.5.3.tm
@@ -0,0 +1,1037 @@
+# -*- tcl -*-
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+#
+# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
+# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# (C) Julian Noble 2003-2023
+#
+# @@ Meta Begin
+# Application overtype 1.5.3
+# Meta platform     tcl
+# Meta license      BSD 
+# @@ Meta End
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin overtype_module_overtype 0 1.5.3]
+#[copyright "2024"]
+#[titledesc {overtype text layout - ansi aware}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {overtype text layout}]             [comment {-- Description at end of page heading --}] 
+#[require overtype]
+#[keywords module text ansi]
+#[description]
+#[para] -
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of overtype 
+#[subsection Concepts]
+#[para] -
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Requirements
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by overtype 
+#[list_begin itemized]
+
+package require Tcl 8.6
+package require textutil
+package require punk::ansi  ;#required to detect, split, strip and calculate lengths
+package require punk::char  ;#box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+#*** !doctools
+#[item] [package {Tcl 8.6}]
+#[item] [package textutil]
+#[item] [package punk::ansi]
+#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
+#[item] [package punk::char]
+#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+
+# #package require frobz
+# #*** !doctools
+# #[item] [package {frobz}]
+
+#*** !doctools
+#[list_end]
+
+
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[section API]
+
+
+#Julian Noble <julian@precisium.com.au> - 2003 
+#Released under standard 'BSD license' conditions.
+#
+#todo - ellipsis truncation indicator for center,right
+
+#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
+# - need to extract and replace ansi codes?
+
+namespace eval overtype {
+	namespace export *
+    variable default_ellipsis_horizontal "..." ;#fallback 
+    variable default_ellipsis_vertical "..." 
+    namespace eval priv {
+        proc _init {} {
+            upvar ::overtype::default_ellipsis_horizontal e_h
+            upvar ::overtype::default_ellipsis_vertical e_v
+            set e_h [format %c 0x2026] ;#Unicode Horizontal Ellipsis
+            set e_v [format %c 0x22EE]
+            #The unicode ellipsis looks more natural than triple-dash which is centred vertically whereas ellipsis is at floorline of text
+            #Also - unicode ellipsis has semantic meaning that other processors can interpret
+            #unicode does also provide a midline horizontal ellipsis 0x22EF
+
+            #set e [format %c 0x2504] ;#punk::char::charshort boxd_ltdshhz  - Box Drawings Light Triple Dash Horizontal
+            #if {![catch {package require punk::char}]} {
+            #    set e [punk::char::charshort boxd_ltdshhz] 
+            #}
+        }
+    }
+    priv::_init
+}
+proc overtype::about {} {
+	return "Simple text formatting. Author JMN. BSD-License"
+}
+
+namespace eval overtype {
+    variable escape_terminals
+    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
+    dict set escape_terminals CSI [list @ \\ ^ _ ` | ~ a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z "\{" "\}"]
+    #dict set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
+    dict set escape_terminals OSC [list \007 \033\\] ;#note mix of 1 and 2-byte terminals 
+
+    #self-contained 2 byte ansi escape sequences - review more?
+    variable ansi_2byte_codes_dict
+    set  ansi_2byte_codes_dict [dict create\
+        "reset_terminal"            "\u001bc"\
+        "save_cursor_posn"          "\u001b7"\
+        "restore_cursor_posn"       "\u001b8"\
+        "cursor_up_one"             "\u001bM"\
+        "NEL - Next Line"           "\u001bE"\
+        "IND - Down one line"       "\u001bD"\
+        "HTS - Set Tab Stop"        "\u001bH"\
+        ]
+
+        #debatable whether strip should reveal the somethinghidden - some terminals don't hide it anyway.
+        #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
+}
+
+
+#proc overtype::stripansi {text} {
+#    variable escape_terminals  ;#dict
+#    variable ansi_2byte_codes_dict
+#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
+#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
+#        #\033 same as \x1b
+#        return $text
+#    }
+#
+#    set text [convert_g0 $text] 
+#
+#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
+#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
+#    set inputlist [split $text ""]
+#    set outputlist [list] 
+#
+#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
+#
+#    set in_escapesequence 0
+#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
+#    set i 0
+#    foreach u $inputlist {
+#        set v [lindex $inputlist $i+1]
+#        set uv ${u}${v}
+#        if {$in_escapesequence eq "2b"} {
+#            #2nd byte - done.
+#            set in_escapesequence 0
+#        } elseif {$in_escapesequence != 0} {
+#            set escseq [dict get $escape_terminals $in_escapesequence]
+#            if {$u in $escseq} {
+#                set in_escapesequence 0
+#            } elseif {$uv in $escseq} {
+#                set in_escapseequence 2b ;#flag next byte as last in sequence
+#            }
+#        } else {
+#            #handle both 7-bit and 8-bit CSI and OSC
+#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
+#                set in_escapesequence CSI
+#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
+#                set in_escapesequence OSC
+#            } elseif {$uv in $2bytecodes} {
+#                #self-contained e.g terminal reset - don't pass through.
+#                set in_escapesequence 2b
+#            } else {
+#                lappend outputlist $u
+#            }
+#        }
+#        incr i
+#    }
+#    return [join $outputlist ""]
+#}
+
+
+
+
+
+proc overtype::string_columns {text} {
+    if {[punk::ansi::ta::detect $text]} {
+        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
+    }
+    return [punk::char::string_width $text]
+}
+
+
+#string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
+proc overtype::left {args} {
+	# @c overtype starting at left (overstrike) 
+	# @c can/should we use something like this?: 'format "%-*s" $len $overtext 
+    variable default_ellipsis_horizontal
+
+	if {[llength $args] < 2} {
+		error {usage: ?-transparent [0|1]? ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
+	}
+    lassign [lrange $args end-1 end] underblock overblock
+    set defaults [dict create\
+        -bias       ignored\
+        -ellipsis   0\
+        -ellipsistext   $default_ellipsis_horizontal\
+        -ellipsiswhitespace 0\
+        -overflow   0\
+        -transparent 0\
+        -exposed1 \uFFFD\
+        -exposed2 \uFFFD\
+    ]
+    set known_opts [dict keys $defaults]
+    set argsflags [lrange $args 0 end-2]
+    dict for {k v} $argsflags {
+        if {$k ni $known_opts} {
+            error "overtype::left unknown option '$k'. Known options: $known_opts"
+        }
+    }
+    set opts [dict merge $defaults $argsflags]
+    # -- --- --- --- --- ---
+    set opt_transparent     [dict get $opts -transparent]
+    set opt_ellipsistext    [dict get $opts -ellipsistext]
+    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
+    set opt_exposed1        [dict get $opts -exposed1] ;#widechar_exposed_left  - todo
+    set opt_exposed2        [dict get $opts -exposed2] ;#widechar_exposed_right - todo
+    # -- --- --- --- --- ---
+
+    set norm [list \r\n \n]
+    set underblock [string map $norm $underblock]
+    set overblock  [string map $norm $overblock]
+
+    set underlines [split $underblock \n]
+    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $underblock] _w colwidth _h colheight
+    set overlines  [split $overblock \n]
+    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $overblock] _w overblock_width _h overblock_height
+    set under_exposed_max [expr {$colwidth - $overblock_width}]
+    set right_exposed $under_exposed_max 
+
+    set outputlines [list]
+    foreach undertext $underlines overtext $overlines {    
+        set undertext_printlen [punk::ansi::printing_length $undertext]
+        if {$undertext_printlen < $colwidth} {
+            set udiff [expr {$colwidth - $undertext_printlen}]
+            set undertext "$undertext[string repeat { } $udiff]"
+        }
+        set overtext_printlen [punk::ansi::printing_length $overtext]
+        set overflowlength [expr {$overtext_printlen - $colwidth}]
+
+        #review
+        #append overtext "\033\[0m"
+
+
+        if {$overflowlength > 0} {
+            #background line is narrower than data in line
+            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow [dict get $opts -overflow] $undertext $overtext]
+            if {![dict get $opts -overflow]} {
+                #set overtext [string range $overtext 0 $colwidth-1] ;#string range won't be correct e.g if contains ansi codes or leading \r or \b etc
+                if {[dict get $opts -ellipsis]} {
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[string trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
+                        set rendered [overtype::right $rendered $opt_ellipsistext]
+                    }
+                }
+            }
+            lappend outputlines $rendered
+        } else {
+            #we know overtext data is shorter or equal (for this line)
+            lappend outputlines [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+        }
+    }
+    return [join $outputlines \n]
+
+}
+
+namespace eval overtype::piper {
+    proc overcentre {args} {
+        if {[llength $args] < 2} {
+            error {usage: ?-bias left|right? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
+        }
+        lassign [lrange $args end-1 end] over under
+        set argsflags [lrange $args 0 end-2]
+        tailcall overtype::centre {*}$argsflags $under $over
+    }
+    proc overleft {args} {
+        if {[llength $args] < 2} {
+            error {usage: ?-start <column>? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
+        }
+        lassign [lrange $args end-1 end] over under
+        set argsflags [lrange $args 0 end-2]
+        tailcall overtype::left {*}$argsflags $under $over
+    }
+}
+#todo - left-right ellipsis ?
+proc overtype::centre {args} {
+    variable default_ellipsis_horizontal
+	if {[llength $args] < 2} {
+		error {usage: ?-transparent [0|1]? ?-bias [left|right]?  ?-overflow [1|0]? undertext overtext}
+	}
+	
+    foreach {underblock overblock} [lrange $args end-1 end] break
+
+    #todo - vertical vs horizontal overflow for blocks
+    set defaults [dict create\
+        -bias       left\
+        -ellipsis   0\
+        -ellipsistext   $default_ellipsis_horizontal\
+        -ellipsiswhitespace 0\
+        -overflow   0\
+        -transparent 0\
+        -exposed1 \uFFFD\
+        -exposed2 \uFFFD\
+    ]
+    set known_opts [dict keys $defaults]
+    set argsflags [lrange $args 0 end-2]
+    dict for {k v} $argsflags {
+        if {$k ni $known_opts} {
+            error "overtype::centre unknown option '$k'. Known options: $known_opts"
+        }
+    }
+    set opts [dict merge $defaults $argsflags]
+    # -- --- --- --- --- ---
+    set opt_transparent     [dict get $opts -transparent]
+    set opt_ellipsis        [dict get $opts -ellipsis]
+    set opt_ellipsistext    [dict get $opts -ellipsistext]
+    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
+    set opt_exposed1        [dict get $opts -exposed1]
+    set opt_exposed2        [dict get $opts -exposed2]
+    # -- --- --- --- --- ---
+
+
+    set norm [list \r\n \n]
+    set underblock [string map $norm $underblock]
+    set overblock  [string map $norm $overblock]
+
+    set underlines [split $underblock \n]
+    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $underblock] _w colwidth _h colheight
+    set overlines  [split $overblock \n]
+    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
+    set under_exposed_max [expr {$colwidth - $overblock_width}]
+    if {$under_exposed_max > 0} {
+        #background block is wider
+        if {$under_exposed_max % 2 == 0} {
+            #even left/right exposure
+            set left_exposed [expr {$under_exposed_max / 2}]
+        } else {
+            set beforehalf [expr {$under_exposed_max / 2}] ;#1 less than half due to integer division
+            if {[string tolower [dict get $opts -bias]] eq "left"} {
+                set left_exposed $beforehalf
+            } else {
+                #bias to the right
+                set left_exposed [expr {$beforehalf + 1}]
+            }
+        }
+    } else {
+        set left_exposed 0
+    }
+
+    set outputlines [list]
+    foreach undertext $underlines overtext $overlines {    
+        set overtext_datalen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
+        if {$ulen < $colwidth} {
+            set udiff [expr {$colwidth - $ulen}]
+            set undertext "$undertext[string repeat { } $udiff]"
+        }
+
+        set overflowlength [expr {$overtext_datalen - $colwidth}]
+        #review - right-to-left langs should elide on left! - extra option required
+
+        if {$overflowlength > 0} {
+            #overlay line wider or equal
+            set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+            #overlay line data is wider - trim if overflow not specified in opts - and overtype an ellipsis at right if it was specified
+            if {![dict get $opts -overflow]} {
+                #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
+                #set overtext [string range $overtext 0 $colwidth-1 ]
+                if {$opt_ellipsis} {
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[string trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
+                        set rendered [overtype::right $rendered $opt_ellipsistext]
+                    }
+                }
+            }
+            lappend outputlines $rendered
+            #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
+        } else {
+            #background block is wider than or equal to data for this line
+            lappend outputlines [renderline -start $left_exposed -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+        }
+    }
+    return [join $outputlines \n]
+}
+
+proc overtype::right {args} {
+    #NOT the same as align-right - which should be done to the overblock first if required
+    variable default_ellipsis_horizontal
+	# @d !todo - implement overflow, length checks etc
+
+	if {[llength $args] < 2} {
+		error {usage: ?-overflow [1|0]? undertext overtext}
+	}
+    foreach {underblock overblock} [lrange $args end-1 end] break
+
+    set defaults [dict create\
+        -bias       ignored\
+        -ellipsis   0\
+        -ellipsistext   $default_ellipsis_horizontal\
+        -ellipsiswhitespace 0\
+        -overflow   0\
+        -transparent 0\
+        -exposed1 \uFFFD\
+        -exposed2 \uFFFD\
+    ]
+    set known_opts [dict keys $defaults]
+    set argsflags [lrange $args 0 end-2]
+    dict for {k v} $argsflags {
+        if {$k ni $known_opts} {
+            error "overtype::centre unknown option '$k'. Known options: $known_opts"
+        }
+    }
+    set opts [dict merge $defaults $argsflags]
+    # -- --- --- --- --- ---
+    set opt_transparent     [dict get $opts -transparent]
+    set opt_ellipsis         [dict get $opts -ellipsis]
+    set opt_ellipsistext    [dict get $opts -ellipsistext]
+    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
+    set opt_overflow        [dict get $opts -overflow]
+    set opt_exposed1        [dict get $opts -exposed1]
+    set opt_exposed2        [dict get $opts -exposed2]
+    # -- --- --- --- --- ---
+    
+    set norm [list \r\n \n]
+    set underblock [string map $norm $underblock]
+    set overblock  [string map $norm $overblock]
+
+    set underlines [split $underblock \n]
+    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $underblock] _w colwidth _h colheight
+    set overlines  [split $overblock \n]
+    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
+    set under_exposed_max [expr {$colwidth - $overblock_width}]
+    set left_exposed $under_exposed_max 
+
+    set outputlines [list]
+    foreach undertext $underlines overtext $overlines {    
+        set overtext_datalen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
+        if {$ulen < $colwidth} {
+            set udiff [expr {$colwidth - $ulen}]
+            puts xxx
+            set undertext "$undertext[string repeat { } $udiff]"
+        }
+        if {$overtext_datalen < $overblock_width} {
+            set odiff [expr {$overblock_width - $overtext_datalen}]
+            #padding always on right - if alignment is required it should be done to block beforehand - not here
+            set overtextpadding "$overtext[string repeat { } $odiff]"
+        }
+
+        set overflowlength [expr {$overtext_datalen - $colwidth}]
+        if {$overflowlength > 0} {	
+            #raw overtext wider than undertext column
+            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -start 0 $undertext $overtext]
+            if {!$opt_overflow} {
+                if {$opt_ellipsis} {
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[string trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
+                        set rendered [overtype::right $rendered $opt_ellipsistext]
+                    }
+                }
+            }
+            lappend outputlines $rendered
+        } else {
+            #padded overtext 
+            lappend outputlines [renderline -transparent $opt_transparent -start $left_exposed $undertext $overtext]
+        }
+    }
+
+    return [join $outputlines \n]
+}
+
+# -- --- --- --- --- --- --- --- --- --- ---
+proc overtype::transparentline {args} {
+    foreach {under over} [lrange $args end-1 end] break
+    set argsflags [lrange $args 0 end-2]
+    set defaults [dict create\
+        -transparent 1\
+        -exposed 1 " "\
+        -exposed 2 " "\
+    ]
+    set newargs [dict merge $defaults $argsflags]
+    tailcall overtype::renderline {*}$newargs $under $over
+}
+#renderline may not make sense as it is in the long run for blocks of text - but is handy in the single-line-handling form anyway.
+# We are trying to handle ansi codes in a block of text which is acting like a mini-terminal in some sense.
+#We can process standard cursor moves such as \b \r - but no way to respond to other cursor movements e.g moving to other lines.
+#
+namespace eval overtype::piper {
+    proc renderline {args} {
+        if {[llength $args] < 2} {
+            error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
+        }
+        foreach {over under} [lrange $args end-1 end] break
+        set argsflags [lrange $args 0 end-2]
+        tailcall overtype::renderline {*}$argsflags $under $over
+    }
+}
+interp alias "" piper_renderline "" overtype::piper::renderline 
+
+#-returnextra to enable returning of overflow and length
+# todo - use punk::ansi::ta::detect to short-circuit processing and do simple string calcs as an optimisation?
+#review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
+#todo - review transparency issues with single/double width characters!
+proc overtype::renderline {args} {
+	if {[llength $args] < 2} {
+		error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? undertext overtext}
+	}
+    lassign [lrange $args end-1 end] under over
+    if {[string first \n $under] >=0 || [string first \n $over] >= 0} {
+        error "overtype::renderline not allowed to contain newlines"
+    }
+    set defaults [dict create\
+        -overflow   0\
+        -transparent 0\
+        -start 0\
+        -returnextra 0\
+        -exposed1 \uFFFD\
+        -exposed2 \uFFFD\
+    ]
+    #exposed1 and exposed2 for first and second col of underying 2wide char which is truncated by transparency or overflow
+
+    set known_opts [dict keys $defaults]
+    set argsflags [lrange $args 0 end-2]
+    dict for {k v} $argsflags {
+        if {$k ni $known_opts} {
+            error "overtype::renderline unknown option '$k'. Known options: $known_opts"
+        }
+    }
+    set opts [dict merge $defaults $argsflags]
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+    set opt_overflow            [dict get $opts -overflow]
+    set opt_colstart            [dict get $opts -start]
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+    set opt_transparent         [dict get $opts -transparent]  
+    if {$opt_transparent eq "0"} {
+        set do_transparency 0
+    } else {
+        set do_transparency 1
+        if {$opt_transparent eq "1"} {
+            set opt_transparent {[\s]}
+        }
+    }
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+    set opt_returnextra         [dict get $opts -returnextra]
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+    set opt_exposed1            [dict get $opts -exposed1]
+    set opt_exposed2            [dict get $opts -exposed2]
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+
+    #-----
+    #
+    if {[string first \t $under] >= 0} {
+        #set under [textutil::tabify::untabify2 $under]
+        set under [textutil::tabify::untabifyLine $under 8] ;#8 is default for untabify2 - review
+    }
+    set overdata $over
+    if {[string first \t $over] >= 0} {
+        #set overdata [textutil::tabify::untabify2 $over]
+        set overdata [textutil::tabify::untabifyLine $over 8]
+    }
+    #-------
+
+    #ta_detect ansi and do simpler processing?
+
+
+    # -- --- --- --- --- --- --- ---
+    set undermap [punk::ansi::ta::split_codes_single $under]
+    set understacks [dict create]
+
+    set i_u -1
+    set i_o 0 
+    set out [list] 
+    set u_codestack [list]
+    set pt_underchars "" ;#for string_columns length calculation for overflow 0 truncation
+    set remainder [list] ;#for returnextra
+    foreach {pt code} $undermap {
+        #pt = plain text
+        append pt_underchars $pt
+        foreach ch [split $pt ""] {
+            set width [punk::char::string_width $ch]
+            incr i_u
+            dict set understacks $i_u $u_codestack 
+            lappend out $ch
+            if {$width > 1} {
+                #presumably there are no triple-column or wider unicode chars.. until the aliens arrive.(?)
+                incr i_u
+                dict set understacks $i_u $u_codestack 
+                lappend out ""
+            }
+        }
+        #underlay should already have been rendered and not have non-sgr codes - but let's check for and not stack them if other codes are here
+        if {[priv::is_sgr $code]} {
+            if {[priv::has_sgr_leadingreset $code]} {
+                set u_codestack [list $code]
+            } else {
+                lappend u_codestack $code
+            }
+        }
+        #consider also other codes that should be stacked..?
+    }
+    #trailing codes in effect for underlay
+    if {[llength $undermap]} {
+        dict set understacks [expr {$i_u + 1}] $u_codestack
+    }
+
+
+    # -- --- --- --- --- --- --- ---
+    ####
+    #if opt_colstart - we need to build a space (or any singlewidth char really) padding on the left of the right number of columns.
+    #this will be processed as transparent - and handle doublewidth underlay characters appropriately
+    set startpad [string repeat " " $opt_colstart]
+    append startpad $overdata ;#overdata with left padding spaces based on col-start under will show through for left-padding portion regardless of -transparency
+    set overmap  [punk::ansi::ta::split_codes_single $startpad]
+    ####
+
+
+
+    set overstacks [dict create]
+    set o_codestack [list]
+    set pt_overchars ""
+    foreach {pt code} $overmap {
+        append pt_overchars $pt
+        foreach ch [split $pt ""] {
+           dict set overstacks $i_o $o_codestack 
+           incr i_o 
+        }
+        if {[priv::is_sgr $code]} {
+            #only stack SGR (graphics rendition) codes - not title sets, cursor moves etc 
+            if {[priv::has_sgr_leadingreset $code]} {
+                #m code which has sgr reset at start - no need to replay prior sgr codes 
+                set o_codestack [list $code]
+            } else {
+                lappend o_codestack $code
+            }
+        }
+    }
+    # -- --- --- --- --- --- --- ---
+
+
+
+
+    set bs [format %c 0x08]
+    set idx 0 ;# line index  (cursor - 1)
+    set idx_over -1
+    foreach {pt code} $overmap {
+        set ptchars [split $pt ""] ;#for lookahead
+        #emit plaintext chars first using existing SGR codes from under/over stack as appropriate
+        #then check if the following code is a cursor movement within the line and adjust index if so
+        foreach ch $ptchars {
+            incr idx_over
+            if {$ch eq "\r"} {
+                set idx $opt_colstart
+            } elseif {$ch eq "\b"} {
+                #review - backspace effect on double-width chars
+                if {$idx > $opt_colstart} {
+                    incr idx -1
+                }
+            } elseif {($idx < $opt_colstart)} {
+                incr idx
+            } elseif {($do_transparency && [regexp $opt_transparent $ch])} {    
+                #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
+                set owidth [punk::char::string_width $ch]
+                if {$idx > [llength $out]-1} {
+                    lappend out " "
+                    dict set understacks $idx [list] ;#review - use idx-1 codestack?
+                    incr idx
+                } else {
+                    set uwidth [punk::char::string_width [lindex $out $idx]]
+                    if {[lindex $out $idx] eq ""} {
+                        #2nd col of 2-wide char in underlay 
+                        incr idx
+                    } elseif {$uwidth == 0} {
+                        #e.g combining diacritic
+                        incr idx
+                    } elseif {$uwidth == 1} {
+                        incr idx
+                        if {$owidth > 1} {
+                            incr idx
+                        } 
+                    } elseif {$uwidth > 1} {
+                        if {[punk::char::string_width $ch] == 1} {
+                            #normal singlewide transparency 
+                            set next_pt_overchar [string index $pt_overchars $idx_over+1] ;#lookahead of next plain-text char in overlay
+                            if {$next_pt_overchar eq ""} {
+                                #special-case trailing transparent - no next_pt_overchar
+                                incr idx
+                            } else {
+                                if {[regexp $opt_transparent $next_pt_overchar]} {
+                                    incr idx
+                                } else {
+                                    #next overlay char is not transparent.. first-half of underlying 2wide char is exposed 
+                                    priv::render_addchar $idx $opt_exposed1 [dict get $overstacks $idx_over]
+                                    incr idx
+                                }
+                            }
+                        } else {
+                            #2wide transparency over 2wide in underlay
+                            incr idx
+                        }
+                    }
+                }
+            } else {
+                #non-transparent char in overlay
+                set owidth [punk::char::string_width $ch]
+                set uwidth [punk::char::string_width [lindex $out $idx]]
+                if {[lindex $out $idx] eq ""} {
+                    #2nd col of 2wide char in underlay
+                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                    incr idx
+                } elseif {$uwidth == 0} {
+                    #e.g combining diacritic - increment before over char  REVIEW
+                    #arguably the previous overchar should have done this - ie lookahead for combiners?
+                    priv::render_addchar $idx "" [dict get $overstacks $idx_over]
+                    incr idx
+                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                    incr idx
+
+                } elseif {$uwidth == 1} {
+                    if {$owidth == 1} {
+                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                        incr idx
+                    } else {
+                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                        incr idx
+                        priv::render_addchar $idx ""  [dict get $overstacks $idx_over]
+                    }
+                } elseif {$uwidth > 1} {
+                    if {$owidth == 1} {
+                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                        incr idx
+                        priv::render_addchar $idx $opt_exposed2 [dict get $overstacks $idx_over]
+                        #don't incr idx - we are just putting a broken-indication in the underlay - which may get overwritten by next overlay char
+                    } else {
+                        #2wide over 2wide
+                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                        incr idx 
+                    }
+                }
+            }
+        } 
+        #check following code
+        if {![priv::is_sgr $code]} {
+
+        }
+    }
+
+    if {$opt_overflow == 0} {
+        #need to truncate to the width of the original undertext
+        #review - string_width vs printing_length here. undertext requirement to be already rendered therefore punk::char::string_width ok?
+        set num_under_columns [punk::char::string_width $pt_underchars] ;#plaintext underchars
+    }
+
+    #coalesce and replay codestacks for out char list
+    set outstring ""    
+    set remstring "" ;#remainder after overflow point reached
+    set i 0
+    set cstack [list]
+    set prevstack [list]
+    set out_rawchars ""; #for overflow counting 
+    set output_to "outstring" ;#var in effect depending on overflow
+    set in_overflow 0 ;#used to stop char-width scanning once in overflow
+    foreach ch $out {
+        append out_rawchars $ch
+        if {$opt_overflow == 0 && !$in_overflow} {
+            if {[set nextvisualwidth [punk::char::string_width $out_rawchars]] < $num_under_columns} {
+            } else {
+                #todo - check if we overflowed with a double-width char ? 
+                #store visualwidth which may be short
+                set in_overflow 1
+            }
+        }
+        set cstack [dict get $understacks $i]
+        if {$cstack ne $prevstack} {
+            if {[llength $prevstack]} {
+                append $output_to \033\[m
+            }
+            foreach code $cstack {
+                append $output_to $code
+            }
+        }
+        append $output_to $ch
+        set prevstack $cstack
+        incr i
+        if {$in_overflow} {
+            set output_to "remstring"
+        }
+    }
+    if {[dict size $understacks] > 0} {
+        append $output_to [join [dict get $understacks [expr {[dict size $understacks]-1}]] ""] ;#tail codes
+    }
+    if {[string length $remstring]} {
+        #puts stderr "remainder:$remstring"
+    }
+    #pdict $understacks
+    if {$opt_returnextra} {
+        return [list $outstring $visualwidth [string length $outstring] $remstring]
+    } else {
+        return $outstring
+    }
+    #return [join $out ""]
+}
+proc overtype::test_renderline {} {
+    set t \uFF5E ;#2-wide tilde
+    set u \uFF3F ;#2-wide underscore
+    set missing \uFFFD
+    return [list $t $u A${t}B]
+}
+
+#same as textblock::size - but we don't want that circular dependency
+proc overtype::blocksize {textblock} {
+    if {$textblock eq ""} {
+        return [dict create width 0 height 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
+    }
+    set textblock [textutil::tabify::untabify2 $textblock]
+    #stripansi on entire block in one go rather than line by line - result should be the same - review - make tests
+    set textblock [punk::ansi::stripansi $textblock]
+    if {[string first \n $textblock] >= 0} {
+        set width [tcl::mathfunc::max {*}[lmap v [lines_as_list -- $textblock] {::punk::char::string_width $v}]]
+    } else {
+        set width [punk::char::string_width $textblock] 
+    }
+    set num_le [expr {[string length $textblock]-[string length [string map [list \n {}] $textblock]]}] ;#faster than splitting into single-char list
+    #our concept of block-height is likely to be different to other line-counting mechanisms
+    set height [expr {$num_le + 1}] ;# one line if no le - 2 if there is one trailing le even if no data follows le
+
+    return [dict create width $width height $height] ;#maintain order in 'image processing' standard width then height - caller may use lassign [dict values [blocksize <data>]] width height
+}
+
+namespace eval overtype::priv {
+
+
+    #todo - move to punk::ansi::codetype
+    proc is_sgr {code} {
+        #SGR (Select Graphic Rendition) - codes ending in 'm' - e.g colour/underline 
+        #we will accept and pass through the less common colon separator (ITU Open Document Architecture) 
+        #Terminals should generally ignore it if they don't use it
+        regexp {\033\[[0-9;:]*m$} $code
+    }
+    proc is_cursor_move_in_line {code} {
+        #review - what about CSI n : m H where row n happens to be current line?
+        regexp {\033\[[0-9]*(:?C|D|G)$}
+    }
+    #pure SGR reset
+    proc is_sgr_reset {code} {
+        #todo 8-bit csi
+        regexp {\033\[0*m$} $code
+    }
+    #whether this code has 0 (or equivalently empty) parameter (but may set others)
+    #if an SGR code as a reset in it - we don't need to carry forward any previous SGR codes
+    #it generally only makes sense for the reset to be the first entry - otherwise the code has ineffective portions
+    #However - detecting zero or empty parameter in other positions requires knowing all other codes that may allow zero or empty params.
+    #We will only look at initial parameter as this is the well-formed normal case.  
+    #Review - consider normalizing sgr codes to remove other redundancies such as setting fg or bg color twice in same code
+    proc has_sgr_leadingreset {code} {
+        set params ""
+        regexp {\033\[(.*)m} $code _match params
+        set plist [split $params ";"]
+        if {[string trim [lindex $plist 0] 0] eq ""} {
+            #e.g \033\[m  \033\[0\;...m  \033\[0000...m
+            return 1
+        } else {
+            return 0
+        }
+    }
+    #has_sgr_reset  - rather than support this - create an sgr normalize function that removes dead params and brings reset to front of param list
+    proc render_addchar {i c stack} {
+        upvar out o
+        upvar understacks ustacks
+        set nxt [llength $o] 
+        if {$i < $nxt} {
+            lset o $i $c
+        } else {
+            lappend o $c
+        }
+        dict set ustacks $i $stack
+    }
+
+}
+
+
+# -- --- --- --- --- --- --- --- --- --- ---
+if 0 {
+namespace eval overtype::ta {
+    namespace path ::overtype
+    # *based* on but not identical to:
+    #https://github.com/perlancar/perl-Text-ANSI-Util/blob/master/lib/Text/ANSI/BaseUtil.pm
+
+    #handle both 7-bit and 8-bit csi 
+    #review - does codepage affect this? e.g ebcdic has 8bit csi in different position
+
+    #CSI
+    #variable re_csi_open {(?:\033\[|\u009b)[0-9;]+} ;#too specific - doesn't detect \033\[m
+    variable re_csi_open {(?:\033\[|\u009b])}
+
+    #colour and style
+    variable re_csi_colour {(?:\033\[|\u009b)[0-9;]*m} ;#e.g \033\[31m  \033\[m  \033\[0m \033\[m0000m
+    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
+    variable re_csi_code  {(?:\033\[|\u009b])[0-9;]*[a-zA-Z\\@^_|~`]}
+
+    #OSC - termnate with BEL (\a \007) or ST (string terminator \033\\)
+    #variable re_esc_osc1 {(?:\033\]|\u009c).*\007}
+    #variable re_esc_osc2 {(?:\033\]|\u009c).*\033\\}
+
+    #test - non-greedy
+    variable re_esc_osc1 {(?:\033\]|\u009c).*?\007}
+    variable re_esc_osc2 {(?:\033\]|\u009c).*?\033\\}
+
+    variable re_ansi_detect "${re_csi_open}|${re_esc_osc1}|${re_esc_osc2}"
+
+    #detect any ansi escapes
+    #review - only detect 'complete' codes - or just use the opening escapes for performance?
+    #proc detect {text} {
+    #    variable re_ansi_detect
+    #    #variable re_csi_open
+    #    #variable re_esc_osc1
+    #    #variable re_esc_osc2
+    #    #todo - other escape sequences
+    #    #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
+    #    expr {[regexp $re_ansi_detect $text]}
+    #}
+    #not in perl ta
+    #proc detect_csi {text} {
+    #    variable re_csi_colour
+    #    expr {[regexp $re_csi_colour $text]}
+    #}
+    proc strip {text} {
+        tailcall punk::ansi::stripansi $text
+    }
+    #note this is character length after stripping ansi codes - not the printing length
+    proc length {text} {
+        string length [punk::ansi::stripansi $text]
+    }
+
+    
+    # -- --- --- --- --- --- 
+    #Split $text to a list containing alternating ANSI color codes and text.
+    #ANSI color codes are always on the second element, fourth, and so on.
+    #(ie plaintext on odd list-indices ansi on even indices)
+    # Example:
+    #ta_split_codes ""              # => ""
+    #ta_split_codes "a"             # => "a"
+    #ta_split_codes "a\e[31m"       # => {"a"   "\e[31m"}
+    #ta_split_codes "\e[31ma"       # => {""    "\e[31m"       "a"}
+    #ta_split_codes "\e[31ma\e[0m"  # => {""    "\e[31m"       "a"  "\e[0m"}
+    #ta_split_codes "\e[31ma\e[0mb" # => {""    "\e[31m"       "a"  "\e[0m", "b"}
+    #ta_split_codes "\e[31m\e[0mb"  # => {""    "\e[31m\e[0m"  "b"}
+    #
+    #proc split_codes {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
+    #    return [_perlish_split $re $text]
+    #}
+    ##like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
+    #proc split_codes_single {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
+    #    return [_perlish_split $re $text]
+    #}
+
+    ##review - tcl greedy expressions may match multiple in one element
+    #proc _perlish_split {re text} {
+    #    if {[string length $text] == 0} {
+    #        return {}
+    #    }
+    #    set list [list]
+    #    set start 0
+    #    while {[regexp -start $start -indices -- $re $text match]} {
+    #        lassign $match      matchStart matchEnd
+    #        lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
+    #        set start [expr {$matchEnd+1}]
+    #    }
+    #    lappend list [string range $text $start end]
+    #    return $list
+    #}
+    ## -- --- --- --- --- --- 
+
+}
+} ;# end if 0
+
+# -- --- --- --- --- --- --- --- --- --- ---
+namespace eval overtype {
+	interp alias {} ::overtype::center {} ::overtype::centre
+}
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Ready   
+package provide overtype [namespace eval overtype {
+    variable version
+    set version 1.5.3 
+}]
+return
+
+#*** !doctools
+#[manpage_end]
diff --git a/src/bootsupport/modules/punk/cap-0.1.0.tm b/src/bootsupport/modules/punk/cap-0.1.0.tm
index 1c70a227..8eeef7fe 100644
--- a/src/bootsupport/modules/punk/cap-0.1.0.tm
+++ b/src/bootsupport/modules/punk/cap-0.1.0.tm
@@ -232,6 +232,7 @@ namespace eval punk::cap {
     #such unregistered capabilitynames may be used just to flag something, or have datamembers significant to callers cooperatively interested in that capname. 
     #we allow registering a capability with an empty handler (capnamespace) - but this means another handler could be registered later.
     proc register_capabilityname {capname capnamespace} {
+        puts stderr "REGISTER_CAPABILITYNAME $capname $capnamespace"
         variable caps
         variable pkgcapsdeclared
         variable pkgcapsaccepted
@@ -245,7 +246,8 @@ namespace eval punk::cap {
         #as handlers can be used to validate during provider registration - ideally handlers should be registered before any pkgs call register_package 
         #we allow loading a handler later though - but will need to validate existing data from pkgs that have already registered as providers 
         if {[set hdlr [capability_get_handler $capname]] ne ""} {
-            error "register_capabilityname cannot register capability:$capname with handler:$capnamespace. There is already a registered handler:$hdlr" 
+            puts stderr "register_capabilityname cannot register capability:$capname with handler:$capnamespace. There is already a registered handler:$hdlr" 
+            return
         }
         #assert: capnamespace may or may not be empty string, capname may or may not already exist in caps dict, caps $capname providers may have existing entries.
         dict set caps $capname handler $capnamespace
@@ -262,7 +264,13 @@ namespace eval punk::cap {
                         if {$cn ne $capname} {
                             continue
                         }
-                        set do_register [$capreg pkg_register $pkg $capdict $fullcapabilitylist]
+                        if {[catch {$capreg pkg_register $pkg $capdict $fullcapabilitylist} do_register]} {
+                            puts stderr "punk::cap::register_capabilityname '$capname' '$capnamespace' failed to register provider package '$pkg' - possible error in handler or provider"
+                            puts stderr "error message:"
+                            puts stderr $do_register
+                            set do_register 0
+                        }
+
                         set list_accepted [dict get $pkgcapsaccepted $pkg]
                         if {$do_register} {
                             if {$capspec ni $list_accepted} {
@@ -337,7 +345,7 @@ namespace eval punk::cap {
     }
 
     #register package with arbitrary capnames from capabilitylist
-    #The registered pkg is a module that provides some service to that capname. Possibly just data members, that the capability will use.
+    #The registered pkg is a module that provides some service to that capname. Possibly just data members or possibly an implementation of an API, that the capability will use.
     proc register_package {pkg capabilitylist args} {
         variable pkgcapsdeclared
         variable pkgcapsaccepted
@@ -370,6 +378,10 @@ namespace eval punk::cap {
         #for each capability
         # - ensure 1st element is a single word
         # - ensure that if 2nd element (capdict) is present - it is dict shaped
+        set capabilitylist_count [llength $capabilitylist]
+        set accepted_count 0
+        set errorlist [list];# list of dicts
+        set warninglist [list]
         foreach capspec $capabilitylist {
             lassign $capspec capname capdict
 
@@ -379,16 +391,23 @@ namespace eval punk::cap {
                 }
             }
             if {[llength $capname] !=1} {
-                error "register_package error. pkg: '$pkg' An entry in the capability list doesn't appear to have a single-word name. Problematic entry:'$capspec'"
+                puts stderr "register_package error. pkg: '$pkg' An entry in the capability list doesn't appear to have a single-word name. Problematic entry:'$capspec'"
+                set reason "First element of capspec not a single-word name"
+                lappend errorlist [dict create msg $reason capspec $capspec]
+                continue
             }
             if {[expr {[llength $capdict] %2 != 0}]} {
-                error "register_package error. pkg:'$pkg' The second element for capname:'$capname' doesn't appear to be a valid dict. Problematic entry: '$capspec'"
+                puts stderr "register_package error. pkg:'$pkg' The second element for capname:'$capname' doesn't appear to be a valid dict. Problematic entry: '$capspec'"
+                set reason "The second element of the capspec isn't a valid dict"
+                lappend errorlist [dict create msg $reason capspec $capspec]
+                continue
             }
             if {$capspec in $pkg_already_accepted} {
                 #review - multiple handlers? if so - will need to record which handler(s) accepted the capspec
                 if {$warnings} {
                     puts stderr "WARNING: register_package pkg $pkg already has capspec marked as accepted: $capspec"
                 }
+                lappend warninglist [dict create msg "pkg $pkg already has this capspec marked as accepted" capspec $capspec]
                 continue
             }
             if {[dict exists $caps $capname]} {
@@ -424,6 +443,14 @@ namespace eval punk::cap {
         } else {
             dict set pkgcapsdeclared $pkg $capabilitylist
         }
+        set resultdict [list num_capabilities $capabilitylist_count num_accepted $accepted_count]
+        if {[llength $errorlist]} {
+            dict set resultdict errors $errorlist
+        }
+        if {[llength $warninglist]} {
+            dict set resultdict warnings $warninglist
+        }
+        return $resultdict
     }
 
     #todo!
@@ -460,7 +487,7 @@ namespace eval punk::cap {
         }
     }
 
-    proc pkgcap {pkg} {
+    proc pkgcap {pkg {capsearch}} {
         variable pkgcapsdeclared
         variable pkgcapsaccepted
         if {[string match ::* $pkg]} {
@@ -469,9 +496,9 @@ namespace eval punk::cap {
         if {[dict exists $pkgcapsdeclared $pkg]} {
             set accepted ""
             if {[dict exists $pkgcapsaccepted $pkg]} {
-                set accepted [dict get $pkgcapsaccepted $pkg]
+                set accepted [lsearch -all -inline -glob -index 0 [dict get $pkgcapsaccepted $pkg] $capsearch]
             }
-            return [dict create declared [dict get $pkgcapsdeclared $pkg] accepted $accepted]
+            return [dict create declared [lsearch -all -inline -glob -index 0 [dict get $pkgcapsdeclared $pkg] $capsearch] accepted $accepted]
         } else {
             return
         }
diff --git a/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm b/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm
index 75a925dd..9c0b9469 100644
--- a/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm
+++ b/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm
@@ -18,7 +18,7 @@
 ##  Requirements
 ##e.g package require frobz
 
-
+package require punk::repo
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
@@ -43,39 +43,163 @@ namespace eval punk::cap::handlers::templates {
                     # -- --- --- --- --- --- --- ---- ---
                     # validation of capdict
                     # -- --- --- --- --- --- --- ---- ---
-                    if {![dict exists $capdict relpath]} {
-                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg'  is attempting to register with punk::cap as a provider of '$capname' capability, but is missing 'relpath' key"
+                    if {![dict exists $capdict vendor]} {
+                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg'  is attempting to register with punk::cap as a provider of '$capname' capability, but is missing the 'vendor' key"
                         return 0
                     }
-                    set provide_statement [package ifneeded $pkg [package require $pkg]]
-                    set tmfile [lindex $provide_statement end]
-                    if {![file exists $tmfile]} {
-                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - unable to determine base folder for package '$pkg' which is attempting to register with punk::cap as a provider of '$capname' capability"
+                    if {![dict exists $capdict path] || ![dict exists $capdict pathtype]} {
+                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg'  is attempting to register with punk::cap as a provider of '$capname' capability, but is missing the 'path' or 'pathtype' key"
                         return 0
                     }
-                    set tpath [file normalize [file join $tmfile [dict get $capdict relpath]]] ;#relpath is relative to the tm *file* - not it's containing folder
-                    if {![file isdirectory $tpath]} {
-                        puts stderr "punk::cap::handlers::templates::capsystem pkg_register WARNING - unable to validate relpath location [dict get $capdict relpath] ($tpath) for package '$pkg' which is attempting to register with punk::cap as a provider of '$capname' capability"
+                    set pathtype [dict get $capdict pathtype]
+                    set vendor   [dict get $capdict vendor]
+                    set known_pathtypes [list adhoc currentproject_multivendor currentproject shellproject_multivendor shellproject  module absolute]
+                    if {$pathtype ni $known_pathtypes} {
+                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg'  is attempting to register with punk::cap as a provider of '$capname' capability, but 'pathtype' value '$pathtype' is not recognised. Known type: $known_pathtypes"
                         return 0
                     }
 
+                    set path [dict get $capdict path]
+
+                    set cname [string map [list . _] $capname]
+
+                    set multivendor_package_whitelist [list punk::mix::templates]
+
+
+                    #for template pathtype module & shellproject* we can resolve whether it's within a project at registration time and store the projectbase rather than rechecking it each time the templates handler api is called
+                    #for template pathtype absolute - we can do the same. 
+                    #There is a small chance for a long-running shell that a project is later created which makes the absolute path within a project - but it seems an unlikely case, and probably won't surprise the user that they need to relaunch the shell or reload the capsystem to see the change.  
+
+                    #adhoc and currentproject* paths are relative to cwd - so no projectbase information can be stored at registration time.
+                    #not all template item types will need projectbase information - as the item data may be self-contained within the template structure - 
+                    #but project_layout will need it - or at least need to know if there is no project - because project_layout data is never stored in the template folder structure directly.
+
+                    if {$pathtype eq "adhoc"} {
+                        if {[file pathtype $path] ne "relative"} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be a relative path"
+                            return 0
+                        }
+                        set extended_capdict $capdict
+                        dict set extended_capdict vendor $vendor
+                    } elseif {$pathtype eq "module"} {
+                        set provide_statement [package ifneeded $pkg [package require $pkg]]
+                        set tmfile [lindex $provide_statement end]
+                        if {![file exists $tmfile]} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - unable to determine base folder for package '$pkg' which is attempting to register with punk::cap as a provider of '$capname' capability"
+                            return 0
+                        }
+
+                        if {[file pathtype $path] ne "relative"} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be a relative path"
+                        }
+                        set tmfolder [file dirname $tmfile]
+                        #todo - handle wrapped or unwrapped tarjar files - in which case we have to adjust tmfolder appropriately
+                        #set tpath [file normalize [file join $tmfile [dict get $capdict relpath]]] ;#relpath is relative to the tm *file* - not it's containing folder
+
+                        set projectinfo    [punk::repo::find_repos $tmfolder]
+                        set projectbase [dict get $projectinfo closest]
+                        #store the projectbase even if it's empty string
+                        set extended_capdict $capdict
+                        set resolved_path [file join $tmfolder $path]
+                        dict set extended_capdict resolved_path $resolved_path
+                        dict set extended_capdict projectbase $projectbase
+                    } elseif {$pathtype eq "currentproject_multivendor"} {
+                        #currently only intended for punk::mix::templates - review if 3rd party _multivendor trees even make sense
+                        if {$pkg ni $multivendor_package_whitelist} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but package is not in whitelist $multivendor_package_whitelist - 3rd party _multivendor tree not supported"
+                            return 0
+                        }
+                        if {[file pathtype $path] ne "relative"} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be a relative path"
+                            return 0
+                        }
+
+                        set extended_capdict $capdict
+                        dict set extended_capdict vendor $vendor ;#vendor key still required.. controlling vendor? 
+                    } elseif {$pathtype eq "currentproject"} {
+                        if {[file pathtype $path] ne "relative"} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be a relative path"
+                            return 0
+                        }
+                        #verify that the relative path is within the relative path of a currentproject_multivendor tree
+                        #todo - api for the _multivendor tree controlling package to validate
+
+
+                        set extended_capdict $capdict
+                        dict set extended_capdict vendor $vendor 
+                    } elseif {$pathtype eq "shellproject"} {
+                        if {[file pathtype $path] ne "relative"} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be a relative path"
+                            return 0
+                        }
+                        set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
+                        set projectinfo [punk::repo::find_repos $shellbase]
+                        set projectbase [dict get $projectinfo closest]
+                        
+                        set extended_capdict $capdict
+                        dict set extended_capdict vendor $vendor
+                        dict set extended_capdict projectbase $projectbase
+                    } elseif {$pathtype eq "shellproject_multivendor"} {
+                        #currently only intended for punk::templates - review if 3rd party _multivendor trees even make sense
+                        if {$pkg ni $multivendor_package_whitelist} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but package is not in whitelist $multivendor_package_whitelist - 3rd party _multivendor tree not supported"
+                            return 0
+                        }
+                        if {[file pathtype $path] ne "relative"} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be a relative path"
+                            return 0
+                        }
+                        set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
+                        set projectinfo [punk::repo::find_repos $shellbase]
+                        set projectbase [dict get $projectinfo closest]
+
+                        set extended_capdict $capdict
+                        dict set extended_capdict vendor $vendor 
+                        dict set extended_capdict projectbase $projectbase
+                    } elseif {$pathtype eq "absolute"} {
+                        if {[file pathtype $path] ne "absolute"} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be absolute"
+                            return 0
+                        }
+                        set normpath [file normalize $path]
+                        if {!file exists $normpath} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' which doesn't seem to exist"
+                            return 0
+                        }
+                        set projectinfo    [punk::repo::find_repos $normpath]
+                        set projectbase [dict get $projectinfo closest]
+
+                        #todo - verify no other provider has registered same absolute path - if sharing a project-external location is needed - they need their own subfolder
+                        set extended_capdict $capdict
+                        dict set extended_capdict resolved_path $normpath 
+                        dict set extended_capdict vendor $vendor
+                        dict set extended_capdict projectbase $projectbase
+                    } else {
+                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' with unrecognised type $pathtype"
+                        return 0
+                    }
 
                     # -- --- --- --- --- --- --- ---- ---
                     # update package internal data 
                     # -- --- --- --- --- --- --- ---- ---
+                    upvar ::punk::cap::handlers::templates::provider_info_$cname provider_info
+
                     if {$capname ni $::punk::cap::handlers::templates::handled_caps} {
                         lappend ::punk::cap::handlers::templates::handled_caps $capname
                     }
-                    set cname [string map [list . _] $capname]
-                    upvar ::punk::cap::handlers::templates::pkg_folders_$cname pfolders
-                    dict lappend pfolders $pkg $tpath
+                    if {![info exists provider_info]  || $extended_capdict ni [dict get $provider_info $pkg]} {
+                        #this checks for duplicates from the same provider - but not if other providers already added the path
+                        #review - 
+                        dict lappend provider_info $pkg $extended_capdict
+                    }
 
 
                     # -- --- --- --- --- --- --- ---- ---
                     # instantiation of api at punk::cap::handlers::templates::api_$capname 
                     # -- --- --- --- --- --- --- ---- ---
-                    if {[info commands ::punk::cap::handlers::templates::$capname] eq ""} {
-                        punk::cap::handlers::templates::class::api create ::punk::cap::handlers::templates::api_$capname $capname
+                    set apicmd "::punk::cap::handlers::templates::api_$capname"
+                    if {[info commands $apicmd] eq ""} {
+                        punk::cap::handlers::templates::class::api create $apicmd $capname
                     }
 
                     return 1
@@ -84,8 +208,8 @@ namespace eval punk::cap::handlers::templates {
                     upvar ::punk::cap::handlers::templates::handled_caps hcaps
                     foreach capname $hcaps {
                         set cname [string map [list . _] $capname]
-                        upvar ::punk::cap::handlers::templates::pkg_folders_$cname pfolders
-                        dict unset pfolders $pkg
+                        upvar ::punk::cap::handlers::templates::provider_info_$cname my_provider_info 
+                        dict unset my_provider_info $pkg
                         #destroy api objects?
                     }
                 }
@@ -109,24 +233,491 @@ namespace eval punk::cap::handlers::templates {
                 set cname [string map [list . _] $capname]
                 set capabilityname $capname
             }
-            method folders {} {
+            method folders {args} {
+                lassign [punk::args::opts_values {
+                    -startdir -default ""
+                } $args -maxvalues 0] _o opts 
+                set opt_startdir [dict get $opts -startdir]
+                if {$opt_startdir eq ""} {
+                    set startdir [pwd]
+                } else {
+                    if {[file pathtype $opt_startdir] eq "relative"} {
+                        set startdir [file join [pwd] $opt_startdir]
+                    } else {
+                        set startdir $opt_startdir
+                    }
+                }
+
+
                 variable capabilityname
                 variable cname
-                upvar punk::cap::handlers::templates::pkg_folders_$cname pkg_folders
+                upvar ::punk::cap::handlers::templates::provider_info_$cname my_provider_info
                 package require punk::cap
                 set capinfo [punk::cap::capability $capabilityname]
                 # e.g {punk.templates {handler punk::mix::templates providers ::somepkg}}
 
                 #use the order of pkgs as registered with punk::cap - may have been modified with punk::cap::promote_package/demote_package
-                set pkgs [dict get $capinfo providers]
+                set providerpkg [dict get $capinfo providers]
                 set folderdict [dict create]
-                foreach pkg $pkgs { 
-                    foreach pfolder [dict get $pkg_folders $pkg] {
-                        dict set folderdict $pfolder [list source $pkg sourcetype package]
+
+                #maintain separate paths for different override levels - all keyed on vendor (or pseudo-vendor '_project')
+                set found_paths_adhoc [dict create]
+                set found_paths_module [dict create]
+                set found_paths_currentproject_multivendor [dict create]
+                set found_paths_currentproject [dict create]
+                set found_paths_shellproject_multivendor [dict create]
+                set found_paths_shellproject [dict create]
+                set found_paths_absolute [list]
+
+
+                foreach pkg $providerpkg { 
+                    set found_paths [list]
+                    #set acceptedlist [dict get [punk::cap::pkgcap $pkg $capabilityname] accepted]
+
+                    foreach capdecl_extended [dict get $my_provider_info $pkg] {
+                        #basic validation and extension was done when accepted - so we can trust the capdecl_extended dictionary has the right entries
+
+                        set path     [dict get $capdecl_extended path]
+                        set pathtype [dict get $capdecl_extended pathtype]
+                        set vendor   [dict get $capdecl_extended vendor]
+                        # projectbase not present in capdecl_extended for all template pathtypes
+                        if {$pathtype eq "adhoc"} {
+                            #e.g (cwd)/templates
+                            set targetpath [file join $startdir [dict get $capdecl_extended path]]
+                            if {[file isdirectory $targetpath]} {
+                                dict lappend found_paths_adhoc $vendor [list pkg $pkg path $targetpath pathtype $pathtype]
+                            }
+                        } elseif {$pathtype eq "module"} {
+                            set module_projectroot [dict get $capdecl_extended projectbase]
+                            dict lappend found_paths_module $vendor [list pkg $pkg path [dict get $capdecl_extended resolved_path] pathtype $pathtype projectbase $module_projectroot]
+                        } elseif {$pathtype eq "currentproject_multivendor"} {
+                            set searchbase $startdir 
+                            set pathinfo    [punk::repo::find_repos $searchbase]
+                            set pwd_projectroot [dict get $pathinfo closest]
+                            if {$pwd_projectroot ne ""} {
+                                set deckbase [file join $pwd_projectroot $path]
+                                if {![file exists $deckbase]} {
+                                   continue 
+                                }
+                                #add vendor/x folders first - earlier in list is lower priority
+                                set vendorbase [file join $deckbase vendor]
+                                if {[file isdirectory $vendorbase]} {
+                                    set vendorfolders [glob -nocomplain -dir $vendorbase -type d -tails *]
+                                    foreach vf $vendorfolders {
+                                        if {$vf ne "_project"} {
+                                            dict lappend found_paths_currentproject_multivendor $vf [list pkg $pkg path [file join $vendorbase $vf] pathtype $pathtype]
+                                        }
+                                    }
+                                    if {[file isdirectory [file join $vendorbase _project]]} {
+                                        dict lappend found_paths_currentproject_multivendor _project [list pkg $pkg path [file join $vendorbase _project] pathtype $pathtype]
+                                    }
+                                }
+                                set custombase [file join $deckbase custom]
+                                if {[file isdirectory $custombase]} {
+                                    set customfolders [glob -nocomplain -dir $custombase -type d -tails *]
+                                    foreach cf $customfolders {
+                                        if {$cf ne "_project"} {
+                                            dict lappend found_paths_currentproject_multivendor $cf [list pkg $pkg path [file join $custombase $cf] pathtype $pathtype]
+                                        }
+                                    }
+                                    if {[file isdirectory [file join $custombase _project]]} {
+                                        dict lappend found_paths_currentproject_multivendor _project [list pkg $pkg path [file join $custombase _project] pathtype $pathtype]
+                                    }
+                                }
+                            }
+                        } elseif {$pathtype eq "currentproject"} {
+                            set searchbase $startdir 
+                            set pathinfo    [punk::repo::find_repos $searchbase]
+                            set pwd_projectroot [dict get $pathinfo closest]
+                            if {$pwd_projectroot ne ""} {
+                                #path relative to projectroot already validated by handler as being within a currentproject_multivendor tree
+                                set targetfolder [file join $pwd_projectroot $path]
+                                if {[file isdirectory $targetfolder]} {
+                                    dict lappend found_paths_currentproject $vendor [list pkg $pkg path $targetfolder pathtype $pathtype]
+                                }
+                            }
+                        } elseif {$pathtype eq "shellproject_multivendor"} {
+                            #review - consider also [info script]  - but it can be empty if we just start a tclsh, load packages and start a repl
+                            #set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
+                            #set pathinfo [punk::repo::find_repos $shellbase]
+                            #set pwd_projectroot [dict get $pathinfo closest]
+
+                            set shell_projectroot [dict get $capdecl_extended projectbase]
+                            if {$shell_projectroot ne ""} {
+                                set deckbase [file join $shell_projectroot $path]
+                                if {![file exists $deckbase]} {
+                                   continue 
+                                }
+                                #add vendor/x folders first - earlier in list is lower priority
+                                set vendorbase [file join $deckbase vendor]
+                                if {[file isdirectory $vendorbase]} {
+                                    set vendorfolders [glob -nocomplain -dir $vendorbase -type d -tails *]
+                                    foreach vf $vendorfolders {
+                                        if {$vf ne "_project"} {
+                                            dict lappend found_paths_shellproject_multivendor $vf [list pkg $pkg path [file join $vendorbase $vf] pathtype $pathtype projectbase $shell_projectroot]
+                                        }
+                                    }
+                                    if {[file isdirectory [file join $vendorbase _project]]} {
+                                        dict lappend found_paths_shellproject_multivendor _project [list pkg $pkg path [file join $vendorbase _project] pathtype $pathtype projectbase $shell_projectroot]
+                                    }
+                                }
+                                set custombase [file join $deckbase custom]
+                                if {[file isdirectory $custombase]} {
+                                    set customfolders [glob -nocomplain -dir $custombase -type d -tails *]
+                                    foreach cf $customfolders {
+                                        if {$cf ne "_project"} {
+                                            dict lappend found_paths_shellproject_multivendor $cf [list pkg $pkg path [file join $custombase $cf] pathtype $pathtype projectbase $shell_projectroot]
+                                        }
+                                    }
+                                    if {[file isdirectory [file join $custombase _project]]} {
+                                        dict lappend found_paths_shellproject_multivendor _project [list pkg $pkg path [file join $custombase _project] pathtype $pathtype projectbase $shell_projectroot]
+                                    }
+                                }
+
+                            }
+
+                        } elseif {$pathtype eq "shellproject"} {
+                            #review - consider also [info script]  - but it can be empty if we just start a tclsh, load packages and start a repl
+                            #set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
+                            #set pathinfo [punk::repo::find_repos $shellbase]
+                            #set pwd_projectroot [dict get $pathinfo closest]
+
+                            set shell_projectroot [dict get $capdecl_extended projectbase]
+                            if {$shell_projectroot ne ""} {
+                                set targetfolder [file join $shell_projectroot $path]
+                                if {[file isdirectory $targetfolder]} {
+                                    dict lappend found_paths_shellproject $vendor [list pkg $pkg path $targetfolder pathtype $pathtype projectbase $shell_projectroot]
+                                }
+                            }
+                        } elseif {$pathtype eq "absolute"} {
+                            #lappend found_paths [dict get $capdecl_extended resolved_path]
+                            set abs_projectroot [dict get $capdecl_extended projectbase]
+                            dict lappend found_paths_absolute $vendor [list pkg $pkg path [dict get $capdecl_extended resolved_path] pathtype $pathtype projectbase $abs_projectroot]
+                        }
+
+                    }
+
+                    #todo - ensure vendor pkg capdict elements such source and allowupdates override any existing entry from a _multivendor pkg?
+                    #currently relying on order in which loaded? review
+                    #foreach pfolder $found_paths {
+                    #    dict set folderdict $pfolder [list source $pkg sourcetype package]
+                    #}
+                }
+
+                #add in order of preference low priority to high
+
+                dict for {vendor pathinfolist} $found_paths_module {
+                    foreach pathinfo $pathinfolist {
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] projectbase [dict get $pathinfo projectbase] vendor $vendor]
+                    }
+                }
+
+                #Templates within project of shell we launched with has lower priority than 'currentproject' (which depends on our CWD)
+                dict for {vendor pathinfolist} $found_paths_shellproject_multivendor {
+                    foreach pathinfo $pathinfolist {
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] projectbase [dict get $pathinfo projectbase] vendor $vendor]
+                    }
+                }
+                dict for {vendor pathinfolist} $found_paths_shellproject {
+                    foreach pathinfo $pathinfolist {
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] projectbase [dict get $pathinfo projectbase] vendor $vendor]
+                    }
+                }
+
+                dict for {vendor pathinfolist} $found_paths_currentproject_multivendor {
+                    foreach pathinfo $pathinfolist {
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] vendor $vendor]
+                    }
+                }
+                dict for {vendor pathinfolist} $found_paths_currentproject {
+                    foreach pathinfo $pathinfolist {
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] vendor $vendor]
+                    }
+                }
+                dict for {vendor pathinfolist} $found_paths_absolute {
+                    foreach pathinfo $pathinfolist {
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] projectbase [dict get $pathinfo projectbase] vendor $vendor]
+                    }
+                }
+                #adhoc paths relative to cwd (or specified -startdir) can override any
+                dict for {vendor pathinfolist} $found_paths_adhoc {
+                    foreach pathinfo $pathinfolist {
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] vendor $vendor]
                     }
                 }
                 return $folderdict
             }
+            method get_itemdict_projectlayouts {args} {
+                lassign [punk::args::opts_values { 
+                    -startdir -default ""
+                    #peek -startdir while allowing all other opts/vals to be verified down-the-line instead of here
+                } $args -maxvalues -1 -anyopts 1] _o opts _v values 
+                set opt_startdir [dict get $opts -startdir]
+                if {$opt_startdir eq ""} {
+                    set searchbase [pwd]
+                } else {
+                    set searchbase $opt_startdir 
+                }
+
+                set refdict [my get_itemdict_projectlayoutrefs {*}$args]
+                set layoutdict [dict create]
+
+                set projectinfo    [punk::repo::find_repos $searchbase]
+                set projectroot [dict get $projectinfo closest]
+
+                dict for {layoutname refinfo} $refdict {
+                    set templatepathtype [dict get $refinfo sourceinfo pathtype]
+                    set sourceinfo [dict get $refinfo sourceinfo]
+                    set path [dict get $refinfo path]
+                    set reftail [file tail $path]
+                    set atparts [split [file rootname $reftail] @]
+                    #may be two @s if referencing a renamed layout override?
+                    # e.g ref may be @vendor+punks+othersample@sample-0.1  or layoutalias-1.1@vendor+punk+othersample@sample-0.1
+                    #there must always be an @ before vendor or custom . There is either a template-name alias or empty string before this first @
+                    #trim off first @ part
+                    set tailats [join [lrange $atparts 1 end] @] 
+                    # @ parts after the first are part of the path within the project_layouts structure
+                    set subpathlist [split $tailats +]
+                    if {[dict exists $refinfo sourceinfo projectbase]} {
+                        #some template pathtypes refer to the projectroot from the template - not the cwd
+                        set projectroot [dict get $refinfo sourceinfo projectbase]
+                    }
+
+                    if {$projectroot ne ""} {
+                        set layoutroot [file join $projectroot src/project_layouts]
+                        set layoutfolder [file join $layoutroot {*}$subpathlist]
+                        if {[file isdirectory $layoutfolder]} {
+                            #todo - check if layoutname already in layoutdict append .ref path to list of refs that linked to this layout?
+                            set layoutinfo [list path $layoutfolder basefolder $layoutroot sourceinfo $sourceinfo]
+                            dict set layoutdict $layoutname $layoutinfo
+                        }
+                    }
+                }
+                return $layoutdict
+            }
+            method get_itemdict_projectlayoutrefs {args} {
+                set config {
+                    -templatefolder_subdir "layout_refs"\
+                    -command_get_items_from_base {apply {{base} {
+                        set matched_files [glob -nocomplain -dir $base -type f *@*.ref]
+                        set items [list]
+                        foreach rf $matched_files {
+                            #puts stderr "--> $rf"
+                            if {[string match ignore* $rf]} {
+                                continue
+                            }
+                            #we silently skip .ref files that don't match - todo - more verification - and warn of invalid .refs?
+                            if {[string match *@vendor+* $rf] || [string match *@custom+* $rf]} {
+                                lappend items $rf
+                            }
+                        }
+                        return $items
+                    }}}\
+                    -command_get_item_name {apply {{vendor basefolder itempath} {
+                        set itemtail [file rootname [file tail $itempath]]
+                        set alias [lindex [split $itemtail @] 0]
+                        if {$alias eq ""} {
+                            set itemname [lindex [split $itemtail +] end]
+                        } else {
+                            set itemname $alias
+                        }
+                        if {$vendor ne "_project"} {
+                            set itemname $vendor.$itemname
+                        }
+                        return $itemname 
+                    }}}
+                }
+                set arglist [concat $config $args]
+                my _get_itemdict {*}$arglist
+            }
+            method get_itemdict_scriptappwrappers {args} {
+                set config {
+                    -templatefolder_subdir "utility/scriptappwrappers"\
+                    -command_get_items_from_base {apply {{base} {
+
+                        set matched_files [punk::path::treefilenames  -dir $base *]
+                        set wrappers [list]
+                        foreach tf $matched_files {
+                            if {[string match ignore* $tf]} {
+                                continue
+                            }
+                            set ext [file extension $tf]
+                            if {[string tolower $ext] in [list "" ".bat" ".cmd" ".sh" ".bash" ".pl" ".ps1" ".tcl"]} {
+                                lappend wrappers $tf
+                            }
+                        }
+                        return $wrappers
+                    }}}\
+                    -command_get_item_name {apply {{vendor basefolder itempath} {
+
+                        set relativepath [punk::path::relative $basefolder $itempath]
+                        set ftail [file tail $itempath]
+                        set tname $relativepath
+                        if {$vendor ne "_project"} {
+                            set tname ${vendor}.$tname
+                        }
+                        return $tname
+                    }}}
+                }
+                set arglist [concat $config $args]
+                my _get_itemdict {*}$arglist
+            }
+            method get_itemdict_moduletemplates {args} {
+                set config {
+                    -templatefolder_subdir "modules"\
+                    -command_get_items_from_base {apply {{base} {
+
+                        set matched_files [punk::path::treefilenames -dir $base template_*.tm]
+                        set tfiles [list]
+                        foreach tf $matched_files {
+                            if {[string match ignore* $tf]} {
+                                continue
+                            }
+                            set ext [file extension $tf]
+                            if {[string tolower $ext] in [list ".tm"]} {
+                                #we will ignore any .tm files that don't have versions that tcl understands - but warn
+                                #this reduces the cases we have to test later
+                                set fname [file tail $tf]
+                                lassign [split [punk::mix::cli::lib::split_modulename_version $fname]] mname ver
+                                if {[catch {punk::mix::cli::lib::validate_modulename $mname} errM]} {
+                                    puts stderr "Invalid module name/version $tf - please rename with standard Tcl .tm module name and version (or leave out version)"
+                                    if {[string match *-* $mname]} {
+                                        puts stderr "Tcl module name cannot contain dash character - except between name and version"
+                                    }
+                                } else {
+                                    lappend tfiles $tf
+                                }
+                            }
+                        }
+                        return $tfiles
+
+                    }}}\
+                    -command_get_item_name {apply {{vendor basefolder itempath} {
+
+                        set relativepath [punk::path::relative $basefolder $itempath] 
+                        set dirs [file dirname $relativepath]
+                        if {$dirs eq "."} {
+                            set dirs ""
+                        }
+                        set moduleprefix [join $dirs ::]
+                        set ftail [file rootname [file tail $itempath]]
+                        set tname [string range $ftail [string length template_] end]
+                        if {$moduleprefix ne ""} {
+                            set tname ${moduleprefix}::$tname
+                        }
+                        if {$vendor ne "_project"} {
+                            set tname ${vendor}.$tname
+                        } 
+                        return $tname
+                    }}}
+                }
+                set arglist [concat $config $args]
+                my _get_itemdict {*}$arglist
+            }
+
+            #shared algorithm for get_itemdict_* methods
+            #requires a -templatefolder_subdir indicating a directory within each template base folder in which to search  
+            #and a file selection mechanism command -command_get_items_from_base
+            #and a name determining command -command_get_item_name
+            method _get_itemdict {args} {
+                lassign [punk::args::opts_values { 
+                    -startdir -default ""
+                    -templatefolder_subdir -optional 0
+                    -command_get_items_from_base -optional 0
+                    -command_get_item_name -optional 0
+                    -not -default "" -multiple 1 
+                    globsearches -default * -multiple 1
+                } $args -maxvalues -1] _o opts _v values 
+                set globsearches [dict get $values globsearches]; #note that in this case our globsearch won't reduce the machine's effort in scannning the filesystem - as we need to search on the renamed results
+                # -- --- --- --- --- --- --- --- ---
+                set opt_startdir [dict get $opts -startdir]
+                set opt_templatefolder_subdir   [dict get $opts -templatefolder_subdir]
+                if {[file pathtype $opt_templatefolder_subdir] ne "relative"} {
+                    error templates::_get_itemdict
+                }
+                # -- --- --- --- --- --- --- --- ---
+                set opt_command_get_items_from_base [dict get $opts -command_get_items_from_base]
+                set opt_command_get_item_name       [dict get $opts -command_get_item_name]
+                set opt_not                         [dict get $opts -not]
+                # -- --- --- --- --- --- --- --- ---
+                set itembases [list]
+                #set tbasedict [punk::mix::base::lib::get_template_basefolders $opt_startdir]
+                set tbasedict [my folders -startdir $opt_startdir ]
+                #turn the dict into a list we can temporarily reverse sort while we expand the items from within each path
+                dict for {tbase folderinfo} $tbasedict {
+                    lappend itembases [list basefolder [file join $tbase $opt_templatefolder_subdir] sourceinfo $folderinfo]
+                }
+
+                set items [list]
+                set itemdict [dict create]
+                set seen_dict [dict create]
+
+                #flip the priority order for layout folders encountered so we can set the trailing #<int> dup/overridden indicators
+                foreach baseinfo [lreverse $itembases] {
+                    set basefolder [dict get $baseinfo basefolder]
+                    set sourceinfo [dict get $baseinfo sourceinfo]
+                    set vendor [dict get $sourceinfo vendor]
+                    #call the custom script from our caller which determines resultset of files we are interested in
+                    set matches  [{*}$opt_command_get_items_from_base $basefolder]
+                    set items_here [dict create] ;#maintain a list keyed on name for sorting within this base only
+                    foreach itempath $matches {
+                        set itemname [{*}$opt_command_get_item_name $vendor $basefolder $itempath]
+                        dict set items_here $itemname [list item $itempath baseinfo $baseinfo] 
+                        #lappend items [list item $itempath baseinfo $baseinfo]
+                    }
+                    set ordered_names [lsort [dict keys $items_here]]
+                    #add to the outer items list 
+                    foreach nm $ordered_names { 
+                        set iteminfo [dict get $items_here $nm]
+                        lappend items [list originalname $nm iteminfo $iteminfo]
+                    }
+                }
+
+                #append #n instance/duplicate name indicators based on cyling through entire list of found items
+                foreach itemrecord $items {
+                    set oname [dict get $itemrecord originalname]
+                    set iteminfo [dict get $itemrecord iteminfo]
+                    set itempath [dict get $iteminfo item]
+                    set baseinfo [dict get $iteminfo baseinfo]
+                    if {![dict exists $seen_dict $oname]} {
+                        dict set seen_dict $oname 1    
+                        dict set itemdict $oname [list path $itempath {*}$baseinfo] ; #first seen of oname gets no number 
+                    } else {
+                        set n [dict get $seen_dict $oname]
+                        incr n
+                        dict incr seen_dict $oname
+                        dict set itemdict ${oname}#$n [list path $itempath {*}$baseinfo]
+                    }
+                }
+
+                #assert path is first key of itemdict {callers are allowed to rely on it being first}
+                #assert itemdict has keys path,basefolder,sourceinfo
+                set result [dict create]
+                set keys [lreverse [dict keys $itemdict]]
+                foreach k $keys {
+                    set maybe "" 
+                    foreach g $globsearches {
+                        if {[string match $g $k]} {
+                            set maybe $k
+                            break
+                        }
+                    }
+                    set not ""
+                    if {$maybe ne ""} {
+                        foreach n $opt_not {
+                            if {[string match $n $k]} {
+                                set not $k
+                                break
+                            }
+                        }
+                    } 
+                    if {$maybe ne "" && $not eq ""} {
+                        dict set result $k [dict get $itemdict $k]
+                    }
+
+                }
+                return $result
+            }
         }
     }
 
diff --git a/src/bootsupport/modules/punk/du-0.1.0.tm b/src/bootsupport/modules/punk/du-0.1.0.tm
index fa02b3a9..65115ec0 100644
--- a/src/bootsupport/modules/punk/du-0.1.0.tm
+++ b/src/bootsupport/modules/punk/du-0.1.0.tm
@@ -825,7 +825,7 @@ namespace eval punk::du {
             ]
             set errors [dict create]
             set known_opts [dict keys $defaults] 
-            foreach k [dict keys $args] {
+            dict for {k -} $args {
                 if {$k ni $known_opts} {
                     error  "du_dirlisting_generic unknown-option $k"
                 }
@@ -1250,7 +1250,7 @@ namespace eval punk::du {
 
     #experiment with csv as easy way to get column like format..
     #The /r is somewhat cheating however.. as it messes up redirected output .. e.g if redirected to text file
-    interp alias {} du {}  .=args>* punk::du::du |> .=>1 natsort::sort -cols 1  -outputformat csv -outputformatoptions {\r\t\t\t} |> list_as_lines <args|
+    interp alias {} du {}  .=args>* punk::du::du |> .=>1 natsort::sort -cols 1  -outputformat csv -outputformatoptions {\r\t\t\t} |> list_as_lines -- <args|
 
 
 }
diff --git a/src/bootsupport/modules/punk/encmime-0.1.0.tm b/src/bootsupport/modules/punk/encmime-0.1.0.tm
new file mode 100644
index 00000000..071250d6
--- /dev/null
+++ b/src/bootsupport/modules/punk/encmime-0.1.0.tm
@@ -0,0 +1,437 @@
+# -*- tcl -*-
+# Maintenance Instruction: leave the 999999.xxx.x as is and use punkshell 'pmix make' or bin/punkmake  to update from <pkg>-buildversion.txt
+# module template: punkshell/src/decktemplates/vendor/punk/modules/template_module-0.0.2.tm
+#
+# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
+# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# (C) 2024
+#
+# @@ Meta Begin
+# Application punk::encmime 0.1.0
+# Meta platform     tcl
+# Meta license      <unspecified>
+# @@ Meta End
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin punkshell_module_punk::encmime 0 0.1.0]
+#[copyright "2024"]
+#[titledesc {mime encodings related subset of tcllib mime}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {mime encoding names and aliases}]             [comment {-- Description at end of page heading --}] 
+#[require punk::encmime]
+#[keywords module encodings]
+#[description]
+#[para] This is a workaround package to provide the mime encoding names used in tcllib's mime package - without additional dependencies
+#[para]tcllib mime loads either Trf or tcl::memchan functions. punk::encmime needs to work in a context where tcllib may not yet be loaded/available, and even these few dependencies are too much. 
+#[para]MAINTENANCE NOTE: The data in this module needs to be checked against the latest tcllib mime package
+#[para]taken from tcllib mime version: 1.7.2 in 2024
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of punk::encmime
+#[subsection Concepts]
+#[para] Where practical - the actual tcllib mime package should be used instead.
+#[para]This set of encoding related functions is a snapshot of the data from the mime package - and may not be up to date.
+#[para]This pseudo-package was created to minimize dependencies for punk::char and punk::overtype
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Requirements
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by punk::encmime
+#[list_begin itemized]
+
+package require Tcl 8.6
+#*** !doctools
+#[item] [package {Tcl 8.6}]
+
+# #package require frobz
+# #*** !doctools
+# #[item] [package {frobz}]
+
+#*** !doctools
+#[list_end]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section API]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# oo::class namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+namespace eval punk::encmime::class {
+    #*** !doctools
+    #[subsection {Namespace punk::encmime::class}]
+    #[para] class definitions
+    if {[info commands [namespace current]::interface_sample1] eq ""} {
+        #*** !doctools
+        #[list_begin enumerated]
+
+        # oo::class create interface_sample1 {
+        #     #*** !doctools
+        #     #[enum] CLASS [class interface_sample1]
+        #     #[list_begin definitions]
+
+        #     method test {arg1} {
+        #         #*** !doctools
+        #         #[call class::interface_sample1    [method test] [arg arg1]]
+        #         #[para] test method
+        #         puts "test: $arg1"
+        #     }
+
+        #     #*** !doctools
+        #     #[list_end] [comment {-- end definitions interface_sample1}]
+        # }
+
+        #*** !doctools
+        #[list_end] [comment {--- end class enumeration ---}]
+    }
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# Base namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+namespace eval punk::encmime {
+    namespace export *
+
+    variable encList {
+        ascii US-ASCII
+        big5 Big5
+        cp1250 Windows-1250
+        cp1251 Windows-1251
+        cp1252 Windows-1252
+        cp1253 Windows-1253
+        cp1254 Windows-1254
+        cp1255 Windows-1255
+        cp1256 Windows-1256
+        cp1257 Windows-1257
+        cp1258 Windows-1258
+        cp437 IBM437
+        cp737 {}
+        cp775 IBM775
+        cp850 IBM850
+        cp852 IBM852
+        cp855 IBM855
+        cp857 IBM857
+        cp860 IBM860
+        cp861 IBM861
+        cp862 IBM862
+        cp863 IBM863
+        cp864 IBM864
+        cp865 IBM865
+        cp866 IBM866
+        cp869 IBM869
+        cp874 {}
+        cp932 {}
+        cp936 GBK
+        cp949 {}
+        cp950 {}
+        dingbats {}
+        ebcdic {}
+        euc-cn EUC-CN
+        euc-jp EUC-JP
+        euc-kr EUC-KR
+        gb12345 GB12345
+        gb1988 GB1988
+        gb2312 GB2312
+        iso2022 ISO-2022
+        iso2022-jp ISO-2022-JP
+        iso2022-kr ISO-2022-KR
+        iso8859-1 ISO-8859-1
+        iso8859-2 ISO-8859-2
+        iso8859-3 ISO-8859-3
+        iso8859-4 ISO-8859-4
+        iso8859-5 ISO-8859-5
+        iso8859-6 ISO-8859-6
+        iso8859-7 ISO-8859-7
+        iso8859-8 ISO-8859-8
+        iso8859-9 ISO-8859-9
+        iso8859-10 ISO-8859-10
+        iso8859-13 ISO-8859-13
+        iso8859-14 ISO-8859-14
+        iso8859-15 ISO-8859-15
+        iso8859-16 ISO-8859-16
+        jis0201 JIS_X0201
+        jis0208 JIS_C6226-1983
+        jis0212 JIS_X0212-1990
+        koi8-r KOI8-R
+        koi8-u KOI8-U
+        ksc5601 KS_C_5601-1987
+        macCentEuro {}
+        macCroatian {}
+        macCyrillic {}
+        macDingbats {}
+        macGreek {}
+        macIceland {}
+        macJapan {}
+        macRoman {}
+        macRomania {}
+        macThai {}
+        macTurkish {}
+        macUkraine {}
+        shiftjis Shift_JIS
+        symbol {}
+        tis-620 TIS-620
+        unicode {}
+        utf-8 UTF-8
+    }
+    variable encodings
+    array set encodings $encList
+    variable reversemap
+    variable encAliasList {
+        ascii ANSI_X3.4-1968
+        ascii iso-ir-6
+        ascii ANSI_X3.4-1986
+        ascii ISO_646.irv:1991
+        ascii ASCII
+        ascii ISO646-US
+        ascii us
+        ascii IBM367
+        ascii cp367
+        cp437 cp437
+        cp437 437
+        cp775 cp775
+        cp850 cp850
+        cp850 850
+        cp852 cp852
+        cp852 852
+        cp855 cp855
+        cp855 855
+        cp857 cp857
+        cp857 857
+        cp860 cp860
+        cp860 860
+        cp861 cp861
+        cp861 861
+        cp861 cp-is
+        cp862 cp862
+        cp862 862
+        cp863 cp863
+        cp863 863
+        cp864 cp864
+        cp865 cp865
+        cp865 865
+        cp866 cp866
+        cp866 866
+        cp869 cp869
+        cp869 869
+        cp869 cp-gr
+        cp936 CP936
+        cp936 MS936
+        cp936 Windows-936
+        iso8859-1 ISO_8859-1:1987
+        iso8859-1 iso-ir-100
+        iso8859-1 ISO_8859-1
+        iso8859-1 latin1
+        iso8859-1 l1
+        iso8859-1 IBM819
+        iso8859-1 CP819
+        iso8859-2 ISO_8859-2:1987
+        iso8859-2 iso-ir-101
+        iso8859-2 ISO_8859-2
+        iso8859-2 latin2
+        iso8859-2 l2
+        iso8859-3 ISO_8859-3:1988
+        iso8859-3 iso-ir-109
+        iso8859-3 ISO_8859-3
+        iso8859-3 latin3
+        iso8859-3 l3
+        iso8859-4 ISO_8859-4:1988
+        iso8859-4 iso-ir-110
+        iso8859-4 ISO_8859-4
+        iso8859-4 latin4
+        iso8859-4 l4
+        iso8859-5 ISO_8859-5:1988
+        iso8859-5 iso-ir-144
+        iso8859-5 ISO_8859-5
+        iso8859-5 cyrillic
+        iso8859-6 ISO_8859-6:1987
+        iso8859-6 iso-ir-127
+        iso8859-6 ISO_8859-6
+        iso8859-6 ECMA-114
+        iso8859-6 ASMO-708
+        iso8859-6 arabic
+        iso8859-7 ISO_8859-7:1987
+        iso8859-7 iso-ir-126
+        iso8859-7 ISO_8859-7
+        iso8859-7 ELOT_928
+        iso8859-7 ECMA-118
+        iso8859-7 greek
+        iso8859-7 greek8
+        iso8859-8 ISO_8859-8:1988
+        iso8859-8 iso-ir-138
+        iso8859-8 ISO_8859-8
+        iso8859-8 hebrew
+        iso8859-9 ISO_8859-9:1989
+        iso8859-9 iso-ir-148
+        iso8859-9 ISO_8859-9
+        iso8859-9 latin5
+        iso8859-9 l5
+        iso8859-10 iso-ir-157
+        iso8859-10 l6
+        iso8859-10 ISO_8859-10:1992
+        iso8859-10 latin6
+        iso8859-14 iso-ir-199
+        iso8859-14 ISO_8859-14:1998
+        iso8859-14 ISO_8859-14
+        iso8859-14 latin8
+        iso8859-14 iso-celtic
+        iso8859-14 l8
+        iso8859-15 ISO_8859-15
+        iso8859-15 Latin-9
+        iso8859-16 iso-ir-226
+        iso8859-16 ISO_8859-16:2001
+        iso8859-16 ISO_8859-16
+        iso8859-16 latin10
+        iso8859-16 l10
+        jis0201 X0201
+        jis0208 iso-ir-87
+        jis0208 x0208
+        jis0208 JIS_X0208-1983
+        jis0212 x0212
+        jis0212 iso-ir-159
+        ksc5601 iso-ir-149
+        ksc5601 KS_C_5601-1989
+        ksc5601 KSC5601
+        ksc5601 korean
+        shiftjis MS_Kanji
+        utf-8 UTF8
+    }
+
+    #*** !doctools
+    #[subsection {Namespace punk::encmime}]
+    #[para] Core API functions for punk::encmime 
+    #[list_begin definitions]
+
+    # ::mime::mapencoding --
+    #
+    #    mime::mapencodings maps tcl encodings onto the proper names for their
+    #    MIME charset type.  This is only done for encodings whose charset types
+    #    were known.  The remaining encodings return {} for now.
+    #
+    # Arguments:
+    #       enc      The tcl encoding to map.
+    #
+    # Results:
+    #    Returns the MIME charset type for the specified tcl encoding, or {}
+    #       if none is known.
+    proc mapencoding {enc} {
+        #*** !doctools
+        #[call mapencoding [arg enc]]
+        #[para]maps tcl encodings onto the proper names for their MIME charset type.
+        #[para]This is only done for encodings whose charset types were known.
+        #[para]The remaining encodings return {} for now.
+        #[para]NOTE: consider using tcllib's mime::mapencoding instead if mime package available
+
+        variable encodings
+        if {[info exists encodings($enc)]} {
+            return $encodings($enc)
+        }
+        return {}
+    }
+
+    proc reversemapencoding {mimeType} {
+        #*** !doctools
+        #[call reversemapencoding [arg mimeType]]
+        #[para]mime::reversemapencodings maps MIME charset types onto tcl encoding names.
+        #[para]Returns the tcl encoding name for the specified mime charset, or {} if none is known
+        #[para] Arguments:
+        #       [list_begin arguments]
+        #       [arg_def string mimeType]       The MIME charset to convert into a tcl encoding type.
+        #       [list_end]
+        #[para]NOTE: consider using tcllib's mime::reversemapencoding instead if mime package available
+
+        variable reversemap
+
+        set lmimeType [string tolower $mimeType]
+        if {[info exists reversemap($lmimeType)]} {
+            return $reversemap($lmimeType)
+        }
+        return {}
+    }
+
+
+
+    #*** !doctools
+    #[list_end] [comment {--- end definitions namespace punk::encmime ---}]
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+::apply {{} {
+    variable encList
+    variable encAliasList
+    variable reversemap
+    foreach {enc mimeType} $encList {
+        if {$mimeType eq {}} continue
+	    set reversemap([string tolower $mimeType]) $enc
+    }
+    foreach {enc mimeType} $encAliasList {
+        set reversemap([string tolower $mimeType]) $enc
+    }
+    # Drop the helper variables
+    unset encList encAliasList
+
+} ::punk::encmime}
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# Secondary API namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+namespace eval punk::encmime::lib {
+    namespace export *
+    namespace path [namespace parent]
+    #*** !doctools
+    #[subsection {Namespace punk::encmime::lib}]
+    #[para] Secondary functions that are part of the API 
+    #[list_begin definitions]
+
+    #proc utility1 {p1 args} {
+    #    #*** !doctools
+    #    #[call lib::[fun utility1] [arg p1] [opt {?option value...?}]]
+    #    #[para]Description of utility1 
+    #    return 1 
+    #}
+
+
+
+    #*** !doctools
+    #[list_end] [comment {--- end definitions namespace punk::encmime::lib ---}]
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[section Internal]
+namespace eval punk::encmime::system {
+    #*** !doctools
+    #[subsection {Namespace punk::encmime::system}]
+    #[para] Internal functions that are not part of the API 
+
+
+
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Ready   
+package provide punk::encmime [namespace eval punk::encmime {
+    variable pkg punk::encmime
+    variable version
+    set version 0.1.0 
+}]
+return
+
+#*** !doctools
+#[manpage_end]
+
diff --git a/src/bootsupport/modules/punk/mix-0.2.tm b/src/bootsupport/modules/punk/mix-0.2.tm
index 482c79a4..f24deb65 100644
--- a/src/bootsupport/modules/punk/mix-0.2.tm
+++ b/src/bootsupport/modules/punk/mix-0.2.tm
@@ -5,7 +5,12 @@ package require punk::cap::handlers::templates ;#handler for templates cap
 punk::cap::register_capabilityname punk.templates ::punk::cap::handlers::templates 
 
 package require punk::mix::templates ;#registers as provider pkg for 'punk.templates' capability with punk::cap
-punk::mix::templates::provider register *
+if {[catch {punk::mix::templates::provider register *} errM]} {
+    puts stderr "punk::mix failure during punk::mix::templates::provider register *"
+    puts stderr $errM
+    puts stderr "-----"
+    puts stderr $::errorInfo
+}
 
 package require punk::mix::base
 package require punk::mix::cli
diff --git a/src/bootsupport/modules/punk/mix/base-0.1.tm b/src/bootsupport/modules/punk/mix/base-0.1.tm
index 47f6c9d8..e9977bec 100644
--- a/src/bootsupport/modules/punk/mix/base-0.1.tm
+++ b/src/bootsupport/modules/punk/mix/base-0.1.tm
@@ -69,6 +69,8 @@ namespace eval punk::mix::base {
         
         set d_commands [get_commands -extension $extension]
         set all_commands [list {*}[dict get $d_commands main] {*}[dict get $d_commands base]]
+
+
         error "Unknown subcommand \"[lindex $args 0]\": must be one of: $all_commands" "punk::mix::base _unknown $ns $args" [list unknown_ensemble_subcommand ensemble punk::mix::base]
     }
     proc _redirected {from_ns subcommand args} {
@@ -93,6 +95,16 @@ namespace eval punk::mix::base {
             }
             tailcall [namespace current] $subcommand {*}$argvals {*}$args -extension $from_ns
         } else {
+            if {[regexp {.*[*?].*} $subcommand]} { 
+                set d_commands [get_commands -extension $from_ns]
+                set all_commands [list {*}[dict get $d_commands main] {*}[dict get $d_commands base]]
+                set matched_commands [lsearch -all -inline $all_commands $subcommand]
+                set commands "" 
+                foreach m $matched_commands {
+                    append commands $m \n
+                }
+                return $commands
+            }
             tailcall [namespace current] $subcommand {*}$args -extension $from_ns
         }
     }
@@ -269,7 +281,9 @@ namespace eval punk::mix::base {
 
         }
         #result for just 'pmix help'
+        puts stderr "-->$args"
         set helpstr ""
+        append helpstr "limit commandlist with a glob search such as *word*"
         append helpstr "commands:\n"
 
         foreach {source cmdlist} $command_info {
@@ -357,59 +371,24 @@ namespace eval punk::mix::base {
         }
 
         #get_template_basefolders
-        #   scriptpath - file or folder
-        #   It represents the base point from which to search for mixtemplates folders either directly related to the scriptpath (../) or in the containing project if any
+        #   startpath - file or folder
+        #   It represents the base point from which to search for templates folders either directly related to the scriptpath (../) or in the containing project if any
         #   The cwd will also be searched for project root - but with lower precedence in the resultset (later in list)
-        proc get_template_basefolders {{scriptpath ""}} {
-            #1 lowest precedence - templates from packages (ordered by order in which packages registered with punk::cap)
-            set folderdict [dict create]
+        proc get_template_basefolders {{startpath ""}} {
+            # templates from punk.templates provider packages (ordered by order in which packages registered with punk::cap)
+            if {[file isfile $startpath]} {
+                set startpath [file dirname $startpath]
+            }
 
             package require punk::cap
             if {[punk::cap::capability_has_handler punk.templates]} {
-                set template_folder_dict [punk::cap::call_handler punk.templates folders]
-                dict for {dir folderinfo} $template_folder_dict {
-                    dict set folderdict $dir $folderinfo
-                }
-            }
-
-            #2 middle precedence - mixtemplates folder relative to cwd
-            set searchbase [pwd] 
-            set fld [file join $searchbase mixtemplates]
-            if {[file isdirectory $fld]} {
-                if {![dict exists $folderdict $fld]} {
-                    dict set folderdict $fld [list source $searchbase sourcetype cwd]
-                }
-            }
-            set pathinfo    [punk::repo::find_repos $searchbase]
-            set pwd_projectroot [dict get $pathinfo closest]
-            if {$pwd_projectroot ne ""} {
-                set fld [file join $pwd_projectroot src/mixtemplates]
-                if {![dict exists $folderdict $fld]} {
-                    dict set folderdict $fld [list source $pwd_projectroot sourcetype project]
-                }
+                set template_folder_dict [punk::cap::call_handler punk.templates folders -startdir $startpath]
+            } else {
+                put stderr "get_template_basefolders WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
             }
 
-            #3 highest precedence - mixtemplates relative to scriptpath argument
-            if {$scriptpath ne ""} {
-                if {[file type $scriptpath] eq "file"} {
-                    set searchbase [file dirname $scriptpath]
-                } else {
-                    set searchbase $scriptpath
-                }
-                if {[file isdirectory [file join $searchbase mixtemplates]]} {
-                    dict set folderdict [file join $searchbase mixtemplates] [list source $searchbase sourcetype pathsearch]
-                }
-                set pathinfo    [punk::repo::find_repos $searchbase]
-                set scriptpath_projectroot [dict get $pathinfo closest]
-                if {$scriptpath_projectroot ne ""} {
-                    set fld [file join $scriptpath_projectroot src/mixtemplates]
-                    if {[file isdirectory $fld]} {
-                        dict set folderdict $fld [list source $scriptpath_projectroot sourcetype project]
-                    }
-                }
-            }
             #don't sort - order in which encountered defines the precedence - with later overriding earlier
-            return $folderdict
+            return $template_folder_dict
         }
 
         proc module_subpath {modulename} {
diff --git a/src/bootsupport/modules/punk/mix/cli-0.3.tm b/src/bootsupport/modules/punk/mix/cli-0.3.tm
index a845285c..13d75d78 100644
--- a/src/bootsupport/modules/punk/mix/cli-0.3.tm
+++ b/src/bootsupport/modules/punk/mix/cli-0.3.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
@@ -128,7 +128,7 @@ namespace eval punk::mix::cli {
 
         #review - why can't we be anywhere in the project? 
         if {([file tail $sourcefolder] ne "src") || (![file exists $sourcefolder/make.tcl])} {
-            puts stderr "pmix make must be run from src folder containing make.tcl - unable to proceed (cwd: [pwd])"
+            puts stderr "deck make must be run from src folder containing make.tcl - unable to proceed (cwd: [pwd])"
             if {[string length $project_base]} {
                 if {[file exists $project_base/src] && [string tolower [pwd]] ne [string tolower $project_base/src]} {
                     puts stderr "Try cd to $project_base/src"
@@ -210,7 +210,7 @@ namespace eval punk::mix::cli {
 
         proc validate_modulename {modulename args} {
             set defaults [list\
-                -name_description modulename\
+                -errorprefix validate_modulename\
                 ]
             if {[llength $args] %2 != 0} {error "validate_modulename args must be name-value pairs: received '$args'"}
             set known_opts [dict keys $defaults]
@@ -221,18 +221,18 @@ namespace eval punk::mix::cli {
             }
             set opts [dict merge $defaults $args]
             # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_name_description            [dict get $opts -name_description]
+            set opt_errorprefix            [dict get $opts -errorprefix]
             # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
-            validate_name_not_empty_or_spaced $modulename -name_description $opt_name_description
+            validate_name_not_empty_or_spaced $modulename -errorprefix $opt_errorprefix
             set testname [string map [list :: ""] $modulename]
             if {[string first : $testname] >=0} {
-                error "$opt_name_description '$modulename' can only contain paired colons"
+                error "$opt_errorprefix '$modulename' can only contain paired colons"
             }
             set badchars [list - "$" "?" "*"]
             foreach bc $badchars {
                 if {[string first $bc $modulename] >= 0} {
-                    error "$opt_name_description '$modulename' can not contain character '$bc'"
+                    error "$opt_errorprefix '$modulename' can not contain character '$bc'"
                 }
             }
             return $modulename
@@ -240,7 +240,7 @@ namespace eval punk::mix::cli {
 
         proc validate_projectname {projectname args} {
             set defaults [list\
-                -name_description projectname\
+                -errorprefix projectname\
                 ]
             if {[llength $args] %2 != 0} {error "validate_modulename args must be name-value pairs: received '$args'"}
             set known_opts [dict keys $defaults]
@@ -251,21 +251,21 @@ namespace eval punk::mix::cli {
             }
             set opts [dict merge $defaults $args]
             # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_name_description            [dict get $opts -name_description]
+            set opt_errorprefix            [dict get $opts -errorprefix]
             # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            validate_name_not_empty_or_spaced $projectname -name_description $opt_name_description
+            validate_name_not_empty_or_spaced $projectname -errorprefix $opt_errorprefix
             set reserved_words [list etc lib bin modules src doc vendorlib vendormodules embedded runtime _aside _build]
             if {$projectname in $reserved_words } {
-                error "$opt_name_description '$projectname' cannot be one of reserved_words: $reserved_words"
+                error "$opt_errorprefix '$projectname' cannot be one of reserved_words: $reserved_words"
             }
             if {[string first "::" $projectname] >= 0} {
-                error "$opt_name_description '$projectname' cannot contain namespace separator '::'"
+                error "$opt_errorprefix '$projectname' cannot contain namespace separator '::'"
             }
             return $projectname 
         }
         proc validate_name_not_empty_or_spaced {name args} {
             set defaults [list\
-                -name_description projectname\
+                -errorprefix projectname\
                 ]
             if {[llength $args] %2 != 0} {error "validate_modulename args must be name-value pairs: received '$args'"}
             set known_opts [dict keys $defaults]
@@ -276,13 +276,13 @@ namespace eval punk::mix::cli {
             }
             set opts [dict merge $defaults $args]
             # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_name_description            [dict get $opts -name_description]
+            set opt_errorprefix            [dict get $opts -errorprefix]
             # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
             if {![string length $name]} {
-                error "$opt_name_description cannot be empty"
+                error "$opt_errorprefix cannot be empty"
             }
             if {[string length [string map [list " " "" \n "" \r "" \t ""] $name]] != [string length $name]} {
-                error "$opt_name_description cannot contain whitespace"
+                error "$opt_errorprefix cannot contain whitespace"
             }
             return $name
         }
@@ -364,7 +364,7 @@ namespace eval punk::mix::cli {
                     if {"project" in $repotypes} {
                         #punk project
                         if {![catch {package require textblock; package require patternpunk}]} {
-                           set result [textblock::join [textblock::join [>punk . logo] "  "] $result]
+                           set result [textblock::join [>punk . logo] "  " $result] 
                            append result \n
                         } 
                     }  
@@ -727,8 +727,8 @@ namespace eval punk::mix::cli {
         proc kettle_reinit {} {
             variable kettle_reset_bodies
             variable kettle_reset_args
-            foreach p [dict keys $kettle_reset_bodies] {
-                set b [dict get $kettle_reset_bodies $p]
+            dict for {p b} $kettle_reset_bodies {
+                #set b [dict get $kettle_reset_bodies $p]
                 set argl [dict get $kettle_reset_args $p]
                 uplevel 1 [list ::proc $p $argl $b]
             }
@@ -751,7 +751,7 @@ namespace eval punk::mix::cli {
                 gui\
             ]
             #set ::kettle::recipe::recipe [dict create]
-            foreach r [dict keys $::kettle::recipe::recipe] {
+            dict for {r -} $::kettle::recipe::recipe {
                 if {$r ni $standard_recipes} {
                     dict unset ::kettle::recipe::recipe $r
                 }
@@ -760,14 +760,14 @@ namespace eval punk::mix::cli {
         proc kettle_call {calltype args} {
             variable kettle_reset_bodies
             if {$calltype ni [list lib shell]} {
-                error "pmix kettle_call 1st argument must be one of: 'lib' for direct use of kettle module or 'shell' to call as separate process"
+                error "deck kettle_call 1st argument must be one of: 'lib' for direct use of kettle module or 'shell' to call as separate process"
             }
             if {$calltype eq "shell"} {
                 set kettleappfile [file dirname [info nameofexecutable]]/kettle
                 set kettlebatfile [file dirname [info nameofexecutable]]/kettle.bat
 
                 if {(![file exists $kettleappfile]) && (![file exists $kettlebatfile])} {
-                    error "pmix kettle_call unable to find installed kettle application file '$kettleappfile' (or '$kettlebatfile' if on windows)"
+                    error "deck kettle_call unable to find installed kettle application file '$kettleappfile' (or '$kettlebatfile' if on windows)"
                 }
                 if {[file exists $kettleappfile]} {
                     set kettlescript $kettleappfile
@@ -780,7 +780,7 @@ namespace eval punk::mix::cli {
             }
             set startdir [pwd]
             if {![file exists $startdir/build.tcl]} {
-                error "pmix kettle must be run from a folder containing build.tcl (cwd: [pwd])"
+                error "deck kettle must be run from a folder containing build.tcl (cwd: [pwd])"
             }
             if {[package provide kettle] eq ""} {
                 puts stdout "Loading kettle package - may be delay on first load ..."
@@ -797,7 +797,7 @@ namespace eval punk::mix::cli {
             }
             set first [lindex $args 0] 
             if {[string match @* $first]} {
-                error "pmix kettle doesn't support special operations - try calling tclsh kettle directly"
+                error "deck kettle doesn't support special operations - try calling tclsh kettle directly"
             }
             if {$first eq "-f"} {
                 set args [lassign $args __ path]
@@ -839,7 +839,7 @@ namespace eval punk::mix::cli {
                     --* {
                         #instead of using: kettle option known
                         if {$o ni $knownopts} {
-                            error "Unable to process unknown option $o." {} [list KETTLE (pmix)]
+                            error "Unable to process unknown option $o." {} [list KETTLE (deck)]
                         }
                         lappend opts $o [lindex $args 1]
                         #::kettle::option set $o [lindex $args 1]
diff --git a/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm b/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm
index 36a654b7..c742bb3a 100644
--- a/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm
@@ -44,7 +44,7 @@ namespace eval punk::mix::commandset::doc {
         }
         #user may delete the comment containing "--- punk::docgen::overwrites" and then manually edit, and we won't overwrite
         #we still generate output in src/docgen so user can diff and manually update if thats what they prefer
-        set oldfiles [punk::path::treefilenames $projectdir/src/doc _module_*.man]
+        set oldfiles [punk::path::treefilenames -dir $projectdir/src/doc _module_*.man]
         foreach maybedoomed $oldfiles {
             set fd [open $maybedoomed r]
             set data [read $fd]
@@ -93,7 +93,10 @@ namespace eval punk::mix::commandset::doc {
                 # -- --- --- --- --- ---
                 puts stdout "BUILDING DOCS at $projectdir/src/embedded from src/doc"
                 if {[catch {
-
+                    if {"::meta" eq [info commands ::meta]} {
+                        puts stderr "There appears to be a leftover ::meta command which is presumed to be from doctools. Destroying object"
+                        ::meta destroy
+                    }
                     punk::mix::cli::lib::kettle_call lib doc
                     #Kettle doc
 
@@ -213,7 +216,7 @@ namespace eval punk::mix::commandset::doc {
             }
             file mkdir $output_base
 
-            set matched_paths [punk::path::treefilenames $codesource_path *.tm -antiglob_paths {**/mix/templates/** **/mixtemplates/**}]
+            set matched_paths [punk::path::treefilenames -dir $codesource_path -antiglob_paths {**/mix/templates/** **/project_layouts/** **/decktemplates/**} *.tm]
             set count 0
             set newdocs [list] 
             set docgen_header_comments ""
diff --git a/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm b/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm
index 0a9ff2d4..9eede1f5 100644
--- a/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm
@@ -18,6 +18,7 @@
 ##  Requirements
 ##e.g package require frobz
 
+package require punk::args
 #sort of a circular dependency when commandset loaded by punk::mix::cli - that's ok, but this could theoretically be loaded by another cli and with another base
 package require punk::mix
 package require punk::mix::base
@@ -28,6 +29,7 @@ package require punk::mix::base
 namespace eval punk::mix::commandset::layout {
     namespace export *
 
+
     #per layout functions
     proc files {layout} {
         set allfiles [lib::layout_all_files $layout]
@@ -38,25 +40,17 @@ namespace eval punk::mix::commandset::layout {
         return [join $templatefiles \n]
     }
     proc templatefiles.relative {layout} {
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
 
-        set bases_containing_layout [list]
-        dict for {tbase folderinfo} $template_base_dict {
-           if {[file exists $tbase/layouts/$layout]} {
-                lappend bases_containing_layout $tbase
-           } 
-        }
-        if {![llength $bases_containing_layout]} {
-            puts stderr "Unable to locate folder for layout '$layout'"
-            puts stderr "searched [dict size $template_base_dict] template folders"
+        set layoutdict [lib::layouts_dict]
+        if {![dict exists $layoutdict $layout]} {
+            puts stderr "layout '$layout' not found."
             return
         }
-        set tpldir [lindex $bases_containing_layout end]
+        set layoutinfo [dict get $layoutdict $layout]
+        set layoutfolder [dict get $layoutinfo path]
 
-        set layout_base $tpldir/layouts
-        set layout_dir [file join $layout_base $layout]
 
-        set stripprefix [file normalize $layout_dir]
+        set stripprefix [file normalize $layoutfolder]
         set templatefiles [lib::layout_scan_for_template_files $layout]
         set tails [list]
         foreach templatefullpath $templatefiles {
@@ -68,46 +62,150 @@ namespace eval punk::mix::commandset::layout {
     #layout collection functions - to be imported with punk::overlay::import_commandset separately
     namespace eval collection {
         namespace export *
-        proc _default {{glob {}}} {
+        proc _defaultx {{glob {}}} {
             if {![string length $glob]} {
                 set glob *
             }
             set layouts [list]
-            #set tplfolderdict [punk::cap::call_handler punk.templates folders]
-            set tplfolderdict [punk::mix::base::lib::get_template_basefolders]
-            dict for {tdir folderinfo} $tplfolderdict {
-                set layout_base $tdir/layouts
-                #collect all layouts and use lsearch glob rather than the filesystem glob (avoid issues with dotted folder names)
-                set all_layouts [lsort [glob -nocomplain -dir $layout_base -type d -tail *]]
-                foreach match [lsearch -all -inline $all_layouts $glob] {
-                   lappend layouts [list $match $folderinfo] 
-                }
+            set layoutdict [punk::cap::call_handler punk.templates get_itemdict_projectlayouts]
+            #set tplfolderdict [punk::mix::base::lib::get_template_basefolders]
+            dict for {layoutname layoutinfo} $layoutdict {
+                lappend layouts [list $layoutname $layoutinfo]
+            }
+            #return [join [lsort -index 0 $layouts] \n]
+            return [join $layouts \n]
+        }
+
+        proc _default {args} {
+            set tdict_low_to_high [as_dict {*}$args]
+            #convert to screen order - with higher priority at the top
+            set tdict [dict create]
+            foreach k [lreverse [dict keys $tdict_low_to_high]] {
+                dict set tdict $k [dict get $tdict_low_to_high $k]
+            }
+
+            package require overtype
+            package require textblock
+            #set pathinfolist [dict values $tdict]
+            #set paths [lsearch -all -inline -index 1 -subindices $pathinfolist *] ;#relies on first key of templates_dict being path
+
+            set names [dict keys $tdict]
+            set paths [list]
+            set pathtypes [list]
+            dict for {nm tinfo} $tdict {
+                lappend paths [dict get $tinfo path]
+                lappend pathtypes [dict get $tinfo sourceinfo pathtype]
+            }
+
+            set title(path) "Path"
+            set widest(path) [tcl::mathfunc::max {*}[lmap v [concat [list $title(path)] $paths] {punk::strlen $v}]]
+            set col(path) [string repeat " " $widest(path)] 
+
+            set title(pathtype) "[a+ green]Path Type[a]"
+            set widest(pathtype) [tcl::mathfunc::max {*}[lmap v [concat [list $title(pathtype)] $pathtypes] {punk::strlen $v}]]
+            set col(pathtype)    [string repeat " " $widest(pathtype)]
+
+            set title(name) "Layout Name"
+            set widest(name) [tcl::mathfunc::max {*}[lmap v [concat [list $title(name)] $names] {punk::strlen $v}]]
+            set col(name) [string repeat " " $widest(name)]
+
+            set vsep " | "
+            set vsep_w [string length $vsep] ;#unicode?
+            set tablewidth [expr {$widest(name) + $vsep_w + $widest(pathtype) + $vsep_w + $widest(path)}]
+            set table ""
+            append table [string repeat - $tablewidth] \n
+            append table "[textblock::join [overtype::left $col(name) $title(name)] $vsep [overtype::left $col(pathtype) $title(pathtype)] $vsep [overtype::left $col(path) $title(path)]]" \n
+            append table [string repeat - $tablewidth] \n
+
+            foreach n $names pt $pathtypes p $paths {
+            append table "[textblock::join [overtype::left $col(name) $n] $vsep [overtype::left $col(pathtype) $pt] $vsep [overtype::left $col(path) $p]]" \n 
+            }
+
+            return $table
+        }
+        proc references {args} {
+            set tdict_low_to_high [references_as_dict {*}$args]
+            #convert to screen order - with higher priority at the top
+            set tdict [dict create]
+            foreach k [lreverse [dict keys $tdict_low_to_high]] {
+                dict set tdict $k [dict get $tdict_low_to_high $k]
             }
-            return [join [lsort -index 0 $layouts] \n]
+
+            package require overtype
+            package require textblock
+            #set pathinfolist [dict values $tdict]
+            #set paths [lsearch -all -inline -index 1 -subindices $pathinfolist *] ;#relies on first key of templates_dict being path
+
+            set names [dict keys $tdict]
+            set paths [list]
+            set pathtypes [list]
+            dict for {nm tinfo} $tdict {
+                lappend paths [dict get $tinfo path]
+                lappend pathtypes [dict get $tinfo sourceinfo pathtype]
+            }
+
+            set title(path) "Path"
+            set widest(path) [tcl::mathfunc::max {*}[lmap v [concat [list $title(path)] $paths] {punk::strlen $v}]]
+            set col(path) [string repeat " " $widest(path)] 
+
+            set title(pathtype) "[a+ green]Path Type[a]"
+            set widest(pathtype) [tcl::mathfunc::max {*}[lmap v [concat [list $title(pathtype)] $pathtypes] {punk::strlen $v}]]
+            set col(pathtype)    [string repeat " " $widest(pathtype)]
+
+            set title(name) "Layout Name"
+            set widest(name) [tcl::mathfunc::max {*}[lmap v [concat [list $title(name)] $names] {punk::strlen $v}]]
+            set col(name) [string repeat " " $widest(name)]
+
+            set vsep " | "
+            set vsep_w [string length $vsep] ;#unicode?
+            set tablewidth [expr {$widest(name) + $vsep_w + $widest(pathtype) + $vsep_w + $widest(path)}]
+            set table ""
+            append table [string repeat - $tablewidth] \n
+            append table "[textblock::join [overtype::left $col(name) $title(name)] $vsep [overtype::left $col(pathtype) $title(pathtype)] $vsep [overtype::left $col(path) $title(path)]]" \n
+            append table [string repeat - $tablewidth] \n
+
+            foreach n $names pt $pathtypes p $paths {
+                append table "[textblock::join [overtype::left $col(name) $n] $vsep [overtype::left $col(pathtype) $pt] $vsep [overtype::left $col(path) $p]]" \n 
+            }
+
+            return $table
         }
 
+        proc as_dict {args} {
+            tailcall punk::mix::commandset::layout::lib::layouts_dict {*}$args
+        }
+        proc references_as_dict {args} {
+            package require punk::cap
+            if {[punk::cap::capability_has_handler punk.templates]} {
+                set ref_dict [punk::cap::call_handler punk.templates get_itemdict_projectlayoutrefs {*}$args]
+            } else {
+                put stderr "commandset::layout::lib::layouts_dict WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
+            }
+            return $ref_dict
+        }        
     }
     namespace eval lib {
+        proc layouts_dict {args} {
+            package require punk::cap
+            if {[punk::cap::capability_has_handler punk.templates]} {
+                set layout_dict [punk::cap::call_handler punk.templates get_itemdict_projectlayouts {*}$args]
+            } else {
+                put stderr "commandset::layout::lib::layouts_dict WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
+            }
+            return $layout_dict
+        }        
+        
         proc layout_all_files {layout} {
-            set tplbasedict [punk::mix::base::lib::get_template_basefolders]
-            set layouts_found [list]
-            dict for {tplbase folderinfo} $tplbasedict {
-                if {[file isdirectory $tplbase/layouts/$layout]} {
-                    lappend layouts_found $tplbase/layouts/$layout
-                }
-            } 
-            if {![llength $layouts_found]} {
+            #todo - allow versionless layout name to pick highest version found
+            set layoutdict [layouts_dict]
+            if {![dict exists $layoutdict $layout]} {
                 puts stderr "layout '$layout' not found."
-                puts stderr "searched [dict size $tplbasedict] template folders"
-                dict for {tplbase pkg} $tplbasedict {
-                    puts stderr " - $tplbase $pkg"
-                }
                 return
             }
-            set layoutfolder [lindex $layouts_found end]
-
+            set layoutinfo [dict get $layoutdict $layout]
+            set layoutfolder [dict get $layoutinfo path]
             if {![file isdirectory $layoutfolder]} {
-                puts stderr "layout '$layout' not found in /layouts within one of template_folders. (get_template_folder returned: $tplbasedict)"
+                puts stderr "layout '$layout' points to path $layoutfolder - but it doesn't seem to exist"
             }
             set file_list [list] 
             util::foreach-file $layoutfolder path {
@@ -118,25 +216,15 @@ namespace eval punk::mix::commandset::layout {
         }
 
         # 
-        #todo - allow specifying which package the layout is from:  e.g "punk::mix::templates project" ??
         proc layout_scan_for_template_files {layout {tags {}}} {
-            #equivalent for projects? punk::mix::commandset::module::lib::templates_dict  -scriptpath "" 
-            set tplbasedict [punk::mix::base::lib::get_template_basefolders]
-            set layouts_found [list]
-            dict for {tpldir pkg} $tplbasedict {
-                if {[file isdirectory $tpldir/layouts/$layout]} {
-                    lappend layouts_found $tpldir/layouts/$layout
-                }
-            } 
-            if {![llength $layouts_found]} {
+            #todo JMN
+            set layoutdict [layouts_dict]
+            if {![dict exists $layoutdict $layout]} {
                 puts stderr "layout '$layout' not found."
-                puts stderr "searched [dict size $tplbasedict] template folders"
-                dict for {tpldir pkg} $tplbasedict {
-                    puts stderr " - $tpldir $pkg"
-                }
                 return
             }
-            set layoutfolder [lindex $layouts_found end]
+            set layoutinfo [dict get $layoutdict $layout]
+            set layoutfolder [dict get $layoutinfo path]
 
             #use last matching layout found.  review silent if multiple?
             if {![llength $tags]} {
diff --git a/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm b/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm
index 0028c439..3bbe8b47 100644
--- a/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm
@@ -419,7 +419,7 @@ namespace eval punk::mix::commandset::loadedlib {
         if {![file exists $source_file]} {
             error "Unable to verify source file existence at: $source_file"
         }
-        set source_data [fcat $source_file -translation binary] 
+        set source_data [fcat -translation binary $source_file] 
         if {![string match "*package provide*" $source_data]} {
             puts stderr "Sorry - unable to verify source file contains 'package provide' statement of some sort  - copy manually"
             return false
diff --git a/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm b/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm
index 19fbadb3..013c3bb8 100644
--- a/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
@@ -9,7 +9,7 @@
 # @@ Meta Begin
 # Application punk::mix::commandset::module 0.1.0
 # Meta platform     tcl
-# Meta license      <unspecified>
+# Meta license      BSD 
 # @@ Meta End
 
 
@@ -17,8 +17,8 @@
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Requirements
 ##e.g package require frobz
-
-
+package require punk::repo
+# depends on punk,punk::mix::base,punk::mix::cli
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
@@ -76,45 +76,69 @@ namespace eval punk::mix::commandset::module {
     }
     #require current dir when calling to be the projectdir, or 
     proc templates {args} {
-        set tdict [templates_dict {*}$args]
+        set tdict_low_to_high [templates_dict {*}$args]
+        #convert to screen order - with higher priority at the top
+        set tdict [dict create]
+        foreach k [lreverse [dict keys $tdict_low_to_high]] {
+            dict set tdict $k [dict get $tdict_low_to_high $k]
+        }
+
+        package require overtype
+        package require textblock
+        #set pathinfolist [dict values $tdict]
+        #set paths [lsearch -all -inline -index 1 -subindices $pathinfolist *] ;#relies on first key of templates_dict being path
 
-        package require overtype       
-        set paths [dict values $tdict]
         set names [dict keys $tdict]
+        set paths [list]
+        set pathtypes [list]
+        dict for {nm tinfo} $tdict {
+            lappend paths [dict get $tinfo path]
+            lappend pathtypes [dict get $tinfo sourceinfo pathtype]
+        }
+
+        set title(path) "Path"
+        set widest(path) [tcl::mathfunc::max {*}[lmap v [concat [list $title(path)] $paths] {punk::strlen $v}]]
+        set col(path) [string repeat " " $widest(path)] 
 
-        set title1 "Path"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $paths] {punk::strlen $v}]]
-        set col1 [string repeat " " $widest1] 
+        set title(pathtype) "[a+ green]Path Type[a]"
+        set widest(pathtype) [tcl::mathfunc::max {*}[lmap v [concat [list $title(pathtype)] $pathtypes] {string length $v}]]
+        set col(pathtype)    [string repeat " " $widest(pathtype)]
 
-        set title2 "Template Name"
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $names] {punk::strlen $v}]]
-        set col2 [string repeat " " $widest2]
+        set title(name) "Template Name"
+        set widest(name) [tcl::mathfunc::max {*}[lmap v [concat [list $title(name)] $names] {string length $v}]]
+        set col(name) [string repeat " " $widest(name)]
 
-        set tablewidth [expr {$widest1 + 1 + $widest2}]
+        set tablewidth [expr {$widest(name) + 1 + $widest(pathtype) + 1 + $widest(name)}]
         set table ""
         append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col1 $title1] [overtype::left $col2 $title2]" \n
+        append table "[textblock::join [overtype::left $col(name) $title(name)] " " [overtype::left $col(pathtype) $title(pathtype)] " " [overtype::left $col(path) $title(path)]]" \n
         append table [string repeat - $tablewidth] \n
 
-        foreach p $paths n $names {
-           append table "[overtype::left $col1 $p] [overtype::left $col2 $n]" \n 
+        foreach n $names pt $pathtypes p $paths {
+           append table "[overtype::left $col(name) $n] [overtype::left $col(pathtype) $pt] [overtype::left $col(path) $p]" \n 
         }
 
         return $table
     }
     #return all module templates with repeated ones suffixed with .2 .3 etc
     proc templates_dict {args} {
-        tailcall lib::templates_dict {*}$args
-    }
+        package require punk::cap
+        if {[punk::cap::capability_has_handler punk.templates]} {
+            set template_folder_dict [punk::cap::call_handler punk.templates get_itemdict_moduletemplates {*}$args]
+        } else {
+            put stderr "get_template_basefolders WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
+        }
+    }        
     proc new {module args} {
         set year [clock format [clock seconds] -format %Y]
         set defaults [list\
             -project \uFFFF\
             -version \uFFFF\
             -license <unspecified>\
-            -template module-0.0.1.tm\
+            -template punk.module\
             -type \uFFFF\
             -force 0\
+            -quiet 0\
             ]
         set opts [dict merge $defaults $args]
 
@@ -133,7 +157,7 @@ namespace eval punk::mix::commandset::module {
         } else {
             set opt_version $opt_version_supplied
             if {![util::is_valid_tm_version $opt_version]} {
-                error "pmix module.new error - supplied -version $opt_version doesn't appear to be a valid Tcl module version"
+                error "deck module.new error - supplied -version $opt_version doesn't appear to be a valid Tcl module version"
             }
         }
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
@@ -144,7 +168,7 @@ namespace eval punk::mix::commandset::module {
             #if it has a dash then version is required to be valid
             lassign [punk::mix::cli::lib::split_modulename_version $module] modulename mversion
             if {![util::is_valid_tm_version $mversion]} {
-                error "pmix module.new error - unable to determine modulename-version from supplied value '$module'"
+                error "deck module.new error - unable to determine modulename-version from supplied value '$module'"
             }
             set mversion_supplied $mversion ;#record as may need to compare to version from templatefile name
             set vcompare_is_mversion_bigger [package vcompare $mversion $opt_version]
@@ -163,15 +187,15 @@ namespace eval punk::mix::commandset::module {
         } else {
             set modulename $module
         }
-        punk::mix::cli::lib::validate_modulename $modulename -name_description "mix module.new name"
+        punk::mix::cli::lib::validate_modulename $modulename -errorprefix "punk::mix::commandset::module::new"
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
         #options
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_project                             [dict get $opts -project]
+        set opt_project                            [dict get $opts -project]
         set testdir [pwd]
         if {![string length [set projectdir [punk::repo::find_project $testdir]]]} {
             if {![string length [set projectdir [punk::repo::find_candidate $testdir]]]} {
-                set msg [punkc::repo::is_candidate_root_requirements_msg]
+                set msg [punk::repo::is_candidate_root_requirements_msg]
                 error "module.new unable to create module in projectdir:$projectdir - directory doesn't appear to meet basic standards $msg"
             }
         }
@@ -187,13 +211,60 @@ namespace eval punk::mix::commandset::module {
         set opt_license                             [dict get $opts -license]
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
         set opt_template                            [dict get $opts -template]
+        if {[regexp {.*[?*].*} $opt_template]} {
+            error "module.new -template does not support glob chars. Use an exact full name including version (and optionally .tm) - or use just the name without version or .tm, and the latest version will be selected"
+        }
 
-        set templates_dict [templates_dict] ;#possibly suffixed with .2 .3 etc
-        #todo - allow versionless name - pick latest which isn't suffixed with .2 etc
-        if {![dict exists $templates_dict $opt_template]} {
-            error "module.new unable to find template '$opt_template'. Known templates: [dict keys $templates_dict]"
+        set templates_dict [templates_dict] ;#keys are possibly prefixed with <vendor>. and/or suffixed with #2 #3 etc if there are collisions - the remaining unsuffixed being the one with highest preference
+        #todo - allow versionless name - pick latest which isn't suffixed with #2 etc
+        #if the user wants to exactly match an unversioned template, in the presence of versioned ones - they may need to include the trailing .tm
+        if {[dict exists $templates_dict $opt_template]} {
+            #exact long name (possibly including version) 
+            #Note - an unversioned .tm template will be matched here - even though versioned templates of the same name may exist.
+            set templatefile        [dict get $templates_dict $opt_template path]
+            set templatefile_info   [dict get $templates_dict $opt_template sourceinfo]
+        } else {
+            #if it wasn't an exact match for opt_template - then opt_template now shouldn't contain a version  (we have also ruled out glob chars * & ? above)
+            #(if it does - then we just won't find anything - which is fine)
+            #module file name could contain dots - but only one dash - if it is versioned
+
+            set matches [lsearch -all -inline [dict keys $templates_dict] $opt_template-*]  ;#the key is of form vendor.modulename-version(#suffix)  (version optional, suffix if lower precedence with same name was found)
+            #only .tm (or .TM .Tm .tM) files make it into the templates_dict - they are allowed to be unversioned though.
+            set key_version_list [list]
+            foreach m $matches {
+                #vendorname could contain dashes or dots - so easiest way to split out is to examine the stored vendor value in sourceinfo
+                set vendor [dict get $templates_dict $m sourceinfo vendor] 
+                if {$vendor ne "_project"} {
+                    #_project special case - not included in module names
+                    set module $m
+                } else {
+                    set module [string range [string length $vendor.] end]
+                }
+                lassign [punk::mix::cli::lib::split_modulename_version $m] _tailmname mversion
+                lappend key_version_list [list $m $mversion]
+            } 
+            if {[llength $matches]} {
+                set highest_m ""
+                set highest_v ""
+                foreach kv $key_version_list {
+                    if {$highest_v eq ""} {
+                        set highest_m [lindex $kv 0]
+                        set highest_v [lindex $kv 1]
+                    } else {
+                        if {[package vcompare $highest_v [lindex $kv 1]] == -1} {
+                            set highest_m [lindex $kv 0]
+                            set highest_v [lindex $kv 1]
+                        }
+                    }
+                }
+                set templatefile       [dict get $templates_dict $highest_m path]
+                set templatefile_info   [dict get $templates_dict $highest_m sourceinfo]
+            } else {
+                error "module.new unable to find template '$opt_template'. [dict size $templates_dict] Known templates. Use deck module.templates to display"
+            }
         }
-        set templatefile [dict get $templates_dict $opt_template]
+
+
         set tpldir [file dirname $templatefile] ;#use same folder for modulename_buildversion.txt, modulename_description.txt if they exist
 
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
@@ -205,6 +276,8 @@ namespace eval punk::mix::commandset::module {
             error "module.new - error - unknown -type '$opt_type' known-types: [punk::mix::cli::lib::module_types]"
         }
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+        set opt_quiet                               [dict get $opts -quiet]
+        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
 
 
@@ -253,6 +326,8 @@ namespace eval punk::mix::commandset::module {
             if {$opt_version_supplied ne "\uFFFF"} {
                 set build_version $opt_version
             } else {
+                #
+
                 if {[util::is_valid_tm_version $t_version]} {
                     if {$mversion_supplied eq ""} {
                         set build_version $t_version
@@ -273,7 +348,19 @@ namespace eval punk::mix::commandset::module {
             set infile_version $build_version
         }
 
-        set template_filedata [string map [list %project% $projectname %pkg% $modulename %year% $year %license% $opt_license %version% $infile_version] $template_filedata]
+        set moduletemplate [file join $projectname [punk::path::relative $projectdir $templatefile]] ;#if templatfile is on another volume - just $templatefile will be returned.
+        #moduletemplate should usually be a relative path - but could be absolute, or contain info about the relative locations of projectdir vs templatefile if template comes from another project or a module outside the project
+        #This path info may be undesired in the template output (%moduletemplate%)
+        #it is nevertheless useful information - and not the only way developer-machine/build-machine paths can leak
+        #for now the user has the option to override any templates and remove %moduletemplate% if it is a security/privacy concern
+        
+        #Don't put litera %x% in the code for the commandset::module itself - to stop them being seen by layout scanner as replacable tokens 
+        set tagnames [list moduletemplate $moduletemplate project $projectname pkg $modulename year $year license $opt_license version $infile_version]
+        set strmap [list]
+        dict for {tag val} $tagnames {
+            lappend strmap %$tag% $val
+        }
+        set template_filedata [string map $strmap $template_filedata]
 
         set modulefile $modulefolder/${moduletail}-$infile_version.tm
         if {[file exists $modulefile]} {
@@ -330,7 +417,9 @@ namespace eval punk::mix::commandset::module {
             }
         }
 
-
+        if {!$opt_quiet} {
+            puts stdout "Creating $modulefile from template $moduletemplate"
+        }
         set fd [open $modulefile w]
         fconfigure $fd -translation binary
         puts -nonewline $fd $template_filedata
@@ -347,50 +436,8 @@ namespace eval punk::mix::commandset::module {
     }
 
     namespace eval lib {
-        proc templates_dict {args} {
-            set defaults [list -scriptpath ""]
-            set opts [dict merge $defaults $args]
-            set opt_scriptpath [dict get $opts -scriptpath]
-
-            set module_template_bases [list]
-            set tbasedict [punk::mix::base::lib::get_template_basefolders $opt_scriptpath]
-            dict for {tbase folderinfo} $tbasedict {
-                lappend module_template_bases [file join $tbase modules]
-            }
-
 
 
-            set template_files [list]
-            foreach basefld $module_template_bases {
-                set matched_files [glob -nocomplain -dir $basefld -type f template_*]
-                foreach tf $matched_files {
-                    if {[string match ignore* $tf]} {
-                        continue
-                    }
-                    set ext [file extension $tf]
-                    if {$ext in [list ".tm"]} {
-                        lappend template_files $tf
-                    }
-                }
-            }
-
-            set tdict [dict create]
-            set seen_dict [dict create]
-            foreach fullpath $template_files {
-                set ftail [file tail $fullpath]
-                set tname [string range $ftail [string length template_] end]
-                if {![dict exists $seen_dict $tname]} {
-                    dict set seen_dict $tname 1 
-                    dict set tdict $tname $fullpath ; #first seen of filename gets no number
-                } else {
-                    set n [dict get $seen_dict $tname]
-                    incr n
-                    dict incr seen_dict $tname
-                    dict set tdict ${tname}.$n $fullpath
-                }
-            }
-            return $tdict
-        }
     }
 
 
diff --git a/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm b/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm
index d8da3a47..badfa87d 100644
--- a/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
@@ -19,8 +19,8 @@
 #*** !doctools
 #[manpage_begin punkshell_module_punk::mix::commandset::project 0 0.1.0]
 #[copyright "2023"]
-#[titledesc {pmix commandset - project}]  [comment {-- Name section and table of contents description --}]
-#[moddesc {pmix CLI commandset - project}]             [comment {-- Description at end of page heading --}] 
+#[titledesc {dec commandset - project}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {deck CLI commandset - project}]             [comment {-- Description at end of page heading --}] 
 #[require punk::mix::commandset::project]
 #[description]
 
@@ -129,7 +129,7 @@ namespace eval punk::mix::commandset::project {
             error "punk::mix::cli::new error: unable to determine containing folder for '$newprojectpath_or_name'"
         }
 
-        punk::mix::cli::lib::validate_projectname $projectname -name_description "punk mix project.new"
+        punk::mix::cli::lib::validate_projectname $projectname -errorprefix "punk mix project.new"
 
 
         set defaults [list\
@@ -139,7 +139,7 @@ namespace eval punk::mix::commandset::project {
             -update 0\
             -confirm 1\
             -modules \uFFFF\
-            -layout project
+            -layout punk.project
         ] ;#todo
         set known_opts [dict keys $defaults]
         foreach {k v} $args {
@@ -151,7 +151,7 @@ namespace eval punk::mix::commandset::project {
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
         set opt_type                                [dict get $opts -type]
         if {$opt_type ni [punk::mix::cli::lib::module_types]} {
-            error "pmix new error - unknown type '$opt_type' known types: [punk::mix::cli::lib::module_types]"
+            error "deck new error - unknown type '$opt_type' known types: [punk::mix::cli::lib::module_types]"
         }
         # -- --- --- --- --- --- --- --- --- --- --- --- ---
         set opt_force                               [dict get $opts -force]
@@ -170,10 +170,10 @@ namespace eval punk::mix::commandset::project {
 
         set fossil_prog [auto_execok fossil]
         if {![string length $fossil_prog]} {
-            puts stderr "The fossil program was not found. A fossil executable is required to use most pmix features."
+            puts stderr "The fossil program was not found. A fossil executable is required to use most deck features."
             if {[string length [set scoop_prog [auto_execok scoop]]]} {
                 #restrict to windows?
-                set answer [util::askuser "scoop detected. Would you like pmix to install fossil now using scoop? Y|N"]
+                set answer [util::askuser "scoop detected. Would you like deck to install fossil now using scoop? Y|N"]
                 if {[string tolower $answer] ne "y"} {
                     puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
                     return
@@ -216,23 +216,31 @@ namespace eval punk::mix::commandset::project {
             puts stdout "This project will be searched for templates"
             puts stdout "-------------------------------------------"
         }
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-        set template_bases_containing_layout [list]
-        dict for {tbase folderinfo} $template_base_dict {
-           if {[file exists $tbase/layouts/$opt_layout]} {
-                lappend template_bases_containing_layout $tbase
-           } 
+
+
+        package require punk::cap
+        if {[punk::cap::capability_has_handler punk.templates]} {
+            set layout_dict [punk::cap::call_handler punk.templates get_itemdict_projectlayouts]
+        } else {
+            put stderr "commandset::project::new WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide layout locations"
+            return
         }
-        if {![llength $template_bases_containing_layout]} {
-            puts stderr "layout '$opt_layout' was not found in template dirs"
-            puts stderr "searched [dict size $template_base_dict] template folders"
-            dict for  {tbase folderinfo} $template_base_dict {
-                puts stderr " - $tbase $folderinfo"
-            }
+        if {[dict exists $layout_dict $opt_layout]} {
+            set layout_name $opt_layout
+            set layout_info [dict get $layout_dict $layout_name]
+            set layout_path [dict get $layout_info path]
+            set layout_sourceinfo [dict get $layout_info sourceinfo]
+        } else {
+            puts stderr "commandset::project::new - no exact match for specified layout-name $opt_layout found"
+            puts stderr "layout names found: [dict keys $layout_dict]"
             return
+
+            #todo - pick highest version layout that matches opt_layout if version not specified but multiple exist
+
+            #set layout_name ...
+            #set layout_info ..
+            #set layout_path ...
         }
-        #review: silently use last entry which had the layout (?)
-        set templatebase [lindex $template_bases_containing_layout end]
 
 
 
@@ -275,7 +283,7 @@ namespace eval punk::mix::commandset::project {
             puts stderr "Unable to create new project at $projectdir - file/folder already exists use -update 1 to fill in missing items from template use -force 1 to overwrite from template"
             return
         } elseif {$project_dir_exists && $opt_force} {
-            puts stderr "mix new WARNING: -force 1 was supplied. Will copy layout $templatebase/layouts/$opt_layout using -force option to overwrite from template"
+            puts stderr "mix new WARNING: -force 1 was supplied. Will copy layout $layout_path using -force option to overwrite from template"
             if {$opt_confirm ni [list 0 no false]} {
                 set answer [util::askuser "Do you want to proceed to possibly overwrite existing files in $projectdir? Y|N"]
                 if {[string tolower $answer] ne "y"} {
@@ -284,7 +292,7 @@ namespace eval punk::mix::commandset::project {
                 }
             }
         } elseif {$project_dir_exists && $opt_update} {
-            puts stderr "mix new WARNING: -update 1 was supplied. Will copy layout $templatebase/layouts/$opt_layout using -update option to add missing items"
+            puts stderr "mix new WARNING: -update 1 was supplied. Will copy layout $layout_path using -update option to add missing items"
         }
 
         set fossil_repo_file "" 
@@ -325,29 +333,38 @@ namespace eval punk::mix::commandset::project {
             }
         }
 
+        #
+
+
+
         file mkdir $projectdir
 
-        set layout_dir $templatebase/layouts/$opt_layout
-        puts stdout ">>> about to call punkcheck::install $layout_dir $projectdir" 
+        puts stdout ">>> about to call punkcheck::install $layout_path $projectdir" 
         set resultdict [dict create]
         set antipaths [list\
             src/doc/*\
             src/doc/include/*\
+            src/PROJECT_LAYOUTS_*\
+        ]
+
+        #set antiglob_dir [list\
+        #    _ignore_*\
+        #]
+        set antiglob_dir [list\
         ]
 
         #default antiglob_dir_core will stop .fossil* from being updated - which is generally desirable as these are likely to be customized
         if {$opt_force} {
             puts stdout "copying layout files - with force applied - overwrite all-targets" 
-            set resultdict [punkcheck::install $layout_dir $projectdir -installer project.new  -overwrite ALL-TARGETS -antiglob_paths $antipaths]
-            #file copy -force $layout_dir $projectdir
+            set resultdict [punkcheck::install $layout_path $projectdir -installer project.new  -overwrite ALL-TARGETS -antiglob_paths $antipaths -antiglob_dir $antiglob_dir]
         } else {
             puts stdout "copying layout files - (if source file changed)" 
-            set resultdict [punkcheck::install $layout_dir $projectdir -installer project.new -overwrite installedsourcechanged-targets -antiglob_paths $antipaths]
+            set resultdict [punkcheck::install $layout_path $projectdir -installer project.new -overwrite installedsourcechanged-targets -antiglob_paths $antipaths -antiglob_dir $antiglob_dir]
         }
         puts stdout [punkcheck::summarize_install_resultdict $resultdict]
 
         puts stdout "copying layout src/doc files (if target missing)"
-        set resultdict [punkcheck::install $layout_dir/src/doc $projectdir/src/doc -punkcheck_folder $projectdir -installer project.new  -overwrite SYNCED-TARGETS]
+        set resultdict [punkcheck::install $layout_path/src/doc $projectdir/src/doc -punkcheck_folder $projectdir -installer project.new  -overwrite SYNCED-TARGETS]
         puts stdout [punkcheck::summarize_install_resultdict $resultdict]
 
         #target folders .fossil-custom and .fossil-settings may not exist. use -createdir 1 to ensure existence. 
@@ -355,33 +372,33 @@ namespace eval punk::mix::commandset::project {
         ## default_antiglob_dir_core  [list "#*" "_aside" ".git" ".fossil*"]
         set override_antiglob_dir_core [list #* _aside .git] 
         puts stdout "copying layout src/.fossil-custom files (if target missing or uncustomised)"
-        set resultdict [punkcheck::install $layout_dir/.fossil-custom $projectdir/.fossil-custom -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
+        set resultdict [punkcheck::install $layout_path/.fossil-custom $projectdir/.fossil-custom -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
         puts stdout [punkcheck::summarize_install_resultdict $resultdict]
 
         puts stdout "copying layout src/.fossil-settings files (if target missing or uncustomised)"
-        set resultdict [punkcheck::install $layout_dir/.fossil-settings $projectdir/.fossil-settings -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
+        set resultdict [punkcheck::install $layout_path/.fossil-settings $projectdir/.fossil-settings -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
         puts stdout [punkcheck::summarize_install_resultdict $resultdict]
 
-
-
-
-        #lappend substfiles $projectdir/README.md
-        #lappend substfiles $projectdir/src/README.md
-        #lappend substfiles $projectdir/src/doc/main.man
-        #expect this in all templates? - todo make these substitutions independent of specific paths and filenames?
         #scan all files in template 
         #
-        #TODO - pmix command to substitute templates? 
+        #TODO - deck command to substitute templates? 
         set templatefiles [punk::mix::commandset::layout::lib::layout_scan_for_template_files $opt_layout]
-        set stripprefix [file normalize $layout_dir]
+        set stripprefix [file normalize $layout_path]
 
+        set tagmap [list [lib::template_tag project] $projectname]
+        if {[llength $templatefiles]} {
+            puts stdout "Filling template file placeholders with the following tag map:"
+            dict for {placeholder value} $tagmap {
+                puts stdout "  $placeholder -> $value" 
+            }
+        }
         foreach templatefullpath $templatefiles {
             set templatetail [punk::repo::path_strip_alreadynormalized_prefixdepth $templatefullpath $stripprefix]
 
             set fpath [file join $projectdir $templatetail]
             if {[file exists $fpath]} {
                 set fd [open $fpath r]; fconfigure $fd -translation binary; set data [read $fd]; close $fd
-                set data2 [string map [list [lib::template_tag project] $projectname] $data]
+                set data2 [string map $tagmap $data]
                 if {$data2 ne $data} {
                     puts stdout "updated template file: $fpath"
                     set fdout [open $fpath w]; fconfigure $fdout -translation binary; puts -nonewline $fdout $data2; close $fdout 
@@ -392,12 +409,12 @@ namespace eval punk::mix::commandset::project {
         }
         #todo - tag substitutions in src/doc tree
 
-
         ::cd $projectdir
 
         if {[file exists $projectdir/src/modules]} {
             foreach m $opt_modules {
                 if {![file exists $projectdir/src/modules/$m-[punk::mix::util::magic_tm_version].tm]} {
+                    #todo - option for -module_template - and check existence at top? or change opt_modules to be a list of dicts with configuration info -template -type etc
                     punk::mix::commandset::module::new $m -project $projectname -type $opt_type 
                 } else {
                     if {$opt_force} {
@@ -531,7 +548,7 @@ namespace eval punk::mix::commandset::project {
             set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
             set col2 [string repeat " " $widest2]
             set title3 "Checkouts"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {punk::strlen $v}]]
+            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {string length $v}]]
             set col3 [string repeat " " $widest3]
             set tablewidth [expr {$widest1 + 1 + $widest2 + 1 + $widest3}]
             
@@ -617,19 +634,19 @@ namespace eval punk::mix::commandset::project {
             set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
             set col2 [string repeat " " $widest2]
             set title3 "Checkouts"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {punk::strlen $v}]]
+            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {string length $v}]]
             set col3 [string repeat " " $widest3]
             set title4 "Project Name"
-            set widest4 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col4_pnames] {punk::strlen $v}]]
+            set widest4 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col4_pnames] {string length $v}]]
             set col4 [string repeat " " $widest4]
             set title5 "Project Code"
-            set widest5 [tcl::mathfunc::max {*}[lmap v [concat [list $title5] $col5_pcodes] {punk::strlen $v}]]
+            set widest5 [tcl::mathfunc::max {*}[lmap v [concat [list $title5] $col5_pcodes] {string length $v}]]
             set col5 [string repeat " " $widest5]
             set title6 "Dup"
-            set widest6 [tcl::mathfunc::max {*}[lmap v [concat [list $title6] $col6_dupids] {punk::strlen $v}]]
+            set widest6 [tcl::mathfunc::max {*}[lmap v [concat [list $title6] $col6_dupids] {string length $v}]]
             set col6 [string repeat " " $widest6]
             set title7 "Description"
-            #set widest7 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col7_pdescs] {punk::strlen $v}]]
+            #set widest7 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col7_pdescs] {string length $v}]]
             set widest7 35
             set col7 [string repeat " " $widest7]
             
@@ -766,7 +783,12 @@ namespace eval punk::mix::commandset::project {
                 puts stderr "Result is from a single repo db [dict keys $fosdb_cache]"
             }
             if {$opt_detail} {
-                puts stderr "Gathering file state for [llength $workdirs] checkout folder(s). Use -detail 0 to omit file state"
+                if {!$opt_detail_explicit_zero} {
+                    set detailmsg "Use -detail 0 to omit file state"
+                } else {
+                    set detailmsg ""
+                }
+                puts stderr "Gathering file state for [llength $workdirs] checkout folder(s). $detailmsg"
                 set c_rev [list]
                 set c_rev_iso [list]
                 set c_unchanged [list]
@@ -881,7 +903,7 @@ namespace eval punk::mix::commandset::project {
                         set index [expr {$answer - 1}]
                         set workingdir [lindex $workdirs $index]
                         ::cd $workingdir
-                        puts stdout [pmix stat]
+                        puts stdout [deck stat]
                         return $workingdir
                     }
                 }
@@ -907,23 +929,8 @@ namespace eval punk::mix::commandset::project {
             }
             set fossil_prog [auto_execok fossil]
 
-            set fossilinfo [exec {*}$fossil_prog info] ;#will give us the necessary config-db info whether in a project folder or not
-            set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
-            if {[llength $matching_lines] != 1} {
-                puts stderr "Unable to find config-db info from fossil. Check your fossil installation."
-                puts stderr "Fossil output was:"
-                puts stderr "-------------" 
-                puts stderr "$fossilinfo"
-                puts stderr "-------------"
-                puts stderr "config-db info:"
-                puts stderr "$matching_lines"
-                return
-            }
-            set ln [lindex $matching_lines 0]
-            set configdb [string trim [string range $ln [string length "config-db: "] end]]
-            if {![file exists $configdb]} {
-                error "config-db not found at path $configdb"
-            }
+            set configdb [punk::repo::fossil_get_configdb]
+
             package require sqlite3
             ::sqlite3 fosconf $configdb
             #set testresult [fosconf eval {select name,value from global_config;}]
diff --git a/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm b/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm
index abfb0e55..2b3ca282 100644
--- a/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm
@@ -68,6 +68,334 @@ namespace eval punk::mix::commandset::repo {
         }
         return $result
     }
+    proc fossil-move-repository {{path ""}} {
+        set searchbase [pwd]
+        set projectinfo    [punk::repo::find_repos $searchbase]
+        set projectbase [dict get $projectinfo closest]
+        set is_fossil [expr {"fossil" in [dict get $projectinfo closest_types]}]
+        if {[catch {
+            package require sqlite3
+        } errM]} {
+            puts stderr "sqlite3 package failed to load"
+            puts stderr "Try using 'fossil test-move-repository <targetpath>' from within an open checkout folder, or ensure that the Tcl sqlite3 package is available."
+            return
+        }
+        set ansiprompt [a+ green bold]
+        set ansiwarn   [a+ red bold]
+        set ansihighlight [a+ cyan bold]
+        set ansireset  [a]
+
+        set in_checkout 0
+        set is_checkout_relink 0; #whether we are attempting to link a checkout that has lost its repo
+        #we may also encounter a different kind of relink candidate - other checkouts of the same repo that we examine and find don't point back.
+        if {$projectbase eq "" || !$is_fossil} {
+            set repodbs [glob -dir $searchbase -type f -tail *.fossil]
+            if {![llength $repodbs]} {
+                puts stderr "Current directory does not seem to be directly below a fossil checkout, and no .fossil files found"
+                puts stderr "Please move to a folder containing the .fossil repository database to move, or to a folder directly within a fossil checkout (and with no intermediate git/fossil repos)"
+                return
+            }
+            set choice_files [list]
+            set i 1
+            set menu_message ""
+            append menu_message "${ansiprompt}Select the number of the fossil repo db to potentially move (confirmation will be requested before any action is taken)${ansireset}" \n
+            foreach db $repodbs {
+                sqlite3 dbinfo [file join $searchbase $db]
+                set ckouts [dbinfo eval {select name from config where name like 'ckout:%'}]
+                dbinfo close
+                lappend choice_files [list index $i repofile $db checkouts [llength $ckouts]]
+                append menu_message "$i  $db checkouts: [llength $ckouts]" \n
+                incr i
+            }
+            puts stdout $menu_message
+            set max [llength $choice_files] 
+            if {$max == 1} {
+                set rangemsg "the number 1"
+            } else {
+                set rangemsg "a number from 1 to $max" 
+            }
+            set answer [punk::repo::askuser "${ansiprompt}Enter $rangemsg to select a .fossil repository database to show details and potentially move. (or N to abort)${ansireset}"]
+            if {![string is integer -strict $answer]} {
+                puts stderr "Aborting"
+                return
+            }
+
+            set index [expr {int($answer) -1}]
+            if {$index >= 0 && $index <= $max-1} {
+                set repo_file_choice [lindex $choice_files $index]
+                set repo_file [dict get $repo_file_choice repofile]
+                set repo_file [file join $searchbase $repo_file]
+                puts stdout "Selected fossil repo database file: $repo_file" 
+            } else {
+                puts stderr " No menu number matched - aborting."
+                return
+            }
+        } else {
+            if {[file exists $projectbase/_FOSSIL_]} {
+                set cdbfile [file join $projectbase/_FOSSIL_]
+            } elseif {[file exists $projectbase/.fslckout]} {
+                set cdbfile [file join $projectbase/.fslckout]
+            } else {
+                puts stderr "No checkout database (_FOSSIL_ or .fslckout) found in nearest repository folder $projectbase (looked upwards from $searchbase)"
+                puts stderr "Unable to locate repository databases for potential move. Please move to a checkout folder or a folder containing .fossil repositories"
+                puts stderr "If run from a location where repositories are found, fossil-move-repository will give you the option to select a repository or cancel the operation"
+                return
+            }
+            set in_checkout 1
+            sqlite3 cdb $cdbfile
+            set repo_file [cdb eval {select value from vvar where name='repository'}]
+            cdb close
+            if {[string length [string trim $repo_file]] && [file pathtype $repo_file] eq "relative"} {
+                set  repo_file [file join $projectbase $repo_file]
+            }
+            if {![string length [string trim $repo_file]] || ![file exists $repo_file]} {
+                puts stderr "${ansiwarn}Checkout at $projectbase points to repository '$repo_file' - but it doesn't seem to exist${ansireset}"
+                set answer [punk::repo::askuser "${ansiprompt}Do you want to link this to an existing repository file? (Y|N)${ansireset}"]
+                if {[string match y* [string tolower $answer]]} {
+                    set is_checkout_relink 1
+                } else {
+                    puts stderr "Aborting - Unable to link this checkout dir to a repository database file"
+                    return
+                }
+            }
+        }
+
+        set pname [file rootname [file tail $repo_file]]
+        set full_path_repo_file [file join $searchbase $repo_file]
+        if {[file isfile $full_path_repo_file]} {
+            sqlite3 dbinfo [file join $searchbase $repo_file]
+            set ckouts [dbinfo eval {select name from config where name like 'ckout:%'}]
+            dbinfo close
+            if {![llength $ckouts]} {
+                puts stdout "Repository db at [file join $searchbase $repo_file] appears to have no open checkouts"
+            } else {
+                puts stdout "Repository db at [file join $searchbase $repo_file] appears to have [llength $ckouts] open checkouts:"
+                foreach ck $ckouts {
+                    puts stdout [string range $ck 6 end]
+                }
+            }
+        } else {
+            puts stderr "${ansiwarn}Missing repository db at $full_path_repo_file${ansireset}"
+        }
+        puts stdout "${ansihighlight}Report for all projects with repository file name $pname${ansireset}"
+        puts stdout [punk::mix::commandset::project::collection::detail $pname]
+        puts stdout [punk::mix::commandset::project::collection::work $pname -detail 1]
+
+        #todo
+        #ask user if they want to select a different pname
+        set wantrenameprompt "${ansiprompt}Would you like to rename the .fossil file? (Y|N)${ansireset}"
+        append wantrenameprompt \n "${ansiprompt}.eg change $pname.fossil to something else such as ${pname}_new.fossil${ansireset}"
+        set answer [punk::repo::askuser $wantrenameprompt]
+        set pname2 $pname
+        if {[string match y* [string tolower $answer]]} {
+            set dorenameprompt "${ansiprompt}Enter the new name and hit enter. (Just an alphanumeric name (possibly with dots/dashes/underscores) without .fossil and without any path)${ansireset}"
+            set namechoice [punk::repo::askuser $dorenameprompt]
+            if {[string length $namechoice]} {
+                set permittedmap [list . "" - "" _ ""]
+                if {[string is alnum -strict [string map $permittedmap $namechoice]]} {
+                    set pname2 $namechoice
+                } else {
+                    puts stderr "Entered name was invalid. Must be numbers,letters,underscore,dot,dash"
+                }
+            }
+            puts stdout "Continuing with name $pname2 - cancel at next prompt if this is incorrect"
+        }
+
+        set target_repodb_folder [punk::repo::fossil_get_repository_folder_for_project $pname2 -parentfolder $searchbase -askpath 1]
+        #target_repodb_folder might be same as source folder - check for same file if name wasn't changed?
+        if {![string length $target_repodb_folder]} {
+            puts stderr "No usable repository database folder selected for $pname2.fossil file"
+            return
+        }
+
+        set existing_target_repofile 0
+        if {[file exists $target_repodb_folder/$pname2.fossil]} {
+            set existing_target_repofile 1
+            puts stdout "${ansiwarn}NOTICE: $target_repodb_folder/$pname2.fossil already exists${ansireset}"
+            if {!$is_checkout_relink} {
+                set finalquestion "${ansiprompt}Are you sure you want to switch the repository $repo_file for the open checkout(s) to the existing file $target_repodb_folder/$pname2.fossil? (Y|N)${ansireset}"
+            } else {
+                set finalquestion "${ansiprompt}Are you sure you want to attempt to linke the repository (previously linked with '$repo_file') for the open checkout(s) to the existing file $target_repodb_folder/$pname2.fossil? (Y|N)${ansireset}"
+            }
+        } else {
+            if {!$is_checkout_relink} { 
+                set finalquestion "${ansiprompt}Proceed to move repository $repo_file to the new file $target_repodb_folder/$pname2.fossil? Y|N${ansireset}"
+            } else {
+                set finalquestion "${ansiprompt}Proceed to attempt link for missing repo db $repo_file to the new file $target_repodb_folder/$pname2.fossil? Y|N${ansireset}"
+            }
+        }
+        set line "${ansiwarn}[string repeat - [string length $finalquestion]]${ansireset}"
+        set finalprompt $line\n
+        append finalprompt $finalquestion \n
+        append finalprompt $line \n
+
+        set answer [punk::repo::askuser $finalprompt]
+        if {[string match y* [string tolower $answer]]} {
+            if {!$existing_target_repofile && !$is_checkout_relink} {
+                if {[catch {
+                    file copy $repo_file $target_repodb_folder/$pname2.fossil
+                } errM]} {
+                    puts stderr "${ansiwarn}FAILED to copy $repo_file to $target_repodb_folder/$pname2.fossil - aborting${ansireset}"
+                    puts stderr "Error message was:\n $errM"
+                    return
+                }
+                if {$in_checkout} {
+                    #in_checkout means we can assume projectbase var exists
+                    #there may be other checkouts on the old repo  
+                    #if so, we will remind the user of their existence
+                    if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} errM]} {
+                        puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                        puts stderr "$errM"
+                    } else {
+
+                        sqlite3 oldrepo $repo_file 
+                        set ckouts [oldrepo eval {select name from config where name like 'ckout:%'}]
+                        set pcode [oldrepo eval {select value from config where name = 'project-code'}]
+                        oldrepo close
+                        if {[string length $pcode] < 20} {
+                            puts stderr "WARNING: Failed to get project-code from repo db $repo_file"
+                        }
+                        set other_checkouts [list]
+                        set norm_projectbase [file normalize $projectbase]
+                        foreach ck $ckouts {
+                            set ckfolder [string trim [string range $ck 6 end]]
+                            if {![file isdirectory $ckfolder]} {
+                                #as the process was launched within a checkout - we won't bother user with reports of non-existant other checkouts
+                                continue
+                            }
+                            if {[file normalize $ckfolder] ne $norm_projectbase} {
+                                lappend other_checkouts $ckfolder
+                            }
+                        }
+                        if {[llength $other_checkouts]} { 
+                            puts stderr "${ansiwarn}Other checkouts of $repo_file that may need consideration${ansireset}"
+                            foreach other $other_checkouts {
+                                puts stdout $other
+                            }
+                        }
+                    }
+                } else {
+                    #we aren't in a checkout - moving a repo to a new db location and/or name so there's no reason to prefer one checkout over another.. presumably the user either wants to move them all - or be asked..
+                    sqlite3 oldrepo $repo_file
+                    set ckouts [oldrepo eval {select name from config where name like 'ckout:%'}]
+                    oldrepo close
+                    if {[llength $ckouts] > 1} {
+                        puts stdout "There are [llength $ckouts] checkouts for the repository you are moving" 
+                        puts stdout "You will be asked for each checkout if you want to adjust it to point to $target_repodb_folder/$pname2.folder"
+                    }
+                    set original_cwd [pwd]
+                    foreach ck $ckouts {
+                        set ckfolder [string trim [string range $ck 6 end]]
+                        if {![file isdirectory $ckfolder]} {
+                            puts stderr "old repo shows a checkout at $ckfolder - but it doesn't seem to exist. Ignoring"
+                            continue
+                        }
+                        cd $ckfolder
+                        puts stdout [exec fossil info]
+                        puts stdout [state]
+                        set answer  [punk::repo::askuser "${ansiprompt}Do you want to point this checkout to $target_repodb_folder/$pname2.folder? (Y|N) Q to stop processing checkouts${ansireset}"]
+                        if {[string match q* [string tolower $answer]]} {
+                            puts stderr "User aborting loop"
+                            break
+                        }
+                        if {[string match y* [string tolower $answer]]} {
+                            if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} moveresult]} {
+                                puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                                puts stderr "$moveresult"
+                            } else {
+                                puts stdout "OK - move performed with result:" 
+                                puts stdout $moveresult
+                            }
+                        }
+                    } 
+                    cd $original_cwd
+
+                }
+            } else {
+                if {$is_checkout_relink} {
+                    #relinking a lost checkout to an existing repo.. we should probably check it's other checkouts and see if they point back
+                    if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} errM]} {
+                        puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                        puts stderr "$errM"
+                    }
+                } else {
+                    if {$in_checkout} {
+                        if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} errM]} {
+                            puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                            puts stderr "$errM"
+                        }
+                    } else {
+                        #not in checkout - we're wanting what pointed to one repo to point to a different existing one - presumably for all checkouts
+                        sqlite3 newrepo $target_repodb_folder/$pname2.fossil
+                        set newpname [newrepo eval {select value from config where name = 'project-name'}]
+                        set newpcode [newrepo eval {select value from config where name = 'project-code'}]
+                        set newckouts [newrepo eval {select name from config where name like 'ckout:%'}]
+                        newrepo close
+
+                        sqlite3 oldrepo $repo_file 
+                        set oldpname [oldrepo eval {select value from config where name = 'project-name'}]
+                        set oldpcode [oldrepo eval {select value from config where name = 'project-code'}]
+                        set oldckouts [oldrepo eval {select name from config where name like 'ckout:%'}]
+                        oldrepo close
+                        if {$newpname eq $oldpname} {
+                            set ansi_newpname [a+ green bold]$newpname[a]
+                            set ansi_oldpname [a+ green bold]$oldpname[a]
+                        } else {
+                            set ansi_newpname [a+ cyan bold]$newpname[a]
+                            set ansi_oldpname [a+ red bold]$oldpname[a]
+                        }
+                        if {$newpcode eq $oldpcode} {
+                            set ansi_newpcode [a+ green bold]$newpcode[a]
+                            set ansi_oldpcode [a+ green bold]$oldpcode[a]
+                        } else {
+                            set ansi_newpcode [a+ cyan bold]$newpcode[a]
+                            set ansi_oldpcode [a+ red bold]$oldpcode[a]
+                        }
+                        puts stdout "Target repository $target_repodb_folder/$pname2.fossil has project-name: $ansi_newpname and [llength $newckouts] existing checkouts"
+                        puts stdout "Target project code: $ansi_newpcode"
+                        puts stdout "Source repository $repo_file has project-name: $ansi_oldpname and [llength $oldckouts] existing checkouts"
+                        puts stdout "Source project code: $ansi_oldpcode"
+                        if {[llength $oldckouts] > 1} {
+                            puts stdout "You will be asked for each checkout if you want to adjust it to point to $target_repodb_folder/$pname2.folder"
+                        }
+                        set original_cwd [pwd]
+                        foreach ck $oldckouts {
+                            set ckfolder [string trim [string range $ck 6 end]]
+                            if {![file isdirectory $ckfolder]} {
+                                puts stderr "old repo shows a checkout at $ckfolder - but it doesn't seem to exist. Ignoring"
+                                continue
+                            }
+                            cd $ckfolder
+                            puts stdout [exec fossil info]
+                            puts stdout [state]
+                            set answer  [punk::repo::askuser "${ansiprompt}Do you want to point this checkout to $target_repodb_folder/$pname2.folder? (Y|N) Q to stop processing checkouts${ansireset}"]
+                            if {[string match q* [string tolower $answer]]} {
+                                puts stderr "User aborting loop"
+                                break
+                            }
+                            if {[string match y* [string tolower $answer]]} {
+                                if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} moveresult]} {
+                                    puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                                    puts stderr "$moveresult"
+                                } else {
+                                    puts stdout "OK - move performed with result:" 
+                                    puts stdout $moveresult
+                                }
+                            }
+                        } 
+                        cd $original_cwd
+
+                    }
+                }
+            }
+
+
+            puts stdout "-done-"
+        } else {
+            puts stdout "-cancelled by user-"
+        }
+
+    }
 }
 
 
diff --git a/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm b/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm
index e40bc899..b1c899da 100644
--- a/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm
@@ -20,6 +20,7 @@
 
 package require punk::mix
 package require punk::mix::base
+package require punk::fileline
 
 
 
@@ -27,83 +28,734 @@ package require punk::mix::base
 namespace eval punk::mix::commandset::scriptwrap {
     namespace export *
 
+    namespace eval fileline {
+        namespace import ::punk::fileline::lib::*
+        namespace import ::punk::fileline::class::*
+    }
 
-    #scriptpath allows templates command to use same custom template set as when multishell pointed to a filepath
-    #it may or may not be within a project
-    #by using the same folder or path, the same project root will be discovered. REVIEW.
-    proc templates_dict {args} {
-        set defaults [list -scriptpath ""]
-        set opts [dict merge $defaults $args]
-        set opt_scriptpath [dict get $opts -scriptpath]
-
-        set wrapper_folders [lib::get_wrapper_folders $opt_scriptpath]
-
-        set wrapper_templates [list]
-        foreach fld $wrapper_folders {
-            set templates [glob -nocomplain -dir $fld -type f *]
-            foreach tf $templates {
-                if {[string match ignore* $tf]} {
-                    continue
-                }
-                set ext [file extension $tf]
-                if {$ext in [list "" ".bat" ".cmd" ".sh"]} {
-                    lappend wrapper_templates $tf
-                }
-            }
+    proc templates {args} {
+        package require overtype
+        package require textblock
+        set tdict_low_to_high [templates_dict {*}$args]
+        #convert to screen order - with higher priority at the top
+        set tdict [dict create]
+        foreach k [lreverse [dict keys $tdict_low_to_high]] {
+            dict set tdict $k [dict get $tdict_low_to_high $k]
         }
+        
+        #set pathinfolist [dict values $tdict]
+        set names [dict keys $tdict]
 
-        set tdict [dict create]
-        set seen_dict [dict create]
-        foreach fullpath $wrapper_templates {
-            set ftail [file tail $fullpath]
-            if {![dict exists $seen_dict $ftail]} {
-                dict set seen_dict $ftail 1 
-                dict set tdict $ftail $fullpath ; #first seen of filename gets no number
-            } else {
-                set n [dict get $seen_dict $ftail]
-                incr n
-                dict incr seen_dict $ftail
-                dict set tdict ${ftail}.$n $fullpath
-            }
+        #set paths [lsearch -all -inline -index 1 -subindices $pathinfolist *]; #first key of templates_dict is path
+        set paths [list]
+        set pathtypes [list]
+        dict for {nm tinfo} $tdict {
+            lappend paths [dict get $tinfo path]
+            lappend pathtypes [dict get $tinfo sourceinfo pathtype]
         }
-        return $tdict
-    }
-    proc templates {args} {
-        package require overtype
-        set tdict [templates_dict {*}$args]
 
-       
-        set paths [dict values $tdict]
-        set names [dict keys $tdict]
+        package require textblock
+        set title(name) "Template Name"
+        set widest(name) [tcl::mathfunc::max {*}[lmap v [concat [list $title(name)] $names] {string length $v}]]
+        set col(name) [string repeat " " $widest(name)]
 
-        set title1 "Path"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $paths] {punk::strlen $v}]]
-        set col1 [string repeat " " $widest1] 
+        set title(pathtype) "[a+ green]Path\nType[a]"
+        set widest(pathtype) [tcl::mathfunc::max {*}[lmap v [concat [list $title(pathtype)] $pathtypes] {textblock::width $v}]]
+        set col(pathtype) [string repeat " " $widest(pathtype)]
 
-        set title2 "Template Name"
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $names] {punk::strlen $v}]]
-        set col2 [string repeat " " $widest2]
+        set title(path) "Path"
+        set widest(path) [tcl::mathfunc::max {*}[lmap v [concat [list $title(path)] $paths] {string length $v}]]
+        set col(path) [string repeat " " $widest(path)] 
 
-        set tablewidth [expr {$widest1 + 1 + $widest2}]
+
+
+
+        set tablewidth [expr {$widest(name) + 1 + $widest(pathtype) + $widest(path)}]
         set table ""
         append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col1 $title1] [overtype::left $col2 $title2]" \n
+        append table [textblock::join [overtype::left $col(name) $title(name)] " " [overtype::left $col(pathtype) $title(pathtype)] " " [overtype::left $col(path) $title(path)]] \n
         append table [string repeat - $tablewidth] \n
 
-        foreach p $paths n $names {
-           append table "[overtype::left $col1 $p] [overtype::left $col2 $n]" \n 
+        foreach n $names pt $pathtypes p $paths {
+           append table "[overtype::left $col(name) $n] [overtype::left $col(pathtype) $pt] [overtype::left $col(path) $p]" \n 
         }
 
 
         return $table
     }
-    #specific filepath to just wrap one script at the tcl-payload or xxx-payload-pre-tcl site
+    proc templates_dict {args} {
+        package require punk::cap
+        if {[punk::cap::capability_has_handler punk.templates]} {
+            return [punk::cap::call_handler punk.templates get_itemdict_scriptappwrappers {*}$args]
+        } else {
+            put stderr "commandset::scriptwrap::templates_dict WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
+        }
+        return
+    }        
+   
+    
+    #A batch file with unix line-endings is sensitive to label positioning. 
+    #batch file with windows crlf line endings can exhibit this problem - but probably only if specifically crafted with long lines deliberately designed to trigger it. 
+    #see: https://www.dostips.com/forum/viewtopic.php?t=8988#p58888 (Call and goto may fail when the batch file has Unix line endings)
+    #The windows batch file scanner appears to parse in 512 Byte chunks.
+    #If a label following a call/goto is at a position spanning a 512 byte block as counted from the call/goto site (callsite assumed to be EOL - works for basic cases at least) then the label won't be found.
+    #A label preceding a call/goto site can't span a 512 byte boundary as counted from the beginning of the file
+    #checkfile produces warnings and errors in ansi-coloured form (both to stdout and a summary in the return value)
+    #The script should then be adjusted with comments and/or whitespace and checkfile should be re-run to confirm there are no new boundary-spanning labels.
+    #checkfile needs to be run even on previously tested scriptwrapper templates because the final :exit label is beyond the payloads and so could span a 512 Byte block
+    #It is more likely to catch issues if adjustments are made to the initial batch-script code in a template.
+    #
+    #cmd allows labels at call sites to span lines with line continuation character ^
+    #target labels can't span lines with ^ - cmd doesn't recognise them (They possibly do span in a way - but but the newlines may be included in the label - so they may be hard/impossible to call).
+    #Note that we can't filter obviously non-batch-script lines before processing - as the way batch label-scanning works it scans in chunks of 512 bytes so all lines are relevant.
+    #This means label-like things could be incorrectly found in other script data - that's partly the point of this check
+    #Note that we can't filter obviously non-batch-script lines before processing - as the way batch label-scanning works it scans in chunks of 512 bytes so all lines are relevant.
+    #This means label-like things could be incorrectly found in other script data - that's partly the point of this check.
+    proc checkfile {filepath args} {
+        if {![file exists $filepath]} {
+            error "punk::mix::commandset:scriptwrap error cannot find file '$filepath'"
+        }
+        set crlf_lf_replacements [list \uFFFF \uFFFE] ;#defaults - if already exist in file - error out with message
+        # -ignore_rems 1 allows testing of alignment state if rems were stripped - todo - lf/crlf-preserving rem strip function
+        set defaults [dict create\
+            -ignore_rems 0\
+            -substitutionmap {}\
+            -crlf_lf_replacements $crlf_lf_replacements\
+        ]
+        set known_opts [dict keys $defaults]
+        foreach {k v} $args {
+            if {$k ni $known_opts} {
+                error "checkfile error - unknown option '$k'. Known options: $known_opts"
+            }
+        }
+        set opts [dict merge $defaults $args]
+        # -- --- --- --- --- --- --- 
+        set opt_ignore_rems     [dict get $opts -ignore_rems]
+        set opt_substitutionmap [dict get $opts -substitutionmap]
+        set opt_crlf_lf_replacements [dict get $opts -crlf_lf_replacements]
+        # -- --- --- --- --- --- --- 
+
+        # #### load file ####
+        ##set raw_filedata [fcat -translation binary $filepath]
+        # - as we may need to look at data beyond a ctrl-z (\x1A) section
+        set fd [open $filepath r]
+        fconfigure $fd -translation binary
+        set raw_filedata [read $fd]
+        close $fd
+        # ###################
+
+
+        set objFile [fileline::textinfo new $raw_filedata]
+
+        if {$opt_ignore_rems} {
+            #! todo
+            error "-ignore_rems unimplemented"
+            if 0 {
+                #todo - rebuild a raw_filedata value from the resultant lines
+                #review. @REM can appear after other commands and an ampersand for example.
+                # - we are interested in stripping lines with leading REMs
+                # - need to work out if a REM line with dos line-continuation should 
+
+                set data ""
+                set skipped_rems 0
+                foreach ln [split $filedata \n] {
+                    set ln [string trim $ln]
+                    if {[string match @REM* $ln] || [string match REM* $ln] || [string match @rem* $ln] || [string match rem* $ln]} {
+                        #ignore
+                        incr skipped_rems
+                    } else {
+                        append data $ln \n ;#!!
+                    }
+                }
+                puts stderr "Skipped $skipped_rems rem lines"
+                set dsize [string length $data]
+            }
+        } else {
+            set dsize [string length $raw_filedata]
+        }
+
+        puts stdout "Examining [$objFile chunklen] bytes of file $filepath for cmd script issues."
+        set le_info [$objFile chunk_le_counts 0 end]
+        set lf_count [dict get $le_info lf]
+        set crlf_count [dict get $le_info crlf]
+        set unterminated_count [dict get $le_info unterminated]
+        set total_count [expr {$lf_count + $crlf_count + $unterminated_count}]
+        puts stdout "lines ending in lf      : $lf_count"
+        puts stdout "lines ending in crlf    : $crlf_count"
+        puts stdout "unterminated lines      : $unterminated_count" ;#commonly 1 for trailing data at end of file. More than one is likely to be an error - or perhaps a policy plugin with different concept of lines?
+        puts stdout "crlf + lf + unterminated: $total_count"
+        puts stdout "line count              : [$objFile linecount]"
+        if {$total_count != [$objFile linecount]} {
+            puts stdout "[a+ yellow bold]WARNING: Linecount mismatch with line-endings - seems fishy[a]"
+        }
+        if {$unterminated_count > 1} {
+            puts stdout "[a+ yellow bold]WARNING: More than one unterminated line reported - seems fishy[a]"
+        }
+        puts "Checking line based labels and 512 byte boundaries from call sites for possible labels and code execution points."
+        set line_count [$objFile linecount]
+        set callid 0 ;#id for callsite and objects created
+        set file_offset 0 
+        set error_labels [list]
+        set warning_labels [list]
+        set call_labels_found [dict create]
+        set target_labels_found [dict create]
+        set possible_target_labels_found [dict create]
+        set warning_target_labels_found [dict create]
+        for {set callingline_index 0} {$callingline_index < $line_count} {incr callingline_index} {
+            set callingline_info [$objFile lineinfo $callingline_index]
+            set callingline_payload [dict get $callingline_info payload]
+            set callingline_len    [dict get $callingline_info linelen] 
+            set callingline_num [expr {$callingline_index + 1}]
+
+            set callposn -1 
+            set trimln [string trim $callingline_payload]
+            if {[string match "rem *" $trimln] || [string match "@rem *" $trimln] || [string match "REM *" $trimln] || [string match "@REM *" $trimln]} {
+                #ignore things that look like a call that are beind a REM
+            } else {
+
+                #todo - better callsite analysis. There can be data between @GOTO or @CALL and : other than just whitespace!
+
+                #todo - allow analysis of colon-less call. May need to check list of internal commands - but what about external ones?
+                #foreach search_regex [list {(.*\s+|^)(@*call\s*:*)(\S.*)} {(.*\s+|^)(@*CALL\s*:*)(\S.*)} {(.*\s+|^)(@*goto\s*:*)(\S.*)} {(.*\s+|^)(@*GOTO\s*:*)(\S.*)}] {}
+                foreach search_regex [list {(.*\s+|^)(@*call\s*:)(\S.*)} {(.*\s+|^)(@*CALL\s*:)(\S.*)} {(.*\s+|^)(@*goto\s*:)(\S.*)} {(.*\s*|.*\s+|^)(@*GOTO\s*:)(\S.*)} {(.*\|\|.*)(@*GOTO\s*:)(\S.*)}] {
+                    if {[regexp $search_regex $callingline_payload _m precall call labelplus]} {
+                        #todo further checks to see if it's actually a batch script line
+                        # - - - - work out what cmd.exe considers start of 512B boundaries when scanning from a callsite
+                        #callposn affected by newlines?
+                        #set callposn [expr {$file_offset + [string length $callingline_payload]}] ;#take callposn as end of line .. review - multiline statements?
+                        set callposn [expr {$file_offset + $callingline_len}] 
+                        
+                        #Note there are anomalies around target labels in bracketed sections such as IF blocks
+                        #this is bad practice - as it can lead to unbalanced braces - but batch files can still work under cmd.exe with them in some cases
+                        #e.g unbalanced trailing bracket may be ignored.
+                        #A working script with target-labels in braces can fail due to boundary issues we don't detect (callsite for boundary counting may need to be at end of entire multiline if block??)
+                        #For now - just make sure punk templates don't do this - but it would be nice to be able to detect.
+
+                        #set callposn $file_offset
+                        #set callposn [expr {$file_offset + [string length $precall]}]
+                        # - - - -
+                        break
+                    }
+                }
+                set callsite_labelfound 0 ;#until proven
+                if {$callposn != -1} {
+                    set callposn_lineindex [lindex [$objFile chunkrange_to_linerange $callposn $callposn] 0]
+                    #the line represented by callposn may actually be beyond the calling_line_index 
+                    set labelinfo [batchlib::get_callsite_label $labelplus]
+                    if {[dict get $labelinfo labelfound]} {
+                        set callsite_labelfound 1
+                        set label [dict get $labelinfo label]
+                        set call_label_record [list label $label line $callingline_num]
+                        dict lappend call_labels_found $label $call_label_record
+                    } else {
+                        puts stderr "[a+ yellow bold]WARNING - apparent callsite $callposn but couldn't verify label[a]"
+                        puts stderr "Line:\n$trimln"
+                    }
+                }
+
+                #todo - multiple calls on one line. - also - determine what cmd considers the starting point for forward scanning when call is in a structure such as an if statement.
+                if {$callsite_labelfound} {
+                    puts stdout "[a+ bold cyan]CALLSITE on line $callingline_num  ending at byte $callposn[a]"
+                    set callsummary [string range "${call}${labelplus}" 0 100]
+                    if {[string length $callsummary] < [string length ${call}${labelplus}]} {
+                        puts stdout "  CALLSITE: $callsummary (truncated to 100 bytes)"    
+                    } else {
+                        puts stdout "  CALLSITE: '${call}${labelplus}'"
+                    }
+                    puts stdout "  [a+ cyan]FULLINE: $callingline_payload[a]"
+
+
+
+                    ##################################
+                    #set labelpluswords [regexp -inline -all {\S+} $labelplus] ;#don't assume labelplus can be treated as Tcl list - use regexp to split
+                    #NOTE it is invalid to assume label always terminated by space - pair of % characters (variable substitution) can contain a space without terminating label
+                    #set word1 [lindex $labelpluswords 0]
+
+
+                    ##################################
+
+
+                    set labelsize [string length $label]
+                    #scan forward for labels at boundaries
+                    set forward_chunk [$objFile chunk $callposn end]
+                    set forward_chunk_base $callposn ;#name for clarity
+
+                    incr callid
+                    set callvar "call-${callid}_fromline-${callingline_num}"
+                    upvar 0 $callvar objForwardScan
+                    set objForwardScan [fileline::textinfo new $forward_chunk]
+
+
+
+                    ##################################################################################################################################
+                    #Forward scan 1 - check at normal line boundaries - and see if collides with a chunk boundary - and if the label is obscured or ok
+                    set dsize [$objForwardScan chunklen]
+                    set num_boundaries [expr {$dsize / 512} ]
+                    puts "scanning $dsize forward bytes in file starting at $forward_chunk_base for label '$label' - num_boundaries: $num_boundaries"
+                    set total_offset $file_offset
+                    set found_forward_label 0
+                    foreach scanlineinfo [$objForwardScan lineinfolist 0 end] {
+                        set scanline_start [dict get $scanlineinfo start]
+                        set scanline_bytes [dict get $scanlineinfo linelen]
+                        set scanline   [dict get $scanlineinfo payload]
+
+                        set line_start_global [expr {$forward_chunk_base + $scanline_start}] 
+                        set line_index_global [lindex [$objFile chunkrange_to_linerange $line_start_global $line_start_global] 0] 
+                        set line_num_global [expr {$line_index_global + 1}]
+
+                        set trimscanline [string trim $scanline]
+
+                        set found_targetlabel_at_line 0 ;# until disproven
+                        if {[string first : $scanline] >= 0} {
+                            set labelinfo [batchlib::get_target_label_from_line $scanline]
+                            if {[dict get $labelinfo labelfound] && [dict get $labelinfo label] eq $label} {
+                                #add to target_labels_found record below
+                                set scan_target_label_record [list label $label line $line_num_global]
+                                set found_targetlabel_at_line 1
+                            }
+                        }   
+
+                        if {$found_targetlabel_at_line} {
+                            set scan_target_label_same_line_seen false
+                            if {[dict exists $target_labels_found $label]} {
+                                set thislabel_records [dict get $target_labels_found $label]
+                                foreach previous $thislabel_records {
+                                    if {[dict get $previous line] eq $line_num_global} {
+                                        set scan_target_label_same_line_seen true 
+                                    }
+                                }
+                            }
+                            incr found_forward_label
+                            if {!$scan_target_label_same_line_seen} {
+                                set label_posn_in_line [string first : $scanline]
+                                set labelposn [expr {$scanline_start + $label_posn_in_line}]
+                                #we only really care about exactly landing on a boundary or else the next 512 byte boundaries above the labelposn
+                                if {($labelposn % 512) == 0} {
+                                    set ubound [expr {($labelposn / 512) * 512}]
+                                } else {
+                                    set ubound [expr {(($labelposn / 512)+1) * 512}]
+                                }
+                                set lbound [expr {$ubound - $labelsize}]
+                                if {($labelposn >= $lbound) && ($labelposn <= $ubound)} {
+                                    dict set scan_target_label_record error linestart_and_call_offset_bytes
+                                    lappend error_labels [list label $label linestart_and_call_offset_bytes $labelposn callsite [list call ${call}${labelplus} call_linenum $callingline_num] bad_target_line $line_num_global]
+                                    puts stdout "[a+ bold red]ERROR: file line: $line_num_global target-label $trimscanline at line-beginning and with byte offset from callsite: $labelposn offset in file: $line_start_global[a]"
+                                    puts stdout "[a+ bold red]  This target-label appears to span the 512byte boundary at byte $ubound[a] [a+ yellow bold]from callsite.[a]"
+                                    puts [$objForwardScan chunk_boundary_display [dict get $scanlineinfo start] [dict get $scanlineinfo end] 512 -linebase $callposn_lineindex+1 -limit 1] ;#+1 on callposn_linindex to do editor-style linenums
+                                } else {
+                                    dict set scan_target_label_record ok 1
+                                    puts stdout "[a+ bold green]OK: file line: $line_num_global target-label $trimscanline at line-beginning and with byte offset from callsite: $labelposn offset in file: $line_start_global[a]"
+                                }
+                                dict lappend target_labels_found $label $scan_target_label_record
+                            } else {
+                                puts stdout "OK - seen label $label on $line_num_global before"
+                            }
+                        }
+                        incr total_offset  $scanline_bytes
+                    }
+                    ##################################################################################################################################
+
+
+                    #todo
+                    #forward scan 2 - check any boundaries missed above because the label isn't at the begining of a line
+                    #these are potentially hidden labels that could activate without requiring the label be at the beginning of a line
+                    #check boundary spans relative to start of this objForwardScan chunk
+
+                    #adjust boundary-search by resetting counter each time crlf encountered 
+                    set forward_lines [$objForwardScan chunkrange_to_lineinfolist 0 end]
+                    set boundary_positions [list 0]
+                    set scanner_offset 0
+                    set scanner_position 0
+                    foreach forwardbline_info $forward_lines {
+                        #review - do we need to check the payload in case we have configured the textinfo object to split the file only on lf - (not true by default)
+                        set forwardbline_len    [dict get $forwardbline_info linelen]
+                        set forwardbline_spaninfo [fileline::range_spans_chunk_boundaries [expr {$scanner_position + $scanner_offset}] [expr {$scanner_position + $scanner_offset + $forwardbline_len}] 512]
+                        set forwardbline_boundaries [dict get $forwardbline_spaninfo boundaries]
+
+                        foreach b $forwardbline_boundaries {
+                            set relb [expr $b + $scanner_offset]
+                            if {$relb <= [dict get $forwardbline_info end]} {
+                                lappend boundary_positions $relb 
+                            } else {
+                                #leave it for the next line - as we may need to adjust offset anyway 
+                                break
+                            }
+                        }
+                        if {[dict get $forwardbline_info le] eq "crlf"} {
+                            set scanner_offset [expr {[dict get $forwardbline_info end] - [lindex $boundary_positions end]}] ;#reset on crlf
+                            #puts "+++++ set scanner_offset $scanner_offset"
+                        }
+                        set scanner_position [dict get $forwardbline_info end]
+                    }
+                    set boundary_positions [lsearch -all -not -inline $boundary_positions 0]
+                    if {[llength $boundary_positions]} {
+                        puts stdout "[a+ blue bold]----> [llength $forward_lines] forward lines, boundaries (possibly with offsets) to check $boundary_positions[a]"
+                    } else {
+                        puts stdout "[a+ blue bold]----> [llength $forward_lines] forward lines, No boundaries to check (generally expected for files with crlf line endings and no extremely long lines)[a]"
+                    }
+
+
+                    if {[llength $boundary_positions]} {
+                        puts stdout "line $callingline_num scan from call label $label ending at position $callposn. Next Callsite-relative boundary [lindex $boundary_positions 0]"
+
+                        for {set i 0} {$i < [llength $boundary_positions]} {incr i} {
+                            set b [lindex $boundary_positions $i]
+                            if {$i < [llength $boundary_positions]-1} {
+                               set nextb [lindex $boundary_positions $i+1]
+                               set top  $nextb 
+                            } else {
+                               set top end
+                            }
+
+                            set forwardbline_infolist [$objForwardScan chunkrange_to_lineinfolist $b $top -show_truncated 1]
+                            set forwardbline_info [lindex $forwardbline_infolist 0]
+                            if {[dict get $forwardbline_info is_truncated]} {
+                                set payload_from_boundary [dict get $forwardbline_info truncated]
+                            } else {
+                                set payload_from_boundary [dict get $forwardbline_info payload]
+                            }
+                            set forwardbline_len    [dict get $forwardbline_info linelen]
+                            set forwardbline_index [dict get $forwardbline_info lineindex]
+                            set forwardbline_start [dict get $forwardbline_info start]
+                            set forwardbline_start_global [expr {$forward_chunk_base + $forwardbline_start}] 
+                            set forwardbline_index_global [lindex [$objFile chunkrange_to_linerange $forwardbline_start_global $forwardbline_start_global] 0] 
+                            set forwardbline_num_global [expr {$forwardbline_index_global + 1}]
+
+                            set found_targetlabel_at_boundary 0
+                            if {[string first : $payload_from_boundary] >= 0} {
+                                #puts stdout "Possible label at boundary $b - testing"
+                                set labelinfo [batchlib::get_target_label_from_line $payload_from_boundary]
+                                if {[dict get $labelinfo labelfound] && [dict get $labelinfo label] eq $label} {
+                                    incr found_forward_label
+                                    set found_targetlabel_at_boundary 1
+                                } elseif {[dict get $labelinfo labelfound]} {
+                                    set unsearched_label [dict get $labelinfo label]
+                                    puts stderr "[a+ cyan]Line $forwardbline_num_global: Found an item that cmd may interpret as a target label because of its location at a boundary $b  - but it doesn't seem to be the one we are looking for. Looking for '$label' Found: '[dict get $labelinfo label]'[a]"
+                                    puts stderr "[a+ yellow]Warning - if the label '$unsearched_label' on line $forwardbline_num_global isn't meant to be a target - it may be safest to make sure batch script isn't using CALL or GOTO with target :$unsearched_label"
+                                    puts stdout "linedata:\n"
+                                    #puts stdout "'$payload_from_boundary'"
+                                    puts [$objForwardScan chunk_boundary_display [dict get $forwardbline_info start] [dict get $forwardbline_info end] 0 -boundaries $b -linebase $callposn_lineindex+1 -limit 1]
+
+                                    #dubious value to check call_labels_found - as we didn't run through and find all call labels first!
+                                    if {$unsearched_label in [dict keys $call_labels_found]} {
+                                        set boundary_target_label_record [list label $unsearched_label line $forwardbline_num_global error found_via_boundary_check_on_a_different_call_label]
+                                        dict lappend warning_target_labels_found $unsearched_label $boundary_target_label_record
+                                    } else {
+                                        set possible_target_label_record [list label $unsearched_label line $forwardbline_num_global]
+                                        dict lappend possible_target_labels_found $unsearched_label $possible_target_label_record
+                                    }
+                                } else {
+                                    set note ""
+                                    if {[dict exists $labelinfo note]} {
+                                        set note [dict get $labelinfo note]
+                                    }
+                                    if {$note ne "prefix_fail"} {
+                                        puts stdout "no label detected at boundary $b - probably ok. Note from target-label scanner: $note"
+                                    }
+                                }
+                                if {$found_targetlabel_at_boundary} {
+                                    set target_label_record [list label $label line $forwardbline_num_global error call_offset_bytes]
+                                    dict lappend target_labels_found $label $target_label_record
+                                    set note "possibly unreliable or dangerous target-label at line $forwardbline_num_global may execute line [expr {$forwardbline_num_global +1}].\n"
+                                    append note "Target label not at line start but was found by scanning 512byte chunks from callsite with count resets at any crlf encountered\n"
+                                    append note "Adjust spacing between line $callingline_num and $forwardbline_num_global to avoid the 512 boundary - and re-test for other boundary problems"
+                                    lappend error_labels [list label $label call_offset_bytes $b callsite [list call ${call}${labelplus} call_linenum $callingline_num] note $note]
+                                    puts stdout "[a+ bold red]ERROR: line $forwardbline_num_global  target-label [dict get $labelinfo rawlabel] found at boundary and with byte offset from callsite: $b [a]"
+                                    puts stdout "[a+ bold red]  This target-label appears to fall at or just after the 512byte boundary at byte $b[a] [a+ yellow bold]from callsite.[a]"
+                                    puts stdout "[a+ bold yellow]Code may execute at line [expr {$forwardbline_num_global + 1}] (or at next 512Byte boundary in some circumstances)[a]"
+                                    puts stdout "[a+ bold yellow]Recommend adjusting spacing between line $callingline_num and $forwardbline_num_global[a]"
+                                    puts stdout [$objForwardScan chunk_boundary_display [dict get $forwardbline_info start] [dict get $forwardbline_info end] 0 -boundaries $b -linebase $callposn_lineindex+1 -limit 1]
+                                }
+                                #if found any label - peek at next boundary
+                                if {[dict get $labelinfo labelfound] && $i+1 < [llength $boundary_positions]} {
+                                    set next_lineinfolist [$objForwardScan chunkrange_to_lineinfolist $nextb end -show_truncated 1]
+                                    set next_lineinfo [lindex $next_lineinfolist 0]
+                                    puts "peek next boundary data - line [expr {$forwardbline_num_global + 1}]:"
+                                    #if {[dict get $next_lineinfo is_truncated]} {
+                                    #    puts [dict get $next_lineinfo truncated]
+                                    #} else {
+                                    #    puts [dict get $next_lineinfo payload]
+                                    #}
+                                    puts [$objForwardScan chunk_boundary_display [dict get $next_lineinfo start] [dict get $next_lineinfo end] 0 -boundaries $nextb -linebase $callposn_lineindex+1 -limit 1]
+                                }
+                            }
+                        }
+                    }
+                    $objForwardScan destroy
+
+                    #scan behind for labels at boundaries - using offset from start of file
+                    #we do a backward scan even if a forward label has been found, so that we can warn of duplicate labels.
+
+                    set prior_start 0
+                    set prior_end $callingline_index ;#only scan from file start to call-site
+
+                    set pline_begin 0
+                    set found_backward_label 0
+                    set p_linenum 0
+                    for {set pidx $prior_start} {$pidx <= $prior_end} {incr pidx} {
+                        set plineinfo [$objFile lineinfo $pidx]
+                        set pline [dict get $plineinfo payload]
+                        incr p_linenum
+                        set pline_bytes [dict get $plineinfo linelen] ;#includes lf or crlf ending bytes
+                        set pline_start $pline_begin
+                        if {$pline_start != [dict get $plineinfo start]} {
+                            error "checkfile error: line $p_linenum - calculated start $pline_start not equal to stored start [dict get $plineinfo start]"
+                        }
+                        set pline_end  [expr {$pline_begin + $pline_bytes -1}]
+                        if {$pline_end != [dict get $plineinfo end]} {
+                            error "checkfile error: line $p_linenum - calculated end $pline_end not equal to stored end [dict get $plineinfo end]"
+                        }
+
+
+                        set trimpline [string trim $pline]
+                        #todo - process leading part of line before :
+                        #e.g the following are valid  (leading # is not part of the examples)
+                        # ======  : label
+                        # also
+                        #%=== ==  : label
+                        # also
+                        #%= ,,,, ;;;  = : label
+                        
+                        #these token delimiters (; , = 0x0B ox0C 0xFF <space> <tab>)
+                        #can also occur after the colon e.g
+                        #:  ;label
+
+                        #the following is a valid target for @GOTO :#something
+                        #: ;#something
+
+                        #It is possible for  closing bracket ) to also be invisible if there is no open ( active 
+                        #This only seems to work for a single ) at beggining of the line  multiple ) even separated by spaces or ; etc seem to stop the target being found.
+                        #The lone unbalanced ) can act like a comment in other contexts  - and can appear multiple times, but only if first ) on the line is followed by a delimiter
+                        #Essentially all characters following the first ) are ignored - but if the first is something like ))  then cmd tries to interpret that as a command and fails
+                        # e.g  
+                        #) ignored
+                        #);))))  ignored
+                        #))    causes error as cmd tries to run "))" as a command.
+                        #This is a reason why *target* labels shouldn't appear in bracketed blocks - as code jumps to a point where ( ) will be unbalanced
+
+                        #target labels are literal with regards to % ie not subject to % expansion - but ^ must still be processed 
+                        if {[string first : $pline] >= 0} {
+                            #space (and some other chars) allowed between colon and label at target - (but not at callsite)
+                            set labelinfo [batchlib::get_target_label_from_line $pline]
+                            if {[dict get $labelinfo labelfound] && [dict get $labelinfo label] eq $label} {
+                                set target_label_record [list label $label line $p_linenum]
+                                puts stdout "$labelinfo"
+                                incr found_backward_label
+                                set prior_label_posn_in_line [string first : $pline]
+                                set prior_label_posn [expr {$pline_begin + $prior_label_posn_in_line}]
+                                if {($prior_label_posn % 512) == 0} {
+                                    set p_ubound [expr {($prior_label_posn / 512) * 512}]
+                                } else {
+                                    set p_ubound [expr {(($prior_label_posn /512) +1) * 512}]
+                                }
+                                set p_lbound [expr {$p_ubound - $labelsize}]
+                                if {($prior_label_posn >= $p_lbound) && ($prior_label_posn <= $p_ubound)} {
+                                    dict set target_label_record error linestart_and_overlap
+                                    lappend error_labels [list label $label linestart_and_overlap $prior_label_posn callsite [list call ${call}${labelplus} call_linenum $callingline_num]]
+                                    puts stdout "[a+ bold red]ERROR: target-label '$trimpline' at line $p_linenum and offset from file start: $prior_label_posn line start: $pline_begin[a]"
+                                    puts stdout "[a+ bold red]  This target-label appears to span the 512byte boundary at byte $p_ubound[a] [a+ yellow bold]from file start[a]"
+                                    puts [$objFile chunk_boundary_display [dict get $plineinfo start] [dict get $plineinfo end] 512 -linebase 1 -limit 1]
+                                } else {
+                                    dict set target_label_record ok 1
+                                    puts stdout "[a+ bold green]OK: file line: $p_linenum  target-label '$trimpline' before call from line $callingline_num. Target is at offset from file start: $prior_label_posn line start: $pline_begin[a]"
+                                }
+                                dict lappend call_labels_found $label $target_label_record
+                            }
+                            #else - label we weren't searching for - even if at file boundary it should be picked up when actually searched?  review 
+                        }
+                        set spaninfo [fileline::range_spans_chunk_boundaries $pline_start $pline_end 512]
+                        if {[dict get $spaninfo is_span]} {
+                            #puts stdout "boundary spanning line $p_linenum byte range $pline_start -> $pline_end [a+ bold purple]$spaninfo[a]"
+                            #check boundaries within the line
+                            set boundaries [dict get $spaninfo boundaries]
+                            foreach b $boundaries {
+                                if {$b == 0} {
+                                    #skip - beginning of line already handled (review?)
+                                    continue
+                                }
+                                #overlap test is just a warning - we have a label-like thing overlapping the boundary
+                                #todo - take account of fact that target label can be ":  <whitespace or label-ignorable chars> labelname" - so using just labelsize won't detect all overlaps
+                                #The label could even be at the end of a long line that appears at first to be a comment e.g something like
+                                # :   whatever                                                                                                                                                    :                   sneakylabel
+                                # or
+                                #@REM  ============================================================================================================================================================                 : sneakylabel
+
+                                #The fact that it overlaps - means it's probably not being found with lf line-endings - and only the label :whatever should be found with crlf endings 
+                                #- but we won't always catch that something's fishy
+                                #review
+                                set overlaptail [string range $pline [expr {$b - $labelsize}] [expr {($b + $labelsize) -1}]] ;#subtracting  labelsize gives earliest possible overlap
+                                if {[string match "*:$label *" $overlaptail] } {
+                                    lappend warning_labels [list label $label warning label_spanning callsite [list call ${call}${labelplus} call_linenum $callingline_num]]
+                                    puts stdout "[a+ bold yellow] WARNING: possible label $label spans boundary $b from start of file"
+                                }
+
+                                set pline_tail [string range $pline $b end]
+
+                                if {[string first : $pline_tail] >= 0} {
+                                    set labelinfo [batchlib::get_target_label_from_line $pline_tail]
+                                    set labelfound 0
+                                    if {[dict get $labelinfo labelfound] && [dict get $labelinfo label] eq $label} {
+                                        set labelfound 1
+                                    } elseif {[dict get $labelinfo labelfound]} {
+                                        puts stdout "Note: detected target label [dict get $labelinfo label] at file offset $b at boundary with no preceeding newline - but it's not the one we're currently scanning for"
+                                    }
+                                    if {$labelfound} {
+                                        set label_found_name [dict get $labelinfo label]
+                                        incr found_backward_label
+
+                                        lappend error_labels [list label $label_found_name file_offset_bytes $b note "label at boundary but no preceeding newline - cmd may interpret as label and execute following line or code at next boundary" callsite [list call ${call}${labelplus} call_linenum $callingline_num]]
+
+                                        puts stdout "[a+ bold red]ERROR: *possible* label '$label_found_name' at line $p_linenum and offset from file start: $b line start: $pline_begin[a]"
+                                        puts stdout "[a+ bold red]  This label with no preceeding newline appears to span the 512byte boundary at byte $b[a] [a+ yellow bold]from file start[a]"
+                                        puts stdout "[a+ bold red]  cmd.exe may find this label - but it probably shouldn't be relied upon[a]"
+                                        puts stdout "[a+ bold yellow] label starting at $b : $pline_tail[a]"
+
+                                        set target_label_record [list label $label_found_name line $p_linenum]
+                                        if {$label_found_name in [dict keys $call_labels_found]} {
+                                            dict set target_label_record error "called_label_at_file_offset_boundary"
+                                            dict lappend target_labels_found $label_found_name $target_label_record
+                                        } else {
+                                            #review - we need to get better at finding all calls!
+                                            dict set target_label_record error "uncalled_label_at_file_offset_boundary"
+                                            dict lappend possible_target_labels_found $label_found_name $target_label_record
+                                        }
+
+
+                                        set tail_start $b
+                                        set tail_end [expr {$b + [string length $pline_tail]}]
+                                        set tail_spaninfo [fileline::range_spans_chunk_boundaries $tail_start $tail_end 512]
+                                        if {[dict get $tail_spaninfo is_span]} {
+                                            set tail_boundaries [dict get $tail_spaninfo boundaries]
+                                            set extra_tail_boundaries [lsearch -all -inline -not $tail_boundaries $b]
+                                            if {[llength $extra_tail_boundaries]} {
+                                                puts "Line $p_linenum also spans additional boundaries: $extra_tail_boundaries"
+                                                set next_boundary [lindex $extra_tail_boundaries 0]
+                                                #boundary doesn't reset if no crlf -  we are still within the line - so can calc from line beginning 
+                                                set next_boundary_data [string range $pline [expr {$pline_begin + $next_boundary}] end]
+                                                puts "Line $p_linenum data at next boundary: [a+ yellow bold]$next_boundary_data[a]"
+                                                puts [$objFile chunk_boundary_display [dict get $plineinfo start] [dict get $plineinfo end] 0 -boundaries $next_boundary -linebase 1 -limit 1]
+
+                                                puts "[a+ yellow bold]NOTE: cmd may attempt to treat this data as code[a]"
+                                            }
+                                        } else {
+                                            if {$pidx+1 < [$objFile linecount]} {
+                                                set nextlineinfo [$objFile lineinfo $pidx+1]
+                                                set nextpayload [dict get $nextlineinfo payload]
+                                                puts "Line $p_linenum + 1 has data: [a+ yellow bold]$nextpayload[a]"
+                                                puts "[a+ yellow bold]NOTE: cmd may attempt to treat this data as code[a]"
+                                            } else {
+                                                #EOF reached 
+                                            }
+                                        }
+                                    }
+                                }
+
+                            }
+
+                        } 
+                        incr pline_begin $pline_bytes
+                    }
+
+                    if {$found_forward_label == 0} {
+                        if {[string toupper $label] eq "EOF"} {
+                            #EOF/eof label is special - it doesn't have to exist - but if it does - it probably shouldn't be spanning a boundary
+                            puts stdout "[a+ bold green]OK: label :$label doesn't exist - but it's usually not meant to.  callsite: [list call ${call}${labelplus} call_linenum $callingline_num] [a]"
+                        } else {
+                            if {$found_backward_label == 0} {
+                                lappend warning_labels [list label $label warning label_not_found callsite [list call ${call}${labelplus} call_linenum $callingline_num]]
+                                puts stdout "[a+ bold yellow]WARNING: label :$label not found (in forward or backward scan)[a]"
+                            }
+                        }
+                    }
+                    if {($found_forward_label + $found_backward_label) > 1} {
+                        #puts "target_labels_found: $target_labels_found"
+                        dict for {targetkey targethits} $target_labels_found {
+                            set targetlines [list]
+                            foreach record $targethits {
+                                lappend targetlines [dict get $record line]
+                            } 
+                            set remaining [list]
+                            set previous "" ;
+                            foreach lnum [lsort -integer -increasing $targetlines] {
+                                if {$previous eq ""} {
+                                    lappend remaining $lnum
+                                } else {
+                                    if {$lnum-1 == $previous} {
+                                        puts stdout "[a+ green bold]OK[a] - target-label $targetkey appears on immediately adjacent lines $previous and $lnum - assuming it is a boundary-avoidance tactic rather than an inadvertent duplicate"
+                                        set remaining [lrange $remaining 0 end-1];#retain latest - we will allow a run of targets on subsequent lines
+                                    }
+                                    lappend remaining $lnum
+                                }
+                                set previous [lindex $remaining end]
+                            }
+                            if {[llength $remaining] > 1} {
+                                lappend warning_labels [list label $label warning multiple_target_labels_found callsite [list call ${call}${labelplus} call_linenum $callingline_num]]
+                                puts stdout "[a+ bold yellow]WARNING: label :$label seems to appear multiple times[a]"
+                            }
+                        }
+                    }
+                }
+            }
+            incr file_offset $callingline_len ;#including per-line stored line-ending 
+        }
+        if {[dict size $possible_target_labels_found] > 0} {
+            #puts stdout "Possibly bogus target-labels: [dict keys $possible_target_labels_found]"
+            set bogus_summary [list] 
+            dict for {pb pbrecords} $possible_target_labels_found {
+                if {$pb in [dict keys $call_labels_found]} {
+                    puts stdout "[a+ yellow bold]Warning - target for label $pb was found with a record as being possibly bogus. record: $pbrecords [a]"
+                    puts stdout "[a+ yellow bold]Consider moving this target-label and re-checking[a]"
+                    puts stdout "[a+ yellow bold]It may be a call label line that was found by boundary scanning - which shouldn't really happen[a]"
+                    puts stdout "Call record [dict get $call_labels_found $pb]"
+                    lappend warning_labels [list label $pb warning possibly_bogus_target list_of_target_hits $pbrecords]
+                }
+                set blines [list] 
+                foreach rec $pbrecords {
+                    lappend blines [dict get $rec line]
+                }
+                lappend bogus_summary [list label $pb found_on_lines $blines]
+            }
+            puts stdout "[a+ cyan]Possibly bogus target-labels: $bogus_summary[a]"
+            puts stdout "These are usually nothing to be concerned about. Some will almost always turn up in a polyglot script that contains batch script."
+            puts stdout "If some of the label names appear to contain newlines, or are prefixes of or exact matches with legitimate labels - you might consider adjusting the boundary spacing with whitespace or comments to get a different result." 
+        }
+        set result ""
+        if {[llength $warning_labels]} {
+            append result "WARNING:" \n
+            append result "The following labels had warnings" \n
+            foreach w $warning_labels {
+                append result "    [a+ bold yellow]$w[a]" \n
+            }
+        }
+        if {[llength $error_labels]} {
+            append result "ERROR: label location errors found" \n
+            append result "The following labels appear to span 512 Byte boundaries or occur on boundaries without a preceding newline and are likely to cause batch script errors" \n
+            append result "For labels spanning boundaries the label is likely to be missed by the batch interpreter" \n
+            append result "For labels occuring at boundaries but not at the beginning of a line, the label may be interpreted as a label when not expected, and the interpreter may run code on next line or next boundary" \n
+            append result "Try adding comments and/or spacing between the call site at the call_lineum indicated and the label and then re-test in case there are further boundary collisions" \n
+            foreach err $error_labels {
+                append result "    [a+ bold red]$err[a]" \n
+            }
+        }
+        if {[dict size $warning_target_labels_found] > 0} {
+            puts stdout "target-labels with minor warnings: [dict keys $warning_target_labels_found]"
+        }
+        append result "call-labels-found:   [dict keys $call_labels_found]" \n
+        append result "target-labels-found: [dict keys $target_labels_found]" \n
+        if {![llength $warning_labels] && ![llength $error_labels]} {
+            puts stderr \n
+            puts stderr "[a+ green bold]OK No warnings or errors considered major enough to return in result.[a]"
+        }
+        return $result
+    }
+    #specific filepath to just wrap one script at the  xxx-pre-launch-suprocess site
     #scriptset name to substiture multiple scriptset.xxx files at the default locations - or as specified in scriptset.wrapconf
     proc multishell {filepath_or_scriptset args} {
         set defaults [dict create\
              -askme 1\
              -outputfolder "\uFFFF"\
              -template "\uFFFF"\
+             -returnextra 0\
         ]
         set known_opts [dict keys $defaults]
         dict for {k v} $args {
@@ -126,6 +778,7 @@ namespace eval punk::mix::commandset::scriptwrap {
         set opt_askme       [dict get $opts -askme]
         set opt_template    [dict get $opts -template]
         set opt_outputfolder [dict get $opts -outputfolder]
+        set opt_returnextra [dict get $opts -returnextra]
         # -- --- --- --- --- --- --- --- --- --- --- ---
 
 
@@ -141,13 +794,14 @@ namespace eval punk::mix::commandset::scriptwrap {
             set specified_path [file join $startdir $filepath_or_scriptset]
         }
         set ext [string trim [file extension $filepath_or_scriptset] .]
-        set allowed_extensions [list wrapconfig tcl ps1 sh bash]
+        set allowed_extensions [list wrapconfig tcl ps1 sh bash pl]
+        set extension_langs [list tcl tcl ps1 powershell sh sh bash bash pl perl]
         #set allowed_extensions [list tcl]
         set found_script 0  
         if {[file exists $specified_path]} {
             set found_script 1
         } else {
-            foreach e $allowed_extensions {
+            foreach e [concat $allowed_extensions [string toupper $allowed_extensions]] {
                 if {[file exists $filepath_or_scriptset.$e]} {
                     set found_script 1
                     break
@@ -328,7 +982,15 @@ namespace eval punk::mix::commandset::scriptwrap {
         }
         set output_file [file join $output_folder $scriptset.$output_extension]
         if {[file exists $output_file]} {
-            error "wrap_in_multishell: target file $output_file already exists.. aborting"
+            set fdexisting [open $output_file r]
+            fconfigure $fdexisting -translation binary
+            set existing_file_data [read $fdexisting]
+            close $fdexisting
+            set objFile_existing [fileline::textinfo new $existing_file_data]
+            puts stdout "wrap_in_multishell: target file $output_file already exists. File size: [$objFile_existing chunklen] Line count: [$objFile_existing linecount]"
+
+            $objFile_existing destroy
+            error "aborting.."
         }
         
 
@@ -356,7 +1018,7 @@ namespace eval punk::mix::commandset::scriptwrap {
             lappend list_input_files $scriptroot/$scriptset.$ext
         }
 
-        #todo - split template at each <ext-payload> etc marker and build a dict of parts
+        #todo - split template at each <ext-*-subprocess> etc marker and build a dict of parts
 
 
         #hack - process one input
@@ -374,7 +1036,9 @@ namespace eval punk::mix::commandset::scriptwrap {
             puts stdout $ln
         }
         puts stdout "-----------------------------------------------\n"
-        puts stdout "Target for above data is '$output_file'"
+        puts stdout "Target for above script data is '$output_file'"
+        set lang [dict get $extension_langs [string tolower $ext]]
+        puts stdout "Language of script being wrapped is $lang"
         if {$opt_askme} {
             set answer [util::askuser "Does this look correct? Y|N"]
             if {[string tolower $answer] ne "y"} {
@@ -389,9 +1053,9 @@ namespace eval punk::mix::commandset::scriptwrap {
         set existing_payload [list]
         foreach ln $template_lines {
 
-            if {[string match  "#<tcl-payload>*" $ln]} {
+            if {[string match  "#<$lang-pre-launch-subprocess>*" $ln]} {
                 set start_idx $line_idx
-            } elseif {[string match "#</tcl-payload>*" $ln]} {
+            } elseif {[string match "#</$lang-pre-launch-subprocess>*" $ln]} {
                 set end_idx $line_idx
                 break
             } elseif {$start_idx > 0} {
@@ -404,20 +1068,20 @@ namespace eval punk::mix::commandset::scriptwrap {
             incr line_idx
         }
         if {($start_idx == 0) || ($end_idx == 0)} {
-            error "wrap_in_multishell was unable to find payload area in template marked with #<tcl-payload>  and #</tcl-payload> on separate lines"
+            error "wrap_in_multishell was unable to find payload area in template marked with #<$lang-pre-launch-subprocess>  and #</$lang-pre-launch-subprocess> on separate lines"
         }
         set existing_string [join $existing_payload \n]
         if {[string length [string trim $existing_string]]} {
-            puts stdout "EXISTING PAYLOAD!!"
+            puts stdout "EXISTING <$lang-pre-launch-subprocess> PAYLOAD!!"
             puts stdout "-----------------------------------------------\n"
             puts stdout $existing_string
             puts stdout "-----------------------------------------------\n"
-            error "wrap_in_multishell found existing payload.. aborting."
+            error "wrap_in_multishell found existing payload for language $lang ... aborting."
             #todo - allow overwrite only in files outside of punkshell distribution?
             if 0 {
-                puts stderr "Found existing payload.. overwrite?" 
+                puts stderr "Found existing $lang payload.. overwrite?" 
                 if {$opt_askme} {
-                    set answer [util::askuser "Are you sure you want to replace the tcl payload shown above? Y|N"]
+                    set answer [util::askuser "Are you sure you want to replace the $lang payload shown above? Y|N"]
                     if {[string tolower $answer] ne "y"} {
                         puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -askme 0 to avoid prompts."
                         return
@@ -436,78 +1100,80 @@ namespace eval punk::mix::commandset::scriptwrap {
         puts -nonewline $fdtarget $newscript
         close $fdtarget
         puts stdout "Wrote script file at $output_file"
-
+        set check_result [checkfile $output_file]
+        set with_errors ""
+        set with_warnings ""
+        set call_labels [list]
+        set target_labels [list]
+        set errorlist [list]
+        set warninglist [list]
+        if {$check_result ne ""} {
+            puts stdout $check_result
+            set check_lines [split $check_result \n]
+            foreach cl $check_lines {
+                set trimcl [string trim $cl]
+                if {[string match "ERROR:*" $trimcl]} {
+                    set with_errors "[a+ bold red]with errors[a]" 
+                    lappend errorlist $trimcl
+                }
+                if {[string match "WARNING:*" $trimcl]} {
+                    set with_warnings "[a+ bold yellow] with warnings[a]"
+                    lappend errorlist $trimcl
+                }
+                if {[string match "call-labels-found:*" $trimcl]} {
+                    set call_labels [string trim [string range $trimcl [string length "call-labels-found:"] end]]
+                }
+                if {[string match "target-labels-found:*" $trimcl]} {
+                    set target_labels [string trim [string range $trimcl [string length "target-labels-found:"] end]]
+                }
+            }
+        } else {
+            puts stderr "Expected output from checkfile - but got none"
+        }
         #even though chmod might exist on windows - we will leave permissions alone
         if {$::tcl_platform(platform) ne "windows"} {
             catch {exec chmod +x $output_file}
         }
-        puts stdout "-done-"
-        return $output_file
+        puts stdout "-done- $with_errors $with_warnings"
+        if {$opt_returnextra} {
+            set result [list filename $output_file batch_call_labels $call_labels batch_target_labels $target_labels]
+            if {[llength $warninglist]} {
+                dict set result warnings $warninglist
+            }
+            if {[llength $errorlist]} {
+                dict set result errors $errorlist
+            }
+        } else {
+            set result [list filename $output_file]
+        }
+
+        return $result
     }
 
     namespace eval lib {
 
-        #get_wrapper_folders
-        #   scriptpath - file or folder
-        #   It represents the base point from which to search for /wrapper folders either directly above the scriptpath or in the containing project if any
-        #   The cwd will also be searched for /wrapper folder and project - but with lower precedence in the resultset (later in list)
-        proc get_wrapper_folders {{scriptpath ""}} {
-            set wrapper_folders [list]
-            if {$scriptpath ne ""} {
-                if {[file type $scriptpath] eq "file"} {
-                    set searchbase [file dirname $scriptpath]
-                } else {
-                    set searchbase $scriptpath
-                }
-                if {[file isdirectory [file join $searchbase wrappers]]} {
-                    lappend wrapper_folders [file join $searchbase wrappers]
-                }
-                set pathinfo    [punk::repo::find_repos $searchbase]
-                set scriptpath_projectroot [dict get $pathinfo closest]
-                if {$scriptpath_projectroot ne ""} {
-                    set fld [file join $scriptpath_projectroot src/scriptapps/wrappers]
-                    if {[file isdirectory $fld]} {
-                        if {$fld ni $wrapper_folders} {
-                            lappend wrapper_folders $fld
-                        }
-                    }
-                }
-            }
-            set searchbase [pwd] 
-            set fld [file join $searchbase wrappers]
-            if {[file isdirectory $fld]} {
-                if {$fld ni $wrapper_folders} {
-                    lappend wrapper_folders $fld
-                }
-            }
-            set pathinfo    [punk::repo::find_repos $searchbase]
-            set pwd_projectroot [dict get $pathinfo closest]
-            if {$pwd_projectroot ne ""} {
-                set fld [file join $pwd_projectroot src/scriptapps/wrappers]
-                if {[file isdirectory $fld]} {
-                    if {$fld ni $wrapper_folders} {
-                        lappend wrapper_folders $fld
-                    }
-                }
-            }
 
-            set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-            set tpldirs [list]
-            dict for {tdir tsourceinfo} $template_base_dict {
-                if {[file exists $tdir/utility/scriptappwrappers]} {
-                        lappend tpldirs $tdir
-                } 
-            }
-            foreach tpldir $tpldirs {
-                set fld [file join $tpldir utility scriptappwrappers]
-                if {[file isdirectory $fld]} {
-                    if {$fld ni $wrapper_folders} {
-                        lappend wrapper_folders $fld
-                    }
+        proc get_wrapper_folders {args} {
+            set opts [dict get [punk::get_leading_opts_and_values { 
+                 -scriptpath ""
+            } $args -maxvalues 0] opts] 
+            # -- --- --- --- --- --- --- --- ---
+            set opt_scriptpath [dict get $opts -scriptpath]
+            # -- --- --- --- --- --- --- --- ---
+
+            set wrapper_template_bases [list]
+            set tbasedict [punk::mix::base::lib::get_template_basefolders $opt_scriptpath]
+            dict for {tbase folderinfo} $tbasedict {
+                set wrapf [file join $tbase utility/scriptappwrappers]
+                if {[file isdirectory $wrapf]} {
+                    lappend wrapper_template_bases [list basefolder $wrapf sourceinfo $folderinfo]
                 }
             }
-            return $wrapper_folders
+            return $wrapper_template_bases
         }
+
+
+        
         proc _scriptapp_tag_from_line {line} {
             set result [list istag 0 raw ""] ;#default assumption. All 
             #----
@@ -656,6 +1322,238 @@ namespace eval punk::mix::commandset::scriptwrap {
 
     }
 
+    namespace eval batchlib {
+        #
+        #see also: https://www.dostips.com/forum/viewtopic.php?t=3803  'Rules for label names vs GOTO and CALL
+        # review - we may need different get_callsite_label functions?
+    
+        proc get_callsite_label {labelstart} {
+            #labelstart is the character immediately following the colon (which is optional at callsite) - a label such as ::label doesn't seem valid at call or target sites
+            #e.g for @goto %= possible comment=% :mylabe%%l etc
+            #we would expect to be passed only "mylabe%%1 etc"
+            #It is up to the caller to determine where a callsite label begins.
+            #note that:
+            #@REM -----
+            #@goto ^
+            #:label 
+            #@REM-----
+            # is a valid callsite - but doesn't appear to be found by the label scanner as it's own target label even though :label is on it's own line from non-batch perspective
+            # so the caller will have to do some batch-style line processing to find all call sites
+            #Also, for the following 2 lines 
+            #@REM ^
+            #:label
+            # the label will be found - yet if the :label was a command such as @GOTO - it would not be run as a callsite 
+
+
+            #a quick'n'dirty fix for some ways various escapes are handled within labels at callsite.
+            #There seem to be very different rules for labels at target site - presumably because they are not part of a command
+            # Mostly it seems target labels are more literal with regards to % chars - but ^ are processed the same way at target label
+            #some rules..
+            #callsite labels can't have space between : and label - but target labels can
+            #label terminated by =,: even if prefixed by ^ and even if in squotes or dquotes
+            #squotes and dquotes otherwise pass through as part of label
+            #may resolve variables within the label - but characters from variable value can terminate.
+            #as we don't have access to the variable values - we should normalize %varname% to empty string at callsite - but perhaps emit warning somewhere 
+            # The target labels don't seem to 
+            #a single % resolves to empty - depending. (starts invar processing - and decides if it was a var depending on whether it was closed?)
+            #sequences of % don't begin a var - number of % in labelname = number of %s divided by 2 and rounded down. ie 1->0 2->1 3-> 1 4->2 5->2 6->3 etc
+            #spaces in % wrapped var names don't terminate label 
+            #spaces aren't escaped by ^ or quoting
+            #sequences of ^ seem to follow same counting rule as %
+            #e.g  @goto :la%path%bel  where path begins with C:\Program Files..   becomes label :laC
+
+            if {[string index $labelstart 0] in [list : " " \t = {;}]} {
+                #return everything as tail - nothing was consumed
+                return [list labelfound 0 note "invalid first character for callsite label" tail $labelstart]
+            }
+
+            #The due to whitespace and most chars except : and % being alowed inside vars - it seems the best first step
+            # -------------- start % handling %
+            set inputchars [split $labelstart ""]
+            set percentrun 0 ;#0|1 because we use invar-toggling rather than running total of number of percents in a sequence
+            set invar 0
+            set labelout ""
+            set varsfound [list]
+            set varterminals [list :]
+            set labelterminals [list + , {;} = " " \t]
+            set varname ""
+            set caretseq 0
+            set inputconsumed 0 
+            foreach c $inputchars {
+                if {!$invar} {
+                    if {$c eq "%"} {
+                        set caretseq 0
+                        set lookahead [lrange $inputchars $inputconsumed+1 end]
+                        if {"%" in $lookahead} {
+                            set invar 1
+                            incr percentrun
+                        } else {
+                            incr percentrun 
+                        }
+                    } elseif {$c eq "^"} {
+                        if {$caretseq} {
+                            set caretseq 0
+                            append labelout "^" ;#for every pair encountered in direct sequence - second gets included in label
+                        } else {
+                            set caretseq 1
+                        }
+                    } else { 
+                        set caretseq 0
+                        if {$percentrun && ($c in [list 0 1 2 3 4 5 6 7 8 9])} {
+                            #subst %i with value - here we have no way of getting that - so use blank - user will get warning that target not found
+                            set percentrun 0
+                        } else {
+                            append labelout [string repeat % [expr {$percentrun / 2}]] 
+                            set percentrun 0
+                            if {$c in $labelterminals} {
+                                break
+                            }
+                            append labelout $c
+                        }
+                    }
+                } else {
+                    #in var - don't do anything with carets(?)
+                    if {$c eq "%" && $percentrun == 1} {
+                        #double percent - rather than just an empty var - emit one % 
+                        append labelout %
+                        set invar 0
+                        set percentrun 0
+                    } elseif {$c eq "%"} {
+                        #presume percentrun is 0 
+                        set invar 0
+                        lappend varsfound $varname; set varname ""
+                    } elseif {$c in $varterminals} { 
+                        set invar 0
+                        lappend varsfound $varname; set varname ""
+                    } else {
+                        if {$percentrun && ($c in [list 0 1 2 3 4 5 6 7 8 9])} {
+                            #review - seems to terminate var - and substitute?
+                            #this branch untested  - case where we have %i  and further %  - what if it was %1var% ? does %1 get substituted ? or %1var% - test
+                            set invar 0
+                            append varname $c
+                        } else {
+                            append varname $c
+                        }
+                        set percentrun 0
+                    }
+                }
+                incr inputconsumed
+            }
+            # -------------- end % handling %
+            set tail [string range $labelstart $inputconsumed end]
+            #caret -- etc
+            if {$labelout eq ""} {
+                set resultdict [dict create labelfound 0]
+                if {[llength $varsfound]} {
+                    dict set resultdict vars $varsfound
+                    dict set resultdict note "empty label but vars exist - may be legit"
+                } else {
+                    dict set resultdict note "empty label - no vars"
+                }
+                dict set resultdict tail $tail
+                return $resultdict
+            }
+
+            return [list labelfound 1 label $labelout tail $tail]
+        }
+        proc get_target_label_from_line {labelline} {
+            #scan a whole line - or a 'line' starting at some chunk boundary we found for a label
+            #caller should resolve any trailing caret and subsequent line and include them in the call
+            #note that we may be scanning all sorts of things in a polyglot file - but we're interested in seeing if cmd.exe might interpret it as a label
+            #target labels don't have %var% processing - they will be literal
+            set firstcolon [string first : $labelline]
+            if {$firstcolon == -1} {
+                return [list labelfound 0 note "no_colon"]
+            }
+            set prefixpart [string range $labelline 0 $firstcolon-1]
+            set targetpart [string range $labelline $firstcolon+1 end]
+
+            set prefixok 1;#default assumption
+            set invisible_prefix_chars [list {;} , = " " \t]
+            set prefixchars [split $prefixpart ""] 
+            # % and ^ in the prefix - whether doubled etc or not - will stop label being found
+            #ANY first char seems to be allowed in prefixpart (it won't be colon, because we already split on that)
+            #perhaps this is done by cmd.exe to reduce off-by-one errors??  weird...
+            # but it does allow labels to be found in certain # tcl/bashsh comment lines, which could be both dangerous and ...useful.
+            #start prefix check at char 1 instead of 0
+            foreach pchar [lrange $prefixchars 1 end] {
+                if {$pchar ni $invisible_prefix_chars} {
+                    set prefixok 0
+                    break
+                }
+            }
+            if {!$prefixok} {
+                return [list labelfound 0 note "prefix_fail"]
+            }
+
+            #no problems before colon - now see if targetpart can be interpreted as a label
+            #we again have some potential invisible chars before label begins.
+            set charindex [expr {$firstcolon +1}] ;#track position so we can return index of where we believe label begins
+            set targetchars [split $targetpart ""] 
+            set inlabel 0
+            set labelposn -1
+            # --- 
+            set inlabel_terminals [list : + " " \t \r \n] ;# , ; =  don't seem to terminate a target label, but do terminate a calling label 
+            # + and whitespace terminate caller and target
+            # --- 
+            # consider:
+            #@goto :14^
+            # :14^ 
+            #caller is searching for label "14" but won't match - presumably target scanner has escaped the trailing space
+            set label ""
+            set rawlabel ""
+            set caretseq 0 ;# 0|1
+            foreach tchar $targetchars {
+                if {$tchar in [list + :]} {
+                    break
+                }
+                if {!$inlabel} {
+                    if {$tchar ni $invisible_prefix_chars} {
+                        #beginning of target label
+                        set labelposn $charindex
+                        set inlabel 1 
+                        append rawlabel $tchar
+                        if {$tchar eq "^"} {
+                            set caretseq 1
+                        } else {
+                            append label $tchar
+                        }
+                    }
+                } else {
+                    if {$tchar in $inlabel_terminals} {
+                        #caret stops them from terminating
+                        if {$caretseq} {
+                            set caretseq 0
+                            append label $tchar
+                            append rawlabel $tchar
+                        } else {
+                            break
+                        }
+                    } else {
+                        append rawlabel $tchar
+                        if {$tchar eq "^"} {
+                            if {$caretseq} {
+                                set caretseq 0
+                                append label "^" ;#for every pair encountered in direct sequence - second gets included in label
+                            } else {
+                                set caretseq 1
+                            }
+                        } else {
+                            set caretseq 0
+                            append label $tchar ;#for target labels - all including %var% is directly part of the label target
+                        }
+                    }
+                }
+                incr charindex
+            }
+            if {$labelposn == -1} {
+                return [list labelfound 0 note "no_label_found_after_colon"]
+            }
+
+            #return rawlabel so we can see it as it appears in the data - as opposed to how it is interpreted as a label by cmd.exe
+            return [list labelfound 1 label $label rawlabel $rawlabel]
+        }
+    }
 
 }
 
diff --git a/src/bootsupport/modules/punk/mix/templates-0.1.0.tm b/src/bootsupport/modules/punk/mix/templates-0.1.0.tm
index 46065bda..5521ad8a 100644
--- a/src/bootsupport/modules/punk/mix/templates-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/templates-0.1.0.tm
@@ -26,19 +26,28 @@ namespace eval punk::mix::templates {
     variable pkg punk::mix::templates
     variable cap_provider
 
-    #punk::cap::register_package punk::mix::templates [list\
-    #   {punk.templates {relpath ../templates}}\
-    #]
-
     namespace eval capsystem {
         if {[info commands capprovider.registration] eq ""} {
             punk::cap::class::interface_capprovider.registration create capprovider.registration
             oo::objdefine capprovider.registration {
                 method get_declarations {} {
                     set decls [list]
-                    lappend decls [list punk.templates {relpath ../templates}]
-                    lappend decls [list punk.templates {relpath ../templates2}]
-                    lappend decls [list punk.test {something blah}]
+                    lappend decls [list punk.templates {path templates pathtype adhoc vendor _project}] ;#todo - split out to a different provider package?
+
+                    lappend decls [list punk.templates {path templates pathtype module vendor punk}]
+                    #only punk::templates is allowed to register a _multivendor path - review
+                    #other punk.template providers should use module, absolute, currentproject and shellproject pathtypes only
+                    lappend decls [list punk.templates {path src/decktemplates pathtype currentproject_multivendor vendor punk}]
+                    lappend decls [list punk.templates {path decktemplates pathtype shellproject_multivendor vendor punk}]
+
+
+                    #we need a way to ensure we don't pull updates from a remote repo into a local project that is actually the same project ? review!
+                    #need flags as to whether/how provider allows template updates that are out of sync with the provider pkg version
+                    #perhaps a separate .txt file (alongside buildversion and description txt files) that has some package require statements (we can't put them in the template itself as the filled template may have nothing to do with the punk.templates provider)
+                    lappend decls [list punk.templates {path src/decktemplates/vendor/punk pathtype currentproject vendor punk allowupdates 0 repo "https://www.gitea1.intx.com.au/jn/punkshell" reposubdir "src/decktemplates/vendor/punk"}]
+                    lappend decls [list punk.isbogus {provider punk::mix::templates something blah}] ;#some  capability for which there is no handler to validate - therefore no warning will result.
+                    #review - we should report unhandled caps somewhere, or provide a mechanism to detect/report.
+                    #we don't want to warn at the time this provider is loaded - as handler may legitimately be loaded later. 
                     return $decls
                 }
             }
@@ -62,6 +71,7 @@ namespace eval punk::mix::templates {
     #provider api
     # -- ---
     #none - declarations only
+    #todo - template folder install/update/status methods?
 }
 
 
diff --git a/src/modules/punk/mix/templates/layouts/project/src/_vfscommon/lib/common_vfs_libs b/src/bootsupport/modules/punk/mix/templates/layout_refs/project@vendor+punk+project-0.1.ref
similarity index 100%
rename from src/modules/punk/mix/templates/layouts/project/src/_vfscommon/lib/common_vfs_libs
rename to src/bootsupport/modules/punk/mix/templates/layout_refs/project@vendor+punk+project-0.1.ref
diff --git a/src/bootsupport/modules/punk/mix/templates/modules/modulename_buildversion.txt b/src/bootsupport/modules/punk/mix/templates/modules/modulename_buildversion.txt
new file mode 100644
index 00000000..53815fbd
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/modules/modulename_buildversion.txt
@@ -0,0 +1,3 @@
+%Major.Minor.Level%
+#First line must be a semantic version number
+#all other lines are ignored.
diff --git a/src/bootsupport/modules/punk/mix/templates/modules/modulename_description.txt b/src/bootsupport/modules/punk/mix/templates/modules/modulename_description.txt
new file mode 100644
index 00000000..ddb209af
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/modules/modulename_description.txt
@@ -0,0 +1,10 @@
+Identifier: %package%
+Version: %version%
+Title: %title%
+Creator: %name% <%email%>
+Description: %description%
+Rights: BSD
+URL: %url%
+Available: 
+Architecture: tcl
+Subject: 
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/a b/tcltest.bat b/src/bootsupport/modules/punk/mix/templates/utility/a b/tcltest.bat
new file mode 100644
index 00000000..4f798a83
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/a b/tcltest.bat	
@@ -0,0 +1,7 @@
+::lindex tcl;#\
+@call tclsh "%~dp0%~n0.bat" %* & goto :eof
+# --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl
+puts stdout "script: [info script]"
+puts stdout "argv: $::argc"
+puts stdout "args: '$::argv'"
+
diff --git a/src/modules/punk/mix/templates/layouts/project/src/scriptapps/wrappers/sample_punk-multishell.cmd b/src/bootsupport/modules/punk/mix/templates/utility/multishell.cmd
similarity index 100%
rename from src/modules/punk/mix/templates/layouts/project/src/scriptapps/wrappers/sample_punk-multishell.cmd
rename to src/bootsupport/modules/punk/mix/templates/utility/multishell.cmd
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/multishell.ps1 b/src/bootsupport/modules/punk/mix/templates/utility/multishell.ps1
new file mode 100644
index 00000000..c2905c97
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/multishell.ps1
@@ -0,0 +1,256 @@
+set -- "$@" "a=[list shebangless punk MULTISHELL tclsh sh bash cmd pwsh powershell;proc Hide s {proc $s args {}}; Hide :;rename set s2;Hide set;s2 1 list]"; set -- : "$@"; $1 = @'
+: heredoc1 - hide from powershell (close sqote for unix shells) ' \
+: << 'HEREDOC1B_HIDE_FROM_BASH_AND_SH'
+: .bat/.cmd launch section, leading colon hides from cmd, trailing slash hides next line from tcl \
+: "[Hide @ECHO; Hide ); Hide (;Hide echo]#not necessary but can help avoid errs in testing"
+: Continuation char at end of this line and rem with curly-braces used to exlude Tcl from the whole cmd block \
+@REM {
+@REM DO NOT MODIFY FIRST LINE OF THIS SCRIPT. shebang #! line is not required and will reduce functionality.
+@REM Even comment lines can be part of the functionality of this script - modify with care.
+@REM Change the value of nextshell in the next line if desired, and code within payload sections as appropriate.
+@SET "nextshell=pwsh"
+@REM nextshell set to pwsh,sh,bash or tclsh
+@REM @ECHO nextshell is %nextshell%
+@SET "validshells=pwsh,sh,bash,tclsh"
+@CALL SET keyRemoved=%%validshells:%nextshell%=%%
+@REM Note that 'powershell' e.g v5 is just a fallback for when pwsh is not available
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@REM  -- cmd/batch file section (ignored on unix)
+@REM  -- This section intended only to launch the next shell
+@REM  -- Avoid customising this if possible. cmd/batch script is probably the least expressive language.
+@REM  -- custom windows payloads should be in powershell,tclsh or sh/bash code sections
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@SETLOCAL EnableExtensions EnableDelayedExpansion
+@SET "winpath=%~dp0"
+@SET "fname=%~nx0"
+@REM @ECHO fname %fname%
+@REM @ECHO winpath %winpath%
+@IF %nextshell%==pwsh (
+    CALL pwsh -nop -c set-executionpolicy -Scope CurrentUser RemoteSigned
+    COPY "%~dp0%~n0.cmd" "%~dp0%~n0.ps1" >NUL 
+    REM test availability of preferred option of powershell7+ pwsh
+    CALL pwsh -nop -nol -c write-host "statusmessage: pwsh-found" >NUL
+    SET pwshtest_exitcode=!errorlevel!
+    REM ECHO pwshtest_exitcode !pwshtest_exitcode!
+    IF !pwshtest_exitcode!==0 CALL pwsh -nop -nol "%~dp0%~n0.ps1" %* & SET task_exitcode=!errorlevel!
+    REM fallback to powershell if pwsh failed 
+    IF NOT !pwshtest_exitcode!==0 (
+        REM CALL powershell -nop -nol -c write-host powershell-found
+        CALL powershell -nop -nol -file "%~dp0%~n0.ps1" %*
+        SET task_exitcode=!errorlevel!
+    )
+) ELSE ( 
+    IF %nextshell%==bash (
+        CALL :getWslPath %winpath% wslpath
+        REM ECHO wslfullpath "!wslpath!%fname%"
+        CALL %nextshell% "!wslpath!%fname%" %* & SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM  probably tclsh or sh
+        IF NOT "x%keyRemoved%"=="x%validshells%" (
+            REM sh uses /c/ instead of /mnt/c - at least if using msys. Todo, review what is the norm on windows with and without msys2,cygwin,wsl
+            REM and what logic if any may be needed. For now sh with /c/xxx seems to work the same as sh with c:/xxx
+            CALL %nextshell% "%~dp0%fname%" %* & SET task_exitcode=!errorlevel!
+        ) ELSE (
+            ECHO %fname% has invalid nextshell value %nextshell% valid options are %validshells%
+            SET task_exitcode=66
+            GOTO :exit
+        )
+    )
+)
+@GOTO :endlib
+:getWslPath
+@SETLOCAL
+    @SET "_path=%~p1"
+    @SET "name=%~nx1"
+    @SET "drive=%~d1"
+    @SET "rtrn=%~2"
+    @SET "result=/mnt/%drive:~0,1%%_path:\=/%%name%"
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        ECHO %result%
+    )
+)
+@GOTO :eof
+:endlib
+
+: \
+@REM @SET taskexit_code=!errorlevel! & goto :exit
+@GOTO :exit
+# }
+# rem call %nextshell% "%~dp0%~n0.cmd" %* 
+# -*- tcl -*-
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- tcl script section
+# -- This is a punk multishell file
+# -- Primary payload target is Tcl, with sh,bash,powershell as helpers
+# -- but it may equally be used with any of these being the primary script.
+# -- It is tuned to run when called as a batch file, a tcl script a sh/bash script or a pwsh/powershell script
+# -- i.e it is a polyglot file.
+# -- The specific layout including some lines that appear just as comments is quite sensitive to change.
+# -- It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# -- e.g ./filename.polypunk.cmd in sh or bash
+# -- e.g tclsh filename.cmd
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+rename set ""; rename s2 set; set k {-- "$@" "a}; if {[info exists ::env($k)]} {unset ::env($k)} ;# tidyup
+Hide :exit;Hide {<#};Hide '@
+namespace eval ::punk::multishell {
+    set last_script_root    [file dirname [file normalize ${argv0}/__]]
+    set last_script         [file dirname [file normalize [info script]/__]] 
+    if {[info exists argv0] &&
+        $last_script eq $last_script_root
+        } {
+        set ::punk::multishell::is_main($last_script) 1 ;#run as executable/script - likely desirable to launch application and return an exitcode
+    } else {
+        set ::punk::multishell::is_main($last_script) 0 ;#sourced - likely to be being used as a library - no launch, no exit. Can use return.
+    }
+    if {"::punk::multishell::is_main" ni [info commands ::punk::multishell::is_main]} {
+        proc ::punk::multishell::is_main {{script_name {}}} {
+            if {$script_name eq ""} {
+                set script_name [file dirname [file normalize [info script]/--]]
+            }
+            return [set ::punk::multishell::is_main($script_name)]
+        }
+    }
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+#puts "argv0    : $::argv0"
+# -- --- --- --- --- --- --- --- --- --- --- ---
+
+
+
+#<tcl-payload>
+
+
+
+# -- --- --- --- --- --- --- --- --- --- --- ---
+# -- Best practice is to always return or exit above, or just by leaving the below defaults in place.
+# -- If the multishell script is modified to have Tcl below the Tcl Payload section,
+# -- then Tcl bracket balancing needs to be carefully managed in the shell and powershell sections below.
+# -- Only the # in front of the two relevant if statements below needs to be removed to enable Tcl below
+# -- but the sh/bash 'then' and 'fi' would also need to be uncommented.
+# -- This facility left in place for experiments on whether configuration payloads etc can be appended
+# -- to tail of file - possibly binary with ctrl-z char - but utility is dependent on which other interpreters/shells
+# -- can be made to ignore/cope with such data.
+if {[::punk::multishell::is_main]} {
+    exit 0
+} else {
+    return 
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+# end hide from unix shells \
+HEREDOC1B_HIDE_FROM_BASH_AND_SH
+# sh/bash \
+shift && set -- "${@:1:$#-1}"
+#------------------------------------------------------
+# -- This if block only needed if Tcl didn't exit or return above.
+if false==false # else {
+    then
+    :
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- sh/bash script section
+# -- leave as is if all that is required is launching the Tcl payload"
+# --
+# -- Note that sh/bash script isn't called when running a .bat/.cmd from cmd.exe on windows by default
+# -- adjust  @call line above ...  to something like @call sh ... @call bash ..  or @call env sh ... etc as appropriate
+# --   if sh/bash scripting needs to run on windows too.
+# --
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin sh Payload
+#printf "start of bash or sh code"
+
+#<shell-payload-pre-tcl>
+
+# -- --- --- --- --- --- --- ---
+exitcode=0 ;#default assumption
+#-- sh/bash launches Tcl here instead of shebang line at top
+#-- use exec to use exitcode (if any) directly from the tcl script
+#exec /usr/bin/env tclsh "$0" "$@"
+#-- alternative - can run sh/bash script after the tcl call.
+/usr/bin/env tclsh "$0" "$@"
+exitcode=$?
+#echo "tcl exitcode: ${exitcode}"
+#-- override exitcode example 
+#exit 66
+# -- --- --- --- --- --- --- ---
+
+#<shell-payload-post-tcl>
+
+
+#printf "sh/bash done \n"
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end sh Payload
+#------------------------------------------------------
+fi
+exit ${exitcode}
+# end hide sh/bash block from Tcl
+# This comment with closing brace should stay in place whether if commented or not }
+#------------------------------------------------------
+# begin hide powershell-block from Tcl - only needed if Tcl didn't exit or return above
+if 0 {
+: end heredoc1 - end hide from powershell \
+'@ 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- powershell/pwsh section
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+function GetScriptName { $myInvocation.ScriptName }
+$scriptname = getScriptName
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin powershell Payload
+#"Timestamp         :    {0,10:yyyy-MM-dd HH:mm:ss}"    -f $(Get-Date)   | write-host
+#"Script Name       :    {0}"    -f $scriptname                          | write-host
+#"Powershell Version:    {0}"    -f $PSVersionTable.PSVersion.Major      | write-host
+#"powershell args   :    {0}"    -f ($args -join ", ")                   | write-host
+# -- --- --- ---
+
+#<powershell-payload-pre-tcl>
+
+
+# -- --- --- --- --- --- --- ---
+tclsh $scriptname $args
+# -- --- --- --- --- --- --- ---
+
+
+#<powershell-payload-post-tcl>
+
+# unbal }
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end powershell Payload
+#"powershell reporting exitcode: {0}" -f $LASTEXITCODE | write-host
+Exit $LASTEXITCODE
+# heredoc2 for powershell to ignore block below
+$1 = @'
+'
+: end hide powershell-block from Tcl \
+# This comment with closing brace should stay in place whether 'if' commented or not }
+: cmd exit label - return exitcode 
+:exit
+: \
+@REM @ECHO exitcode: !task_exitcode!
+: \
+@EXIT /B !task_exitcode!
+# cmd has exited
+: end heredoc2 \
+'@
+<#
+# id:tailblock0
+# -- powershell multiline comment 
+#>
+<#
+# id:tailblock1
+# <ctrl-z>
+
+# </ctrl-z>
+# -- unreachable by tcl directly if ctrl-z character is in the <ctrl-z> section above. (but file can be read and split on \x1A)
+# -- Potential for zip and/or base64 contents, but we can't stop pwsh parser from slurping in the data
+# -- so for example a plain text tar archive could cause problems depending on the content.
+# -- final line in file must be the powershell multiline comment terminator or other data it can handle.
+# -- e.g plain # comment lines will work too
+# -- (for example a powershell digital signature is a # commented block of data at the end of the file)
+#>
+
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/basic/multishell-old.cmd b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/basic/multishell-old.cmd
new file mode 100644
index 00000000..1cb9e0ef
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/basic/multishell-old.cmd
@@ -0,0 +1,270 @@
+set -- "$@" "a=[list shebangless punk MULTISHELL tclsh sh bash cmd pwsh powershell;proc Hide s {proc $s args {}}; Hide :;rename set s2;Hide set;s2 1 list]"; set -- : "$@"; $1 = @'
+: heredoc1 - hide from powershell (close sqote for unix shells) ' \
+: << 'HEREDOC1B_HIDE_FROM_BASH_AND_SH'
+: .bat/.cmd launch section, leading colon hides from cmd, trailing slash hides next line from tcl \
+: "[Hide @ECHO; Hide ); Hide (;Hide echo]#not necessary but can help avoid errs in testing"
+: Continuation char at end of this line and rem with curly-braces used to exlude Tcl from the whole cmd block \
+@REM {
+@REM DO NOT MODIFY FIRST LINE OF THIS SCRIPT. shebang #! line is not required and will reduce functionality.
+@REM Even comment lines can be part of the functionality of this script - modify with care.
+@REM Change the value of nextshell in the next line if desired, and code within payload sections as appropriate.
+@SET "nextshell=pwsh"
+@REM nextshell set to pwsh,sh,bash or tclsh
+@REM @ECHO nextshell is %nextshell%
+@SET "validshells=pwsh,sh,bash,tclsh"
+@CALL SET keyRemoved=%%validshells:%nextshell%=%%
+@REM Note that 'powershell' e.g v5 is just a fallback for when pwsh is not available
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@REM  -- cmd/batch file section (ignored on unix)
+@REM  -- This section intended only to launch the next shell
+@REM  -- Avoid customising this if possible. cmd/batch script is probably the least expressive language.
+@REM  -- custom windows payloads should be in powershell,tclsh or sh/bash code sections
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@SETLOCAL EnableExtensions EnableDelayedExpansion
+@SET "winpath=%~dp0"
+@SET "fname=%~nx0"
+@REM @ECHO fname %fname%
+@REM @ECHO winpath %winpath%
+@IF %nextshell%==pwsh (
+    CALL pwsh -nop -c set-executionpolicy -Scope CurrentUser RemoteSigned
+    COPY "%~dp0%~n0.cmd" "%~dp0%~n0.ps1" >NUL 
+    REM test availability of preferred option of powershell7+ pwsh
+    CALL pwsh -nop -nol -c write-host "statusmessage: pwsh-found" >NUL
+    SET pwshtest_exitcode=!errorlevel!
+    REM ECHO pwshtest_exitcode !pwshtest_exitcode!
+    IF !pwshtest_exitcode!==0 CALL pwsh -nop -nol "%~dp0%~n0.ps1" %* & SET task_exitcode=!errorlevel!
+    REM fallback to powershell if pwsh failed 
+    IF NOT !pwshtest_exitcode!==0 (
+        REM CALL powershell -nop -nol -c write-host powershell-found
+        CALL powershell -nop -nol -file "%~dp0%~n0.ps1" %*
+        SET task_exitcode=!errorlevel!
+    )
+) ELSE ( 
+    IF %nextshell%==bash (
+        CALL :getWslPath %winpath% wslpath
+        REM ECHO wslfullpath "!wslpath!%fname%"
+        CALL %nextshell% "!wslpath!%fname%" %* & SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM  probably tclsh or sh
+        IF NOT "x%keyRemoved%"=="x%validshells%" (
+            REM sh uses /c/ instead of /mnt/c - at least if using msys. Todo, review what is the norm on windows with and without msys2,cygwin,wsl
+            REM and what logic if any may be needed. For now sh with /c/xxx seems to work the same as sh with c:/xxx
+            CALL %nextshell% "%~dp0%fname%" %* & SET task_exitcode=!errorlevel!
+        ) ELSE (
+            ECHO %fname% has invalid nextshell value %nextshell% valid options are %validshells%
+            SET task_exitcode=66
+            GOTO :exit
+        )
+    )
+)
+@GOTO :endlib
+:getWslPath
+@SETLOCAL
+    @SET "_path=%~p1"
+    @SET "name=%~nx1"
+    @SET "drive=%~d1"
+    @SET "rtrn=%~2"
+    @SET "result=/mnt/%drive:~0,1%%_path:\=/%%name%"
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        ECHO %result%
+    )
+)
+@GOTO :eof
+:endlib
+
+: \
+@REM @SET taskexit_code=!errorlevel! & goto :exit
+@GOTO :exit
+# }
+# rem call %nextshell% "%~dp0%~n0.cmd" %* 
+# -*- tcl -*-
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- tcl script section
+# -- This is a punk multishell file
+# -- Primary payload target is Tcl, with sh,bash,powershell as helpers
+# -- but it may equally be used with any of these being the primary script.
+# -- It is tuned to run when called as a batch file, a tcl script a sh/bash script or a pwsh/powershell script
+# -- i.e it is a polyglot file.
+# -- The specific layout including some lines that appear just as comments is quite sensitive to change.
+# -- It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# -- e.g ./filename.polypunk.cmd in sh or bash
+# -- e.g tclsh filename.cmd
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+rename set ""; rename s2 set; set k {-- "$@" "a}; if {[info exists ::env($k)]} {unset ::env($k)} ;# tidyup
+Hide :exit;Hide {<#};Hide '@
+namespace eval ::punk::multishell {
+    set last_script_root    [file dirname [file normalize ${argv0}/__]]
+    set last_script         [file dirname [file normalize [info script]/__]] 
+    if {[info exists argv0] &&
+        $last_script eq $last_script_root
+        } {
+        set ::punk::multishell::is_main($last_script) 1 ;#run as executable/script - likely desirable to launch application and return an exitcode
+    } else {
+        set ::punk::multishell::is_main($last_script) 0 ;#sourced - likely to be being used as a library - no launch, no exit. Can use return.
+    }
+    if {"::punk::multishell::is_main" ni [info commands ::punk::multishell::is_main]} {
+        proc ::punk::multishell::is_main {{script_name {}}} {
+            if {$script_name eq ""} {
+                set script_name [file dirname [file normalize [info script]/--]]
+            }
+            if {![info exists ::punk::multishell::is_main($script_name)]} {
+                #e.g a .dll or something else unanticipated
+                puts stderr "Warning punk::multishell didn't recognize info script result: $script_name - will treat as if sourced and return instead of exiting"
+                puts stderr "Info: script_root: [file dirname [file normalize ${argv0}/__]]"
+                return 0
+            }
+            return [set ::punk::multishell::is_main($script_name)]
+        }
+    }
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+#puts "argv0    : $::argv0"
+# -- --- --- --- --- --- --- --- --- --- --- ---
+
+
+#<tcl-payload>
+#</tcl-payload>
+
+
+
+# -- --- --- --- --- --- --- --- --- --- --- ---
+# -- Best practice is to always return or exit above, or just by leaving the below defaults in place.
+# -- If the multishell script is modified to have Tcl below the Tcl Payload section,
+# -- then Tcl bracket balancing needs to be carefully managed in the shell and powershell sections below.
+# -- Only the # in front of the two relevant if statements below needs to be removed to enable Tcl below
+# -- but the sh/bash 'then' and 'fi' would also need to be uncommented.
+# -- This facility left in place for experiments on whether configuration payloads etc can be appended
+# -- to tail of file - possibly binary with ctrl-z char - but utility is dependent on which other interpreters/shells
+# -- can be made to ignore/cope with such data.
+if {[::punk::multishell::is_main]} {
+    exit 0
+} else {
+    return 
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+# end hide from unix shells \
+HEREDOC1B_HIDE_FROM_BASH_AND_SH
+# sh/bash \
+shift && set -- "${@:1:$#-1}"
+#------------------------------------------------------
+# -- This if block only needed if Tcl didn't exit or return above.
+if false==false # else {
+    then
+    :
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- sh/bash script section
+# -- leave as is if all that is required is launching the Tcl payload"
+# --
+# -- Note that sh/bash script isn't called when running a .bat/.cmd from cmd.exe on windows by default
+# -- adjust  @call line above ...  to something like @call sh ... @call bash ..  or @call env sh ... etc as appropriate
+# --   if sh/bash scripting needs to run on windows too.
+# --
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin sh Payload
+#printf "start of bash or sh code"
+
+#<shell-payload-pre-tcl>
+#</shell-payload-pre-tcl>
+
+# -- --- --- --- --- --- --- ---
+#<shell-launch-tcl>
+exitcode=0 ;#default assumption
+#-- sh/bash launches Tcl here instead of shebang line at top
+#-- use exec to use exitcode (if any) directly from the tcl script
+#exec /usr/bin/env tclsh "$0" "$@"
+#-- alternative - can run sh/bash script after the tcl call.
+/usr/bin/env tclsh "$0" "$@"
+exitcode=$?
+#echo "tcl exitcode: ${exitcode}"
+#-- override exitcode example 
+#exit 66
+#</shell-launch-tcl>
+# -- --- --- --- --- --- --- ---
+
+#<shell-payload-post-tcl>
+#</shell-payload-post-tcl>
+
+
+#printf "sh/bash done \n"
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end sh Payload
+#------------------------------------------------------
+fi
+exit ${exitcode}
+# end hide sh/bash block from Tcl
+# This comment with closing brace should stay in place whether if commented or not }
+#------------------------------------------------------
+# begin hide powershell-block from Tcl - only needed if Tcl didn't exit or return above
+if 0 {
+: end heredoc1 - end hide from powershell \
+'@ 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- powershell/pwsh section
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+function GetScriptName { $myInvocation.ScriptName }
+$scriptname = getScriptName
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin powershell Payload
+#"Timestamp         :    {0,10:yyyy-MM-dd HH:mm:ss}"    -f $(Get-Date)   | write-host
+#"Script Name       :    {0}"    -f $scriptname                          | write-host
+#"Powershell Version:    {0}"    -f $PSVersionTable.PSVersion.Major      | write-host
+#"powershell args   :    {0}"    -f ($args -join ", ")                   | write-host
+# -- --- --- ---
+
+#<powershell-payload-pre-tcl>
+#</powershell-payload-pre-tcl>
+
+
+# -- --- --- --- --- --- --- ---
+#<powershell-launch-tcl>
+tclsh $scriptname $args
+#</powershell-launch-tcl>
+# -- --- --- --- --- --- --- ---
+
+
+#<powershell-payload-post-tcl>
+#</powershell-payload-post-tcl>
+
+# unbal }
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end powershell Payload
+#"powershell reporting exitcode: {0}" -f $LASTEXITCODE | write-host
+Exit $LASTEXITCODE
+# heredoc2 for powershell to ignore block below
+$1 = @'
+'
+: end hide powershell-block from Tcl \
+# This comment with closing brace should stay in place whether 'if' commented or not }
+: cmd exit label - return exitcode 
+:exit
+: \
+@REM @ECHO exitcode: !task_exitcode!
+: \
+@EXIT /B !task_exitcode!
+# cmd has exited
+: end heredoc2 \
+'@
+<#
+# id:tailblock0
+# -- powershell multiline comment 
+#>
+<#
+# id:tailblock1
+# <ctrl-z>
+
+# </ctrl-z>
+# -- unreachable by tcl directly if ctrl-z character is in the <ctrl-z> section above. (but file can be read and split on \x1A)
+# -- Potential for zip and/or base64 contents, but we can't stop pwsh parser from slurping in the data
+# -- so for example a plain text tar archive could cause problems depending on the content.
+# -- final line in file must be the powershell multiline comment terminator or other data it can handle.
+# -- e.g plain # comment lines will work too
+# -- (for example a powershell digital signature is a # commented block of data at the end of the file)
+#>
+
+
diff --git a/src/modules/punk/mix/templates/layouts/project/src/scriptapps/wrappers/sample_punk-shellbat.bat b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/basic/shellbat.bat
similarity index 100%
rename from src/modules/punk/mix/templates/layouts/project/src/scriptapps/wrappers/sample_punk-shellbat.bat
rename to src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/basic/shellbat.bat
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/multishell.cmd b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/multishell.cmd
new file mode 100644
index 00000000..fff93dcc
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/multishell.cmd
@@ -0,0 +1,661 @@
+: "punk MULTISHELL - shebangless polyglot for Tcl Perl sh bash cmd pwsh powershell" + "[rename set s;proc Hide x {proc $x args {}};Hide :]" + "\$(function : {<#pwsh#>})" + "perlhide" + qw^
+set -- "$@" "a=[Hide <#;Hide set;s 1 list]"; set -- : "$@";$1 = @'
+: heredoc1 - hide from powershell using @ and squote above. close sqote for unix shells + ' \
+: .bat/.cmd launch section, leading colon hides from cmd, trailing slash hides next line from tcl + \
+: "[Hide @GOTO; Hide =begin; Hide @REM] #not necessary but can help avoid errs in testing" +
+: << 'HEREDOC1B_HIDE_FROM_BASH_AND_SH'
+: STRONG SUGGESTION: DO NOT MODIFY FIRST LINE OF THIS SCRIPT - except for first double quoted section.
+: shebang line is not required on unix or windows and will reduce functionality and/or portability.
+: Even comment lines can be part of the functionality of this script (both on unix and windows) - modify with care.
+@GOTO :skip_perl_pod_start ^;
+=begin excludeperl 
+: skip_perl_pod_start
+: Continuation char at end of this line and rem with curly-braces used to exlude Tcl from the whole cmd block \
+:  {
+@REM ############################################################################################################################
+@REM THIS IS A POLYGLOT SCRIPT - supporting payloads in Tcl, bash, sh and/or powershelll (powershell.exe or pwsh.exe)
+@REM It should remain portable between unix-like OSes & windows if the proper structure is maintained.
+@REM ############################################################################################################################
+@REM On windows, change the value of nextshell to one of the listed 2 digit values if desired, and add code within payload sections for tcl,sh,bash,powershell as appropriate.
+@REM This wrapper can be edited manually (carefully!) - or sh,bash,tcl,powershell scripts can be wrapped using the Tcl-based punkshell system
+@REM e.g from within a running punkshell: deck scriptwrap.multishell <inputfilepath> -outputfolder <folderpath> 
+@REM On unix-like systems, call with sh, bash or tclsh. (powershell untested on unix - and requires wscript if security elevation is used)
+@REM Due to lack of shebang (#! line) Unix-like systems will probably (hopefully) default to sh if the script is called without an interpreter - but it may depend on the shell in use when called.
+@REM If you find yourself really wanting/needing to add a shebang line - do so on the basis that the script will exist on unix-like systems only. 
+@SETLOCAL EnableExtensions EnableDelayedExpansion
+@SET "validshells= ^(10^) 'pwsh' ^(11^) 'sh' (^12^) 'bash' (^13^) 'tclsh' (^14^) 'perl'"
+@SET "shells[10]=pwsh"
+@SET "shells[11]=sh"
+@set "shells[12]=bash"
+@SET "shells[13]=tclsh"
+@SET "shells[14]=perl"
+: <nextshell>
+@SET "nextshell=13"
+: </nextshell>
+@rem asadmin is for automatic elevation to administrator. Separate window will be created (seems unavoidable with current elevation mechanism) and user will still get security prompt (probably reasonable).
+: <asadmin>
+@SET "asadmin=0"
+: </asadmin>
+@REM nextshell set to index for validshells .eg 10 for pwsh  
+@REM @ECHO nextshell is %nextshell%
+@SET "selected=!shells[%nextshell%]!"
+@REM @ECHO selected %selected%
+@CALL SET "keyRemoved=%%validshells:'!selected!'=%%"
+@REM @ECHO keyremoved %keyRemoved%
+@REM Note that 'powershell' e.g v5 is just a fallback for when pwsh is not available
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@REM  -- cmd/batch file section (ignored on unix but should be left in place)
+@REM  -- This section intended mainly to launch the next shell (and to escalate privileges if necessary)
+@REM  -- Avoid customising this if you are not familiar with batch scripting. cmd/batch script can be useful, but is probably the least expressive language and most error prone.
+@REM  -- For example - as this file needs to use unix-style lf line-endings - the label scanner is susceptible to the 512Byte boundary issue: https://www.dostips.com/forum/viewtopic.php?t=8988#p58888
+@REM  -- This label issue can be triggered/abused in files with crlf line endings too - but it is less likely to happen accidentaly.
+@REm  -- See also: https://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/4095133#4095133
+@REM ############################################################################################################################
+@REM  -- Due to this issue -seemingly trivial edits of the batch file section can break the script! (for Windows anyway)
+@REM  -- Even something as simple as adding or removing an @REM
+@REM  -- From within punkshell - use:
+@REM  --     deck scriptwrap.checkfile <filepath>
+@REM  -- to check your templates or final wrapped scripts for byte boundary issues
+@REM  -- It will report any labels that are on boundaries
+@REM  -- This is why the nextshell value above is a 2 digit key instead of a string - so that editing the value doesn't change the byte offsets.
+@REM  -- Editing your sh,bash,tcl,pwsh payloads is much less likely to cause an issue. There is the possibility of the final batch :exit_multishell label spanning a boundary - so testing using deck scriptwrap.checkfile is still recommended.
+@REM  -- Alternatively, as you should do anyway - test the final script on windows   
+@REM  -- Aside from adding comments/whitespace to tweak the location of labels - you can try duplicating the label (e.g just add the label on a line above) but this is not guaranteed to work in all situations.
+@REM  -- '@REM' is a safer comment mechanism than a leading colon - which is used sparingly here.
+@REM  -- A colon anywhere in the script that happens to land on a 512 Byte boundary (from file start or from a callsite) could be misinterpreted as a label
+@REM  -- It is unknown what versions of cmd interpreters behave this way - and deck scriptwrap.checkfile doesn't check all such boundaries.
+@REm  -- For this reason, batch labels should be chosen to be relatively unlikely to collide with other strings in the file, and simple names such as :exit or :end should probably be avoided
+@REM ############################################################################################################################
+@REM  -- custom windows payloads should be in powershell,tclsh (or sh/bash if available) code sections
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@SET "winpath=%~dp0"
+@SET "fname=%~nx0"
+@REM @ECHO fname %fname%
+@REM @ECHO winpath %winpath%
+@REM @ECHO commandlineascalled %0
+@REM @ECHO commandlineresolved %~f0
+@CALL :getNormalizedScriptTail nftail
+@REM @ECHO normalizedscripttail %nftail%
+@CALL :getFileTail %0 clinetail
+@REM @ECHO clinetail %clinetail%
+@CALL :stringToUpper %~nx0 capscripttail
+@REM @ECHO capscriptname: %capscripttail%
+
+@IF "%nftail%"=="%capscripttail%" (
+    @ECHO forcing asadmin=1 due to file name on filesystem being uppercase
+    @SET "asadmin=1"
+) else (
+    @CALL :stringToUpper %clinetail% capcmdlinetail
+    @REM @ECHO capcmdlinetail !capcmdlinetail!
+    IF "%clinetail%"=="!capcmdlinetail!" (
+        @ECHO forcing asadmin=1 due to cmdline scriptname in uppercase
+        @set "asadmin=1"
+    )
+)
+@SET "vbsGetPrivileges=%temp%\punk_bat_elevate_%fname%.vbs"
+@SET arglist=%*
+@IF "%1"=="PUNK-ELEVATED" (
+    GOTO :gotPrivileges
+)
+@IF !asadmin!==1 (
+    net file 1>NUL 2>NUL
+    @IF '!errorlevel!'=='0' ( GOTO :gotPrivileges ) else ( GOTO :getPrivileges )
+)
+@GOTO skip_privileges
+:getPrivileges
+@IF '%1'=='PUNK-ELEVATED' (echo PUNK-ELEVATED & shift /1 & goto :gotPrivileges )
+@ECHO Set UAC = CreateObject^("Shell.Application"^) > "%vbsGetPrivileges%"
+@ECHO args = "PUNK-ELEVATED " >> "%vbsGetPrivileges%"
+@ECHO For Each strArg in WScript.Arguments >> "%vbsGetPrivileges%"
+@ECHO args = args ^& strArg ^& " " >> "%vbsGetPrivileges%"
+@ECHO Next >> "%vbsGetPrivileges%"
+@ECHO UAC.ShellExecute "%~dp0%~n0%~x0", args, "", "runas", 1 >> "%vbsGetPrivileges%"
+@ECHO Launching script in new windows due to administrator elevation
+@"%SystemRoot%\System32\WScript.exe" "%vbsGetPrivileges%" %*
+@EXIT /B
+
+:gotPrivileges
+@REM setlocal & pushd .
+@PUSHD .
+@cd /d %~dp0
+@IF "%1"=="PUNK-ELEVATED" (
+    @DEL "%vbsGetPrivileges%" 1>nul 2>nul
+    @SET arglist=%arglist:~14%
+)
+
+:skip_privileges
+@SET need_ps1=0
+@REM we want the ps1 to exist even if the nextshell isn't powershell
+@if not exist "%~dp0%~n0.ps1" (
+    @SET need_ps1=1
+) ELSE (
+    fc "%~dp0%~n0%~x0" "%~dp0%~n0.ps1" >nul || goto different
+    @REM @ECHO "files same"
+    @SET need_ps1=0
+)
+@GOTO :pscontinue
+:different
+@REM @ECHO "files differ"
+@SET need_ps1=1
+:pscontinue
+@IF !need_ps1!==1 (
+    COPY "%~dp0%~n0%~x0" "%~dp0%~n0.ps1" >NUL 
+)
+@REM avoid using CALL to launch pwsh,tclsh etc - it will intercept some args such as /?
+@IF "!shells[%nextshell%]!"=="pwsh" (
+    REM pws vs powershell hasn't been tested because we didn't need to copy cmd to ps1 this time
+    REM test availability of preferred option of powershell7+ pwsh
+    pwsh -nop -nol -c set-executionpolicy -Scope Process Unrestricted; write-host "statusmessage: pwsh-found" >NUL
+    SET pwshtest_exitcode=!errorlevel!
+    REM ECHO pwshtest_exitcode !pwshtest_exitcode!
+    REM fallback to powershell if pwsh failed 
+    IF !pwshtest_exitcode!==0 (
+        pwsh -nop -nol -c set-executionpolicy -Scope Process Unrestricted; "%~dp0%~n0.ps1" %arglist%
+        SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM CALL powershell -nop -nol -c write-host powershell-found
+        REM powershell -nop -nol -file "%~dp0%~n0.ps1" %*
+        powershell -nop -nol -c set-executionpolicy -Scope Process Unrestricted; %~dp0%~n0.ps1" %arglist%
+        SET task_exitcode=!errorlevel!
+    )
+) ELSE ( 
+    IF "!shells[%nextshell%]!"=="bash" (
+        CALL :getWslPath %winpath% wslpath
+        REM ECHO wslfullpath "!wslpath!%fname%"
+        !shells[%nextshell%]! "!wslpath!%fname%" %arglist%
+        SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM  probably tclsh or sh
+        IF NOT "x%keyRemoved%"=="x%validshells%" (
+            REM sh on windows uses /c/ instead of /mnt/c - at least if using msys. Todo, review what is the norm on windows with and without msys2,cygwin,wsl
+            REM and what logic if any may be needed. For now sh with /c/xxx seems to work the same as sh with c:/xxx
+            !shells[%nextshell%]! "%~dp0%fname%" %arglist%
+            SET task_exitcode=!errorlevel!
+        ) ELSE (
+            ECHO %fname% has invalid nextshell value ^(%nextshell%^) !shells[%nextshell%]! valid options are %validshells%
+            SET task_exitcode=66
+            @REM boundary padding
+            GOTO :exit_multishell
+        )
+    )
+)
+@REM batch file library functions
+@REM boundary padding
+@GOTO :endlib
+
+:getWslPath
+@SETLOCAL
+    @SET "_path=%~p1"
+    @SET "name=%~nx1"
+    @SET "drive=%~d1"
+    @SET "rtrn=%~2"
+    @SET "result=/mnt/%drive:~0,1%%_path:\=/%%name%"
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        ECHO %result%
+    )
+)
+@EXIT /B
+
+:getFileTail
+@REM return tail of file without any normalization e.g c:/punkshell/bin/Punk.cmd returns Punk.cmd even if file is punk.cmd
+@REM we can't use things such as %~nx1 as it can change capitalisation
+@REM This function is designed explicitly to preserve capitalisation
+@REM accepts full paths with either / or \ as delimiters - or 
+@SETLOCAL
+    @SET "rtrn=%~2"
+    @SET "arg=%~1"
+    @REM @SET "result=%_arg:*/=%"
+    @REM @SET "result=%~1"
+    @SET LF=^
+
+
+    : The above 2 empty lines are important. Don't remove
+    @CALL :stringContains "!arg!" "\" hasBackSlash
+    @IF "!hasBackslash!"=="true" (
+        @for %%A in ("!LF!") do @(
+            @FOR /F %%B in ("!arg:\=%%~A!") do @set "result=%%B"
+        )
+    ) ELSE (
+        @CALL :stringContains "!arg!" "/" hasForwardSlash
+        @IF "!hasForwardSlash!"=="true" (
+            @FOR %%A in ("!LF!") do @(
+                @FOR /F %%B in ("!arg:/=%%~A!") do @set "result=%%B"
+            )
+        ) ELSE (
+            @set "result=%arg%"
+        )
+    )
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+@REM  boundary padding
+@REM boundary padding
+:getNormalizedScriptTail
+@SETLOCAL
+    @SET "result=%~nx0"
+    @SET "rtrn=%~1"
+@ENDLOCAL & (
+    @IF "%~1" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+
+:getNormalizedFileTailFromPath
+@REM warn via echo, and do not set return variable if path not found
+@REM note that %~nx1 does not preserve case of provided path - hence the name 'normalized'
+@REM boundary padding
+@REM boundary padding
+@REM boundary padding
+@REM boundary padding
+@SETLOCAL
+    @CALL :stringContains %~1 "\" hasBackSlash
+    @CALL :stringContains %~1 "/" hasForwardSlash
+    @IF "%hasBackslash%-%hasForwardslash%"=="false-false" (
+        @SET "P=%cd%%~1"
+        @CALL :getNormalizedFileTailFromPath "!P!" ftail2
+        @SET "result=!ftail2!"
+    ) else (
+        @IF EXIST "%~1" (
+            @SET "result=%~nx1"
+        ) else (
+            @ECHO error getNormalizedFileTailFromPath file not found: %~1
+            @EXIT /B 1
+        )
+    )
+    @SET "rtrn=%~2"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO getNormalizedFileTailFromPath %1 result: %result%
+    )
+)
+@EXIT /B
+
+:stringContains
+@REM usage: @CALL:stringContains string needle returnvarname
+@SETLOCAL
+    @SET "rtrn=%~3"
+    @SET "string=%~1"
+    @SET "needle=%~2"
+    @IF "!string:%needle%=!"=="!string!" @(
+        @SET "result=false"
+    ) ELSE (
+        @SET "result=true"
+    )
+@ENDLOCAL & (
+    @IF "%~3" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO stringContains %string% %needle% result: %result%
+    )
+)
+@EXIT /B
+
+:stringToUpper
+@SETLOCAL
+    @SET "rtrn=%~2"
+    @SET "string=%~1"
+    @SET "capstring=%~1"
+    @FOR %%A in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO @(
+        @SET "capstring=!capstring:%%A=%%A!"
+    )
+    @SET "result=!capstring!"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO stringToUpper %string% result: %result%
+    )
+)
+@EXIT /B
+
+:isNumeric
+@SETLOCAL
+    @SET "notnumeric="&FOR /F "delims=0123456789" %%i in ("%1") do set "notnumeric=%%i"
+    @IF defined notnumeric (
+        @SET "result=false"
+    ) else (
+        @SET "result=true"
+    )
+    @SET "rtrn=%~2"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+
+:endlib
+: \
+@REM @SET taskexit_code=!errorlevel! & goto :exit_multishell
+@GOTO :exit_multishell
+# }
+# -*- tcl -*-
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- tcl script section
+# -- This is a punk multishell file
+# -- Primary payload target is Tcl, with sh,bash,powershell as helpers
+# -- but it may equally be used with any of these being the primary script.
+# -- It is tuned to run when called as a batch file, a tcl script a sh/bash script or a pwsh/powershell script
+# -- i.e it is a polyglot file.
+# -- The specific layout including some lines that appear just as comments is quite sensitive to change.
+# -- It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# -- e.g ./filename.polypunk.cmd in sh or bash
+# -- e.g tclsh filename.cmd
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+rename set ""; rename s set; set k {-- "$@" "a}; if {[info exists ::env($k)]} {unset ::env($k)} ;# tidyup and restore
+Hide :exit_multishell;Hide {<#};Hide '@
+namespace eval ::punk::multishell {
+    set last_script_root    [file dirname [file normalize ${argv0}/__]]
+    set last_script         [file dirname [file normalize [info script]/__]] 
+    if {[info exists argv0] &&
+        $last_script eq $last_script_root
+        } {
+        set ::punk::multishell::is_main($last_script) 1 ;#run as executable/script - likely desirable to launch application and return an exitcode
+    } else {
+        set ::punk::multishell::is_main($last_script) 0 ;#sourced - likely to be being used as a library - no launch, no exit. Can use return.
+    }
+    if {"::punk::multishell::is_main" ni [info commands ::punk::multishell::is_main]} {
+        proc ::punk::multishell::is_main {{script_name {}}} {
+            if {$script_name eq ""} {
+                set script_name [file dirname [file normalize [info script]/--]]
+            }
+            if {![info exists ::punk::multishell::is_main($script_name)]} {
+                #e.g a .dll or something else unanticipated
+                puts stderr "Warning punk::multishell didn't recognize info script result: $script_name - will treat as if sourced and return instead of exiting"
+                puts stderr "Info: script_root: [file dirname [file normalize ${argv0}/__]]"
+                return 0
+            }
+            return [set ::punk::multishell::is_main($script_name)]
+        }
+    }
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+#puts "argv0    : $::argv0"
+# -- --- --- --- --- --- --- --- --- --- --- ---
+
+
+#<tcl-pre-launch-subprocess>
+#</tcl-pre-launch-subprocess>
+
+#<tcl-launch-subprocess>
+#</tcl-launch-subproces>
+
+
+#<tcl-post-launch-subprocess>
+#</tcl-post-launch-subproces>
+
+
+# -- --- --- --- --- --- --- --- --- --- --- ---
+# -- Best practice is to always return or exit above, or just by leaving the below defaults in place.
+# -- If the multishell script is modified to have Tcl below the Tcl Payload section,
+# -- then Tcl bracket balancing needs to be carefully managed in the shell and powershell sections below.
+# -- Only the # in front of the two relevant if statements below needs to be removed to enable Tcl below
+# -- but the sh/bash 'then' and 'fi' would also need to be uncommented.
+# -- This facility left in place for experiments on whether configuration payloads etc can be appended
+# -- to tail of file - possibly binary with ctrl-z char - but utility is dependent on which other interpreters/shells
+# -- can be made to ignore/cope with such data.
+if {[::punk::multishell::is_main]} {
+    exit 0
+} else {
+    return 
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+# end hide from unix shells \
+HEREDOC1B_HIDE_FROM_BASH_AND_SH
+# sh/bash \
+shift && set -- "${@:1:$#-1}"
+#------------------------------------------------------
+# -- This if block only needed if Tcl didn't exit or return above.
+if false==false # else {
+    then
+    : #
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- sh/bash script section
+# -- leave as is if all that is required is launching the Tcl payload"
+# --
+# -- Note that sh/bash script isn't called when running a .bat/.cmd from cmd.exe on windows by default
+# -- adjust the %nextshell% value above 
+# --   if sh/bash scripting needs to run on windows too.
+# --
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin sh Payload
+exitcode=0
+#printf "start of bash or sh code"
+
+#<shell-pre-launch-subprocess>
+#</shell-pre-launch-subprocess>
+
+# -- --- --- --- --- --- --- ---
+#<shell-launch-subprocess>
+#-- sh/bash launches Tcl here instead of shebang line at top
+#-- use exec to use exitcode (if any) directly from the tcl script
+#exec /usr/bin/env tclsh "$0" "$@"
+#-- alternative - can run sh/bash script after the tcl call.
+/usr/bin/env tclsh "$0" "$@"
+exitcode=$?
+#echo "sh/bash reporting tcl exitcode: ${exitcode}"
+#-- override exitcode example 
+#exit 66
+#</shell-launch-subprocess>
+# -- --- --- --- --- --- --- ---
+
+#<shell-post-launch-subprocess>
+#</shell-post-launch-subproces>
+
+
+#printf "sh/bash done \n"
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end sh Payload
+#------------------------------------------------------
+fi
+exit ${exitcode}
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- Perl script section
+# -- leave the script below as is, if all that is required is launching the Tcl payload"
+# --
+# -- Note that perl script isn't called by default when simply running this script by name
+# -- adjust  the nextshell value at the top of the script to point to perl
+# --
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+=cut
+#!/user/bin/perl
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin perl Payload
+my $exit_code = 0;
+#use ExtUtils::Installed;
+#my $installed = ExtUtils::Installed->new();
+#my @modules = $installed->modules();
+#print "Modules:\n";
+#foreach my $m (@modules) {
+#    print "$m\n";
+#}
+# -- --- ---
+
+
+
+my $scriptname = $0;
+print "perl $scriptname\n";
+my $i =1;
+foreach my $a(@ARGV) {
+    print "Arg # $i: $a\n";
+}
+
+#<perl-pre-launch-subprocess>
+#</perl-pre-launch-subprocess>
+
+
+
+# -- --- --- --- --- --- --- ---
+#<perl-launch-subprocess>
+$exit_code=system("tclsh", $scriptname, @ARGV);
+#print "perl reporting tcl exitcode: $exit_code";
+#</perl-launch-subprocess>
+# -- --- --- --- --- --- --- ---
+
+#<perl-post-launch-subprocess>
+#</perl-post-launch-subprocess>
+
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end perl Payload
+exit $exit_code;
+__END__
+
+# end hide sh/bash/perl block from Tcl
+# This comment with closing brace should stay in place whether if commented or not }
+#------------------------------------------------------
+# begin hide powershell-block from Tcl - only needed if Tcl didn't exit or return above
+if 0 {
+: end heredoc1 - end hide from powershell \
+'@ 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- powershell/pwsh section
+# -- Do not edit if current file is the .ps1
+# -- Edit the corresponding .cmd and it will autocopy 
+# -- unbalanced braces { } here *even in comments* will cause problems if there was no Tcl exit or return above
+# -- custom script should generally go below the begin_powershell_payload line
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+function GetScriptName { $myInvocation.ScriptName }
+$scriptname = GetScriptName
+function GetDynamicParamDictionary {
+    [CmdletBinding()]
+    param(
+        [Parameter(ValueFromPipeline=$true, Mandatory=$true)]
+        [string] $CommandName
+    )
+
+    begin {
+        # Get a list of params that should be ignored (they're common to all advanced functions)
+        $CommonParameterNames = [System.Runtime.Serialization.FormatterServices]::GetUninitializedObject([type] [System.Management.Automation.Internal.CommonParameters]) | 
+            Get-Member -MemberType Properties | 
+            Select-Object -ExpandProperty Name
+    }
+
+    process {
+        # Create the dictionary that this scriptblock will return:
+        $DynParamDictionary = New-Object System.Management.Automation.RuntimeDefinedParameterDictionary
+
+        # Convert to object array and get rid of Common params:
+        (Get-Command $CommandName | select -exp Parameters).GetEnumerator() | 
+            Where-Object { $CommonParameterNames -notcontains $_.Key } |
+            ForEach-Object {
+                $DynamicParameter = New-Object System.Management.Automation.RuntimeDefinedParameter (
+                    $_.Key,
+                    $_.Value.ParameterType,
+                    $_.Value.Attributes
+                )
+                $DynParamDictionary.Add($_.Key, $DynamicParameter)
+            }
+
+        # Return the dynamic parameters
+        return $DynParamDictionary
+    }
+}
+# GetDynamicParamDictionary 
+# - This can make it easier to share a single set of param definitions between functions
+# - sample usage
+#function ParameterDefinitions {
+#    param(
+#        [Parameter(Mandatory)][string] $myargument
+#    )
+#}
+#function psmain {
+#   [CmdletBinding()]
+#   param()
+#   dynamicparam { GetDynamicParamDictionary ParameterDefinitions }
+#   process {
+#       #called once with $PSBoundParameters dictionary
+#       #can be used to validate arguments, or set a simpler variable name for access
+#       switch ($PSBoundParameters.keys) {
+#           'myargumentname' { 
+#               Set-Variable -Name $_ -Value $PSBoundParameters."$_"
+#           }
+#           #...
+#       }
+#       foreach ($boundparam in $PSBoundParameters.GetEnumerator()) {
+#           #...
+#       }
+#   }
+#   end {
+#       #Main function logic
+#       Write-Host "myargumentname value is: $myargumentname"
+#       #myotherfunction @PSBoundParameters
+#   }
+#}
+#psmain @args
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin powershell Payload
+#"Timestamp         :    {0,10:yyyy-MM-dd HH:mm:ss}"    -f $(Get-Date)   | write-host
+#"Script Name       :    {0}"    -f $scriptname                          | write-host
+#"Powershell Version:    {0}"    -f $PSVersionTable.PSVersion.Major      | write-host
+#"powershell args   :    {0}"    -f ($args -join ", ")                   | write-host
+# -- --- --- ---
+
+#<powershell-pre-launch-subprocess>
+#</powershell-pre-launch-subprocess>
+
+
+# -- --- --- --- --- --- --- ---
+#<powershell-launch-subprocess>
+tclsh $scriptname $args
+#"powershell reporting exitcode: {0}" -f $LASTEXITCODE | write-host
+#</powershell-launch-subprocess>
+# -- --- --- --- --- --- --- ---
+
+
+#<powershell-post-launch-subprocess>
+#</powershell-post-launch-subprocess>
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end powershell Payload
+Exit $LASTEXITCODE
+# heredoc2 for powershell to ignore block below
+$1 = @'
+'
+: comment end hide powershell-block from Tcl \
+# This comment with closing brace should stay in place whether 'if' commented or not }
+: multishell doubled-up cmd exit label - return exitcode 
+:exit_multishell
+:exit_multishell
+: \
+@REM @ECHO exitcode: !task_exitcode!
+: \
+@IF "%1"=="PUNK-ELEVATED" (echo. & @cmd /k echo elevated prompt: type exit to quit)
+: \
+@EXIT /B !task_exitcode!
+# cmd has exited
+: comment end heredoc2 \
+'@
+<#
+# id:tailblock0
+# -- powershell multiline comment 
+#>
+<#
+no script engine should try to run me
+# id:tailblock1
+# <ctrl-z>
+
+# </ctrl-z>
+# -- unreachable by tcl directly if ctrl-z character is in the <ctrl-z> section above. (but file can be read and split on \x1A)
+# -- Potential for zip and/or base64 contents, but we can't stop pwsh parser from slurping in the data
+# -- so for example a plain text tar archive could cause problems depending on the content.
+# -- final line in file must be the powershell multiline comment terminator or other data it can handle.
+# -- e.g plain # comment lines will work too
+# -- (for example a powershell digital signature is a # commented block of data at the end of the file)
+#>
+
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/multishell1.cmd b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/multishell1.cmd
new file mode 100644
index 00000000..17fe4c15
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/multishell1.cmd
@@ -0,0 +1,524 @@
+: "[rename set s;proc Hide x {proc $x args {}};Hide :]" "\$(function : {<#pwsh#>})" ^
+set -- "$@" "a=[list shebangless punk MULTISHELL tclsh sh bash cmd pwsh powershell;proc Hide x {proc $x args {}}; Hide <#;Hide set;s 1 list]"; set -- : "$@";$1 = @'
+: heredoc1 - hide from powershell using @ and squote above. (close sqote for unix shells) ' \
+: .bat/.cmd launch section, leading colon hides from cmd, trailing slash hides next line from tcl \
+: "[Hide @ECHO; Hide ); Hide (;Hide echo; Hide @REM]#not necessary but can help avoid errs in testing"
+: << 'HEREDOC1B_HIDE_FROM_BASH_AND_SH'
+: Continuation char at end of this line and rem with curly-braces used to exlude Tcl from the whole cmd block \
+:  {
+: STRONG SUGGESTION: DO NOT MODIFY FIRST LINE OF THIS SCRIPT. shebang #! line is not required on unix or windows and will reduce functionality and/or portability.
+: Even comment lines can be part of the functionality of this script (both on unix and windows) - modify with care.
+@REM ############################################################################################################################
+@REM THIS IS A POLYGLOT SCRIPT - supporting payloads in Tcl, bash, sh and/or powershelll (powershell.exe or pwsh.exe)
+@REM It should remain portable between unix-like OSes & windows if the proper structure is maintained.
+@REM ############################################################################################################################
+@REM On windows, change the value of nextshell to one of the listed 2 digit values if desired, and add code within payload sections for tcl,sh,bash,powershell as appropriate.
+@REM This wrapper can be edited manually (carefully!) - or sh,bash,tcl,powershell scripts can be wrapped using the Tcl-based punkshell system
+@REM e.g from within a running punkshell: pmix scriptwrap.multishell <inputfilepath> -outputfolder <folderpath> 
+@REM On unix-like systems, call with sh, bash or tclsh. (powershell untested on unix - and requires wscript if security elevation is used)
+@REM Due to lack of shebang (#! line) Unix-like systems will probably (hopefully) default to sh if the script is called without an interpreter - but it may depend on the shell in use when called.
+@REM If you find yourself really wanting/needing to add a shebang line - do so on the basis that the script will exist on unix-like systems only. 
+@SETLOCAL EnableExtensions EnableDelayedExpansion
+@SET "validshells= ^(10^) 'pwsh' ^(11^) 'sh' (^12^) 'bash' (^13^) 'tclsh'"
+@SET "shells[10]=pwsh"
+@SET "shells[11]=sh"
+@set "shells[12]=bash"
+@SET "shells[13]=tclsh"
+: <nextshell>
+@SET "nextshell=13"
+: </nextshell>
+@rem asadmin is for automatic elevation to administrator. Separate window will be created (seems unavoidable with current elevation mechanism) and user will still get security prompt (probably reasonable).
+: <asadmin>
+@SET "asadmin=0"
+: </asadmin>
+@REM nextshell set to index for validshells .eg 10 for pwsh  
+@REM @ECHO nextshell is %nextshell%
+@SET "selected=!shells[%nextshell%]!"
+@REM @ECHO selected %selected%
+@CALL SET "keyRemoved=%%validshells:'!selected!'=%%"
+@REM @ECHO keyremoved %keyRemoved%
+@REM Note that 'powershell' e.g v5 is just a fallback for when pwsh is not available
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@REM  -- cmd/batch file section (ignored on unix but should be left in place)
+@REM  -- This section intended mainly to launch the next shell (and to escalate privileges if necessary)
+@REM  -- Avoid customising this if you are not familiar with batch scripting. cmd/batch script can be useful, but is probably the least expressive language and most error prone.
+@REM  -- For example - as this file needs to use unix-style lf line-endings - the label scanner is susceptible to the 512Byte boundary issue: https://www.dostips.com/forum/viewtopic.php?t=8988#p58888
+@REM  -- This label issue can be triggered/abused in files with crlf line endings too - but it is less likely to happen accidentaly.
+@REm  -- See also: https://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/4095133#4095133
+@REM ############################################################################################################################
+@REM  -- Due to this issue -seemingly trivial edits of the batch file section can break the script! (for Windows anyway)
+@REM  -- Even something as simple as adding or removing an @REM
+@REM  -- From within punkshell - use:
+@REM  --     pmix scriptwrap.checkfile <filepath>
+@REM  -- to check your templates or final wrapped scripts for byte boundary issues
+@REM  -- It will report any labels that are on boundaries
+@REM  -- This is why the nextshell value above is a 2 digit key instead of a string - so that editing the value doesn't change the byte offsets.
+@REM  -- Editing your sh,bash,tcl,pwsh payloads is much less likely to cause an issue. There is the possibility of the final batch :exit_multishell label spanning a boundary - so testing using pmix scriptwrap.checkfile is still recommended.
+@REM  -- Alternatively, as you should do anyway - test the final script on windows   
+@REM  -- Aside from adding comments/whitespace to tweak the location of labels - you can try duplicating the label (e.g just add the label on a line above) but this is not guaranteed to work in all situations.
+@REM  -- '@REM' is a safer comment mechanism than a leading colon - which is used sparingly here.
+@REM  -- A colon anywhere in the script that happens to land on a 512 Byte boundary (from file start or from a callsite) could be misinterpreted as a label
+@REM  -- It is unknown what versions of cmd interpreters behave this way - and pmix scriptwrap.checkfile doesn't check all such boundaries.
+@REm  -- For this reason, batch labels should be chosen to be relatively unlikely to collide with other strings in the file, and simple names such as :exit or :end should probably be avoided
+@REM ############################################################################################################################
+@REM  -- custom windows payloads should be in powershell,tclsh (or sh/bash if available) code sections
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@SET "winpath=%~dp0"
+@SET "fname=%~nx0"
+@REM @ECHO fname %fname%
+@REM @ECHO winpath %winpath%
+@REM @ECHO commandlineascalled %0
+@REM @ECHO commandlineresolved %~f0
+@CALL :getNormalizedScriptTail nftail
+@REM @ECHO normalizedscripttail %nftail%
+@CALL :getFileTail %0 clinetail
+@REM @ECHO clinetail %clinetail%
+@CALL :stringToUpper %~nx0 capscripttail
+@REM @ECHO capscriptname: %capscripttail%
+
+@IF "%nftail%"=="%capscripttail%" (
+    @ECHO forcing asadmin=1 due to file name on filesystem being uppercase
+    @SET "asadmin=1"
+) else (
+    @CALL :stringToUpper %clinetail% capcmdlinetail
+    @REM @ECHO capcmdlinetail !capcmdlinetail!
+    IF "%clinetail%"=="!capcmdlinetail!" (
+        @ECHO forcing asadmin=1 due to cmdline scriptname in uppercase
+        @set "asadmin=1"
+    )
+)
+@SET "vbsGetPrivileges=%temp%\punk_bat_elevate_%fname%.vbs"
+@SET arglist=%*
+@IF "%1"=="PUNK-ELEVATED" (
+    GOTO :gotPrivileges
+)
+@IF !asadmin!==1 (
+    net file 1>NUL 2>NUL
+    @IF '!errorlevel!'=='0' ( GOTO :gotPrivileges ) else ( GOTO :getPrivileges )
+)
+@GOTO skip_privileges
+:getPrivileges
+@IF '%1'=='PUNK-ELEVATED' (echo PUNK-ELEVATED & shift /1 & goto :gotPrivileges )
+@ECHO Set UAC = CreateObject^("Shell.Application"^) > "%vbsGetPrivileges%"
+@ECHO args = "PUNK-ELEVATED " >> "%vbsGetPrivileges%"
+@ECHO For Each strArg in WScript.Arguments >> "%vbsGetPrivileges%"
+@ECHO args = args ^& strArg ^& " " >> "%vbsGetPrivileges%"
+@ECHO Next >> "%vbsGetPrivileges%"
+@ECHO UAC.ShellExecute "%~dp0%~n0.cmd", args, "", "runas", 1 >> "%vbsGetPrivileges%"
+@ECHO Launching script in new windows due to administrator elevation
+@"%SystemRoot%\System32\WScript.exe" "%vbsGetPrivileges%" %*
+@EXIT /B
+
+:gotPrivileges
+@REM setlocal & pushd .
+@PUSHD .
+@cd /d %~dp0
+@IF "%1"=="PUNK-ELEVATED" (
+    @DEL "%vbsGetPrivileges%" 1>nul 2>nul
+    @SET arglist=%arglist:~14%
+)
+
+:skip_privileges
+@SET need_ps1=0
+@REM we want the ps1 to exist even if the nextshell isn't powershell
+@if not exist "%~dp0%~n0.ps1" (
+    @SET need_ps1=1
+) ELSE (
+    fc "%~dp0%~n0.cmd" "%~dp0%~n0.ps1" >nul || goto different
+    @REM @ECHO "files same"
+    @SET need_ps1=0
+)
+@GOTO :pscontinue
+:different
+@REM @ECHO "files differ"
+@SET need_ps1=1
+:pscontinue
+@IF !need_ps1!==1 (
+    COPY "%~dp0%~n0.cmd" "%~dp0%~n0.ps1" >NUL 
+)
+@REM avoid using CALL to launch pwsh,tclsh etc - it will intercept some args such as /?
+@IF "!shells[%nextshell%]!"=="pwsh" (
+    REM pws vs powershell hasn't been tested because we didn't need to copy cmd to ps1 this time
+    REM test availability of preferred option of powershell7+ pwsh
+    pwsh -nop -nol -c set-executionpolicy -Scope Process Unrestricted; write-host "statusmessage: pwsh-found" >NUL
+    SET pwshtest_exitcode=!errorlevel!
+    REM ECHO pwshtest_exitcode !pwshtest_exitcode!
+    REM fallback to powershell if pwsh failed 
+    IF !pwshtest_exitcode!==0 (
+        pwsh -nop -nol -c set-executionpolicy -Scope Process Unrestricted; "%~dp0%~n0.ps1" %arglist% & SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM CALL powershell -nop -nol -c write-host powershell-found
+        REM powershell -nop -nol -file "%~dp0%~n0.ps1" %*
+        powershell -nop -nol -c set-executionpolicy -Scope Process Unrestricted; %~dp0%~n0.ps1" %arglist%
+        SET task_exitcode=!errorlevel!
+    )
+) ELSE ( 
+    IF "!shells[%nextshell%]!"=="bash" (
+        CALL :getWslPath %winpath% wslpath
+        REM ECHO wslfullpath "!wslpath!%fname%"
+        !shells[%nextshell%]! "!wslpath!%fname%" %arglist% & SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM  probably tclsh or sh
+        IF NOT "x%keyRemoved%"=="x%validshells%" (
+            REM sh on windows uses /c/ instead of /mnt/c - at least if using msys. Todo, review what is the norm on windows with and without msys2,cygwin,wsl
+            REM and what logic if any may be needed. For now sh with /c/xxx seems to work the same as sh with c:/xxx
+            !shells[%nextshell%]! "%~dp0%fname%" %arglist% & SET task_exitcode=!errorlevel!
+        ) ELSE (
+            ECHO %fname% has invalid nextshell value ^(%nextshell%^) !shells[%nextshell%]! valid options are %validshells%
+            SET task_exitcode=66
+            GOTO :exit_multishell
+        )
+    )
+)
+@REM batch file library functions
+@GOTO :endlib
+
+:getWslPath
+@SETLOCAL
+    @SET "_path=%~p1"
+    @SET "name=%~nx1"
+    @SET "drive=%~d1"
+    @SET "rtrn=%~2"
+    @SET "result=/mnt/%drive:~0,1%%_path:\=/%%name%"
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        ECHO %result%
+    )
+)
+@EXIT /B
+
+:getFileTail
+@REM return tail of file without any normalization e.g c:/punkshell/bin/Punk.cmd returns Punk.cmd even if file is punk.cmd
+@REM we can't use things such as %~nx1 as it can change capitalisation
+@REM This function is designed explicitly to preserve capitalisation
+@REM accepts full paths with either / or \ as delimiters - or 
+@SETLOCAL
+    @SET "rtrn=%~2"
+    @SET "arg=%~1"
+    @REM @SET "result=%_arg:*/=%"
+    @REM @SET "result=%~1"
+    @SET LF=^
+
+
+    : The above 2 empty lines are important. Don't remove
+    @CALL :stringContains "!arg!" "\" hasBackSlash
+    @IF "!hasBackslash!"=="true" (
+        @for %%A in ("!LF!") do @(
+            @FOR /F %%B in ("!arg:\=%%~A!") do @set "result=%%B"
+        )
+    ) ELSE (
+        @CALL :stringContains "!arg!" "/" hasForwardSlash
+        @IF "!hasForwardSlash!"=="true" (
+            @FOR %%A in ("!LF!") do @(
+                @FOR /F %%B in ("!arg:/=%%~A!") do @set "result=%%B"
+            )
+        ) ELSE (
+            @set "result=%arg%"
+        )
+    )
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+@REM  boundary padding
+:getNormalizedScriptTail
+@SETLOCAL
+    @SET "result=%~nx0"
+    @SET "rtrn=%~1"
+@ENDLOCAL & (
+    @IF "%~1" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+
+:getNormalizedFileTailFromPath
+@REM warn via echo, and do not set return variable if path not found
+@REM note that %~nx1 does not preserve case of provided path - hence the name 'normalized'
+@REM boundary padding
+@REM boundary padding
+@SETLOCAL
+    @CALL :stringContains %~1 "\" hasBackSlash
+    @CALL :stringContains %~1 "/" hasForwardSlash
+    @IF "%hasBackslash%-%hasForwardslash%"=="false-false" (
+        @SET "P=%cd%%~1"
+        @CALL :getNormalizedFileTailFromPath "!P!" ftail2
+        @SET "result=!ftail2!"
+    ) else (
+        @IF EXIST "%~1" (
+            @SET "result=%~nx1"
+        ) else (
+            @ECHO error getNormalizedFileTailFromPath file not found: %~1
+            @EXIT /B 1
+        )
+    )
+    @SET "rtrn=%~2"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO getNormalizedFileTailFromPath %1 result: %result%
+    )
+)
+@EXIT /B
+
+:stringContains
+@REM usage: @CALL:stringContains string needle returnvarname
+@SETLOCAL
+    @SET "rtrn=%~3"
+    @SET "string=%~1"
+    @SET "needle=%~2"
+    @IF "!string:%needle%=!"=="!string!" @(
+        @SET "result=false"
+    ) ELSE (
+        @SET "result=true"
+    )
+@ENDLOCAL & (
+    @IF "%~3" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO stringContains %string% %needle% result: %result%
+    )
+)
+@EXIT /B
+
+:stringToUpper
+@SETLOCAL
+    @SET "rtrn=%~2"
+    @SET "string=%~1"
+    @SET "capstring=%~1"
+    @FOR %%A in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO @(
+        @SET "capstring=!capstring:%%A=%%A!"
+    )
+    @SET "result=!capstring!"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO stringToUpper %string% result: %result%
+    )
+)
+@EXIT /B
+
+:isNumeric
+@SETLOCAL
+    @SET "notnumeric="&FOR /F "delims=0123456789" %%i in ("%1") do set "notnumeric=%%i"
+    @IF defined notnumeric (
+        @SET "result=false"
+    ) else (
+        @SET "result=true"
+    )
+    @SET "rtrn=%~2"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+
+:endlib
+: \
+@REM @SET taskexit_code=!errorlevel! & goto :exit_multishell
+@GOTO :exit_multishell
+# }
+# -*- tcl -*-
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- tcl script section
+# -- This is a punk multishell file
+# -- Primary payload target is Tcl, with sh,bash,powershell as helpers
+# -- but it may equally be used with any of these being the primary script.
+# -- It is tuned to run when called as a batch file, a tcl script a sh/bash script or a pwsh/powershell script
+# -- i.e it is a polyglot file.
+# -- The specific layout including some lines that appear just as comments is quite sensitive to change.
+# -- It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# -- e.g ./filename.polypunk.cmd in sh or bash
+# -- e.g tclsh filename.cmd
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+rename set ""; rename s set; set k {-- "$@" "a}; if {[info exists ::env($k)]} {unset ::env($k)} ;# tidyup and restore
+Hide :exit_multishell;Hide {<#};Hide '@
+namespace eval ::punk::multishell {
+    set last_script_root    [file dirname [file normalize ${argv0}/__]]
+    set last_script         [file dirname [file normalize [info script]/__]] 
+    if {[info exists argv0] &&
+        $last_script eq $last_script_root
+        } {
+        set ::punk::multishell::is_main($last_script) 1 ;#run as executable/script - likely desirable to launch application and return an exitcode
+    } else {
+        set ::punk::multishell::is_main($last_script) 0 ;#sourced - likely to be being used as a library - no launch, no exit. Can use return.
+    }
+    if {"::punk::multishell::is_main" ni [info commands ::punk::multishell::is_main]} {
+        proc ::punk::multishell::is_main {{script_name {}}} {
+            if {$script_name eq ""} {
+                set script_name [file dirname [file normalize [info script]/--]]
+            }
+            if {![info exists ::punk::multishell::is_main($script_name)]} {
+                #e.g a .dll or something else unanticipated
+                puts stderr "Warning punk::multishell didn't recognize info script result: $script_name - will treat as if sourced and return instead of exiting"
+                puts stderr "Info: script_root: [file dirname [file normalize ${argv0}/__]]"
+                return 0
+            }
+            return [set ::punk::multishell::is_main($script_name)]
+        }
+    }
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+#puts "argv0    : $::argv0"
+# -- --- --- --- --- --- --- --- --- --- --- ---
+
+
+#<tcl-payload>
+#</tcl-payload>
+
+
+
+# -- --- --- --- --- --- --- --- --- --- --- ---
+# -- Best practice is to always return or exit above, or just by leaving the below defaults in place.
+# -- If the multishell script is modified to have Tcl below the Tcl Payload section,
+# -- then Tcl bracket balancing needs to be carefully managed in the shell and powershell sections below.
+# -- Only the # in front of the two relevant if statements below needs to be removed to enable Tcl below
+# -- but the sh/bash 'then' and 'fi' would also need to be uncommented.
+# -- This facility left in place for experiments on whether configuration payloads etc can be appended
+# -- to tail of file - possibly binary with ctrl-z char - but utility is dependent on which other interpreters/shells
+# -- can be made to ignore/cope with such data.
+if {[::punk::multishell::is_main]} {
+    exit 0
+} else {
+    return 
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+# end hide from unix shells \
+HEREDOC1B_HIDE_FROM_BASH_AND_SH
+# sh/bash \
+shift && set -- "${@:1:$#-1}"
+#------------------------------------------------------
+# -- This if block only needed if Tcl didn't exit or return above.
+if false==false # else {
+    then
+    : #
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- sh/bash script section
+# -- leave as is if all that is required is launching the Tcl payload"
+# --
+# -- Note that sh/bash script isn't called when running a .bat/.cmd from cmd.exe on windows by default
+# -- adjust  @call line above ...  to something like @call sh ... @call bash ..  or @call env sh ... etc as appropriate
+# --   if sh/bash scripting needs to run on windows too.
+# --
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin sh Payload
+#printf "start of bash or sh code"
+
+#<shell-payload-pre-tcl>
+#</shell-payload-pre-tcl>
+
+# -- --- --- --- --- --- --- ---
+#<shell-launch-tcl>
+exitcode=0 ;#default assumption
+#-- sh/bash launches Tcl here instead of shebang line at top
+#-- use exec to use exitcode (if any) directly from the tcl script
+#exec /usr/bin/env tclsh "$0" "$@"
+#-- alternative - can run sh/bash script after the tcl call.
+/usr/bin/env tclsh "$0" "$@"
+exitcode=$?
+#echo "tcl exitcode: ${exitcode}"
+#-- override exitcode example 
+#exit 66
+#</shell-launch-tcl>
+# -- --- --- --- --- --- --- ---
+
+#<shell-payload-post-tcl>
+#</shell-payload-post-tcl>
+
+
+#printf "sh/bash done \n"
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end sh Payload
+#------------------------------------------------------
+fi
+exit ${exitcode}
+# end hide sh/bash block from Tcl
+# This comment with closing brace should stay in place whether if commented or not }
+#------------------------------------------------------
+# begin hide powershell-block from Tcl - only needed if Tcl didn't exit or return above
+if 0 {
+: end heredoc1 - end hide from powershell \
+'@ 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- powershell/pwsh section
+# -- Do not edit if current file is the .ps1
+# -- Edit the corresponding .cmd and it will autocopy 
+# -- unbalanced braces { } here *even in comments* will cause problems if there was no Tcl exit or return above
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+function GetScriptName { $myInvocation.ScriptName }
+$scriptname = getScriptName
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin powershell Payload
+#"Timestamp         :    {0,10:yyyy-MM-dd HH:mm:ss}"    -f $(Get-Date)   | write-host
+#"Script Name       :    {0}"    -f $scriptname                          | write-host
+#"Powershell Version:    {0}"    -f $PSVersionTable.PSVersion.Major      | write-host
+#"powershell args   :    {0}"    -f ($args -join ", ")                   | write-host
+# -- --- --- ---
+
+#<powershell-payload-pre-tcl>
+#</powershell-payload-pre-tcl>
+
+
+# -- --- --- --- --- --- --- ---
+#<powershell-launch-tcl>
+tclsh $scriptname $args
+#</powershell-launch-tcl>
+# -- --- --- --- --- --- --- ---
+
+
+#<powershell-payload-post-tcl>
+#</powershell-payload-post-tcl>
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end powershell Payload
+#"powershell reporting exitcode: {0}" -f $LASTEXITCODE | write-host
+Exit $LASTEXITCODE
+# heredoc2 for powershell to ignore block below
+$1 = @'
+'
+: comment end hide powershell-block from Tcl \
+# This comment with closing brace should stay in place whether 'if' commented or not }
+: multishell doubled-up cmd exit label - return exitcode 
+:exit_multishell
+:exit_multishell
+: \
+@REM @ECHO exitcode: !task_exitcode!
+: \
+@IF "%1"=="PUNK-ELEVATED" (echo. & @cmd /k echo elevated prompt: type exit to quit)
+: \
+@EXIT /B !task_exitcode!
+# cmd has exited
+: comment end heredoc2 \
+'@
+<#
+# id:tailblock0
+# -- powershell multiline comment 
+#>
+<#
+# id:tailblock1
+# <ctrl-z>
+
+# </ctrl-z>
+# -- unreachable by tcl directly if ctrl-z character is in the <ctrl-z> section above. (but file can be read and split on \x1A)
+# -- Potential for zip and/or base64 contents, but we can't stop pwsh parser from slurping in the data
+# -- so for example a plain text tar archive could cause problems depending on the content.
+# -- final line in file must be the powershell multiline comment terminator or other data it can handle.
+# -- e.g plain # comment lines will work too
+# -- (for example a powershell digital signature is a # commented block of data at the end of the file)
+#>
+
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-multishell-old.cmd b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-multishell-old.cmd
new file mode 100644
index 00000000..1cb9e0ef
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-multishell-old.cmd
@@ -0,0 +1,270 @@
+set -- "$@" "a=[list shebangless punk MULTISHELL tclsh sh bash cmd pwsh powershell;proc Hide s {proc $s args {}}; Hide :;rename set s2;Hide set;s2 1 list]"; set -- : "$@"; $1 = @'
+: heredoc1 - hide from powershell (close sqote for unix shells) ' \
+: << 'HEREDOC1B_HIDE_FROM_BASH_AND_SH'
+: .bat/.cmd launch section, leading colon hides from cmd, trailing slash hides next line from tcl \
+: "[Hide @ECHO; Hide ); Hide (;Hide echo]#not necessary but can help avoid errs in testing"
+: Continuation char at end of this line and rem with curly-braces used to exlude Tcl from the whole cmd block \
+@REM {
+@REM DO NOT MODIFY FIRST LINE OF THIS SCRIPT. shebang #! line is not required and will reduce functionality.
+@REM Even comment lines can be part of the functionality of this script - modify with care.
+@REM Change the value of nextshell in the next line if desired, and code within payload sections as appropriate.
+@SET "nextshell=pwsh"
+@REM nextshell set to pwsh,sh,bash or tclsh
+@REM @ECHO nextshell is %nextshell%
+@SET "validshells=pwsh,sh,bash,tclsh"
+@CALL SET keyRemoved=%%validshells:%nextshell%=%%
+@REM Note that 'powershell' e.g v5 is just a fallback for when pwsh is not available
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@REM  -- cmd/batch file section (ignored on unix)
+@REM  -- This section intended only to launch the next shell
+@REM  -- Avoid customising this if possible. cmd/batch script is probably the least expressive language.
+@REM  -- custom windows payloads should be in powershell,tclsh or sh/bash code sections
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@SETLOCAL EnableExtensions EnableDelayedExpansion
+@SET "winpath=%~dp0"
+@SET "fname=%~nx0"
+@REM @ECHO fname %fname%
+@REM @ECHO winpath %winpath%
+@IF %nextshell%==pwsh (
+    CALL pwsh -nop -c set-executionpolicy -Scope CurrentUser RemoteSigned
+    COPY "%~dp0%~n0.cmd" "%~dp0%~n0.ps1" >NUL 
+    REM test availability of preferred option of powershell7+ pwsh
+    CALL pwsh -nop -nol -c write-host "statusmessage: pwsh-found" >NUL
+    SET pwshtest_exitcode=!errorlevel!
+    REM ECHO pwshtest_exitcode !pwshtest_exitcode!
+    IF !pwshtest_exitcode!==0 CALL pwsh -nop -nol "%~dp0%~n0.ps1" %* & SET task_exitcode=!errorlevel!
+    REM fallback to powershell if pwsh failed 
+    IF NOT !pwshtest_exitcode!==0 (
+        REM CALL powershell -nop -nol -c write-host powershell-found
+        CALL powershell -nop -nol -file "%~dp0%~n0.ps1" %*
+        SET task_exitcode=!errorlevel!
+    )
+) ELSE ( 
+    IF %nextshell%==bash (
+        CALL :getWslPath %winpath% wslpath
+        REM ECHO wslfullpath "!wslpath!%fname%"
+        CALL %nextshell% "!wslpath!%fname%" %* & SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM  probably tclsh or sh
+        IF NOT "x%keyRemoved%"=="x%validshells%" (
+            REM sh uses /c/ instead of /mnt/c - at least if using msys. Todo, review what is the norm on windows with and without msys2,cygwin,wsl
+            REM and what logic if any may be needed. For now sh with /c/xxx seems to work the same as sh with c:/xxx
+            CALL %nextshell% "%~dp0%fname%" %* & SET task_exitcode=!errorlevel!
+        ) ELSE (
+            ECHO %fname% has invalid nextshell value %nextshell% valid options are %validshells%
+            SET task_exitcode=66
+            GOTO :exit
+        )
+    )
+)
+@GOTO :endlib
+:getWslPath
+@SETLOCAL
+    @SET "_path=%~p1"
+    @SET "name=%~nx1"
+    @SET "drive=%~d1"
+    @SET "rtrn=%~2"
+    @SET "result=/mnt/%drive:~0,1%%_path:\=/%%name%"
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        ECHO %result%
+    )
+)
+@GOTO :eof
+:endlib
+
+: \
+@REM @SET taskexit_code=!errorlevel! & goto :exit
+@GOTO :exit
+# }
+# rem call %nextshell% "%~dp0%~n0.cmd" %* 
+# -*- tcl -*-
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- tcl script section
+# -- This is a punk multishell file
+# -- Primary payload target is Tcl, with sh,bash,powershell as helpers
+# -- but it may equally be used with any of these being the primary script.
+# -- It is tuned to run when called as a batch file, a tcl script a sh/bash script or a pwsh/powershell script
+# -- i.e it is a polyglot file.
+# -- The specific layout including some lines that appear just as comments is quite sensitive to change.
+# -- It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# -- e.g ./filename.polypunk.cmd in sh or bash
+# -- e.g tclsh filename.cmd
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+rename set ""; rename s2 set; set k {-- "$@" "a}; if {[info exists ::env($k)]} {unset ::env($k)} ;# tidyup
+Hide :exit;Hide {<#};Hide '@
+namespace eval ::punk::multishell {
+    set last_script_root    [file dirname [file normalize ${argv0}/__]]
+    set last_script         [file dirname [file normalize [info script]/__]] 
+    if {[info exists argv0] &&
+        $last_script eq $last_script_root
+        } {
+        set ::punk::multishell::is_main($last_script) 1 ;#run as executable/script - likely desirable to launch application and return an exitcode
+    } else {
+        set ::punk::multishell::is_main($last_script) 0 ;#sourced - likely to be being used as a library - no launch, no exit. Can use return.
+    }
+    if {"::punk::multishell::is_main" ni [info commands ::punk::multishell::is_main]} {
+        proc ::punk::multishell::is_main {{script_name {}}} {
+            if {$script_name eq ""} {
+                set script_name [file dirname [file normalize [info script]/--]]
+            }
+            if {![info exists ::punk::multishell::is_main($script_name)]} {
+                #e.g a .dll or something else unanticipated
+                puts stderr "Warning punk::multishell didn't recognize info script result: $script_name - will treat as if sourced and return instead of exiting"
+                puts stderr "Info: script_root: [file dirname [file normalize ${argv0}/__]]"
+                return 0
+            }
+            return [set ::punk::multishell::is_main($script_name)]
+        }
+    }
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+#puts "argv0    : $::argv0"
+# -- --- --- --- --- --- --- --- --- --- --- ---
+
+
+#<tcl-payload>
+#</tcl-payload>
+
+
+
+# -- --- --- --- --- --- --- --- --- --- --- ---
+# -- Best practice is to always return or exit above, or just by leaving the below defaults in place.
+# -- If the multishell script is modified to have Tcl below the Tcl Payload section,
+# -- then Tcl bracket balancing needs to be carefully managed in the shell and powershell sections below.
+# -- Only the # in front of the two relevant if statements below needs to be removed to enable Tcl below
+# -- but the sh/bash 'then' and 'fi' would also need to be uncommented.
+# -- This facility left in place for experiments on whether configuration payloads etc can be appended
+# -- to tail of file - possibly binary with ctrl-z char - but utility is dependent on which other interpreters/shells
+# -- can be made to ignore/cope with such data.
+if {[::punk::multishell::is_main]} {
+    exit 0
+} else {
+    return 
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+# end hide from unix shells \
+HEREDOC1B_HIDE_FROM_BASH_AND_SH
+# sh/bash \
+shift && set -- "${@:1:$#-1}"
+#------------------------------------------------------
+# -- This if block only needed if Tcl didn't exit or return above.
+if false==false # else {
+    then
+    :
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- sh/bash script section
+# -- leave as is if all that is required is launching the Tcl payload"
+# --
+# -- Note that sh/bash script isn't called when running a .bat/.cmd from cmd.exe on windows by default
+# -- adjust  @call line above ...  to something like @call sh ... @call bash ..  or @call env sh ... etc as appropriate
+# --   if sh/bash scripting needs to run on windows too.
+# --
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin sh Payload
+#printf "start of bash or sh code"
+
+#<shell-payload-pre-tcl>
+#</shell-payload-pre-tcl>
+
+# -- --- --- --- --- --- --- ---
+#<shell-launch-tcl>
+exitcode=0 ;#default assumption
+#-- sh/bash launches Tcl here instead of shebang line at top
+#-- use exec to use exitcode (if any) directly from the tcl script
+#exec /usr/bin/env tclsh "$0" "$@"
+#-- alternative - can run sh/bash script after the tcl call.
+/usr/bin/env tclsh "$0" "$@"
+exitcode=$?
+#echo "tcl exitcode: ${exitcode}"
+#-- override exitcode example 
+#exit 66
+#</shell-launch-tcl>
+# -- --- --- --- --- --- --- ---
+
+#<shell-payload-post-tcl>
+#</shell-payload-post-tcl>
+
+
+#printf "sh/bash done \n"
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end sh Payload
+#------------------------------------------------------
+fi
+exit ${exitcode}
+# end hide sh/bash block from Tcl
+# This comment with closing brace should stay in place whether if commented or not }
+#------------------------------------------------------
+# begin hide powershell-block from Tcl - only needed if Tcl didn't exit or return above
+if 0 {
+: end heredoc1 - end hide from powershell \
+'@ 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- powershell/pwsh section
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+function GetScriptName { $myInvocation.ScriptName }
+$scriptname = getScriptName
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin powershell Payload
+#"Timestamp         :    {0,10:yyyy-MM-dd HH:mm:ss}"    -f $(Get-Date)   | write-host
+#"Script Name       :    {0}"    -f $scriptname                          | write-host
+#"Powershell Version:    {0}"    -f $PSVersionTable.PSVersion.Major      | write-host
+#"powershell args   :    {0}"    -f ($args -join ", ")                   | write-host
+# -- --- --- ---
+
+#<powershell-payload-pre-tcl>
+#</powershell-payload-pre-tcl>
+
+
+# -- --- --- --- --- --- --- ---
+#<powershell-launch-tcl>
+tclsh $scriptname $args
+#</powershell-launch-tcl>
+# -- --- --- --- --- --- --- ---
+
+
+#<powershell-payload-post-tcl>
+#</powershell-payload-post-tcl>
+
+# unbal }
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end powershell Payload
+#"powershell reporting exitcode: {0}" -f $LASTEXITCODE | write-host
+Exit $LASTEXITCODE
+# heredoc2 for powershell to ignore block below
+$1 = @'
+'
+: end hide powershell-block from Tcl \
+# This comment with closing brace should stay in place whether 'if' commented or not }
+: cmd exit label - return exitcode 
+:exit
+: \
+@REM @ECHO exitcode: !task_exitcode!
+: \
+@EXIT /B !task_exitcode!
+# cmd has exited
+: end heredoc2 \
+'@
+<#
+# id:tailblock0
+# -- powershell multiline comment 
+#>
+<#
+# id:tailblock1
+# <ctrl-z>
+
+# </ctrl-z>
+# -- unreachable by tcl directly if ctrl-z character is in the <ctrl-z> section above. (but file can be read and split on \x1A)
+# -- Potential for zip and/or base64 contents, but we can't stop pwsh parser from slurping in the data
+# -- so for example a plain text tar archive could cause problems depending on the content.
+# -- final line in file must be the powershell multiline comment terminator or other data it can handle.
+# -- e.g plain # comment lines will work too
+# -- (for example a powershell digital signature is a # commented block of data at the end of the file)
+#>
+
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-multishell.cmd b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-multishell.cmd
new file mode 100644
index 00000000..0e6b9ff9
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-multishell.cmd
@@ -0,0 +1,661 @@
+: "punk MULTISHELL - shebangless polyglot for Tcl Perl sh bash cmd pwsh powershell" + "[rename set s;proc Hide x {proc $x args {}};Hide :]" + "\$(function : {<#pwsh#>})" + "perlhide" + qw^
+set -- "$@" "a=[Hide <#;Hide set;s 1 list]"; set -- : "$@";$1 = @'
+: heredoc1 - hide from powershell using @ and squote above. close sqote for unix shells + ' \
+: .bat/.cmd launch section, leading colon hides from cmd, trailing slash hides next line from tcl + \
+: "[Hide @GOTO; Hide =begin; Hide @REM] #not necessary but can help avoid errs in testing" +
+: << 'HEREDOC1B_HIDE_FROM_BASH_AND_SH'
+: STRONG SUGGESTION: DO NOT MODIFY FIRST LINE OF THIS SCRIPT - except for first double quoted section.
+: shebang line is not required on unix or windows and will reduce functionality and/or portability.
+: Even comment lines can be part of the functionality of this script (both on unix and windows) - modify with care.
+@GOTO :skip_perl_pod_start ^;
+=begin excludeperl 
+: skip_perl_pod_start
+: Continuation char at end of this line and rem with curly-braces used to exlude Tcl from the whole cmd block \
+:  {
+@REM ############################################################################################################################
+@REM THIS IS A POLYGLOT SCRIPT - supporting payloads in Tcl, bash, sh and/or powershelll (powershell.exe or pwsh.exe)
+@REM It should remain portable between unix-like OSes & windows if the proper structure is maintained.
+@REM ############################################################################################################################
+@REM On windows, change the value of nextshell to one of the listed 2 digit values if desired, and add code within payload sections for tcl,sh,bash,powershell as appropriate.
+@REM This wrapper can be edited manually (carefully!) - or sh,bash,tcl,powershell scripts can be wrapped using the Tcl-based punkshell system
+@REM e.g from within a running punkshell: pmix scriptwrap.multishell <inputfilepath> -outputfolder <folderpath> 
+@REM On unix-like systems, call with sh, bash or tclsh. (powershell untested on unix - and requires wscript if security elevation is used)
+@REM Due to lack of shebang (#! line) Unix-like systems will probably (hopefully) default to sh if the script is called without an interpreter - but it may depend on the shell in use when called.
+@REM If you find yourself really wanting/needing to add a shebang line - do so on the basis that the script will exist on unix-like systems only. 
+@SETLOCAL EnableExtensions EnableDelayedExpansion
+@SET "validshells= ^(10^) 'pwsh' ^(11^) 'sh' (^12^) 'bash' (^13^) 'tclsh' (^14^) 'perl'"
+@SET "shells[10]=pwsh"
+@SET "shells[11]=sh"
+@set "shells[12]=bash"
+@SET "shells[13]=tclsh"
+@SET "shells[14]=perl"
+: <nextshell>
+@SET "nextshell=13"
+: </nextshell>
+@rem asadmin is for automatic elevation to administrator. Separate window will be created (seems unavoidable with current elevation mechanism) and user will still get security prompt (probably reasonable).
+: <asadmin>
+@SET "asadmin=0"
+: </asadmin>
+@REM nextshell set to index for validshells .eg 10 for pwsh  
+@REM @ECHO nextshell is %nextshell%
+@SET "selected=!shells[%nextshell%]!"
+@REM @ECHO selected %selected%
+@CALL SET "keyRemoved=%%validshells:'!selected!'=%%"
+@REM @ECHO keyremoved %keyRemoved%
+@REM Note that 'powershell' e.g v5 is just a fallback for when pwsh is not available
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@REM  -- cmd/batch file section (ignored on unix but should be left in place)
+@REM  -- This section intended mainly to launch the next shell (and to escalate privileges if necessary)
+@REM  -- Avoid customising this if you are not familiar with batch scripting. cmd/batch script can be useful, but is probably the least expressive language and most error prone.
+@REM  -- For example - as this file needs to use unix-style lf line-endings - the label scanner is susceptible to the 512Byte boundary issue: https://www.dostips.com/forum/viewtopic.php?t=8988#p58888
+@REM  -- This label issue can be triggered/abused in files with crlf line endings too - but it is less likely to happen accidentaly.
+@REm  -- See also: https://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/4095133#4095133
+@REM ############################################################################################################################
+@REM  -- Due to this issue -seemingly trivial edits of the batch file section can break the script! (for Windows anyway)
+@REM  -- Even something as simple as adding or removing an @REM
+@REM  -- From within punkshell - use:
+@REM  --     pmix scriptwrap.checkfile <filepath>
+@REM  -- to check your templates or final wrapped scripts for byte boundary issues
+@REM  -- It will report any labels that are on boundaries
+@REM  -- This is why the nextshell value above is a 2 digit key instead of a string - so that editing the value doesn't change the byte offsets.
+@REM  -- Editing your sh,bash,tcl,pwsh payloads is much less likely to cause an issue. There is the possibility of the final batch :exit_multishell label spanning a boundary - so testing using pmix scriptwrap.checkfile is still recommended.
+@REM  -- Alternatively, as you should do anyway - test the final script on windows   
+@REM  -- Aside from adding comments/whitespace to tweak the location of labels - you can try duplicating the label (e.g just add the label on a line above) but this is not guaranteed to work in all situations.
+@REM  -- '@REM' is a safer comment mechanism than a leading colon - which is used sparingly here.
+@REM  -- A colon anywhere in the script that happens to land on a 512 Byte boundary (from file start or from a callsite) could be misinterpreted as a label
+@REM  -- It is unknown what versions of cmd interpreters behave this way - and pmix scriptwrap.checkfile doesn't check all such boundaries.
+@REm  -- For this reason, batch labels should be chosen to be relatively unlikely to collide with other strings in the file, and simple names such as :exit or :end should probably be avoided
+@REM ############################################################################################################################
+@REM  -- custom windows payloads should be in powershell,tclsh (or sh/bash if available) code sections
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@SET "winpath=%~dp0"
+@SET "fname=%~nx0"
+@REM @ECHO fname %fname%
+@REM @ECHO winpath %winpath%
+@REM @ECHO commandlineascalled %0
+@REM @ECHO commandlineresolved %~f0
+@CALL :getNormalizedScriptTail nftail
+@REM @ECHO normalizedscripttail %nftail%
+@CALL :getFileTail %0 clinetail
+@REM @ECHO clinetail %clinetail%
+@CALL :stringToUpper %~nx0 capscripttail
+@REM @ECHO capscriptname: %capscripttail%
+
+@IF "%nftail%"=="%capscripttail%" (
+    @ECHO forcing asadmin=1 due to file name on filesystem being uppercase
+    @SET "asadmin=1"
+) else (
+    @CALL :stringToUpper %clinetail% capcmdlinetail
+    @REM @ECHO capcmdlinetail !capcmdlinetail!
+    IF "%clinetail%"=="!capcmdlinetail!" (
+        @ECHO forcing asadmin=1 due to cmdline scriptname in uppercase
+        @set "asadmin=1"
+    )
+)
+@SET "vbsGetPrivileges=%temp%\punk_bat_elevate_%fname%.vbs"
+@SET arglist=%*
+@IF "%1"=="PUNK-ELEVATED" (
+    GOTO :gotPrivileges
+)
+@IF !asadmin!==1 (
+    net file 1>NUL 2>NUL
+    @IF '!errorlevel!'=='0' ( GOTO :gotPrivileges ) else ( GOTO :getPrivileges )
+)
+@GOTO skip_privileges
+:getPrivileges
+@IF '%1'=='PUNK-ELEVATED' (echo PUNK-ELEVATED & shift /1 & goto :gotPrivileges )
+@ECHO Set UAC = CreateObject^("Shell.Application"^) > "%vbsGetPrivileges%"
+@ECHO args = "PUNK-ELEVATED " >> "%vbsGetPrivileges%"
+@ECHO For Each strArg in WScript.Arguments >> "%vbsGetPrivileges%"
+@ECHO args = args ^& strArg ^& " " >> "%vbsGetPrivileges%"
+@ECHO Next >> "%vbsGetPrivileges%"
+@ECHO UAC.ShellExecute "%~dp0%~n0%~x0", args, "", "runas", 1 >> "%vbsGetPrivileges%"
+@ECHO Launching script in new windows due to administrator elevation
+@"%SystemRoot%\System32\WScript.exe" "%vbsGetPrivileges%" %*
+@EXIT /B
+
+:gotPrivileges
+@REM setlocal & pushd .
+@PUSHD .
+@cd /d %~dp0
+@IF "%1"=="PUNK-ELEVATED" (
+    @DEL "%vbsGetPrivileges%" 1>nul 2>nul
+    @SET arglist=%arglist:~14%
+)
+
+:skip_privileges
+@SET need_ps1=0
+@REM we want the ps1 to exist even if the nextshell isn't powershell
+@if not exist "%~dp0%~n0.ps1" (
+    @SET need_ps1=1
+) ELSE (
+    fc "%~dp0%~n0%~x0" "%~dp0%~n0.ps1" >nul || goto different
+    @REM @ECHO "files same"
+    @SET need_ps1=0
+)
+@GOTO :pscontinue
+:different
+@REM @ECHO "files differ"
+@SET need_ps1=1
+:pscontinue
+@IF !need_ps1!==1 (
+    COPY "%~dp0%~n0%~x0" "%~dp0%~n0.ps1" >NUL 
+)
+@REM avoid using CALL to launch pwsh,tclsh etc - it will intercept some args such as /?
+@IF "!shells[%nextshell%]!"=="pwsh" (
+    REM pws vs powershell hasn't been tested because we didn't need to copy cmd to ps1 this time
+    REM test availability of preferred option of powershell7+ pwsh
+    pwsh -nop -nol -c set-executionpolicy -Scope Process Unrestricted; write-host "statusmessage: pwsh-found" >NUL
+    SET pwshtest_exitcode=!errorlevel!
+    REM ECHO pwshtest_exitcode !pwshtest_exitcode!
+    REM fallback to powershell if pwsh failed 
+    IF !pwshtest_exitcode!==0 (
+        pwsh -nop -nol -c set-executionpolicy -Scope Process Unrestricted; "%~dp0%~n0.ps1" %arglist%
+        SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM CALL powershell -nop -nol -c write-host powershell-found
+        REM powershell -nop -nol -file "%~dp0%~n0.ps1" %*
+        powershell -nop -nol -c set-executionpolicy -Scope Process Unrestricted; %~dp0%~n0.ps1" %arglist%
+        SET task_exitcode=!errorlevel!
+    )
+) ELSE ( 
+    IF "!shells[%nextshell%]!"=="bash" (
+        CALL :getWslPath %winpath% wslpath
+        REM ECHO wslfullpath "!wslpath!%fname%"
+        !shells[%nextshell%]! "!wslpath!%fname%" %arglist%
+        SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM  probably tclsh or sh
+        IF NOT "x%keyRemoved%"=="x%validshells%" (
+            REM sh on windows uses /c/ instead of /mnt/c - at least if using msys. Todo, review what is the norm on windows with and without msys2,cygwin,wsl
+            REM and what logic if any may be needed. For now sh with /c/xxx seems to work the same as sh with c:/xxx
+            !shells[%nextshell%]! "%~dp0%fname%" %arglist%
+            SET task_exitcode=!errorlevel!
+        ) ELSE (
+            ECHO %fname% has invalid nextshell value ^(%nextshell%^) !shells[%nextshell%]! valid options are %validshells%
+            SET task_exitcode=66
+            @REM boundary padding
+            GOTO :exit_multishell
+        )
+    )
+)
+@REM batch file library functions
+@REM boundary padding
+@GOTO :endlib
+
+:getWslPath
+@SETLOCAL
+    @SET "_path=%~p1"
+    @SET "name=%~nx1"
+    @SET "drive=%~d1"
+    @SET "rtrn=%~2"
+    @SET "result=/mnt/%drive:~0,1%%_path:\=/%%name%"
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        ECHO %result%
+    )
+)
+@EXIT /B
+
+:getFileTail
+@REM return tail of file without any normalization e.g c:/punkshell/bin/Punk.cmd returns Punk.cmd even if file is punk.cmd
+@REM we can't use things such as %~nx1 as it can change capitalisation
+@REM This function is designed explicitly to preserve capitalisation
+@REM accepts full paths with either / or \ as delimiters - or 
+@SETLOCAL
+    @SET "rtrn=%~2"
+    @SET "arg=%~1"
+    @REM @SET "result=%_arg:*/=%"
+    @REM @SET "result=%~1"
+    @SET LF=^
+
+
+    : The above 2 empty lines are important. Don't remove
+    @CALL :stringContains "!arg!" "\" hasBackSlash
+    @IF "!hasBackslash!"=="true" (
+        @for %%A in ("!LF!") do @(
+            @FOR /F %%B in ("!arg:\=%%~A!") do @set "result=%%B"
+        )
+    ) ELSE (
+        @CALL :stringContains "!arg!" "/" hasForwardSlash
+        @IF "!hasForwardSlash!"=="true" (
+            @FOR %%A in ("!LF!") do @(
+                @FOR /F %%B in ("!arg:/=%%~A!") do @set "result=%%B"
+            )
+        ) ELSE (
+            @set "result=%arg%"
+        )
+    )
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+@REM  boundary padding
+@REM boundary padding
+:getNormalizedScriptTail
+@SETLOCAL
+    @SET "result=%~nx0"
+    @SET "rtrn=%~1"
+@ENDLOCAL & (
+    @IF "%~1" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+
+:getNormalizedFileTailFromPath
+@REM warn via echo, and do not set return variable if path not found
+@REM note that %~nx1 does not preserve case of provided path - hence the name 'normalized'
+@REM boundary padding
+@REM boundary padding
+@REM boundary padding
+@REM boundary padding
+@SETLOCAL
+    @CALL :stringContains %~1 "\" hasBackSlash
+    @CALL :stringContains %~1 "/" hasForwardSlash
+    @IF "%hasBackslash%-%hasForwardslash%"=="false-false" (
+        @SET "P=%cd%%~1"
+        @CALL :getNormalizedFileTailFromPath "!P!" ftail2
+        @SET "result=!ftail2!"
+    ) else (
+        @IF EXIST "%~1" (
+            @SET "result=%~nx1"
+        ) else (
+            @ECHO error getNormalizedFileTailFromPath file not found: %~1
+            @EXIT /B 1
+        )
+    )
+    @SET "rtrn=%~2"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO getNormalizedFileTailFromPath %1 result: %result%
+    )
+)
+@EXIT /B
+
+:stringContains
+@REM usage: @CALL:stringContains string needle returnvarname
+@SETLOCAL
+    @SET "rtrn=%~3"
+    @SET "string=%~1"
+    @SET "needle=%~2"
+    @IF "!string:%needle%=!"=="!string!" @(
+        @SET "result=false"
+    ) ELSE (
+        @SET "result=true"
+    )
+@ENDLOCAL & (
+    @IF "%~3" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO stringContains %string% %needle% result: %result%
+    )
+)
+@EXIT /B
+
+:stringToUpper
+@SETLOCAL
+    @SET "rtrn=%~2"
+    @SET "string=%~1"
+    @SET "capstring=%~1"
+    @FOR %%A in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO @(
+        @SET "capstring=!capstring:%%A=%%A!"
+    )
+    @SET "result=!capstring!"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO stringToUpper %string% result: %result%
+    )
+)
+@EXIT /B
+
+:isNumeric
+@SETLOCAL
+    @SET "notnumeric="&FOR /F "delims=0123456789" %%i in ("%1") do set "notnumeric=%%i"
+    @IF defined notnumeric (
+        @SET "result=false"
+    ) else (
+        @SET "result=true"
+    )
+    @SET "rtrn=%~2"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+
+:endlib
+: \
+@REM @SET taskexit_code=!errorlevel! & goto :exit_multishell
+@GOTO :exit_multishell
+# }
+# -*- tcl -*-
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- tcl script section
+# -- This is a punk multishell file
+# -- Primary payload target is Tcl, with sh,bash,powershell as helpers
+# -- but it may equally be used with any of these being the primary script.
+# -- It is tuned to run when called as a batch file, a tcl script a sh/bash script or a pwsh/powershell script
+# -- i.e it is a polyglot file.
+# -- The specific layout including some lines that appear just as comments is quite sensitive to change.
+# -- It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# -- e.g ./filename.polypunk.cmd in sh or bash
+# -- e.g tclsh filename.cmd
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+rename set ""; rename s set; set k {-- "$@" "a}; if {[info exists ::env($k)]} {unset ::env($k)} ;# tidyup and restore
+Hide :exit_multishell;Hide {<#};Hide '@
+namespace eval ::punk::multishell {
+    set last_script_root    [file dirname [file normalize ${argv0}/__]]
+    set last_script         [file dirname [file normalize [info script]/__]] 
+    if {[info exists argv0] &&
+        $last_script eq $last_script_root
+        } {
+        set ::punk::multishell::is_main($last_script) 1 ;#run as executable/script - likely desirable to launch application and return an exitcode
+    } else {
+        set ::punk::multishell::is_main($last_script) 0 ;#sourced - likely to be being used as a library - no launch, no exit. Can use return.
+    }
+    if {"::punk::multishell::is_main" ni [info commands ::punk::multishell::is_main]} {
+        proc ::punk::multishell::is_main {{script_name {}}} {
+            if {$script_name eq ""} {
+                set script_name [file dirname [file normalize [info script]/--]]
+            }
+            if {![info exists ::punk::multishell::is_main($script_name)]} {
+                #e.g a .dll or something else unanticipated
+                puts stderr "Warning punk::multishell didn't recognize info script result: $script_name - will treat as if sourced and return instead of exiting"
+                puts stderr "Info: script_root: [file dirname [file normalize ${argv0}/__]]"
+                return 0
+            }
+            return [set ::punk::multishell::is_main($script_name)]
+        }
+    }
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+#puts "argv0    : $::argv0"
+# -- --- --- --- --- --- --- --- --- --- --- ---
+
+
+#<tcl-pre-launch-subprocess>
+#</tcl-pre-launch-subprocess>
+
+#<tcl-launch-subprocess>
+#</tcl-launch-subproces>
+
+
+#<tcl-post-launch-subprocess>
+#</tcl-post-launch-subproces>
+
+
+# -- --- --- --- --- --- --- --- --- --- --- ---
+# -- Best practice is to always return or exit above, or just by leaving the below defaults in place.
+# -- If the multishell script is modified to have Tcl below the Tcl Payload section,
+# -- then Tcl bracket balancing needs to be carefully managed in the shell and powershell sections below.
+# -- Only the # in front of the two relevant if statements below needs to be removed to enable Tcl below
+# -- but the sh/bash 'then' and 'fi' would also need to be uncommented.
+# -- This facility left in place for experiments on whether configuration payloads etc can be appended
+# -- to tail of file - possibly binary with ctrl-z char - but utility is dependent on which other interpreters/shells
+# -- can be made to ignore/cope with such data.
+if {[::punk::multishell::is_main]} {
+    exit 0
+} else {
+    return 
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+# end hide from unix shells \
+HEREDOC1B_HIDE_FROM_BASH_AND_SH
+# sh/bash \
+shift && set -- "${@:1:$#-1}"
+#------------------------------------------------------
+# -- This if block only needed if Tcl didn't exit or return above.
+if false==false # else {
+    then
+    : #
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- sh/bash script section
+# -- leave as is if all that is required is launching the Tcl payload"
+# --
+# -- Note that sh/bash script isn't called when running a .bat/.cmd from cmd.exe on windows by default
+# -- adjust the %nextshell% value above 
+# --   if sh/bash scripting needs to run on windows too.
+# --
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin sh Payload
+exitcode=0
+#printf "start of bash or sh code"
+
+#<shell-pre-launch-subprocess>
+#</shell-pre-launch-subprocess>
+
+# -- --- --- --- --- --- --- ---
+#<shell-launch-subprocess>
+#-- sh/bash launches Tcl here instead of shebang line at top
+#-- use exec to use exitcode (if any) directly from the tcl script
+#exec /usr/bin/env tclsh "$0" "$@"
+#-- alternative - can run sh/bash script after the tcl call.
+/usr/bin/env tclsh "$0" "$@"
+exitcode=$?
+#echo "sh/bash reporting tcl exitcode: ${exitcode}"
+#-- override exitcode example 
+#exit 66
+#</shell-launch-subprocess>
+# -- --- --- --- --- --- --- ---
+
+#<shell-post-launch-subprocess>
+#</shell-post-launch-subproces>
+
+
+#printf "sh/bash done \n"
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end sh Payload
+#------------------------------------------------------
+fi
+exit ${exitcode}
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- Perl script section
+# -- leave the script below as is, if all that is required is launching the Tcl payload"
+# --
+# -- Note that perl script isn't called by default when simply running this script by name
+# -- adjust  the nextshell value at the top of the script to point to perl
+# --
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+=cut
+#!/user/bin/perl
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin perl Payload
+my $exit_code = 0;
+#use ExtUtils::Installed;
+#my $installed = ExtUtils::Installed->new();
+#my @modules = $installed->modules();
+#print "Modules:\n";
+#foreach my $m (@modules) {
+#    print "$m\n";
+#}
+# -- --- ---
+
+
+
+my $scriptname = $0;
+print "perl $scriptname\n";
+my $i =1;
+foreach my $a(@ARGV) {
+    print "Arg # $i: $a\n";
+}
+
+#<perl-pre-launch-subprocess>
+#</perl-pre-launch-subprocess>
+
+
+
+# -- --- --- --- --- --- --- ---
+#<perl-launch-subprocess>
+$exit_code=system("tclsh", $scriptname, @ARGV);
+#print "perl reporting tcl exitcode: $exit_code";
+#</perl-launch-subprocess>
+# -- --- --- --- --- --- --- ---
+
+#<perl-post-launch-subprocess>
+#</perl-post-launch-subprocess>
+
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end perl Payload
+exit $exit_code;
+__END__
+
+# end hide sh/bash/perl block from Tcl
+# This comment with closing brace should stay in place whether if commented or not }
+#------------------------------------------------------
+# begin hide powershell-block from Tcl - only needed if Tcl didn't exit or return above
+if 0 {
+: end heredoc1 - end hide from powershell \
+'@ 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- powershell/pwsh section
+# -- Do not edit if current file is the .ps1
+# -- Edit the corresponding .cmd and it will autocopy 
+# -- unbalanced braces { } here *even in comments* will cause problems if there was no Tcl exit or return above
+# -- custom script should generally go below the begin_powershell_payload line
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+function GetScriptName { $myInvocation.ScriptName }
+$scriptname = GetScriptName
+function GetDynamicParamDictionary {
+    [CmdletBinding()]
+    param(
+        [Parameter(ValueFromPipeline=$true, Mandatory=$true)]
+        [string] $CommandName
+    )
+
+    begin {
+        # Get a list of params that should be ignored (they're common to all advanced functions)
+        $CommonParameterNames = [System.Runtime.Serialization.FormatterServices]::GetUninitializedObject([type] [System.Management.Automation.Internal.CommonParameters]) | 
+            Get-Member -MemberType Properties | 
+            Select-Object -ExpandProperty Name
+    }
+
+    process {
+        # Create the dictionary that this scriptblock will return:
+        $DynParamDictionary = New-Object System.Management.Automation.RuntimeDefinedParameterDictionary
+
+        # Convert to object array and get rid of Common params:
+        (Get-Command $CommandName | select -exp Parameters).GetEnumerator() | 
+            Where-Object { $CommonParameterNames -notcontains $_.Key } |
+            ForEach-Object {
+                $DynamicParameter = New-Object System.Management.Automation.RuntimeDefinedParameter (
+                    $_.Key,
+                    $_.Value.ParameterType,
+                    $_.Value.Attributes
+                )
+                $DynParamDictionary.Add($_.Key, $DynamicParameter)
+            }
+
+        # Return the dynamic parameters
+        return $DynParamDictionary
+    }
+}
+# GetDynamicParamDictionary 
+# - This can make it easier to share a single set of param definitions between functions
+# - sample usage
+#function ParameterDefinitions {
+#    param(
+#        [Parameter(Mandatory)][string] $myargument
+#    )
+#}
+#function psmain {
+#   [CmdletBinding()]
+#   param()
+#   dynamicparam { GetDynamicParamDictionary ParameterDefinitions }
+#   process {
+#       #called once with $PSBoundParameters dictionary
+#       #can be used to validate arguments, or set a simpler variable name for access
+#       switch ($PSBoundParameters.keys) {
+#           'myargumentname' { 
+#               Set-Variable -Name $_ -Value $PSBoundParameters."$_"
+#           }
+#           #...
+#       }
+#       foreach ($boundparam in $PSBoundParameters.GetEnumerator()) {
+#           #...
+#       }
+#   }
+#   end {
+#       #Main function logic
+#       Write-Host "myargumentname value is: $myargumentname"
+#       #myotherfunction @PSBoundParameters
+#   }
+#}
+#psmain @args
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin powershell Payload
+#"Timestamp         :    {0,10:yyyy-MM-dd HH:mm:ss}"    -f $(Get-Date)   | write-host
+#"Script Name       :    {0}"    -f $scriptname                          | write-host
+#"Powershell Version:    {0}"    -f $PSVersionTable.PSVersion.Major      | write-host
+#"powershell args   :    {0}"    -f ($args -join ", ")                   | write-host
+# -- --- --- ---
+
+#<powershell-pre-launch-subprocess>
+#</powershell-pre-launch-subprocess>
+
+
+# -- --- --- --- --- --- --- ---
+#<powershell-launch-subprocess>
+tclsh $scriptname $args
+#"powershell reporting exitcode: {0}" -f $LASTEXITCODE | write-host
+#</powershell-launch-subprocess>
+# -- --- --- --- --- --- --- ---
+
+
+#<powershell-post-launch-subprocess>
+#</powershell-post-launch-subprocess>
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end powershell Payload
+Exit $LASTEXITCODE
+# heredoc2 for powershell to ignore block below
+$1 = @'
+'
+: comment end hide powershell-block from Tcl \
+# This comment with closing brace should stay in place whether 'if' commented or not }
+: multishell doubled-up cmd exit label - return exitcode 
+:exit_multishell
+:exit_multishell
+: \
+@REM @ECHO exitcode: !task_exitcode!
+: \
+@IF "%1"=="PUNK-ELEVATED" (echo. & @cmd /k echo elevated prompt: type exit to quit)
+: \
+@EXIT /B !task_exitcode!
+# cmd has exited
+: comment end heredoc2 \
+'@
+<#
+# id:tailblock0
+# -- powershell multiline comment 
+#>
+<#
+no script engine should try to run me
+# id:tailblock1
+# <ctrl-z>
+
+# </ctrl-z>
+# -- unreachable by tcl directly if ctrl-z character is in the <ctrl-z> section above. (but file can be read and split on \x1A)
+# -- Potential for zip and/or base64 contents, but we can't stop pwsh parser from slurping in the data
+# -- so for example a plain text tar archive could cause problems depending on the content.
+# -- final line in file must be the powershell multiline comment terminator or other data it can handle.
+# -- e.g plain # comment lines will work too
+# -- (for example a powershell digital signature is a # commented block of data at the end of the file)
+#>
+
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-multishell1.cmd b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-multishell1.cmd
new file mode 100644
index 00000000..17fe4c15
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-multishell1.cmd
@@ -0,0 +1,524 @@
+: "[rename set s;proc Hide x {proc $x args {}};Hide :]" "\$(function : {<#pwsh#>})" ^
+set -- "$@" "a=[list shebangless punk MULTISHELL tclsh sh bash cmd pwsh powershell;proc Hide x {proc $x args {}}; Hide <#;Hide set;s 1 list]"; set -- : "$@";$1 = @'
+: heredoc1 - hide from powershell using @ and squote above. (close sqote for unix shells) ' \
+: .bat/.cmd launch section, leading colon hides from cmd, trailing slash hides next line from tcl \
+: "[Hide @ECHO; Hide ); Hide (;Hide echo; Hide @REM]#not necessary but can help avoid errs in testing"
+: << 'HEREDOC1B_HIDE_FROM_BASH_AND_SH'
+: Continuation char at end of this line and rem with curly-braces used to exlude Tcl from the whole cmd block \
+:  {
+: STRONG SUGGESTION: DO NOT MODIFY FIRST LINE OF THIS SCRIPT. shebang #! line is not required on unix or windows and will reduce functionality and/or portability.
+: Even comment lines can be part of the functionality of this script (both on unix and windows) - modify with care.
+@REM ############################################################################################################################
+@REM THIS IS A POLYGLOT SCRIPT - supporting payloads in Tcl, bash, sh and/or powershelll (powershell.exe or pwsh.exe)
+@REM It should remain portable between unix-like OSes & windows if the proper structure is maintained.
+@REM ############################################################################################################################
+@REM On windows, change the value of nextshell to one of the listed 2 digit values if desired, and add code within payload sections for tcl,sh,bash,powershell as appropriate.
+@REM This wrapper can be edited manually (carefully!) - or sh,bash,tcl,powershell scripts can be wrapped using the Tcl-based punkshell system
+@REM e.g from within a running punkshell: pmix scriptwrap.multishell <inputfilepath> -outputfolder <folderpath> 
+@REM On unix-like systems, call with sh, bash or tclsh. (powershell untested on unix - and requires wscript if security elevation is used)
+@REM Due to lack of shebang (#! line) Unix-like systems will probably (hopefully) default to sh if the script is called without an interpreter - but it may depend on the shell in use when called.
+@REM If you find yourself really wanting/needing to add a shebang line - do so on the basis that the script will exist on unix-like systems only. 
+@SETLOCAL EnableExtensions EnableDelayedExpansion
+@SET "validshells= ^(10^) 'pwsh' ^(11^) 'sh' (^12^) 'bash' (^13^) 'tclsh'"
+@SET "shells[10]=pwsh"
+@SET "shells[11]=sh"
+@set "shells[12]=bash"
+@SET "shells[13]=tclsh"
+: <nextshell>
+@SET "nextshell=13"
+: </nextshell>
+@rem asadmin is for automatic elevation to administrator. Separate window will be created (seems unavoidable with current elevation mechanism) and user will still get security prompt (probably reasonable).
+: <asadmin>
+@SET "asadmin=0"
+: </asadmin>
+@REM nextshell set to index for validshells .eg 10 for pwsh  
+@REM @ECHO nextshell is %nextshell%
+@SET "selected=!shells[%nextshell%]!"
+@REM @ECHO selected %selected%
+@CALL SET "keyRemoved=%%validshells:'!selected!'=%%"
+@REM @ECHO keyremoved %keyRemoved%
+@REM Note that 'powershell' e.g v5 is just a fallback for when pwsh is not available
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@REM  -- cmd/batch file section (ignored on unix but should be left in place)
+@REM  -- This section intended mainly to launch the next shell (and to escalate privileges if necessary)
+@REM  -- Avoid customising this if you are not familiar with batch scripting. cmd/batch script can be useful, but is probably the least expressive language and most error prone.
+@REM  -- For example - as this file needs to use unix-style lf line-endings - the label scanner is susceptible to the 512Byte boundary issue: https://www.dostips.com/forum/viewtopic.php?t=8988#p58888
+@REM  -- This label issue can be triggered/abused in files with crlf line endings too - but it is less likely to happen accidentaly.
+@REm  -- See also: https://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/4095133#4095133
+@REM ############################################################################################################################
+@REM  -- Due to this issue -seemingly trivial edits of the batch file section can break the script! (for Windows anyway)
+@REM  -- Even something as simple as adding or removing an @REM
+@REM  -- From within punkshell - use:
+@REM  --     pmix scriptwrap.checkfile <filepath>
+@REM  -- to check your templates or final wrapped scripts for byte boundary issues
+@REM  -- It will report any labels that are on boundaries
+@REM  -- This is why the nextshell value above is a 2 digit key instead of a string - so that editing the value doesn't change the byte offsets.
+@REM  -- Editing your sh,bash,tcl,pwsh payloads is much less likely to cause an issue. There is the possibility of the final batch :exit_multishell label spanning a boundary - so testing using pmix scriptwrap.checkfile is still recommended.
+@REM  -- Alternatively, as you should do anyway - test the final script on windows   
+@REM  -- Aside from adding comments/whitespace to tweak the location of labels - you can try duplicating the label (e.g just add the label on a line above) but this is not guaranteed to work in all situations.
+@REM  -- '@REM' is a safer comment mechanism than a leading colon - which is used sparingly here.
+@REM  -- A colon anywhere in the script that happens to land on a 512 Byte boundary (from file start or from a callsite) could be misinterpreted as a label
+@REM  -- It is unknown what versions of cmd interpreters behave this way - and pmix scriptwrap.checkfile doesn't check all such boundaries.
+@REm  -- For this reason, batch labels should be chosen to be relatively unlikely to collide with other strings in the file, and simple names such as :exit or :end should probably be avoided
+@REM ############################################################################################################################
+@REM  -- custom windows payloads should be in powershell,tclsh (or sh/bash if available) code sections
+@REM  ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+@SET "winpath=%~dp0"
+@SET "fname=%~nx0"
+@REM @ECHO fname %fname%
+@REM @ECHO winpath %winpath%
+@REM @ECHO commandlineascalled %0
+@REM @ECHO commandlineresolved %~f0
+@CALL :getNormalizedScriptTail nftail
+@REM @ECHO normalizedscripttail %nftail%
+@CALL :getFileTail %0 clinetail
+@REM @ECHO clinetail %clinetail%
+@CALL :stringToUpper %~nx0 capscripttail
+@REM @ECHO capscriptname: %capscripttail%
+
+@IF "%nftail%"=="%capscripttail%" (
+    @ECHO forcing asadmin=1 due to file name on filesystem being uppercase
+    @SET "asadmin=1"
+) else (
+    @CALL :stringToUpper %clinetail% capcmdlinetail
+    @REM @ECHO capcmdlinetail !capcmdlinetail!
+    IF "%clinetail%"=="!capcmdlinetail!" (
+        @ECHO forcing asadmin=1 due to cmdline scriptname in uppercase
+        @set "asadmin=1"
+    )
+)
+@SET "vbsGetPrivileges=%temp%\punk_bat_elevate_%fname%.vbs"
+@SET arglist=%*
+@IF "%1"=="PUNK-ELEVATED" (
+    GOTO :gotPrivileges
+)
+@IF !asadmin!==1 (
+    net file 1>NUL 2>NUL
+    @IF '!errorlevel!'=='0' ( GOTO :gotPrivileges ) else ( GOTO :getPrivileges )
+)
+@GOTO skip_privileges
+:getPrivileges
+@IF '%1'=='PUNK-ELEVATED' (echo PUNK-ELEVATED & shift /1 & goto :gotPrivileges )
+@ECHO Set UAC = CreateObject^("Shell.Application"^) > "%vbsGetPrivileges%"
+@ECHO args = "PUNK-ELEVATED " >> "%vbsGetPrivileges%"
+@ECHO For Each strArg in WScript.Arguments >> "%vbsGetPrivileges%"
+@ECHO args = args ^& strArg ^& " " >> "%vbsGetPrivileges%"
+@ECHO Next >> "%vbsGetPrivileges%"
+@ECHO UAC.ShellExecute "%~dp0%~n0.cmd", args, "", "runas", 1 >> "%vbsGetPrivileges%"
+@ECHO Launching script in new windows due to administrator elevation
+@"%SystemRoot%\System32\WScript.exe" "%vbsGetPrivileges%" %*
+@EXIT /B
+
+:gotPrivileges
+@REM setlocal & pushd .
+@PUSHD .
+@cd /d %~dp0
+@IF "%1"=="PUNK-ELEVATED" (
+    @DEL "%vbsGetPrivileges%" 1>nul 2>nul
+    @SET arglist=%arglist:~14%
+)
+
+:skip_privileges
+@SET need_ps1=0
+@REM we want the ps1 to exist even if the nextshell isn't powershell
+@if not exist "%~dp0%~n0.ps1" (
+    @SET need_ps1=1
+) ELSE (
+    fc "%~dp0%~n0.cmd" "%~dp0%~n0.ps1" >nul || goto different
+    @REM @ECHO "files same"
+    @SET need_ps1=0
+)
+@GOTO :pscontinue
+:different
+@REM @ECHO "files differ"
+@SET need_ps1=1
+:pscontinue
+@IF !need_ps1!==1 (
+    COPY "%~dp0%~n0.cmd" "%~dp0%~n0.ps1" >NUL 
+)
+@REM avoid using CALL to launch pwsh,tclsh etc - it will intercept some args such as /?
+@IF "!shells[%nextshell%]!"=="pwsh" (
+    REM pws vs powershell hasn't been tested because we didn't need to copy cmd to ps1 this time
+    REM test availability of preferred option of powershell7+ pwsh
+    pwsh -nop -nol -c set-executionpolicy -Scope Process Unrestricted; write-host "statusmessage: pwsh-found" >NUL
+    SET pwshtest_exitcode=!errorlevel!
+    REM ECHO pwshtest_exitcode !pwshtest_exitcode!
+    REM fallback to powershell if pwsh failed 
+    IF !pwshtest_exitcode!==0 (
+        pwsh -nop -nol -c set-executionpolicy -Scope Process Unrestricted; "%~dp0%~n0.ps1" %arglist% & SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM CALL powershell -nop -nol -c write-host powershell-found
+        REM powershell -nop -nol -file "%~dp0%~n0.ps1" %*
+        powershell -nop -nol -c set-executionpolicy -Scope Process Unrestricted; %~dp0%~n0.ps1" %arglist%
+        SET task_exitcode=!errorlevel!
+    )
+) ELSE ( 
+    IF "!shells[%nextshell%]!"=="bash" (
+        CALL :getWslPath %winpath% wslpath
+        REM ECHO wslfullpath "!wslpath!%fname%"
+        !shells[%nextshell%]! "!wslpath!%fname%" %arglist% & SET task_exitcode=!errorlevel!
+    ) ELSE (
+        REM  probably tclsh or sh
+        IF NOT "x%keyRemoved%"=="x%validshells%" (
+            REM sh on windows uses /c/ instead of /mnt/c - at least if using msys. Todo, review what is the norm on windows with and without msys2,cygwin,wsl
+            REM and what logic if any may be needed. For now sh with /c/xxx seems to work the same as sh with c:/xxx
+            !shells[%nextshell%]! "%~dp0%fname%" %arglist% & SET task_exitcode=!errorlevel!
+        ) ELSE (
+            ECHO %fname% has invalid nextshell value ^(%nextshell%^) !shells[%nextshell%]! valid options are %validshells%
+            SET task_exitcode=66
+            GOTO :exit_multishell
+        )
+    )
+)
+@REM batch file library functions
+@GOTO :endlib
+
+:getWslPath
+@SETLOCAL
+    @SET "_path=%~p1"
+    @SET "name=%~nx1"
+    @SET "drive=%~d1"
+    @SET "rtrn=%~2"
+    @SET "result=/mnt/%drive:~0,1%%_path:\=/%%name%"
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        ECHO %result%
+    )
+)
+@EXIT /B
+
+:getFileTail
+@REM return tail of file without any normalization e.g c:/punkshell/bin/Punk.cmd returns Punk.cmd even if file is punk.cmd
+@REM we can't use things such as %~nx1 as it can change capitalisation
+@REM This function is designed explicitly to preserve capitalisation
+@REM accepts full paths with either / or \ as delimiters - or 
+@SETLOCAL
+    @SET "rtrn=%~2"
+    @SET "arg=%~1"
+    @REM @SET "result=%_arg:*/=%"
+    @REM @SET "result=%~1"
+    @SET LF=^
+
+
+    : The above 2 empty lines are important. Don't remove
+    @CALL :stringContains "!arg!" "\" hasBackSlash
+    @IF "!hasBackslash!"=="true" (
+        @for %%A in ("!LF!") do @(
+            @FOR /F %%B in ("!arg:\=%%~A!") do @set "result=%%B"
+        )
+    ) ELSE (
+        @CALL :stringContains "!arg!" "/" hasForwardSlash
+        @IF "!hasForwardSlash!"=="true" (
+            @FOR %%A in ("!LF!") do @(
+                @FOR /F %%B in ("!arg:/=%%~A!") do @set "result=%%B"
+            )
+        ) ELSE (
+            @set "result=%arg%"
+        )
+    )
+@ENDLOCAL & (
+    @if "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+@REM  boundary padding
+:getNormalizedScriptTail
+@SETLOCAL
+    @SET "result=%~nx0"
+    @SET "rtrn=%~1"
+@ENDLOCAL & (
+    @IF "%~1" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+
+:getNormalizedFileTailFromPath
+@REM warn via echo, and do not set return variable if path not found
+@REM note that %~nx1 does not preserve case of provided path - hence the name 'normalized'
+@REM boundary padding
+@REM boundary padding
+@SETLOCAL
+    @CALL :stringContains %~1 "\" hasBackSlash
+    @CALL :stringContains %~1 "/" hasForwardSlash
+    @IF "%hasBackslash%-%hasForwardslash%"=="false-false" (
+        @SET "P=%cd%%~1"
+        @CALL :getNormalizedFileTailFromPath "!P!" ftail2
+        @SET "result=!ftail2!"
+    ) else (
+        @IF EXIST "%~1" (
+            @SET "result=%~nx1"
+        ) else (
+            @ECHO error getNormalizedFileTailFromPath file not found: %~1
+            @EXIT /B 1
+        )
+    )
+    @SET "rtrn=%~2"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO getNormalizedFileTailFromPath %1 result: %result%
+    )
+)
+@EXIT /B
+
+:stringContains
+@REM usage: @CALL:stringContains string needle returnvarname
+@SETLOCAL
+    @SET "rtrn=%~3"
+    @SET "string=%~1"
+    @SET "needle=%~2"
+    @IF "!string:%needle%=!"=="!string!" @(
+        @SET "result=false"
+    ) ELSE (
+        @SET "result=true"
+    )
+@ENDLOCAL & (
+    @IF "%~3" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO stringContains %string% %needle% result: %result%
+    )
+)
+@EXIT /B
+
+:stringToUpper
+@SETLOCAL
+    @SET "rtrn=%~2"
+    @SET "string=%~1"
+    @SET "capstring=%~1"
+    @FOR %%A in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO @(
+        @SET "capstring=!capstring:%%A=%%A!"
+    )
+    @SET "result=!capstring!"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO stringToUpper %string% result: %result%
+    )
+)
+@EXIT /B
+
+:isNumeric
+@SETLOCAL
+    @SET "notnumeric="&FOR /F "delims=0123456789" %%i in ("%1") do set "notnumeric=%%i"
+    @IF defined notnumeric (
+        @SET "result=false"
+    ) else (
+        @SET "result=true"
+    )
+    @SET "rtrn=%~2"
+@ENDLOCAL & (
+    @IF "%~2" neq "" (
+        @SET "%rtrn%=%result%"
+    ) ELSE (
+        @ECHO %result%
+    )
+)
+@EXIT /B
+
+:endlib
+: \
+@REM @SET taskexit_code=!errorlevel! & goto :exit_multishell
+@GOTO :exit_multishell
+# }
+# -*- tcl -*-
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- tcl script section
+# -- This is a punk multishell file
+# -- Primary payload target is Tcl, with sh,bash,powershell as helpers
+# -- but it may equally be used with any of these being the primary script.
+# -- It is tuned to run when called as a batch file, a tcl script a sh/bash script or a pwsh/powershell script
+# -- i.e it is a polyglot file.
+# -- The specific layout including some lines that appear just as comments is quite sensitive to change.
+# -- It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# -- e.g ./filename.polypunk.cmd in sh or bash
+# -- e.g tclsh filename.cmd
+# -- 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+rename set ""; rename s set; set k {-- "$@" "a}; if {[info exists ::env($k)]} {unset ::env($k)} ;# tidyup and restore
+Hide :exit_multishell;Hide {<#};Hide '@
+namespace eval ::punk::multishell {
+    set last_script_root    [file dirname [file normalize ${argv0}/__]]
+    set last_script         [file dirname [file normalize [info script]/__]] 
+    if {[info exists argv0] &&
+        $last_script eq $last_script_root
+        } {
+        set ::punk::multishell::is_main($last_script) 1 ;#run as executable/script - likely desirable to launch application and return an exitcode
+    } else {
+        set ::punk::multishell::is_main($last_script) 0 ;#sourced - likely to be being used as a library - no launch, no exit. Can use return.
+    }
+    if {"::punk::multishell::is_main" ni [info commands ::punk::multishell::is_main]} {
+        proc ::punk::multishell::is_main {{script_name {}}} {
+            if {$script_name eq ""} {
+                set script_name [file dirname [file normalize [info script]/--]]
+            }
+            if {![info exists ::punk::multishell::is_main($script_name)]} {
+                #e.g a .dll or something else unanticipated
+                puts stderr "Warning punk::multishell didn't recognize info script result: $script_name - will treat as if sourced and return instead of exiting"
+                puts stderr "Info: script_root: [file dirname [file normalize ${argv0}/__]]"
+                return 0
+            }
+            return [set ::punk::multishell::is_main($script_name)]
+        }
+    }
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+#puts "argv0    : $::argv0"
+# -- --- --- --- --- --- --- --- --- --- --- ---
+
+
+#<tcl-payload>
+#</tcl-payload>
+
+
+
+# -- --- --- --- --- --- --- --- --- --- --- ---
+# -- Best practice is to always return or exit above, or just by leaving the below defaults in place.
+# -- If the multishell script is modified to have Tcl below the Tcl Payload section,
+# -- then Tcl bracket balancing needs to be carefully managed in the shell and powershell sections below.
+# -- Only the # in front of the two relevant if statements below needs to be removed to enable Tcl below
+# -- but the sh/bash 'then' and 'fi' would also need to be uncommented.
+# -- This facility left in place for experiments on whether configuration payloads etc can be appended
+# -- to tail of file - possibly binary with ctrl-z char - but utility is dependent on which other interpreters/shells
+# -- can be made to ignore/cope with such data.
+if {[::punk::multishell::is_main]} {
+    exit 0
+} else {
+    return 
+}
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+# end hide from unix shells \
+HEREDOC1B_HIDE_FROM_BASH_AND_SH
+# sh/bash \
+shift && set -- "${@:1:$#-1}"
+#------------------------------------------------------
+# -- This if block only needed if Tcl didn't exit or return above.
+if false==false # else {
+    then
+    : #
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- sh/bash script section
+# -- leave as is if all that is required is launching the Tcl payload"
+# --
+# -- Note that sh/bash script isn't called when running a .bat/.cmd from cmd.exe on windows by default
+# -- adjust  @call line above ...  to something like @call sh ... @call bash ..  or @call env sh ... etc as appropriate
+# --   if sh/bash scripting needs to run on windows too.
+# --
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin sh Payload
+#printf "start of bash or sh code"
+
+#<shell-payload-pre-tcl>
+#</shell-payload-pre-tcl>
+
+# -- --- --- --- --- --- --- ---
+#<shell-launch-tcl>
+exitcode=0 ;#default assumption
+#-- sh/bash launches Tcl here instead of shebang line at top
+#-- use exec to use exitcode (if any) directly from the tcl script
+#exec /usr/bin/env tclsh "$0" "$@"
+#-- alternative - can run sh/bash script after the tcl call.
+/usr/bin/env tclsh "$0" "$@"
+exitcode=$?
+#echo "tcl exitcode: ${exitcode}"
+#-- override exitcode example 
+#exit 66
+#</shell-launch-tcl>
+# -- --- --- --- --- --- --- ---
+
+#<shell-payload-post-tcl>
+#</shell-payload-post-tcl>
+
+
+#printf "sh/bash done \n"
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end sh Payload
+#------------------------------------------------------
+fi
+exit ${exitcode}
+# end hide sh/bash block from Tcl
+# This comment with closing brace should stay in place whether if commented or not }
+#------------------------------------------------------
+# begin hide powershell-block from Tcl - only needed if Tcl didn't exit or return above
+if 0 {
+: end heredoc1 - end hide from powershell \
+'@ 
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+# -- powershell/pwsh section
+# -- Do not edit if current file is the .ps1
+# -- Edit the corresponding .cmd and it will autocopy 
+# -- unbalanced braces { } here *even in comments* will cause problems if there was no Tcl exit or return above
+# ## ### ### ### ### ### ### ### ### ### ### ### ### ###
+function GetScriptName { $myInvocation.ScriptName }
+$scriptname = getScriptName
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---begin powershell Payload
+#"Timestamp         :    {0,10:yyyy-MM-dd HH:mm:ss}"    -f $(Get-Date)   | write-host
+#"Script Name       :    {0}"    -f $scriptname                          | write-host
+#"Powershell Version:    {0}"    -f $PSVersionTable.PSVersion.Major      | write-host
+#"powershell args   :    {0}"    -f ($args -join ", ")                   | write-host
+# -- --- --- ---
+
+#<powershell-payload-pre-tcl>
+#</powershell-payload-pre-tcl>
+
+
+# -- --- --- --- --- --- --- ---
+#<powershell-launch-tcl>
+tclsh $scriptname $args
+#</powershell-launch-tcl>
+# -- --- --- --- --- --- --- ---
+
+
+#<powershell-payload-post-tcl>
+#</powershell-payload-post-tcl>
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- ---end powershell Payload
+#"powershell reporting exitcode: {0}" -f $LASTEXITCODE | write-host
+Exit $LASTEXITCODE
+# heredoc2 for powershell to ignore block below
+$1 = @'
+'
+: comment end hide powershell-block from Tcl \
+# This comment with closing brace should stay in place whether 'if' commented or not }
+: multishell doubled-up cmd exit label - return exitcode 
+:exit_multishell
+:exit_multishell
+: \
+@REM @ECHO exitcode: !task_exitcode!
+: \
+@IF "%1"=="PUNK-ELEVATED" (echo. & @cmd /k echo elevated prompt: type exit to quit)
+: \
+@EXIT /B !task_exitcode!
+# cmd has exited
+: comment end heredoc2 \
+'@
+<#
+# id:tailblock0
+# -- powershell multiline comment 
+#>
+<#
+# id:tailblock1
+# <ctrl-z>
+
+# </ctrl-z>
+# -- unreachable by tcl directly if ctrl-z character is in the <ctrl-z> section above. (but file can be read and split on \x1A)
+# -- Potential for zip and/or base64 contents, but we can't stop pwsh parser from slurping in the data
+# -- so for example a plain text tar archive could cause problems depending on the content.
+# -- final line in file must be the powershell multiline comment terminator or other data it can handle.
+# -- e.g plain # comment lines will work too
+# -- (for example a powershell digital signature is a # commented block of data at the end of the file)
+#>
+
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-shellbat.bat b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-shellbat.bat
new file mode 100644
index 00000000..aa9039a9
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/scriptappwrappers/punk-shellbat.bat
@@ -0,0 +1,112 @@
+: "[proc : args {}]" ;# *tcl shellbat - call with sh,bash,tclsh on any platform, or with cmd on windows.
+: <<'HIDE_FROM_BASH_AND_SH'
+: ;# leading colon hides from .bat, trailing slash hides next line from tcl \
+@call tclsh "%~dp0%~n0.bat" %*
+: ;#\
+@set taskexitcode=%errorlevel% & goto :exit
+# -*- tcl -*-
+# #################################################################################################
+# This is a tcl shellbat file
+# It is tuned to run when called as a batch file, a tcl script, an sh script or a bash script,
+# so the specific layout and characters used are quite sensitive to change.
+# It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# e.g ./filename.sh.bat in sh or bash or powershell
+# e.g filename.sh or filename.sh.bat at windows command prompt
+# e.g tclsh filename.sh.bat |  sh filename.sh.bat  | bash filename.sh.bat
+# In all cases an arbitrary number of arguments are accepted
+# To avoid the initial commandline on stdout when calling as a batch file on windows, use:
+# cmd /Q /c filename.sh.bat
+# (because we cannot use @if to silence it, as this isn't understood by tcl,sh or bash)
+# #################################################################################################
+#fconfigure stdout -translation crlf
+# --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+
+
+#<tcl-payload>
+#<tcl-payload/>
+
+# --- --- --- --- --- --- --- --- --- --- --- --- ---
+# only exit if needed. see exitcode notes at bottom of file and exit there for consistency across invocation methods
+# --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+#--
+#-- bash/sh code follows. 
+#-- protect from tcl using line continuation char on the previous comment for each line, like so: \
+printf "etc"
+#-- or alternatively place sh/bash script within the false==false block
+#-- whilst being careful to balance braces {}
+#-- For more complex needs you should call out to external scripts
+#--
+#-- END marker for hide_from_bash_and_sh\
+HIDE_FROM_BASH_AND_SH
+
+#---------------------------------------------------------
+#-- This if statement hides(mostly) a sh/bash code block from Tcl
+if false==false # else { 
+then
+:
+#---------------------------------------------------------
+    #-- leave as is if all that's required is launching the Tcl payload"
+    #--
+    #-- Note that sh/bash script isn't called when running a .bat from cmd.exe on windows by default
+    #-- adjust line 4:  @call tclsh ...  to something like @call sh ... @call bash ..  or @call env sh ... etc as appropriate
+    #--   if sh/bash scripting needs to run on windows too.
+    #--
+    #printf "start of bash or sh code"
+    
+    #<shell-payload-pre-tcl>
+    #</shell-payload-pre-tcl>
+
+
+    #-- sh/bash launches Tcl here instead of shebang line at top
+    #<shell-launch-tcl>
+    #-- use exec to use exitcode (if any) directly from the tcl script
+    exec /usr/bin/env tclsh "$0" "$@"
+    #</shell-launch-tcl>
+    
+    #-- alternative - if sh/bash script required to run after the tcl call.
+    #/usr/bin/env tclsh "$0" "$@"
+    #tcl_exitcode=$?
+    #echo "tcl_exitcode: ${tcl_exitcode}"
+    
+    #<shell-payload-post-tcl>
+    #</shell-payload-post-tcl>
+    
+    #-- override exitcode example
+    #exit 66
+    
+    #printf "No need for trailing slashes for sh/bash code here\n"
+#---------------------------------------------------------
+fi
+# closing brace for Tcl }
+#---------------------------------------------------------
+
+#-- tcl and shell script now both active
+
+#-- comment for line sample 1 with trailing continuation slash \
+#printf "tcl-invisible sh/bash line sample 1 \n"
+
+#-- comment for line sample 2 with trailing continuation slash \
+#printf "tcl-invisible sh/bash line sample 2 \n"
+
+
+#-- Consistent exitcode from sh,bash,tclsh or cmd
+#-- Call exit in tcl (or sh/bash) code only if explicitly required, otherwise leave this commented out.
+#-- (script might be more widely useable without explicit exit. e.g in tcl: set ::argc 1; set ::argv "val"; source filename.sh.bat )
+#-- exit line unprotected by trailing slash will work for tcl and/or sh/bash
+#exit 0 
+#exit 42
+
+
+
+#-- make sure sh/bash/tcl all skip over .bat style exit \
+: <<'shell_end'
+#-- .bat exit with exitcode from tcl process \
+:exit
+: ;# \
+@exit /B %taskexitcode%
+# .bat has exited \
+shell_end
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/shellbat.txt b/src/bootsupport/modules/punk/mix/templates/utility/shellbat.txt
new file mode 100644
index 00000000..25c7d1d8
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/shellbat.txt
@@ -0,0 +1,104 @@
+: "[proc : args {}]" ;# *tcl shellbat - call with sh,bash,tclsh on any platform, or with cmd on windows.
+: <<'HIDE_FROM_BASH_AND_SH'
+: ;# leading colon hides from .bat, trailing slash hides next line from tcl \
+@call tclsh "%~dp0%~n0.bat" %*
+: ;#\
+@set taskexitcode=%errorlevel% & goto :exit
+# -*- tcl -*-
+# #################################################################################################
+# This is a tcl shellbat file
+# It is tuned to run when called as a batch file, a tcl script, an sh script or a bash script,
+# so the specific layout and characters used are quite sensitive to change.
+# It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# e.g ./filename.sh.bat in sh or bash or powershell
+# e.g filename.sh or filename.sh.bat at windows command prompt
+# e.g tclsh filename.sh.bat |  sh filename.sh.bat  | bash filename.sh.bat
+# In all cases an arbitrary number of arguments are accepted
+# To avoid the initial commandline on stdout when calling as a batch file on windows, use:
+# cmd /Q /c filename.sh.bat
+# (because we cannot use @if to silence it, as this isn't understood by tcl,sh or bash)
+# #################################################################################################
+#fconfigure stdout -translation crlf
+# --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+
+
+#<tcl-payload>
+
+# --- --- --- --- --- --- --- --- --- --- --- --- ---
+# only exit if needed. see exitcode notes at bottom of file and exit there for consistency across invocation methods
+# --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+#--
+#-- bash/sh code follows. 
+#-- protect from tcl using line continuation char on the previous comment for each line, like so: \
+printf "etc"
+#-- or alternatively place sh/bash script within the false==false block
+#-- whilst being careful to balance braces {}
+#-- For more complex needs you should call out to external scripts
+#--
+#-- END marker for hide_from_bash_and_sh\
+HIDE_FROM_BASH_AND_SH
+
+#---------------------------------------------------------
+#-- This if statement hides(mostly) a sh/bash code block from Tcl
+if false==false # else { 
+then
+:
+#---------------------------------------------------------
+    #-- leave as is if all that's required is launching the Tcl payload"
+    #--
+    #-- Note that sh/bash script isn't called when running a .bat from cmd.exe on windows by default
+    #-- adjust line 4:  @call tclsh ...  to something like @call sh ... @call bash ..  or @call env sh ... etc as appropriate
+    #--   if sh/bash scripting needs to run on windows too.
+    #--
+    #printf "start of bash or sh code"
+    
+
+    #-- sh/bash launches Tcl here instead of shebang line at top
+
+    #-- use exec to use exitcode (if any) directly from the tcl script
+    exec /usr/bin/env tclsh "$0" "$@"
+    
+    #-- alternative - if sh/bash script required to run after the tcl call.
+    #/usr/bin/env tclsh "$0" "$@"
+    #tcl_exitcode=$?
+    #echo "tcl_exitcode: ${tcl_exitcode}"
+    
+    #-- override exitcode example
+    #exit 66
+    
+    #printf "No need for trailing slashes for sh/bash code here\n"
+#---------------------------------------------------------
+fi
+# closing brace for Tcl }
+#---------------------------------------------------------
+
+#-- tcl and shell script now both active
+
+#-- comment for line sample 1 with trailing continuation slash \
+#printf "tcl-invisible sh/bash line sample 1 \n"
+
+#-- comment for line sample 2 with trailing continuation slash \
+#printf "tcl-invisible sh/bash line sample 2 \n"
+
+
+#-- Consistent exitcode from sh,bash,tclsh or cmd
+#-- Call exit in tcl (or sh/bash) code only if explicitly required, otherwise leave this commented out.
+#-- (script might be more widely useable without explicit exit. e.g in tcl: set ::argc 1; set ::argv "val"; source filename.sh.bat )
+#-- exit line unprotected by trailing slash will work for tcl and/or sh/bash
+#exit 0 
+#exit 42
+
+
+
+#-- make sure sh/bash/tcl all skip over .bat style exit \
+: <<'shell_end'
+#-- .bat exit with exitcode from tcl process \
+:exit
+: ;# \
+@exit /B %taskexitcode%
+# .bat has exited \
+shell_end
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/shellbat_v1.txt b/src/bootsupport/modules/punk/mix/templates/utility/shellbat_v1.txt
new file mode 100644
index 00000000..e504ee01
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/shellbat_v1.txt
@@ -0,0 +1,106 @@
+if (true=="shellbat") #;#\
+: <<'HIDE_FROM_BASH_AND_SH'
+::lindex tcl;# leading colons hide from .bat, trailing slash hides next line from tcl \
+@call tclsh "%~dp0%~n0.bat" %*
+::lindex tcl;#\
+@set taskexitcode=%errorlevel% & goto :exit
+# -*- tcl -*-
+# #################################################################################################
+# This is a tcl shellbat file
+# It is tuned to run when called as a batch file, a tcl script, an sh script or a bash script,
+# so the specific layout and characters used are quite sensitive to change.
+# It can be called on unix or windows platforms with or without the interpreter being specified on the commandline.
+# e.g ./filename.sh.bat in sh or bash or powershell
+# e.g filename.sh or filename.sh.bat at windows command prompt
+# e.g tclsh filename.sh.bat |  sh filename.sh.bat  | bash filename.sh.bat
+# In all cases an arbitrary number of arguments are accepted
+# To avoid the initial commandline on stdout when calling as a batch file on windows, use:
+# cmd /Q /c filename.sh.bat
+# (because we cannot use @if to silence it, as this isn't understood by tcl,sh or bash)
+# #################################################################################################
+#fconfigure stdout -translation crlf
+# --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl Payload
+#puts "script   : [info script]"
+#puts "argcount : $::argc"
+#puts "argvalues: $::argv"
+
+#<tcl-payload>
+
+# --- --- --- --- --- --- --- --- --- --- --- --- ---
+# only exit if needed. see exitcode notes at bottom of file and exit there for consistency across invocation methods
+# --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl Payload
+#--
+#-- bash/sh code follows. 
+#-- protect from tcl using line continuation char on the previous comment for each line, like so: \
+printf "etc"
+#-- or alternatively place sh/bash script within the false==false block
+#-- whilst being careful to balance braces {}
+#-- For more complex needs you should call out to external scripts
+#--
+#-- END marker for hide_from_bash_and_sh\
+HIDE_FROM_BASH_AND_SH
+#\
+then
+
+#---------------------------------------------------------
+if false==false # else { 
+then
+:
+#---------------------------------------------------------
+    #-- leave as is if all that's required is launching the Tcl payload"
+    #--
+    #-- Note that sh/bash script isn't called when running a .bat from cmd.exe on windows by default
+    #-- adjust line 4:  @call tclsh ...  to something like @call sh ... @call bash ..  or @call env sh ... etc as appropriate
+    #--   if sh/bash scripting needs to run on windows too.
+    #--
+    #printf "start of bash or sh code"
+    
+
+    #-- sh/bash launches Tcl here instead of shebang line at top
+
+    #-- use exec to use exitcode (if any) directly from the tcl script
+    exec /usr/bin/env tclsh "$0" "$@"
+    
+    #-- alternative - if sh/bash script required to run after the tcl call.
+    #/usr/bin/env tclsh "$0" "$@"
+    #tcl_exitcode=$?
+    #echo "tcl_exitcode: ${tcl_exitcode}"
+    
+    #-- override exitcode example
+    #exit 66
+    
+    #printf "No need for trailing slashes for sh/bash code here\n"
+#---------------------------------------------------------
+fi
+# }
+#---------------------------------------------------------
+
+#-- comment for line sample 1 with trailing continuation slash \
+#printf "tcl-invisible sh/bash line sample 1 \n"
+
+#-- comment for line sample 2 with trailing continuation slash \
+#printf "tcl-invisible sh/bash line sample 2 \n"
+
+
+#-- Consistent exitcode from sh,bash,tclsh or cmd
+#-- Call exit in tcl (or sh/bash) code only if explicitly required, otherwise leave this commented out.
+#-- (script might be more widely useable without explicit exit. e.g in tcl: set ::argc 1; set ::argv "val"; source filename.sh.bat )
+#-- exit line unprotected by trailing slash will work for tcl and/or sh/bash
+#exit 0 
+#exit 42
+
+
+#---------------------------------------------------------
+#-- end if true==shellbat on very first line\
+fi
+#---------------------------------------------------------
+
+#-- make sure sh/bash/tcl all skip over .bat style exit \
+: <<'shell_end'
+#-- .bat exit with exitcode from tcl process \
+:exit
+::lindex tcl;#\
+@exit /B %taskexitcode%
+#\
+shell_end
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/tclbatheader.txt b/src/bootsupport/modules/punk/mix/templates/utility/tclbatheader.txt
new file mode 100644
index 00000000..b2e0367f
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/tclbatheader.txt
@@ -0,0 +1,3 @@
+::lindex tcl;#\
+@call tclsh "%~dp0%~n0.bat" %* & goto :eof
+# --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/tclbattest.bat b/src/bootsupport/modules/punk/mix/templates/utility/tclbattest.bat
new file mode 100644
index 00000000..396aea56
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/tclbattest.bat
@@ -0,0 +1,8 @@
+::lindex tcl;#\
+@call tclsh "%~dp0%~n0.bat" %* & goto :eof
+# --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl
+puts stdout "exe: [info nameof]"
+puts stdout "scr: [info script]"
+puts stdout "argc: $::argc"
+puts stdout "argv: '$::argv'"
+
diff --git a/src/bootsupport/modules/punk/mix/templates/utility/tclbattest2.bat b/src/bootsupport/modules/punk/mix/templates/utility/tclbattest2.bat
new file mode 100644
index 00000000..fbf2fcd0
--- /dev/null
+++ b/src/bootsupport/modules/punk/mix/templates/utility/tclbattest2.bat
@@ -0,0 +1,19 @@
+::set - {
+@goto start
+# -- tcl bat 
+:start
+@echo off
+set script=%0
+echo %*
+if exist %script%.bat set script=%script%.bat
+tclsh %script% %* 
+goto end of BAT file
+};unset - ;# --- --- --- --- --- --- --- --- --- --- --- --- ---begin Tcl
+
+puts stdout "exe: [info nameof]"
+puts stdout "scr: [info script]"
+puts stdout "argc: $::argc"
+puts stdout "argv: '$::argv'"
+
+# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---end Tcl\
+:end of BAT file
diff --git a/src/bootsupport/modules/punk/mix/util-0.1.0.tm b/src/bootsupport/modules/punk/mix/util-0.1.0.tm
index 5622bc02..44c01721 100644
--- a/src/bootsupport/modules/punk/mix/util-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/util-0.1.0.tm
@@ -35,13 +35,10 @@ namespace eval punk::mix::util {
 
     namespace export *
 
-
+    #NOTE fileutil::cat seems to silently ignore options if passed at end instead of before file!
     proc fcat {args} {
         variable has_winpath
 
-        if {$::tcl_platform(platform) ne "windows"} {
-            return [fileutil::cat {*}$args]
-        }
 
         set knownopts [list -eofchar -translation -encoding --]
         set last_opt 0
@@ -73,7 +70,21 @@ namespace eval punk::mix::util {
         if {![llength $paths]} {
             error "Unable to find file in the supplied arguments: $args. Ensure options are all -opt val pairs and that file name(s) follow"
         }
+
         #puts stderr "opts: $opts  paths: $paths"
+
+        #let's proceed, but warn the user if an apparent option is in paths 
+        foreach opt [list -encoding -eofchar -translation] {
+            if {$opt in $paths} {
+                puts stderr "fcat WARNING: apparent option $opt found after file argument(s) (expected them before filenames). Passing to fileutil::cat anyway - but for at least some versions, these options may be ignored. commandline 'fcat $args'"
+            }
+        }
+
+        if {$::tcl_platform(platform) ne "windows"} {
+            return [fileutil::cat {*}$args]
+        }
+
+
         set finalpaths [list]
         foreach p $paths {
             if {$has_winpath && [punk::winpath::illegalname_test $p]} {
diff --git a/src/bootsupport/modules/punk/ns-0.1.0.tm b/src/bootsupport/modules/punk/ns-0.1.0.tm
index 156d51d1..c9bbc3d3 100644
--- a/src/bootsupport/modules/punk/ns-0.1.0.tm
+++ b/src/bootsupport/modules/punk/ns-0.1.0.tm
@@ -17,7 +17,7 @@
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Requirements
 ##e.g package require frobz
-
+package require punk::args
 
 namespace eval ::punk_dynamic::ns {
 
@@ -356,8 +356,8 @@ namespace eval punk::ns {
         }
 
 
-        return [list_as_lines [lsort $result]]
-        #.= lsort $result |> list_as_lines
+        return [list_as_lines -- [lsort $result]]
+        #.= lsort $result |> list_as_lines --
     }
 
     proc nsglob_as_re {glob} {
@@ -1601,23 +1601,33 @@ namespace eval punk::ns {
     }
     interp alias "" use "" punk::ns::pkguse
 
-    proc nsimport_noclobber {pattern {ns ""}} {
-        set source_ns [namespace qualifiers $pattern]
+    proc nsimport_noclobber {args} {
+        set argspecs {
+            -targetnamespace -default "" -optional 1
+            -prefix -default "" -optional 1
+            sourcepattern -type string -optional 0
+        }
+        lassign [punk::args::opts_values $argspecs $args -minvalues 1 -maxvalues 1] _o opts _v values
+        set sourcepattern [dict get $values sourcepattern]
+
+        set source_ns [namespace qualifiers $sourcepattern]
         if {![namespace exists $source_ns]} {
             error "nsimport_noclobber error namespace $source_ns not found"
         }
-        if {$ns eq ""} {
-            set ns [uplevel 1 {namespace current}]
-        } elseif {![string match ::* $ns]} {
-            set nscaller [uplevel 1 {namespace current}]
-            set ns [punk::nsjoin $nscaller $ns]
+        set target_ns [dict get $opts -targetnamespace]
+        set nscaller [uplevel 1 {namespace current}]
+        if {$target_ns eq ""} {
+            set target_ns $nscaller
+        } elseif {![string match ::* $target_ns]} {
+            set target_ns [punk::nsjoin $nscaller $target_ns]
         }
+
         set a_export_patterns [namespace eval $source_ns {namespace export}] 
-        set a_commands [info commands $pattern]
+        set a_commands [info commands $sourcepattern]
         set a_tails [lmap v $a_commands {namespace tail $v}]
         set a_exported_tails [list]
-        foreach pattern $a_export_patterns {
-            set matches [lsearch -all -inline $a_tails $pattern]
+        foreach epattern $a_export_patterns {
+            set matches [lsearch -all -inline $a_tails $epattern]
             foreach m $matches {
                 if {$m ni $a_exported_tails} {
                     lappend a_exported_tails $m
@@ -1626,7 +1636,7 @@ namespace eval punk::ns {
         }
         set imported_commands [list]
         foreach e $a_exported_tails {
-            set imported [namespace eval $ns [string map [list <func> $e <a> $source_ns] {
+            set imported [namespace eval $target_ns [string map [list <func> $e <a> $source_ns] {
                 set cmd ""
                 if {![catch {namespace import <a>::<func>}]} {
                     set cmd <func>
diff --git a/src/bootsupport/modules/punk/path-0.1.0.tm b/src/bootsupport/modules/punk/path-0.1.0.tm
index f877417a..2f1ee6c5 100644
--- a/src/bootsupport/modules/punk/path-0.1.0.tm
+++ b/src/bootsupport/modules/punk/path-0.1.0.tm
@@ -198,29 +198,47 @@ namespace eval punk::path {
 
     #todo - implement treefiles which acts like dirfiles but allows path globbing in the same way as punk::ns::ns/ 
     #then review if treefiles can replace dirfiles or if both should exist (dirfiles can have literal glob chars in path segments - but that is a rare usecase)
-    proc treefilenames {basepath tailglob args} {
+    proc treefilenames {args} {
         #*** !doctools
-        #[call [fun treefilenames] [arg basepath] [arg tailglob] [opt {option value...}]]
-        #basic (glob based) list of filenames matching tailglob - recursive
-        #no natsorting - so order is dependent on filesystem
-        set defaults [dict create\
-            -call-depth-internal 0\
-            -antiglob_paths {}\
-        ]
-        set opts [dict merge $defaults $args]
+        #[call [fun treefilenames]  [opt {option value...}] [opt {globpattern...}]]
+        #[para]basic (glob based) list of filenames matching each pattern in tailglobs - recursive
+        #[para] options:
+        #[para] [opt -dir] <path> 
+        #[para]     defaults to [lb]pwd[rb] - base path for tree to search
+        #[para] [opt -antiglob_paths] <list> 
+        #[para]     list of path patterns to exclude - may include * and ** path segments e.g /usr/**
+        #[para]no natsorting - so order is dependent on filesystem
+
+        lassign [punk::get_leading_opts_and_values {
+            -directory "\uFFFF"
+            -call-depth-internal 0
+            -antiglob_paths {}
+        } $args] _o opts _v tailglobs 
+
+        # -- --- --- --- --- --- ---
         set opt_antiglob_paths [dict get $opts -antiglob_paths]
         set CALLDEPTH [dict get $opts -call-depth-internal]
+        # -- --- --- --- --- --- ---
+        set opt_dir             [dict get $opts -directory]
+        if {$opt_dir eq "\uFFFF"} {
+            set opt_dir [pwd]
+        }
+        # -- --- --- --- --- --- ---
 
         set files [list]
         if {$CALLDEPTH == 0} {
-            if {![file isdirectory $basepath]} {
+            if {![file isdirectory $opt_dir]} {
                 return [list] 
             }
+            set opts [dict merge $opts [list -directory $opt_dir]]
+            if {![llength $tailglobs]} {
+                lappend tailglobs *
+            }
         }
 
         set skip 0
         foreach anti $opt_antiglob_paths {
-            if {[globmatchpath $anti $basepath]} {
+            if {[globmatchpath $anti $opt_dir]} {
                 set skip 1
                 break
             }
@@ -230,9 +248,9 @@ namespace eval punk::path {
         }
 
         #todo - account for vfs where matched path could appear to be a directory but is mounted so could be a desired match?
-        set dirfiles [glob -nocomplain -dir $basepath -type f $tailglob] 
+        set dirfiles [lsort [glob -nocomplain -dir $opt_dir -type f {*}$tailglobs]]
         lappend files  {*}$dirfiles
-        set dirdirs [glob -nocomplain -dir $basepath -type d *]
+        set dirdirs [glob -nocomplain -dir $opt_dir -type d *]
         foreach dir $dirdirs {
             set skip 0
             foreach anti $opt_antiglob_paths {
@@ -244,8 +262,8 @@ namespace eval punk::path {
             if {$skip} {
                 continue
             }
-            set nextargs [dict merge $args [list -call-depth-internal [incr CALLDEPTH]]]
-            lappend files {*}[treefilenames $dir $tailglob {*}$nextargs]
+            set nextopts [dict merge $opts [list -directory $dir -call-depth-internal [incr CALLDEPTH]]]
+            lappend files {*}[treefilenames {*}$nextopts {*}$tailglobs]
         }
         return $files
     }
@@ -270,14 +288,30 @@ namespace eval punk::path {
         #[item]
         #[para] Notes:
         #[para]    Both paths must be the same type - ie both absolute or both relative
-        #[para]    Case sensitive.  ie  relative /etc /etC 
+        #[para]    Case sensitive.  ie  punk::path::relative /etc /etC 
         #      will return ../etC
         #[para]    On windows, the drive-letter component (only) is not case sensitive
-        #[para]    ie relative c:/etc  C:/etc  returns .  
-        #[para]    but relative c:/etc C:/Etc returns ../Etc
+        #[example_begin]
+        #    P% punk::path::relative c:/etc  C:/etc
+        #    -  .
+        #[example_end]
+        #[para] The part following the driveletter is case sensitive so in the following cases it recognises the driveletter matches but not the tail
+        #[example_begin]
+        #    P% punk::path::relative c:/etc C:/Etc
+        #    -  ../Etc
+        #[example_end]
         #[para]    On windows, if the paths are absolute and specifiy different volumes, only the location will be returned.
-        #    ie  relative c:/etc d:/etc/blah
-        #    returns d:/etc/blah
+        #[example_begin]
+        #    P% punk::path::relative c:/etc d:/etc/blah
+        #    -  d:/etc/blah
+        #[example_end]
+        #[para] Unix-like examples:
+        #[example_begin]
+        #   P% punk::path::relative /usr/local/etc/ /usr/local/etc/somewhere/below
+        #   - somewhere/below
+        #   P% punk::path::relative /usr/local/etc/somewhere /usr/local/lib/here   
+        #   - ../../lib/here
+        #[example_end]
         #[list_end]
 
         #see also kettle
diff --git a/src/bootsupport/modules/punk/repo-0.1.1.tm b/src/bootsupport/modules/punk/repo-0.1.1.tm
index d2aaf9fc..1a8ac6ec 100644
--- a/src/bootsupport/modules/punk/repo-0.1.1.tm
+++ b/src/bootsupport/modules/punk/repo-0.1.1.tm
@@ -779,10 +779,10 @@ namespace eval punk::repo {
 
             package require overtype
             set title1 "Path"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {punk::strlen $v}]]
+            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {lib::strlen $v}]]
             set col1 [string repeat " " $widest1]
             set title2 "Repo-type(s)"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
+            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {string length $v}]]
             set col2 [string repeat " " $widest2]
             set tablewidth [expr {$widest1 + 1 + $widest2}]
 
@@ -827,19 +827,61 @@ namespace eval punk::repo {
         }
     }
     proc fossil_get_repository_folder_for_project {projectname args} {
-
-        set defaults [list -parentfolder \uFFFF -extrachoice \uFFFF] 
+        set defaults [list\
+            -parentfolder \uFFFF\
+            -extrachoices \uFFFF\
+            -askpath   0\
+            -ansi \uFFFF\
+            -ansi_prompt \uFFFF\
+            -ansi_warning  \uFFFF\
+        ] 
+        if {[llength $args] % 2 != 0} {
+            error "fossil_get_repository_folder requires args to be option-value pairs. Received '$args'"
+        }
+        dict for {k v} $args {
+            if {$k ni [dict keys $defaults]} {
+                error "fossil_get_repository_folder unrecognised option $k. Known options: [dict keys $defaults]"
+            }
+        }
         set opts            [dict merge $defaults $args]
-
+        # -- --- --- --- --- ---
         set opt_parentfolder [dict get $opts -parentfolder]
         if {$opt_parentfolder eq "\uFFFF"} {
             set opt_parentfolder [pwd]
         }
-        set opt_extrachoice [dict get $opts -extrachoice]
-        set extrachoice ""
-        if {$opt_extrachoice ne "\uFFFF"} {
-            set extrachoice $opt_extrachoice
+        # -- --- --- --- --- ---
+        set opt_extrachoices [dict get $opts -extrachoices]
+        set extrachoices [list]
+        if {$opt_extrachoices ne "\uFFFF"} {
+            set extrachoices $opt_extrachoices
+        }
+        # -- --- --- --- --- ---
+        set opt_askpath [dict get $opts -askpath]
+        # -- --- --- --- --- ---
+        set opt_ansi [dict get $opts -ansi]
+        set opt_ansi_prompt [dict get $opts -ansi_prompt]
+        set opt_ansi_warning [dict get $opts -ansi_warning]
+        if {$opt_ansi eq "\uFFFF"} {
+            set opt_ansi 1
+        }
+        if {$opt_ansi} {
+            if {$opt_ansi_prompt eq "\uFFFF"} {
+                set ansiprompt [a+ green bold] 
+            } else {
+                set ansiprompt [$opt_ansi_prompt]
+            }
+            if {$opt_ansi_warning eq "\uFFFF"} {
+                set ansiwarn [a+ red bold]
+            } else {
+                set ansiwarn [$opt_ansi_warning]
+            }
+            set ansireset [a]
+        } else {
+            set ansiprompt ""
+            set ansiwarn ""
+            set ansireset ""
         }
+        # -- --- --- --- --- ---
 
         set startdir $opt_parentfolder
 
@@ -849,25 +891,8 @@ namespace eval punk::repo {
             return
         }
 
-        set fossilinfo [exec {*}$fossil_prog info] ;#will give us the necessary config-db info whether in a project folder or not
-        set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
-        if {[llength $matching_lines] != 1} {
-            puts stderr "Unable to find config-db info from fossil. Check your fossil installation."
-            puts stderr "Fossil output was:"
-            puts stderr "-------------"
-            puts stderr "$fossilinfo"
-            puts stderr "-------------"
-            puts stderr "config-db info:"
-            puts stderr "$matching_lines"
-            return
-        }
-        set trimmedline [string trim [lindex $matching_lines 0]]
-        set firstcolon [string first : $trimmedline]
-        set config_db_path [string trim [string range $trimmedline $firstcolon+1 end]]
-        if {![file exists $config_db_path]} {
-            puts stderr "Unable to verify fossil global configuration info at path: $config_db_path"
-            return
-        }
+        set config_db_path [fossil_get_configdb]
+
         set config_db_folder [file dirname $config_db_path]
 
         #NOTE: we could use fossil all info to detect all locations of .fossil files - but there may be many that are specific to projects if the user wasn't in the habit of using a default location
@@ -914,10 +939,11 @@ namespace eval punk::repo {
         if {$tp ni $testpaths} {
             lappend testpaths $tp
         }
-        if {[string length $extrachoice]} {
-            set tp $extrachoice
-            if {$tp ni $testpaths} {
-                lappend testpaths $tp
+        if {[llength $extrachoices]} {
+            foreach tp $extrachoices {
+                if {$tp ni $testpaths} {
+                    lappend testpaths $tp
+                }
             }
         }
 
@@ -956,7 +982,7 @@ namespace eval punk::repo {
                 set existingfossils "( no existing .fossil files found )"
             }
             if {"$projectname.fossil" in $existing_fossils} {
-                set conflict "CONFLICT - $projectname.fossil already exists in this folder"
+                set conflict "${ansiwarn}CONFLICT - $projectname.fossil already exists in this folder${ansireset}"
             } else {
                 set conflict ""
             }
@@ -975,9 +1001,9 @@ namespace eval punk::repo {
 
         set menu_message ""
         if {[llength $choice_folders]} {
-            append menu_message "Select the number of the folder to use to store the .fossil repository file" \n
+            append menu_message "${ansiprompt}Select the number of the folder to use to store the .fossil repository file${ansireset}" \n
         } else {
-            append menu_message "--- NO suitable writable folders or locations found for .fossil file. Consider setting FOSSIL_HOME environment variable and check that folders are writable.--" \n
+            append menu_message "${ansiwarn}--- NO suitable writable folders or locations found for .fossil file. Consider setting FOSSIL_HOME environment variable and check that folders are writable.--${ansireset}" \n
         }
 
         set conflicted_options [list]
@@ -1003,7 +1029,7 @@ namespace eval punk::repo {
         if {[llength $readonly_repo_folder_locations]} {
             append menu_message "--------------------------------------------------" \n
             foreach readonly $readonly_repo_folder_locations {
-                append menu_message "<unavailable not writable> $readonly" \n
+                append menu_message "${ansiwarn}<unavailable not writable> $readonly${ansireset}" \n
             }
             append menu_message "--------------------------------------------------" \n
         }
@@ -1011,11 +1037,11 @@ namespace eval punk::repo {
         #see if we can reasonably use the only available option and not bug the user
         #Todo - option to always prompt?
         #we will not auto-select if there is even one conflicted_option - as that seems like something you should know about
-        if {![llength $conflicted_options] && ([llength $choice_folders] == 1)} {
+        if {![llength $conflicted_options] && ([llength $choice_folders] == 1) && !$opt_askpath} {
             set repo_folder_choice [lindex $choice_folders 0]
             set repository_folder [dict get $repo_folder_choice folder]
         } else {
-            if {[llength $choice_folders]} {
+            if {[llength $choice_folders] || $opt_askpath} {
                 puts stdout $menu_message
                 set max [llength $choice_folders] 
                 if {$max == 1} {
@@ -1023,24 +1049,73 @@ namespace eval punk::repo {
                 } else {
                     set rangemsg "a number from 1 to $max" 
                 }
-                set answer [askuser "Enter $rangemsg to select location. (or N to abort)"]
-                if {![string is integer -strict $answer]} {
-                    puts stderr "Aborting"
-                    return
+                set menuprompt "${ansiprompt}Enter $rangemsg to select location. (or N to abort)${ansireset}"
+                if {$opt_askpath} {
+                    set askpathprompt "${ansiprompt}Enter the word: path followed by an absolute path to a folder if you would like to manually enter a folder${ansireset}"
+                    append menuprompt \n $askpathprompt
                 }
+                set answer [askuser $menuprompt]
+                if {$opt_askpath && [string match "path*" [string tolower $answer]]} {
+                    set is_done 0
+                    set repository_folder [string trim [string range $answer 4 end]]
+                    while {!$is_done} {
+
+                        if {![file isdirectory $repository_folder]} {
+                            puts stderr "${ansiwarn}Sorry - unable to find entered location '$repository_folder'${ansireset}"
+                            if {[file isdirectory [file dirname $repository_folder]]} {
+                                set answer [askuser "${ansiprompt}Do you want to create this folder? Type just the word mkdir to create it, or N for no${ansireset}"]
+                                if {[string equal mkdir [string tolower $answer]]} {
+                                    if {[catch {file mkdir $repository_folder} errM]} {
+                                        puts stderr "Failed to create folder $repository_folder. Error $errM" 
+                                    }
+                                }
+                            } else {
+                                puts stderr "${ansiwarn}Not offering to create directory because parent folder not found${ansireset}"
+                            }
+                        }
 
-                set index [expr {int($answer) -1}]
-                if {$index >= 0 && $index <= $max-1} {
-                    set repo_folder_choice [lindex $choice_folders $index]
-                    set repository_folder [dict get $repo_folder_choice folder]
-                    puts stdout "Selected fossil location $repository_folder" 
+                        if {![file isdirectory $repository_folder]} {
+                            set answer [askuser "${ansiprompt}Try again? (Y|N)${ansireset}"]
+                            if {[string match y* [string tolower $answer]]} {
+                                set answer [askuser $askpathprompt]
+                                if {[string match "path*" [string tolower $answer]]} {
+                                    set repository_folder [string trim [string range $answer 4 end]]
+                                } else {
+                                    puts stderr "Answer didn't begin with the word path"
+                                    set is_done 1
+                                }
+                            } else {
+                                set is_done 1
+                            }
+                        } else {
+                            set is_done 1
+                        }
+                    }
+                    if {$is_done && ![file isdirectory $repository_folder]} {
+                        puts stderr "Aborting"
+                        return
+                    }
                 } else {
-                    puts stderr " No menu number matched - aborting."
-                    return
+                    if {![string is integer -strict $answer]} {
+                        puts stderr "Aborting"
+                        return
+                    }
+                    set index [expr {int($answer) -1}]
+                    if {$index >= 0 && $index <= $max-1} {
+                        set repo_folder_choice [lindex $choice_folders $index]
+                        set repository_folder [dict get $repo_folder_choice folder]
+                        puts stdout "Selected fossil location $repository_folder" 
+                    } else {
+                        puts stderr " No menu number matched - aborting."
+                        return
+                    }
                 }
+
+
+
             } else {
                 puts stdout $menu_message
-                set answer [askuser "Hit enter to exit"]
+                set answer [askuser "${ansiprompt}Hit enter to exit${ansireset}"]
                 return
             }
         }
@@ -1053,26 +1128,26 @@ namespace eval punk::repo {
         if {$path eq {}} { set path [pwd] }
         # ::kettle::path::revision.git
         do_in_path $path {
-        try {
-            #git describe will error with 'No names found' if repo has no tags
-            #set v [::exec {*}[auto_execok git] describe]
-            set v [::exec {*}[auto_execok git] rev-parse HEAD] ;# consider 'git rev-parse --short HEAD'
-        } on error {e o} {
-            set v [lindex [split [dict get $o -errorinfo] \n] 0]
-        }
+            try {
+                #git describe will error with 'No names found' if repo has no tags
+                #set v [::exec {*}[auto_execok git] describe]
+                set v [::exec {*}[auto_execok git] rev-parse HEAD] ;# consider 'git rev-parse --short HEAD'
+            } on error {e o} {
+                set v [lindex [split [dict get $o -errorinfo] \n] 0]
+            }
         }
         return [string trim $v]
     }
     proc git_remote {{path {{}}}} {
         if {$path eq {}} { set path [pwd] }
         do_in_path $path {
-        try {
-            #git describe will error with 'No names found' if repo has no tags
-            #set v [::exec {*}[auto_execok git] describe]
-            set v [::exec {*}[auto_execok git] -remote -v] ;# consider 'git rev-parse --short HEAD'
-        } on error {e o} {
-            set v [lindex [split [dict get $o -errorinfo] \n] 0]
-        }
+            try {
+                #git describe will error with 'No names found' if repo has no tags
+                #set v [::exec {*}[auto_execok git] describe]
+                set v [::exec {*}[auto_execok git] -remote -v] ;# consider 'git rev-parse --short HEAD'
+            } on error {e o} {
+                set v [lindex [split [dict get $o -errorinfo] \n] 0]
+            }
         }
         return [string trim $v]
     }
@@ -1104,6 +1179,148 @@ namespace eval punk::repo {
             return Unknown
         }
     }
+    proc fossil_get_configdb {{path {}}} {
+        #fossil info will *usually* give us the necessary config-db info whether in a project folder or not but..
+        #a) It's expensive to shell-out and call it
+        #b) it won't give us a result if we are in a checkout folder which has had its repository moved 
+        #this fairly extensive mechanism is designed to find it even if the environment has some weird goings-on regarding the filesystem/environment variables
+        #This is unlikely to be necessary in most scenarios, where the location is related to the user's home directory
+        
+        #attempt 1 - environment vars  and well-known locations 
+        #This is first because it's faster - but hopefully it's aligned with how fossil does it
+
+        if {"windows" eq $::tcl_platform(platform)} {
+            foreach varname [list FOSSIL_HOME LOCALAPPDATA APPDATA USERPROFILES] {
+                if {[info exists ::env($varname)]} {
+                    set testfile [file join $::env($varname) _fossil]
+                    if {[file exists $testfile]} {
+                        return $testfile
+                    }
+                }
+            }
+            if {[info exists ::env(HOMEDRIVE)] && [info exists ::env(HOMEPATH)]} {
+                set testfile $::env(HOMEDRIVE)$::env(HOMEPATH)\\_fossil"
+                if {[file exists $testfile]} {
+                    return $testfile
+                }
+            } 
+        } else {
+            foreach varname [list FOSSIL_HOME HOME ] {
+                if {[info exists ::env($varname)]} {
+                    set testfile [file join $::env($varname) .fossil]
+                    if {[file exists $testfile]} {
+                        return $testfile
+                    }
+                }
+            }
+            if {[info exists ::env(XDG_CONFIG_HOME)]} {
+                set testfile [file join $::env(XDG_CONFIG_HOME) fossil.db]
+                if {[file exists $testfile]} {
+                    return $testfile
+                }
+                set testfile [file join $::env(XDG_CONFIG_HOME) .config fossil.db]
+                if {[file exists $testfile]} {
+                    return $testfile
+                }
+            } 
+            if {[info exists ::env(HOME)]} {
+                set testfile [file join $::env(HOME) .config fossil.db]
+                if {[file exists $testfile]} {
+                    return $testfile
+                }
+            } 
+        }
+
+
+        set original_cwd [pwd]
+        #attempt2 - let fossil do it for us - hopefully based on current folder
+        if {$path eq {}} {set path [pwd]}
+        set fossilcmd [auto_execok fossil]
+        if {![llength $fossilcmd]} {
+            set fossil_ok 0
+        } else {
+            set fossil_ok 1
+        }
+        try {
+            while {$fossil_ok} {
+                cd $path
+                if {[catch {exec {*}$fossilcmd info} fossilinfo]} {
+                    #a detached repo above us can result in an error from fossil info
+                    set next [file dirname $path]
+                } else {
+                    set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
+                    if {[llength $matching_lines] == 1} {
+                        set trimmedline [string trim [lindex $matching_lines 0]]
+                        set firstcolon [string first : $trimmedline]
+                        set config_db_path [string trim [string range $trimmedline $firstcolon+1 end]]
+                        if {[file exists $config_db_path]} {
+                            return $config_db_path
+                        }
+                    }
+                    set next [file dirname $path]
+                }
+
+                if {$next eq $path || $next eq ""} {
+                    break
+                }
+                set path $next
+            }
+        } on error {errmsg options} {
+            #puts "errmsg:$errmgs options:$options"
+        } finally {
+            cd $original_cwd
+        }
+
+        #attempt 3 - getting desperate.. find other repos, determine their checkouts and run fossil in them to get a result 
+        if {$fossil_ok} {
+            #It should be extremely rare to need to resort to sqlite on the databases to find other potential repo paths
+            #Conceivably only on some weird VFS or where some other filesystem strangeness is going on with our original path - or if the root volume itself is a broken fossil checkout
+            #Examining the other repos gives us a chance at discovering some other filesystem/paths where things may not be broken
+            if {![catch {package require sqlite3} errPackage]} {
+                #use fossil all ls and sqlite 
+                if {[catch {exec {*}$fossilcmd all ls} repolines]} {
+                    error "fossil_get_configdb cannot find repositories"
+                } else {
+                    set repolines [string map [list \r\n \n] $repolines]
+                    set repolist [split $repolines \n]
+                    set dbcmd "fossil_get_configdb_tempdb"
+                    foreach repodb $repolist {
+                        catch {rename $dbcmd ""}
+                        if {[file exists $repodb]} {
+                            if {![catch {sqlite3 $dbcmd $repodb}]} {
+                                set ckoutrecords [$dbcmd eval {select name from config where name like 'ckout:%'}]
+                                catch {$dbcmd close}
+                                foreach ck $ckoutrecords {
+                                    set ckfolder [string range $ck 6 end]
+                                    #puts stdout "ckfolder $ckfolder"
+                                    if {[file isdirectory $ckfolder]} {
+                                        set result ""
+                                        do_in_path $ckfolder {
+                                            if {![catch {exec {*}$fossilcmd info} fossilinfo]} {
+                                                set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
+                                                if {[llength $matching_lines] == 1} {
+                                                    set trimmedline [string trim [lindex $matching_lines 0]]
+                                                    set firstcolon [string first : $trimmedline]
+                                                    set config_db_path [string trim [string range $trimmedline $firstcolon+1 end]]
+                                                    if {[file exists $config_db_path]} {
+                                                        set result $config_db_path
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        if {$result ne ""} {
+                                            return $result
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        error "fossil_get_configdb exhausted search options"
+    }
     #------------------------------------
     
     #temporarily cd to workpath to run script - return to correct path even on failure
@@ -1256,7 +1473,19 @@ namespace eval punk::repo {
     interp alias {} gconf {} git config --global -l
 
 }
+namespace eval punk::repo::lib {
+    #-----------------------------------------------------------------------------------
+    #strlen is important for testing issues with string representationa and shimmering.
+    #This specific implementation with append (as at 2023-09) is designed to ensure the original str representation isn't changed
+    #It may need to be reviewed with different Tcl versions in case the append empty string is 'optimised/tuned' in some way that affects the behaviour
+    #The use of this function instead of string length can make a difference in certain circumstances with 'path' object representations
+    proc strlen {str} {
+        append str2 $str {}
+        string length $str2
+    }
+    #-----------------------------------------------------------------------------------
 
+}
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
diff --git a/src/bootsupport/modules/punkcheck-0.1.0.tm b/src/bootsupport/modules/punkcheck-0.1.0.tm
index 4582ac50..c58fe244 100644
--- a/src/bootsupport/modules/punkcheck-0.1.0.tm
+++ b/src/bootsupport/modules/punkcheck-0.1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
@@ -36,6 +36,7 @@ namespace eval punkcheck {
             uuid\
             start_installer_event  installfile_*
 
+        #antiglob_dir & antiglob_file entries match the pattern at any level - should not contain path separators
         variable default_antiglob_dir_core  [list "#*" "_aside" ".git" ".fossil*"]
         variable default_antiglob_file_core ""
         proc uuid {} {
@@ -1155,15 +1156,15 @@ namespace eval punkcheck {
                 -installer punkcheck::install\
                 ]
 
-            set opts [dict merge $defaults $args]
             if {([llength $args] %2) != 0} {
                 error "punkcheck::install requires option-style arguments to be in pairs. Received args: $args"
             }
-            foreach k [dict keys $args] {
+            foreach {k -} $args {
                 if {$k ni [dict keys $defaults]} {
                     error "punkcheck::install  unrecognised option '$k' known options: '[dict keys $defaults]'"
                 }
             }
+            set opts [dict merge $defaults $args]
 
             #The choice to recurse using the original values of srcdir & tgtdir, and passing the subpath down as a list in -subdirlist seems an odd one.
             #(as opposed to a more 'standard' mechanism of adjusting srcdir & tgtdir as we move down the tree)
@@ -1194,6 +1195,12 @@ namespace eval punkcheck {
             }
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set opt_antiglob_file                       [dict get $opts -antiglob_file]
+            #validate no path seps
+            foreach af $opt_antiglob_file {
+                if {[llength [file split $af]] > 1} {
+                    error "punkcheck::install received invalid -antiglob_file entry '$af'. -antiglob_file entries are meant to match to a file name at any level so cannot contain path separators"
+                }
+            } 
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set opt_antiglob_dir_core                   [dict get $opts -antiglob_dir_core]
             if {$opt_antiglob_dir_core eq "\uFFFF"} {
@@ -1202,8 +1209,15 @@ namespace eval punkcheck {
             }
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set opt_antiglob_dir                        [dict get $opts -antiglob_dir]
+            #validate no path seps
+            foreach ad $opt_antiglob_dir {
+                if {[llength [file split $ad]] > 1} {
+                    error "punkcheck::install received invalid -antiglob_dir entry '$ad'. -antiglob_dir entries are meant to match to a directory name at any level so cannot contain path separators"
+                }
+            } 
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set opt_antiglob_paths                     [dict get $opts -antiglob_paths] ;#todo - combine with config file in source tree .punkcheckpublish (?)
+            #antiglob_paths will usually contain file separators - and may contain glob patterns within each segment
             set antiglob_paths_matched [list]
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set known_whats [list no-targets newer-targets older-targets all-targets installedsourcechanged-targets synced-targets]
@@ -1586,6 +1600,21 @@ namespace eval punkcheck {
                     continue
                 }
 
+                set relative_source_path [file join $relative_source_dir $d]
+                set is_antipath 0
+                foreach antipath $opt_antiglob_paths {
+                    #puts "testing folder - globmatchpath $antipath  vs $relative_source_path" 
+                    if {[punk::path::globmatchpath $antipath $relative_source_path]} {
+                        lappend antiglob_paths_matched [file join $current_source_dir $d]
+                        puts stdout "SKIPPING FOLDER $relative_source_path due to antiglob_path-match: $antipath "
+                        set is_antipath 1
+                        break
+                    }
+                }
+                if {$is_antipath} {
+                    continue
+                }
+                
 
                 if {![file exists $current_target_dir/$d]} {
                     file mkdir $current_target_dir/$d
diff --git a/src/bootsupport/modules/smtp-1.5.1.tm b/src/bootsupport/modules/smtp-1.5.1.tm
new file mode 100644
index 00000000..f0d93f7b
--- /dev/null
+++ b/src/bootsupport/modules/smtp-1.5.1.tm
@@ -0,0 +1,1508 @@
+# smtp.tcl - SMTP client
+#
+# Copyright (c) 1999-2000 Marshall T. Rose
+# Copyright (c) 2003-2006 Pat Thoyts
+#
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+#
+
+package require Tcl 8.3
+package require mime 1.4.1
+
+catch {
+    package require SASL 1.0;           # tcllib 1.8
+    package require SASL::NTLM 1.0;     # tcllib 1.8
+}
+
+#
+# state variables:
+#
+#    sd: socket to server
+#    afterID: afterID associated with ::smtp::timer
+#    options: array of user-supplied options
+#    readable: semaphore for vwait
+#    addrs: number of recipients negotiated
+#    error: error during read
+#    line: response read from server
+#    crP: just put a \r in the data
+#    nlP: just put a \n in the data
+#    size: number of octets sent in DATA
+#
+
+namespace eval ::smtp {
+    variable  trf 1
+    variable  smtp
+    array set smtp { uid 0 }
+
+    namespace export sendmessage
+}
+
+if {[catch {package require Trf  2.0}]} {
+    # Trf is not available, but we can live without it as long as the
+    # transform and unstack procs are defined.
+
+    # Warning!
+    # This is a fragile emulation of the more general calling sequence
+    # that appears to work with this code here.
+
+    proc transform {args} {
+	upvar state mystate
+	set mystate(size) 1
+    }
+    proc unstack {channel} {
+        # do nothing
+        return
+    }
+    set ::smtp::trf 0
+}
+
+
+# ::smtp::sendmessage --
+#
+#	Sends a mime object (containing a message) to some recipients
+#
+# Arguments:
+#	part  The MIME object containing the message to send
+#       args  A list of arguments specifying various options for sending the
+#             message:
+#             -atleastone  A boolean specifying whether or not to send the
+#                          message at all if any of the recipients are
+#                          invalid.  A value of false (as defined by
+#                          ::smtp::boolean) means that ALL recipients must be
+#                          valid in order to send the message.  A value of
+#                          true means that as long as at least one recipient
+#                          is valid, the message will be sent.
+#             -debug       A boolean specifying whether or not debugging is
+#                          on.  If debugging is enabled, status messages are
+#                          printed to stderr while trying to send mail.
+#             -queue       A boolean specifying whether or not the message
+#                          being sent should be queued for later delivery.
+#             -header      A single RFC 822 header key and value (as a list),
+#                          used to specify to whom to send the message
+#                          (To, Cc, Bcc), the "From", etc.
+#             -originator  The originator of the message (equivalent to
+#                          specifying a From header).
+#             -recipients  A string containing recipient e-mail addresses.
+#                          NOTE: This option overrides any recipient addresses
+#                          specified with -header.
+#             -servers     A list of mail servers that could process the
+#                          request.
+#             -ports       A list of SMTP ports to use for each SMTP server
+#                          specified
+#             -client      The string to use as our host name for EHLO or HELO
+#                          This defaults to 'localhost' or [info hostname]
+#             -maxsecs     Maximum number of seconds to allow the SMTP server
+#                          to accept the message. If not specified, the default
+#                          is 120 seconds.
+#             -usetls      A boolean flag. If the server supports it and we
+#                          have the package, use TLS to secure the connection.
+#             -tlspolicy   A command to call if the TLS negotiation fails for
+#                          some reason. Return 'insecure' to continue with
+#                          normal SMTP or 'secure' to close the connection and
+#                          try another server.
+#             -tlsimport   after a succesfull socket command, import tls on
+#                          channel - used for native smtps negotiation
+#             -username    These are needed if your SMTP server requires
+#             -password    authentication.
+#
+# Results:
+#	Message is sent.  On success, return "".  On failure, throw an
+#       exception with an error code and error message.
+
+proc ::smtp::sendmessage {part args} {
+    global errorCode errorInfo
+
+    # Here are the meanings of the following boolean variables:
+    # aloP -- value of -atleastone option above.
+    # debugP -- value of -debug option above.
+    # origP -- 1 if -originator option was specified, 0 otherwise.
+    # queueP -- value of -queue option above.
+
+    set aloP 0
+    set debugP 0
+    set origP 0
+    set queueP 0
+    set maxsecs 120
+    set originator ""
+    set recipients ""
+    set servers [list localhost]
+    set client "" ;# default is set after options processing
+    set ports [list 25]
+    set tlsP 1
+    set tlspolicy {}
+    set tlsimport 0
+    set username {}
+    set password {}
+
+    array set header ""
+
+    # lowerL will contain the list of header keys (converted to lower case)
+    # specified with various -header options.  mixedL is the mixed-case version
+    # of the list.
+    set lowerL ""
+    set mixedL ""
+
+    # Parse options (args).
+
+    if {[expr {[llength $args]%2}]} {
+        # Some option didn't get a value.
+        error "Each option must have a value!  Invalid option list: $args"
+    }
+
+    foreach {option value} $args {
+        switch -- $option {
+            -atleastone {set aloP   [boolean $value]}
+            -debug      {set debugP [boolean $value]}
+            -queue      {set queueP [boolean $value]}
+            -usetls     {set tlsP   [boolean $value]}
+            -tlspolicy  {set tlspolicy $value}
+            -tlsimport  {set tlsimport [boolean $value]}
+	    -maxsecs    {set maxsecs [expr {$value < 0 ? 0 : $value}]}
+            -header {
+                if {[llength $value] != 2} {
+                    error "-header expects a key and a value, not $value"
+                }
+                set mixed [lindex $value 0]
+                set lower [string tolower $mixed]
+                set disallowedHdrList \
+                    [list content-type \
+                          content-transfer-encoding \
+                          content-md5 \
+                          mime-version]
+                if {[lsearch -exact $disallowedHdrList $lower] > -1} {
+                    error "Content-Type, Content-Transfer-Encoding,\
+                        Content-MD5, and MIME-Version cannot be user-specified."
+                }
+                if {[lsearch -exact $lowerL $lower] < 0} {
+                    lappend lowerL $lower
+                    lappend mixedL $mixed
+                }
+
+                lappend header($lower) [lindex $value 1]
+            }
+
+            -originator {
+                set originator $value
+                if {$originator == ""} {
+                    set origP 1
+                }
+            }
+
+            -recipients {
+                set recipients $value
+            }
+
+            -servers {
+                set servers $value
+            }
+
+            -client {
+                set client $value
+            }
+
+            -ports {
+                set ports $value
+            }
+
+            -username { set username $value }
+            -password { set password $value }
+
+            default {
+                error "unknown option $option"
+            }
+        }
+    }
+
+    if {[lsearch -glob $lowerL resent-*] >= 0} {
+        set prefixL resent-
+        set prefixM Resent-
+    } else {
+        set prefixL ""
+        set prefixM ""
+    }
+
+    # Set a bunch of variables whose value will be the real header to be used
+    # in the outbound message (with proper case and prefix).
+
+    foreach mixed {From Sender To cc Dcc Bcc Date Message-ID} {
+        set lower [string tolower $mixed]
+	# FRINK: nocheck
+        set ${lower}L $prefixL$lower
+	# FRINK: nocheck
+        set ${lower}M $prefixM$mixed
+    }
+
+    if {$origP} {
+        # -originator was specified with "", so SMTP sender should be marked "".
+        set sender ""
+    } else {
+        # -originator was specified with a value, OR -originator wasn't
+        # specified at all.
+
+        # If no -originator was provided, get the originator from the "From"
+        # header.  If there was no "From" header get it from the username
+        # executing the script.
+
+        set who "-originator"
+        if {$originator == ""} {
+            if {![info exists header($fromL)]} {
+                set originator $::tcl_platform(user)
+            } else {
+                set originator [join $header($fromL) ,]
+
+                # Indicate that we're using the From header for the originator.
+
+                set who $fromM
+            }
+        }
+
+	# If there's no "From" header, create a From header with the value
+	# of -originator as the value.
+
+        if {[lsearch -exact $lowerL $fromL] < 0} {
+            lappend lowerL $fromL
+            lappend mixedL $fromM
+            lappend header($fromL) $originator
+        }
+
+	# ::mime::parseaddress returns a list whose elements are huge key-value
+	# lists with info about the addresses.  In this case, we only want one
+	# originator, so we want the length of the main list to be 1.
+
+        set addrs [::mime::parseaddress $originator]
+        if {[llength $addrs] > 1} {
+            error "too many mailboxes in $who: $originator"
+        }
+        array set aprops {error "invalid address \"$from\""}
+        array set aprops [lindex $addrs 0]
+        if {$aprops(error) != ""} {
+            error "error in $who: $aprops(error)"
+        }
+
+	# sender = validated originator or the value of the From header.
+
+        set sender $aprops(address)
+
+	# If no Sender header has been specified and From is different from
+	# originator, then set the sender header to the From.  Otherwise, don't
+	# specify a Sender header.
+        set from [join $header($fromL) ,]
+        if {[lsearch -exact $lowerL $senderL] < 0 && \
+                [string compare $originator $from]} {
+            if {[info exists aprops]} {
+                unset aprops
+            }
+            array set aprops {error "invalid address \"$from\""}
+            array set aprops [lindex [::mime::parseaddress $from] 0]
+            if {$aprops(error) != ""} {
+                error "error in $fromM: $aprops(error)"
+            }
+            if {[string compare $aprops(address) $sender]} {
+                lappend lowerL $senderL
+                lappend mixedL $senderM
+                lappend header($senderL) $aprops(address)
+            }
+        }
+    }
+
+    # We're done parsing the arguments.
+
+    if {$recipients != ""} {
+        set who -recipients
+    } elseif {![info exists header($toL)]} {
+        error "need -header \"$toM ...\""
+    } else {
+        set recipients [join $header($toL) ,]
+	# Add Cc values to recipients list
+	set who $toM
+        if {[info exists header($ccL)]} {
+            append recipients ,[join $header($ccL) ,]
+            append who /$ccM
+        }
+
+        set dccInd [lsearch -exact $lowerL $dccL]
+        if {$dccInd >= 0} {
+	    # Add Dcc values to recipients list, and get rid of Dcc header
+	    # since we don't want to output that.
+            append recipients ,[join $header($dccL) ,]
+            append who /$dccM
+
+            unset header($dccL)
+            set lowerL [lreplace $lowerL $dccInd $dccInd]
+            set mixedL [lreplace $mixedL $dccInd $dccInd]
+        }
+    }
+
+    set brecipients ""
+    set bccInd [lsearch -exact $lowerL $bccL]
+    if {$bccInd >= 0} {
+        set bccP 1
+
+	# Build valid bcc list and remove bcc element of header array (so that
+	# bcc info won't be sent with mail).
+        foreach addr [::mime::parseaddress [join $header($bccL) ,]] {
+            if {[info exists aprops]} {
+                unset aprops
+            }
+            array set aprops {error "invalid address \"$from\""}
+            array set aprops $addr
+            if {$aprops(error) != ""} {
+                error "error in $bccM: $aprops(error)"
+            }
+            lappend brecipients $aprops(address)
+        }
+
+        unset header($bccL)
+        set lowerL [lreplace $lowerL $bccInd $bccInd]
+        set mixedL [lreplace $mixedL $bccInd $bccInd]
+    } else {
+        set bccP 0
+    }
+
+    # If there are no To headers, add "" to bcc list.  WHY??
+    if {[lsearch -exact $lowerL $toL] < 0} {
+        lappend lowerL $bccL
+        lappend mixedL $bccM
+        lappend header($bccL) ""
+    }
+
+    # Construct valid recipients list from recipients list.
+
+    set vrecipients ""
+    foreach addr [::mime::parseaddress $recipients] {
+        if {[info exists aprops]} {
+            unset aprops
+        }
+        array set aprops {error "invalid address \"$from\""}
+        array set aprops $addr
+        if {$aprops(error) != ""} {
+            error "error in $who: $aprops(error)"
+        }
+        lappend vrecipients $aprops(address)
+    }
+
+    # If there's no date header, get the date from the mime message.  Same for
+    # the message-id.
+
+    if {([lsearch -exact $lowerL $dateL] < 0) \
+            && ([catch {::mime::getheader $part $dateL}])} {
+        lappend lowerL $dateL
+        lappend mixedL $dateM
+        lappend header($dateL) [::mime::parsedatetime -now proper]
+    }
+
+    if {([lsearch -exact $lowerL ${message-idL}] < 0) \
+            && ([catch {::mime::getheader $part ${message-idL}}])} {
+        lappend lowerL ${message-idL}
+        lappend mixedL ${message-idM}
+        lappend header(${message-idL}) [::mime::uniqueID]
+
+    }
+
+	set origheaders {}
+	set orignames [join [lmap name [::mime::getheader $part -names] {
+		list [string tolower $name] $name
+	}]]
+
+    # Take all the headers defined earlier and add them to the MIME message.
+    foreach lower $lowerL mixed $mixedL {
+        foreach value $header($lower) {
+			if {![dict exists $origheaders $lower]} {
+				if {![catch {::mime::getheader $part $lower} cres]} {
+					dict set origheaderx $lower $cres
+				}
+			}
+            ::mime::setheader $part $mixed $value -mode append
+        }
+    }
+
+    if {[string length $client] < 1} {
+        if {![string compare $servers localhost]} {
+            set client localhost
+        } else {
+            set client [info hostname]
+        }
+    }
+
+    # Create smtp token, which essentially means begin talking to the SMTP
+    # server.
+    set token [initialize -debug $debugP -client $client \
+		                -maxsecs $maxsecs -usetls $tlsP \
+                                -multiple $bccP -queue $queueP \
+                                -servers $servers -ports $ports \
+                                -tlspolicy $tlspolicy -tlsimport $tlsimport \
+                                -username $username -password $password]
+
+    if {![string match "::smtp::*" $token]} {
+	# An error occurred and $token contains the error info
+	array set respArr $token
+	return -code error $respArr(diagnostic)
+    }
+
+    set code [catch { sendmessageaux $token $part \
+                                           $sender $vrecipients $aloP } \
+                    cres copts]
+
+    # Send the message to bcc recipients as a MIME attachment.
+
+    if {($code == 0) && ($bccP)} {
+        set inner [::mime::initialize -canonical message/rfc822 \
+                                    -header [list Content-Description \
+                                                  "Original Message"] \
+                                    -parts [list $part]]
+
+        set subject "\[$bccM\]"
+        if {[info exists header(subject)]} {
+            append subject " " [lindex $header(subject) 0]
+        }
+
+        set outer [::mime::initialize \
+                         -canonical multipart/digest \
+                         -header [list From $originator] \
+                         -header [list Bcc ""] \
+                         -header [list Date \
+                                       [::mime::parsedatetime -now proper]] \
+                         -header [list Subject $subject] \
+                         -header [list Message-ID [::mime::uniqueID]] \
+                         -header [list Content-Description \
+                                       "Blind Carbon Copy"] \
+                         -parts [list $inner]]
+
+
+        set code [catch { sendmessageaux $token $outer \
+                                               $sender $brecipients \
+                                               $aloP } cres2 copts2]
+        if {$code == 0} {
+            append cres $cres2
+        } 
+
+        catch { ::mime::finalize $inner -subordinates none }
+        catch { ::mime::finalize $outer -subordinates none }
+    }
+
+    # Determine if there was any error in prior operations and set errorcodes
+    # and error messages appropriately.
+
+    switch -- $code {
+        0 {
+            set status orderly
+        }
+        default {
+            set status abort
+        }
+    }
+
+    # Destroy SMTP token 'cause we're done with it.
+    catch { finalize $token -close $status }
+
+	# Restore provided MIME object to original state (without the SMTP
+	# headers).  To avoid an incorect attempt to set a read-only header like
+	# "Content-Type', the only original headers that were saved were those that
+	# were later modified.
+	foreach {key value} $origheaders {
+		mime::setheader $part $key {} -mode delete
+		::mime::setheader $part [dict get orignames $key] $value -mode append
+	}
+
+    return -options $copts $cres
+}
+
+# ::smtp::sendmessageaux --
+#
+#	Sends a mime object (containing a message) to some recipients using an
+#       existing SMTP token.
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#	part        The MIME object containing the message to send.
+#       originator  The e-mail address of the entity sending the message,
+#                   usually the From clause.
+#       recipients  List of e-mail addresses to whom message will be sent.
+#       aloP        Boolean "atleastone" setting; see the -atleastone option
+#                   in ::smtp::sendmessage for details.
+#
+# Results:
+#	Message is sent.  On success, return "".  On failure, throw an
+#       exception with an error code and error message.
+
+proc ::smtp::sendmessageaux {token part originator recipients aloP} {
+    global errorCode errorInfo
+
+    winit $token $part $originator
+
+    set goodP 0
+    set badP 0
+    set oops ""
+    foreach recipient $recipients {
+        set code [catch { waddr $token $recipient } result]
+        set ecode $errorCode
+        set einfo $errorInfo
+
+        switch -- $code {
+            0 {
+                incr goodP
+            }
+
+            7 {
+                incr badP
+
+                array set response $result
+                lappend oops [list $recipient $response(code) \
+                                   $response(diagnostic)]
+            }
+
+            default {
+                return -code $code -errorinfo $einfo -errorcode $ecode $result
+            }
+        }
+    }
+
+    if {($goodP) && ((!$badP) || ($aloP))} {
+        wtext $token $part
+    } else {
+        catch { talk $token 300 RSET }
+    }
+
+    return $oops
+}
+
+# ::smtp::initialize --
+#
+#	Create an SMTP token and open a connection to the SMTP server.
+#
+# Arguments:
+#       args  A list of arguments specifying various options for sending the
+#             message:
+#             -debug       A boolean specifying whether or not debugging is
+#                          on.  If debugging is enabled, status messages are
+#                          printed to stderr while trying to send mail.
+#             -client      Either localhost or the name of the local host.
+#             -multiple    Multiple messages will be sent using this token.
+#             -queue       A boolean specifying whether or not the message
+#                          being sent should be queued for later delivery.
+#             -servers     A list of mail servers that could process the
+#                          request.
+#             -ports       A list of ports on mail servers that could process
+#                          the request (one port per server-- defaults to 25).
+#             -usetls      A boolean to indicate we will use TLS if possible.
+#             -tlspolicy   Command called if TLS setup fails.
+#             -tlsimport   after a succesfull socket command, import tls on
+#                          channel - used for native smtps negotiation
+#             -username    These provide the authentication information
+#             -password    to be used if needed by the SMTP server.
+#
+# Results:
+#	On success, return an smtp token.  On failure, throw
+#       an exception with an error code and error message.
+
+proc ::smtp::initialize {args} {
+    global errorCode errorInfo
+
+    variable smtp
+
+    set token [namespace current]::[incr smtp(uid)]
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    array set state [list afterID "" options "" readable 0]
+    array set options [list -debug 0 -client localhost -multiple 1 \
+                            -maxsecs 120 -queue 0 -servers localhost \
+                            -ports 25 -usetls 1 -tlspolicy {} \
+                            -tlsimport 0 \
+                            -username {} -password {}]
+    array set options $args
+    set state(options) [array get options]
+
+    # Iterate through servers until one accepts a connection (and responds
+    # nicely).
+
+    foreach server $options(-servers) port $options(-ports) {
+        if {$server == ""} continue
+
+	set state(readable) 0
+        if {$port == ""} { set port 25 }
+
+        if {$options(-debug)} {
+            puts stderr "Trying $server..."
+            flush stderr
+        }
+
+        if {[info exists state(sd)]} {
+            unset state(sd)
+        }
+
+        if {[set code [catch {
+            set state(sd) [socket -async $server $port]
+            if { $options(-tlsimport) } {
+                package require tls
+                tls::import $state(sd)
+            }
+            fconfigure $state(sd) -blocking off -translation binary
+            fileevent $state(sd) readable [list ::smtp::readable $token]
+        } result]]} {
+            set ecode $errorCode
+            set einfo $errorInfo
+
+            catch { close $state(sd) }
+            continue
+        }
+
+        if {[set code [catch { hear $token 600 } result]]} {
+            array set response [list code 400 diagnostic $result]
+        } else {
+            array set response $result
+        }
+        set ecode $errorCode
+        set einfo $errorInfo
+        switch -- $response(code) {
+            220 {
+            }
+
+            421 - default {
+                # 421 - Temporary problem on server
+                catch {close $state(sd)}
+                continue
+            }
+        }
+
+        set r [initialize_ehlo $token]
+        if {$r != {}} {
+            return $r
+        }
+    }
+
+    # None of the servers accepted our connection, so close everything up and
+    # return an error.
+    finalize $token -close drop
+
+    return -code $code -errorinfo $einfo -errorcode $ecode $result
+}
+
+# If we cannot load the tls package, ignore the error
+# Result value is a Tcl return code, not a bool.
+# 0 == OK
+proc ::smtp::load_tls {} {
+    set r [catch {package require tls}]
+    if {$r} {set ::errorInfo ""}
+    return $r
+}
+
+proc ::smtp::initialize_ehlo {token} {
+    global errorCode errorInfo
+    upvar einfo einfo
+    upvar ecode ecode
+    upvar code  code
+
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+    array set options $state(options)
+
+    # Try enhanced SMTP first.
+
+    if {[set code [catch {smtp::talk $token 300 "EHLO $options(-client)"} \
+                       result]]} {
+        array set response [list code 400 diagnostic $result args ""]
+    } else {
+        array set response $result
+    }
+    set ecode $errorCode
+    set einfo $errorInfo
+    if {(500 <= $response(code)) && ($response(code) <= 599)} {
+        if {[set code [catch { talk $token 300 \
+                                   "HELO $options(-client)" } \
+                           result]]} {
+            array set response [list code 400 diagnostic $result args ""]
+        } else {
+            array set response $result
+        }
+        set ecode $errorCode
+        set einfo $errorInfo
+    }
+
+    if {$response(code) == 250} {
+        # Successful response to HELO or EHLO command, so set up queuing
+        # and whatnot and return the token.
+
+        set state(esmtp) $response(args)
+
+        if {(!$options(-multiple)) \
+                && ([lsearch $response(args) ONEX] >= 0)} {
+            catch {smtp::talk $token 300 ONEX}
+        }
+        if {($options(-queue)) \
+                && ([lsearch $response(args) XQUE] >= 0)} {
+            catch {smtp::talk $token 300 QUED}
+        }
+
+        # Support STARTTLS extension.
+        # The state(tls) item is used to see if we have already tried this.
+        if {($options(-usetls)) && ![info exists state(tls)] \
+                && (([lsearch $response(args) STARTTLS] >= 0)
+                    || ([lsearch $response(args) TLS] >= 0))} {
+            if {[load_tls] == 0} {
+                set state(tls) 0
+                if {![catch {smtp::talk $token 300 STARTTLS} resp]} {
+                    array set starttls $resp
+                    if {$starttls(code) == 220} {
+                        fileevent $state(sd) readable {}
+                        catch {
+                            ::tls::import $state(sd)
+                            catch {::tls::handshake $state(sd)} msg
+                            set state(tls) 1
+                        }
+                        fileevent $state(sd) readable \
+                            [list ::smtp::readable $token]
+                        return [initialize_ehlo $token]
+                    } else {
+                        # Call a TLS client policy proc here
+                        #  returns secure   - close and try another server.
+                        #  returns insecure - continue on current socket
+                        set policy insecure
+                        if {$options(-tlspolicy) != {}} {
+                            catch {
+                                eval $options(-tlspolicy) \
+                                    [list $starttls(code)] \
+                                    [list $starttls(diagnostic)]
+                            } policy
+                        }
+                        if {$policy != "insecure"} {
+                            set code error
+                            set ecode $starttls(code)
+                            set einfo $starttls(diagnostic)
+                            catch {close $state(sd)}
+                            return {}
+                        }
+                    }
+                }
+            }
+        }
+
+        # If we have not already tried and the server supports it and we
+        # have a username -- lets try to authenticate.
+        #
+        if {![info exists state(auth)]
+            && [llength [package provide SASL]] != 0
+            && [set andx [lsearch -glob $response(args) "AUTH*"]] >= 0
+            && [string length $options(-username)] > 0 } {
+
+            # May be AUTH mech or AUTH=mech
+            # We want to use the strongest mechanism that has been offered
+            # and that we support. If we cannot find a mechanism that
+            # succeeds, we will go ahead and try to carry on unauthenticated.
+            # This may still work else we'll get an unauthorised error later.
+
+            set mechs [string range [lindex $response(args) $andx] 5 end]
+            foreach mech [SASL::mechanisms] {
+                if {[lsearch -exact $mechs $mech] == -1} { continue }
+                if {[catch {
+                    Authenticate $token $mech
+                } msg]} {
+                    if {$options(-debug)} {
+                        puts stderr "AUTH $mech failed: $msg "
+                        flush stderr
+                    }
+                }
+                if {[info exists state(auth)] && $state(auth)} {
+                    if {$state(auth) == 1} {
+                        break
+                    } else {
+                        # After successful AUTH we are supposed to redo
+                        # our connection for mechanisms that setup a new
+                        # security layer -- these should set state(auth)
+                        # greater than 1
+                        fileevent $state(sd) readable \
+                            [list ::smtp::readable $token]
+                        return [initialize_ehlo $token]
+                    }
+                }
+            }
+        }
+
+        return $token
+    } else {
+        # Bad response; close the connection and hope the next server
+        # is happier.
+        catch {close $state(sd)}
+    }
+    return {}
+}
+
+proc ::smtp::SASLCallback {token context command args} {
+    upvar #0 $token state
+    upvar #0 $context ctx
+    array set options $state(options)
+    switch -exact -- $command {
+        login    { return "" }
+        username { return $options(-username) }
+        password { return $options(-password) }
+        hostname { return [info host] }
+        realm    {
+            if {[string equal $ctx(mech) "NTLM"] \
+                    && [info exists ::env(USERDOMAIN)]} {
+                return $::env(USERDOMAIN)
+            } else {
+                return ""
+            }
+        }
+        default  {
+            return -code error "error: unsupported SASL information requested"
+        }
+    }
+}
+
+proc ::smtp::Authenticate {token mechanism} {
+    upvar 0 $token state
+    package require base64
+    set ctx [SASL::new -mechanism $mechanism \
+                 -callback [list [namespace origin SASLCallback] $token]]
+
+    set state(auth) 0
+    set result [smtp::talk $token 300 "AUTH $mechanism"]
+    array set response $result
+
+    while {$response(code) == 334} {
+        # The NTLM initial response is not base64 encoded so handle it.
+        if {[catch {base64::decode $response(diagnostic)} challenge]} {
+            set challenge $response(diagnostic)
+        }
+        SASL::step $ctx $challenge
+        set result [smtp::talk $token 300 \
+                        [base64::encode -maxlen 0 [SASL::response $ctx]]]
+        array set response $result
+    }
+
+    if {$response(code) == 235} {
+        set state(auth) 1
+        return $result
+    } else {
+        return -code 7 $result
+    }
+}
+
+# ::smtp::finalize --
+#
+#	Deletes an SMTP token by closing the connection to the SMTP server,
+#       cleanup up various state.
+#
+# Arguments:
+#       token   SMTP token that has an open connection to the SMTP server.
+#       args    Optional arguments, where the only useful option is -close,
+#               whose valid values are the following:
+#               orderly     Normal successful completion.  Close connection and
+#                           clear state variables.
+#               abort       A connection exists to the SMTP server, but it's in
+#                           a weird state and needs to be reset before being
+#                           closed.  Then clear state variables.
+#               drop        No connection exists, so we just need to clean up
+#                           state variables.
+#
+# Results:
+#	SMTP connection is closed and state variables are cleared.  If there's
+#       an error while attempting to close the connection to the SMTP server,
+#       throw an exception with the error code and error message.
+
+proc ::smtp::finalize {token args} {
+    global errorCode errorInfo
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    array set options [list -close orderly]
+    array set options $args
+
+    switch -- $options(-close) {
+        orderly {
+            set code [catch { talk $token 120 QUIT } result]
+        }
+
+        abort {
+            set code [catch {
+                talk $token 0 RSET
+                talk $token 0 QUIT
+            } result]
+        }
+
+        drop {
+            set code 0
+            set result ""
+        }
+
+        default {
+            error "unknown value for -close $options(-close)"
+        }
+    }
+    set ecode $errorCode
+    set einfo $errorInfo
+
+    catch { close $state(sd) }
+
+    if {$state(afterID) != ""} {
+        catch { after cancel $state(afterID) }
+    }
+
+    foreach name [array names state] {
+        unset state($name)
+    }
+    # FRINK: nocheck
+    unset $token
+
+    return -code $code -errorinfo $einfo -errorcode $ecode $result
+}
+
+# ::smtp::winit --
+#
+#	Send originator info to SMTP server.  This occurs after HELO/EHLO
+#       command has completed successfully (in ::smtp::initialize).  This function
+#       is called by ::smtp::sendmessageaux.
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#       part        MIME token for the message to be sent. May be used for
+#                   handling some SMTP extensions.
+#       originator  The e-mail address of the entity sending the message,
+#                   usually the From clause.
+#       mode        SMTP command specifying the mode of communication.  Default
+#                   value is MAIL.
+#
+# Results:
+#	Originator info is sent and SMTP server's response is returned.  If an
+#       error occurs, throw an exception.
+
+proc ::smtp::winit {token part originator {mode MAIL}} {
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    if {[lsearch -exact [list MAIL SEND SOML SAML] $mode] < 0} {
+        error "unknown origination mode $mode"
+    }
+
+    set from "$mode FROM:<$originator>"
+
+    # RFC 1870 -  SMTP Service Extension for Message Size Declaration
+    if {[info exists state(esmtp)]
+        && [lsearch -glob $state(esmtp) "SIZE*"] != -1} {
+        catch {
+            set size [string length [mime::buildmessage $part]]
+            append from " SIZE=$size"
+        }
+    }
+
+    array set response [set result [talk $token 600 $from]]
+
+    if {$response(code) == 250} {
+        set state(addrs) 0
+        return $result
+    } else {
+        return -code 7 $result
+    }
+}
+
+# ::smtp::waddr --
+#
+#	Send recipient info to SMTP server.  This occurs after originator info
+#       is sent (in ::smtp::winit).  This function is called by
+#       ::smtp::sendmessageaux.
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#       recipient   One of the recipients to whom the message should be
+#                   delivered.
+#
+# Results:
+#	Recipient info is sent and SMTP server's response is returned.  If an
+#       error occurs, throw an exception.
+
+proc ::smtp::waddr {token recipient} {
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    set result [talk $token 3600 "RCPT TO:<$recipient>"]
+    array set response $result
+
+    switch -- $response(code) {
+        250 - 251 {
+            incr state(addrs)
+            return $result
+        }
+
+        default {
+            return -code 7 $result
+        }
+    }
+}
+
+# ::smtp::wtext --
+#
+#	Send message to SMTP server.  This occurs after recipient info
+#       is sent (in ::smtp::winit).  This function is called by
+#       ::smtp::sendmessageaux.
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#	part        The MIME object containing the message to send.
+#
+# Results:
+#	MIME message is sent and SMTP server's response is returned.  If an
+#       error occurs, throw an exception.
+
+proc ::smtp::wtext {token part} {
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+    array set options $state(options)
+
+    set result [talk $token 300 DATA]
+    array set response $result
+    if {$response(code) != 354} {
+        return -code 7 $result
+    }
+
+    if {[catch { wtextaux $token $part } result]} {
+        catch { puts -nonewline $state(sd) "\r\n.\r\n" ; flush $state(sd) }
+        return -code 7 [list code 400 diagnostic $result]
+    }
+
+    set secs $options(-maxsecs)
+
+    set result [talk $token $secs .]
+    array set response $result
+    switch -- $response(code) {
+        250 - 251 {
+            return $result
+        }
+
+        default {
+            return -code 7 $result
+        }
+    }
+}
+
+# ::smtp::wtextaux --
+#
+#	Helper function that coordinates writing the MIME message to the socket.
+#       In particular, it stacks the channel leading to the SMTP server, sets up
+#       some file events, sends the message, unstacks the channel, resets the
+#       file events to their original state, and returns.
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#	part        The MIME object containing the message to send.
+#
+# Results:
+#	Message is sent.  If anything goes wrong, throw an exception.
+
+proc ::smtp::wtextaux {token part} {
+    global errorCode errorInfo
+
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    # Workaround a bug with stacking channels on top of TLS.
+    # FRINK: nocheck
+    set trf [set [namespace current]::trf]
+    if {[info exists state(tls)] && $state(tls)} {
+        set trf 0
+    }
+
+    flush $state(sd)
+    fileevent $state(sd) readable ""
+    if {$trf} {
+        transform -attach $state(sd) -command [list ::smtp::wdata $token]
+        fconfigure $state(sd) -blocking on
+    } else {
+        set state(size) 1
+    }
+    fileevent $state(sd) readable [list ::smtp::readable $token]
+
+    # If trf is not available, get the contents of the message,
+    # replace all '.'s that start their own line with '..'s, and
+    # then write the mime body out to the filehandle. Do not forget to
+    # deal with bare LF's here too (SF bug #499242).
+
+    if {$trf} {
+        set code [catch { ::mime::copymessage $part $state(sd) } result]
+    } else {
+        set code [catch { ::mime::buildmessage $part } result]
+        if {$code == 0} {
+	    # Detect and transform bare LF's into proper CR/LF
+	    # sequences.
+
+	    while {[regsub -all -- {([^\r])\n} $result "\\1\r\n" result]} {}
+            regsub -all -- {\n\.}      $result "\n.."   result
+
+            # Fix for bug #827436 - mail data must end with CRLF.CRLF
+            if {[string compare [string index $result end] "\n"] != 0} {
+                append result "\r\n"
+            }
+            set state(size) [string length $result]
+            puts -nonewline $state(sd) $result
+            set result ""
+	}
+    }
+    set ecode $errorCode
+    set einfo $errorInfo
+
+    flush $state(sd)
+    fileevent $state(sd) readable ""
+    if {$trf} {
+        unstack $state(sd)
+        fconfigure $state(sd) -blocking off
+    }
+    fileevent $state(sd) readable [list ::smtp::readable $token]
+
+    return -code $code -errorinfo $einfo -errorcode $ecode $result
+}
+
+# ::smtp::wdata --
+#
+#	This is the custom transform using Trf to do CR/LF translation.  If Trf
+#       is not installed on the system, then this function never gets called and
+#       no translation occurs.
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#       command     Trf provided command for manipulating socket data.
+#	buffer      Data to be converted.
+#
+# Results:
+#	buffer is translated, and state(size) is set.  If Trf is not installed
+#       on the system, the transform proc defined at the top of this file sets
+#       state(size) to 1.  state(size) is used later to determine a timeout
+#       value.
+
+proc ::smtp::wdata {token command buffer} {
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    switch -- $command {
+        create/write -
+        clear/write  -
+        delete/write {
+            set state(crP) 0
+            set state(nlP) 1
+            set state(size) 0
+        }
+
+        write {
+            set result ""
+
+            foreach c [split $buffer ""] {
+                switch -- $c {
+                    "." {
+                        if {$state(nlP)} {
+                            append result .
+                        }
+                        set state(crP) 0
+                        set state(nlP) 0
+                    }
+
+                    "\r" {
+                        set state(crP) 1
+                        set state(nlP) 0
+                    }
+
+                    "\n" {
+                        if {!$state(crP)} {
+                            append result "\r"
+                        }
+                        set state(crP) 0
+                        set state(nlP) 1
+                    }
+
+                    default {
+                        set state(crP) 0
+                        set state(nlP) 0
+                    }
+                }
+
+                append result $c
+            }
+
+            incr state(size) [string length $result]
+            return $result
+        }
+
+        flush/write {
+            set result ""
+
+            if {!$state(nlP)} {
+                if {!$state(crP)} {
+                    append result "\r"
+                }
+                append result "\n"
+            }
+
+            incr state(size) [string length $result]
+            return $result
+        }
+
+	create/read -
+        delete/read {
+	    # Bugfix for [#539952]
+        }
+
+	query/ratio {
+	    # Indicator for unseekable channel,
+	    # for versions of Trf which ask for
+	    # this.
+	    return {0 0}
+	}
+	query/maxRead {
+	    # No limits on reading bytes from the channel below, for
+	    # versions of Trf which ask for this information
+	    return -1
+	}
+
+	default {
+	    # Silently pass all unknown commands.
+	    #error "Unknown command \"$command\""
+	}
+    }
+
+    return ""
+}
+
+# ::smtp::talk --
+#
+#	Sends an SMTP command to a server
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#	secs        Timeout after which command should be aborted.
+#       command     Command to send to SMTP server.
+#
+# Results:
+#	command is sent and response is returned.  If anything goes wrong, throw
+#       an exception.
+
+proc ::smtp::talk {token secs command} {
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    array set options $state(options)
+
+    if {$options(-debug)} {
+        puts stderr "--> $command (wait upto $secs seconds)"
+        flush stderr
+    }
+
+    if {[catch { puts -nonewline $state(sd) "$command\r\n"
+                 flush $state(sd) } result]} {
+        return [list code 400 diagnostic $result]
+    }
+
+    if {$secs == 0} {
+        return ""
+    }
+
+    return [hear $token $secs]
+}
+
+# ::smtp::hear --
+#
+#	Listens for SMTP server's response to some prior command.
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#	secs        Timeout after which we should stop waiting for a response.
+#
+# Results:
+#	Response is returned.
+
+proc ::smtp::hear {token secs} {
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    array set options $state(options)
+
+    array set response [list args ""]
+
+    set firstP 1
+    while {1} {
+        if {$secs >= 0} {
+	    ## SF [ 836442 ] timeout with large data
+	    ## correction, aotto 031105 -
+	    if {$secs > 600} {set secs 600}
+            set state(afterID) [after [expr {$secs*1000}] \
+                                      [list ::smtp::timer $token]]
+        }
+
+        if {!$state(readable)} {
+            vwait ${token}(readable)
+        }
+
+        # Wait until socket is readable.
+        if {$state(readable) !=  -1} {
+            catch { after cancel $state(afterID) }
+            set state(afterID) ""
+        }
+
+        if {$state(readable) < 0} {
+            array set response [list code 400 diagnostic $state(error)]
+            break
+        }
+        set state(readable) 0
+
+        if {$options(-debug)} {
+            puts stderr "<-- $state(line)"
+            flush stderr
+        }
+
+        if {[string length $state(line)] < 3} {
+            array set response \
+                  [list code 500 \
+                        diagnostic "response too short: $state(line)"]
+            break
+        }
+
+        if {$firstP} {
+            set firstP 0
+
+            if {[scan [string range $state(line) 0 2] %d response(code)] \
+                    != 1} {
+                array set response \
+                      [list code 500 \
+                            diagnostic "unrecognizable code: $state(line)"]
+                break
+            }
+
+            set response(diagnostic) \
+                [string trim [string range $state(line) 4 end]]
+        } else {
+            lappend response(args) \
+                    [string trim [string range $state(line) 4 end]]
+        }
+
+        # When status message line ends in -, it means the message is complete.
+
+        if {[string compare [string index $state(line) 3] -]} {
+            break
+        }
+    }
+
+    return [array get response]
+}
+
+# ::smtp::readable --
+#
+#	Reads a line of data from SMTP server when the socket is readable.  This
+#       is the callback of "fileevent readable".
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#
+# Results:
+#	state(line) contains the line of data and state(readable) is reset.
+#       state(readable) gets the following values:
+#       -3  if there's a premature eof,
+#       -2  if reading from socket fails.
+#       1   if reading from socket was successful
+
+proc ::smtp::readable {token} {
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    if {[catch { array set options $state(options) }]} {
+        return
+    }
+
+    set state(line) ""
+    if {[catch { gets $state(sd) state(line) } result]} {
+        set state(readable) -2
+        set state(error) $result
+    } elseif {$result == -1} {
+        if {[eof $state(sd)]} {
+            set state(readable) -3
+            set state(error) "premature end-of-file from server"
+        }
+    } else {
+        # If the line ends in \r, remove the \r.
+        if {![string compare [string index $state(line) end] "\r"]} {
+            set state(line) [string range $state(line) 0 end-1]
+        }
+        set state(readable) 1
+    }
+
+    if {$state(readable) < 0} {
+        if {$options(-debug)} {
+            puts stderr "    ... $state(error) ..."
+            flush stderr
+        }
+
+        catch { fileevent $state(sd) readable "" }
+    }
+}
+
+# ::smtp::timer --
+#
+#	Handles timeout condition on any communication with the SMTP server.
+#
+# Arguments:
+#       token       SMTP token that has an open connection to the SMTP server.
+#
+# Results:
+#	Sets state(readable) to -1 and state(error) to an error message.
+
+proc ::smtp::timer {token} {
+    # FRINK: nocheck
+    variable $token
+    upvar 0 $token state
+
+    array set options $state(options)
+
+    set state(afterID) ""
+    set state(readable) -1
+    set state(error) "read from server timed out"
+
+    if {$options(-debug)} {
+        puts stderr "    ... $state(error) ..."
+        flush stderr
+    }
+}
+
+# ::smtp::boolean --
+#
+#	Helper function for unifying boolean values to 1 and 0.
+#
+# Arguments:
+#       value   Some kind of value that represents true or false (i.e. 0, 1,
+#               false, true, no, yes, off, on).
+#
+# Results:
+#	Return 1 if the value is true, 0 if false.  If the input value is not
+#       one of the above, throw an exception.
+
+proc ::smtp::boolean {value} {
+    switch -- [string tolower $value] {
+        0 - false - no - off {
+            return 0
+        }
+
+        1 - true - yes - on {
+            return 1
+        }
+
+        default {
+            error "unknown boolean value: $value"
+        }
+    }
+}
+
+# -------------------------------------------------------------------------
+
+package provide smtp 1.5.1
+
+# -------------------------------------------------------------------------
+# Local variables:
+# indent-tabs-mode: nil
+# End:
diff --git a/src/build.tcl b/src/build.tcl
index ee541f5b..734ccb87 100644
--- a/src/build.tcl
+++ b/src/build.tcl
@@ -1,6 +1,6 @@
 #!/bin/sh
 # -*- tcl -*- \
 # 'build.tcl' name as required by kettle
-# Can be run directly - but also using `pmix Kettle ...`  or `pmix KettleShell  ...`\
+# Can be run directly - but also using `deck Kettle ...`  or `deck KettleShell  ...`\
 exec ./kettle -f "$0" "${1+$@}"
 kettle doc
diff --git a/src/modules/punk/mix/templates/layouts/project/src/buildsuites/samplesuite1/tcl/empty_project_source.txt b/src/decktemplates/custom/_project/layout_refs/@custom+_project+punk.shell-0.1.ref
similarity index 100%
rename from src/modules/punk/mix/templates/layouts/project/src/buildsuites/samplesuite1/tcl/empty_project_source.txt
rename to src/decktemplates/custom/_project/layout_refs/@custom+_project+punk.shell-0.1.ref
diff --git a/src/modules/punk/mix/templates/layouts/project/src/buildsuites/samplesuite1/tk/empty_project_source.txt b/src/decktemplates/custom/_project/layout_refs/test1@vendor+punk+sample-0.1.ref
similarity index 100%
rename from src/modules/punk/mix/templates/layouts/project/src/buildsuites/samplesuite1/tk/empty_project_source.txt
rename to src/decktemplates/custom/_project/layout_refs/test1@vendor+punk+sample-0.1.ref
diff --git a/src/decktemplates/vendor/_project/layout_refs/@vendor+_project+punk.shell-0.1.ref b/src/decktemplates/vendor/_project/layout_refs/@vendor+_project+punk.shell-0.1.ref
new file mode 100644
index 00000000..e69de29b
diff --git a/src/decktemplates/vendor/_project/layout_refs/test2@vendor+punk+sample-0.1.ref b/src/decktemplates/vendor/_project/layout_refs/test2@vendor+punk+sample-0.1.ref
new file mode 100644
index 00000000..e69de29b
diff --git a/src/decktemplates/vendor/punk/layout_refs/@vendor+punk+basic.ref b/src/decktemplates/vendor/punk/layout_refs/@vendor+punk+basic.ref
new file mode 100644
index 00000000..e69de29b
diff --git a/src/decktemplates/vendor/punk/layout_refs/@vendor+punk+minimal.ref b/src/decktemplates/vendor/punk/layout_refs/@vendor+punk+minimal.ref
new file mode 100644
index 00000000..e69de29b
diff --git a/src/decktemplates/vendor/punk/layout_refs/@vendor+punk+sample-0.1.ref b/src/decktemplates/vendor/punk/layout_refs/@vendor+punk+sample-0.1.ref
new file mode 100644
index 00000000..e69de29b
diff --git a/src/decktemplates/vendor/punk/layout_refs/project@vendor+punk+project-0.1.ref b/src/decktemplates/vendor/punk/layout_refs/project@vendor+punk+project-0.1.ref
new file mode 100644
index 00000000..e69de29b
diff --git a/src/decktemplates/vendor/punk/modules/template_module-0.0.2.tm b/src/decktemplates/vendor/punk/modules/template_module-0.0.2.tm
index bde17848..f8f01847 100644
--- a/src/decktemplates/vendor/punk/modules/template_module-0.0.2.tm
+++ b/src/decktemplates/vendor/punk/modules/template_module-0.0.2.tm
@@ -108,10 +108,15 @@ namespace eval %pkg% {
 
 
 
-    #proc sample1 {p1 args} {
+    #proc sample1 {p1 n args} {
     #    #*** !doctools
-    #    #[call [fun sample1] [arg p1] [opt {option value...}]]
+    #    #[call [fun sample1] [arg p1] [arg n] [opt {option value...}]]
     #    #[para]Description of sample1 
+    #    #[para] Arguments:
+    #    #   [list_begin arguments]
+    #    #   [arg_def tring p1]       A description of string argument p1.
+    #    #   [arg_def integer n]      A description of integer argument n.
+    #    #   [list_end]
     #    return "ok" 
     #}
 
diff --git a/src/make.tcl b/src/make.tcl
index c01c9775..10d8e7ed 100644
--- a/src/make.tcl
+++ b/src/make.tcl
@@ -339,28 +339,28 @@ if {$::punkmake::command eq "bootsupport"} {
                 }
             }
 
-            foreach folder $bootsupport_module_folders {
-                #explicitly ignore punk/mix/templates folder even if specified in config. 
-                #punk/mix/templates contains modules including punk/mix/templates itself - the actual templates aren't needed for the bootsupport system,
-                # as make.tcl shouldn't be building new projects from the one being made.
-                #review.
-                #should we be autodetecting such recursive folder structures - (or is the bootsupport copying in need of a rethink?)
-                if {[string trim $folder /] eq "punk/mix/templates"} {
-                    puts stderr "IGNORING punk/mix/templates - not needed/desirable in bootsupport"
-                    continue
-                }
-                set src [file join $projectroot/modules $folder]
-                if {![file isdirectory $src]} {
-                    puts stderr "bootsupport folder not found: $src"
-                    continue
-                }
-                set tgt [file join $targetroot $folder]
-                file mkdir $tgt
+            if {[llength $bootsupport_module_folders] % 2 != 0} {
+                #todo - change include_modules.config structure to be line based? we have no way of verifying paired entries because we accept a flat list
+                puts stderr "WARNING - Skipping bootsupport_module_folders - list should be a list of base subpath pairs"
+            } else {
+                foreach {base subfolder} $bootsupport_module_folders {
+                    #user should be careful not to include recursive/cyclic structures e.g module that has a folder which contains other modules from this project
+                    #It will probably work somewhat.. but may make updates confusing.. or worse - start making deeper and deeper copies
+                    set src [file join $projectroot $base $subfolder]
+                    if {![file isdirectory $src]} {
+                        puts stderr "bootsupport folder not found: $src"
+                        continue
+                    }
+
+                    #subfolder is the common relative path - so don't include the base in the target path
+                    set tgt [file join $targetroot $subfolder]
+                    file mkdir $tgt
 
-                puts stdout "BOOTSUPPORT non_tm_files $src - copying to $tgt (if source file changed)"
-                set overwrite "installedsourcechanged-targets"
-                set resultdict [punkcheck::install_non_tm_files $src $tgt -installer make.tcl -overwrite $overwrite -punkcheck_folder $projectroot/src/bootsupport]
-                puts stdout [punkcheck::summarize_install_resultdict $resultdict]
+                    puts stdout "BOOTSUPPORT non_tm_files $src - copying to $tgt (if source file changed)"
+                    set overwrite "installedsourcechanged-targets"
+                    set resultdict [punkcheck::install_non_tm_files $src $tgt -installer make.tcl -overwrite $overwrite -punkcheck_folder $projectroot/src/bootsupport]
+                    puts stdout [punkcheck::summarize_install_resultdict $resultdict]
+                }
             }
 
         }
@@ -370,13 +370,13 @@ if {$::punkmake::command eq "bootsupport"} {
 
     #/modules/punk/mix/templates/layouts only applies if the project has it's own copy of the punk/mix modules. Generally this should only apply to the punkshell project itself.
     set layout_bases [list\
-        $sourcefolder/mixtemplates/layouts\
-        $sourcefolder/modules/punk/mix/templates/layouts\
+        $sourcefolder/project_layouts/custom/_project\
     ]
     foreach project_layout_base $layout_bases {
         if {[file exists $project_layout_base]} {
             set project_layouts [glob -nocomplain -dir $project_layout_base -type d -tail *]
             foreach layoutname $project_layouts {
+                #don't auto-create src/bootsupport - just update it if it exists
                 if {[file exists  [file join $project_layout_base $layoutname/src/bootsupport]]} {
                     set antipaths [list\
                         README.md\
@@ -451,61 +451,67 @@ if {[file exists $sourcefolder/vendormodules]} {
 #e.g The default project layout is mainly folder structure and readme files - but has some scripts developed under the main src that we want to sync
 #src to  src/modules/punk/mix/templates/layouts/project/src
 
-set layout_update_list    [list\
+set old_layout_update_list    [list\
     [list project $sourcefolder/modules/punk/mix/templates]\
     [list basic $sourcefolder/mixtemplates]\
     ]  
+set layout_bases    [list\
+    $sourcefolder/project_layouts/custom/_project\
+    ]  
 
-foreach layoutinfo $layout_update_list {
-    lassign $layoutinfo layout templatebase
-    if {![file exists $templatebase]} {
+foreach layoutbase $layout_bases {
+    if {![file exists $layoutbase]} {
         continue
     }
-    set config [dict create\
-        -make-step sync_templates\
-    ]
-    #----------
-    set tpl_installer [punkcheck::installtrack new make.tcl $templatebase/.punkcheck]
-    $tpl_installer set_source_target $sourcefolder $templatebase
-    set tpl_event [$tpl_installer start_event $config]
-    #----------
-    set pairs [list]
-    set pairs [list\
-        [list $sourcefolder/build.tcl  $templatebase/layouts/$layout/src/build.tcl]\
-        [list $sourcefolder/make.tcl  $templatebase/layouts/$layout/src/make.tcl]\
-    ]
-
-    foreach filepair $pairs {
-        lassign $filepair srcfile tgtfile
-        file mkdir [file dirname $tgtfile]
+    set project_layouts [glob -nocomplain -dir $layoutbase -type d -tail *]
+    foreach layoutname $project_layouts {
+        set config [dict create\
+            -make-step sync_layouts\
+        ]
         #----------
-        $tpl_event targetset_init INSTALL   $tgtfile
-        $tpl_event targetset_addsource      $srcfile
+        set tpl_installer [punkcheck::installtrack new make.tcl $layoutbase/.punkcheck]
+        $tpl_installer set_source_target $sourcefolder $layoutbase
+        set tpl_event [$tpl_installer start_event $config]
         #----------
-        if {\
-               [llength [dict get [$tpl_event targetset_source_changes] changed]]\
-            || [llength [$tpl_event get_targets_exist]] < [llength [$tpl_event get_targets]]\
-            } {
-            $tpl_event targetset_started
-            # -- --- --- --- --- ---
-            puts stdout "punk module templates: Copying from $srcfile to $tgtfile"
-            if {[catch {
-                file copy -force $srcfile $tgtfile
-            } errM]} {
-                $tpl_event targetset_end FAILED -note "copy failed with err: $errM"
+        set pairs [list]
+        set pairs [list\
+            [list $sourcefolder/build.tcl  $layoutbase/$layoutname/src/build.tcl]\
+            [list $sourcefolder/make.tcl  $layoutbase/$layoutname/src/make.tcl]\
+        ]
+
+        foreach filepair $pairs {
+            lassign $filepair srcfile tgtfile
+
+            file mkdir [file dirname $tgtfile]
+            #----------
+            $tpl_event targetset_init INSTALL   $tgtfile
+            $tpl_event targetset_addsource      $srcfile
+            #----------
+            if {\
+                [llength [dict get [$tpl_event targetset_source_changes] changed]]\
+                || [llength [$tpl_event get_targets_exist]] < [llength [$tpl_event get_targets]]\
+                } {
+                $tpl_event targetset_started
+                # -- --- --- --- --- ---
+                puts stdout "PROJECT LAYOUT update - layoutname: $layoutname Copying from $srcfile to $tgtfile"
+                if {[catch {
+                    file copy -force $srcfile $tgtfile
+                } errM]} {
+                    $tpl_event targetset_end FAILED -note "layout:$layoutname copy failed with err: $errM"
+                } else {
+                    $tpl_event targetset_end OK -note "layout:$layoutname"
+                }
+                # -- --- --- --- --- ---
             } else {
-                $tpl_event targetset_end OK -note "test"
+                puts stderr "."
+                $tpl_event targetset_end SKIPPED
             }
-            # -- --- --- --- --- ---
-        } else {
-            puts stderr "."
-            $tpl_event targetset_end SKIPPED
         }
-    }
 
-    $tpl_event end
-    $tpl_event destroy
-    $tpl_installer destroy
+        $tpl_event end
+        $tpl_event destroy
+        $tpl_installer destroy
+    }
 }
 ########################################################
 
@@ -658,7 +664,7 @@ if {[file exists $mapfile]} {
 
 set vfs_folders [glob -nocomplain -dir $sourcefolder -types d -tail *.vfs]
 #add any extra .vfs folders found in runtime/mapvfs.config file (e.g myotherruntimes/something.vfs)
-foreach vfs [dict keys $vfs_runtime_map] {
+dict for {vfs -} $vfs_runtime_map {
     if {$vfs ni $vfs_folders} {
         lappend vfs_folders $vfs
     }
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/README.md b/src/mixtemplates/layouts/basic/src/bootsupport/README.md
deleted file mode 100644
index f1f51421..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/README.md
+++ /dev/null
@@ -1 +0,0 @@
-bootsupport libs and modules
\ No newline at end of file
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/cksum-1.1.4.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/cksum-1.1.4.tm
deleted file mode 100644
index 0fb17981..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/cksum-1.1.4.tm
+++ /dev/null
@@ -1,200 +0,0 @@
-# cksum.tcl - Copyright (C) 2002 Pat Thoyts <patthoyts@users.sourceforge.net>
-#
-# Provides a Tcl only implementation of the unix cksum(1) command. This is
-# similar to the sum(1) command but the algorithm is better defined and
-# standardized across multiple platforms by POSIX 1003.2/D11.2
-#
-# This command has been verified against the cksum command from the GNU
-# textutils package version 2.0
-#
-# -------------------------------------------------------------------------
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-# -------------------------------------------------------------------------
-
-package require Tcl 8.5-;                # tcl minimum version
-
-namespace eval ::crc {
-    namespace export cksum
-
-    variable cksum_tbl [list 0x0 \
-           0x04C11DB7 0x09823B6E 0x0D4326D9 0x130476DC 0x17C56B6B \
-           0x1A864DB2 0x1E475005 0x2608EDB8 0x22C9F00F 0x2F8AD6D6 \
-           0x2B4BCB61 0x350C9B64 0x31CD86D3 0x3C8EA00A 0x384FBDBD \
-           0x4C11DB70 0x48D0C6C7 0x4593E01E 0x4152FDA9 0x5F15ADAC \
-           0x5BD4B01B 0x569796C2 0x52568B75 0x6A1936C8 0x6ED82B7F \
-           0x639B0DA6 0x675A1011 0x791D4014 0x7DDC5DA3 0x709F7B7A \
-           0x745E66CD 0x9823B6E0 0x9CE2AB57 0x91A18D8E 0x95609039 \
-           0x8B27C03C 0x8FE6DD8B 0x82A5FB52 0x8664E6E5 0xBE2B5B58 \
-           0xBAEA46EF 0xB7A96036 0xB3687D81 0xAD2F2D84 0xA9EE3033 \
-           0xA4AD16EA 0xA06C0B5D 0xD4326D90 0xD0F37027 0xDDB056FE \
-           0xD9714B49 0xC7361B4C 0xC3F706FB 0xCEB42022 0xCA753D95 \
-           0xF23A8028 0xF6FB9D9F 0xFBB8BB46 0xFF79A6F1 0xE13EF6F4 \
-           0xE5FFEB43 0xE8BCCD9A 0xEC7DD02D 0x34867077 0x30476DC0 \
-           0x3D044B19 0x39C556AE 0x278206AB 0x23431B1C 0x2E003DC5 \
-           0x2AC12072 0x128E9DCF 0x164F8078 0x1B0CA6A1 0x1FCDBB16 \
-           0x018AEB13 0x054BF6A4 0x0808D07D 0x0CC9CDCA 0x7897AB07 \
-           0x7C56B6B0 0x71159069 0x75D48DDE 0x6B93DDDB 0x6F52C06C \
-           0x6211E6B5 0x66D0FB02 0x5E9F46BF 0x5A5E5B08 0x571D7DD1 \
-           0x53DC6066 0x4D9B3063 0x495A2DD4 0x44190B0D 0x40D816BA \
-           0xACA5C697 0xA864DB20 0xA527FDF9 0xA1E6E04E 0xBFA1B04B \
-           0xBB60ADFC 0xB6238B25 0xB2E29692 0x8AAD2B2F 0x8E6C3698 \
-           0x832F1041 0x87EE0DF6 0x99A95DF3 0x9D684044 0x902B669D \
-           0x94EA7B2A 0xE0B41DE7 0xE4750050 0xE9362689 0xEDF73B3E \
-           0xF3B06B3B 0xF771768C 0xFA325055 0xFEF34DE2 0xC6BCF05F \
-           0xC27DEDE8 0xCF3ECB31 0xCBFFD686 0xD5B88683 0xD1799B34 \
-           0xDC3ABDED 0xD8FBA05A 0x690CE0EE 0x6DCDFD59 0x608EDB80 \
-           0x644FC637 0x7A089632 0x7EC98B85 0x738AAD5C 0x774BB0EB \
-           0x4F040D56 0x4BC510E1 0x46863638 0x42472B8F 0x5C007B8A \
-           0x58C1663D 0x558240E4 0x51435D53 0x251D3B9E 0x21DC2629 \
-           0x2C9F00F0 0x285E1D47 0x36194D42 0x32D850F5 0x3F9B762C \
-           0x3B5A6B9B 0x0315D626 0x07D4CB91 0x0A97ED48 0x0E56F0FF \
-           0x1011A0FA 0x14D0BD4D 0x19939B94 0x1D528623 0xF12F560E \
-           0xF5EE4BB9 0xF8AD6D60 0xFC6C70D7 0xE22B20D2 0xE6EA3D65 \
-           0xEBA91BBC 0xEF68060B 0xD727BBB6 0xD3E6A601 0xDEA580D8 \
-           0xDA649D6F 0xC423CD6A 0xC0E2D0DD 0xCDA1F604 0xC960EBB3 \
-           0xBD3E8D7E 0xB9FF90C9 0xB4BCB610 0xB07DABA7 0xAE3AFBA2 \
-           0xAAFBE615 0xA7B8C0CC 0xA379DD7B 0x9B3660C6 0x9FF77D71 \
-           0x92B45BA8 0x9675461F 0x8832161A 0x8CF30BAD 0x81B02D74 \
-           0x857130C3 0x5D8A9099 0x594B8D2E 0x5408ABF7 0x50C9B640 \
-           0x4E8EE645 0x4A4FFBF2 0x470CDD2B 0x43CDC09C 0x7B827D21 \
-           0x7F436096 0x7200464F 0x76C15BF8 0x68860BFD 0x6C47164A \
-           0x61043093 0x65C52D24 0x119B4BE9 0x155A565E 0x18197087 \
-           0x1CD86D30 0x029F3D35 0x065E2082 0x0B1D065B 0x0FDC1BEC \
-           0x3793A651 0x3352BBE6 0x3E119D3F 0x3AD08088 0x2497D08D \
-           0x2056CD3A 0x2D15EBE3 0x29D4F654 0xC5A92679 0xC1683BCE \
-           0xCC2B1D17 0xC8EA00A0 0xD6AD50A5 0xD26C4D12 0xDF2F6BCB \
-           0xDBEE767C 0xE3A1CBC1 0xE760D676 0xEA23F0AF 0xEEE2ED18 \
-           0xF0A5BD1D 0xF464A0AA 0xF9278673 0xFDE69BC4 0x89B8FD09 \
-           0x8D79E0BE 0x803AC667 0x84FBDBD0 0x9ABC8BD5 0x9E7D9662 \
-           0x933EB0BB 0x97FFAD0C 0xAFB010B1 0xAB710D06 0xA6322BDF \
-           0xA2F33668 0xBCB4666D 0xB8757BDA 0xB5365D03 0xB1F740B4 ]
-
-    variable uid
-    if {![info exists uid]} {set uid 0}
-}
-
-# crc::CksumInit -- 
-#
-#	Create and initialize a cksum context. This is cleaned up when we
-#	call CksumFinal to obtain the result.
-#
-proc ::crc::CksumInit {} {
-    variable uid
-    set token [namespace current]::[incr uid]
-    upvar #0 $token state
-    array set state {t 0 l 0}
-    return $token
-}
-
-proc ::crc::CksumUpdate {token data} {
-    variable cksum_tbl
-    upvar #0 $token state
-    set t $state(t)
-    binary scan $data c* r
-    foreach {n} $r {
-        set index [expr { (($t >> 24) ^ ($n & 0xFF)) & 0xFF }]
-        # Since the introduction of built-in bigInt support with Tcl
-        # 8.5, bit-shifting $t to the left no longer overflows,
-        # keeping it 32 bits long.  The value grows bigger and bigger
-        # instead - a severe hit on performance.  For this reason we
-        # do a bitwise AND against 0xFFFFFFFF at each step to keep the
-        # value within limits.
-        set t [expr {0xFFFFFFFF & (($t << 8) ^ [lindex $cksum_tbl $index])}]
-        incr state(l)
-    }
-    set state(t) $t
-    return
-}
-
-proc ::crc::CksumFinal {token} {
-    variable cksum_tbl
-    upvar #0 $token state
-    set t $state(t)
-    for {set i $state(l)} {$i > 0} {set i [expr {$i>>8}]} {
-        set index [expr {(($t >> 24) ^ $i) & 0xFF}]
-        set t [expr {0xFFFFFFFF & (($t << 8) ^ [lindex $cksum_tbl $index])}]
-    }
-    unset state
-    return [expr {~$t & 0xFFFFFFFF}]
-}
-
-# crc::Pop --
-#
-#	Pop the nth element off a list. Used in options processing.
-#
-proc ::crc::Pop {varname {nth 0}} {
-    upvar $varname args
-    set r [lindex $args $nth]
-    set args [lreplace $args $nth $nth]
-    return $r
-}
-
-# Description:
-#  Provide a Tcl equivalent of the unix cksum(1) command.
-# Options:
-#  -filename name  - return a checksum for the specified file.
-#  -format string  - return the checksum using this format string.
-#  -chunksize size - set the chunking read size
-#
-proc ::crc::cksum {args} {
-    array set opts [list -filename {} -channel {} -chunksize 4096 \
-                        -format %u -command {}]
-    while {[string match -* [set option [lindex $args 0]]]} {
-        switch -glob -- $option {
-            -file*   { set opts(-filename) [Pop args 1] }
-            -chan*   { set opts(-channel) [Pop args 1] }
-            -chunk*  { set opts(-chunksize) [Pop args 1] }
-            -for*    { set opts(-format)   [Pop args 1] }
-            -command { set opts(-command)  [Pop args 1] }
-            default {
-                if {[llength $args] == 1} { break }
-                if {[string compare $option "--"] == 0} { Pop args ; break }
-                set err [join [lsort [array names opts -*]] ", "]
-                return -code error "bad option \"option\": must be $err"
-            }
-        }
-        Pop args
-    }
-
-    if {$opts(-filename) != {}} {
-        set opts(-channel) [open $opts(-filename) r]
-        fconfigure $opts(-channel) -translation binary
-    }
-
-    if {$opts(-channel) == {}} {
-
-        if {[llength $args] != 1} {
-            return -code error "wrong # args: should be\
-                cksum ?-format string?\
-                -channel chan | -filename file | string"
-        }
-        set tok [CksumInit]
-        CksumUpdate $tok [lindex $args 0]
-        set r [CksumFinal $tok]
-    
-    } else {
-
-        set tok [CksumInit]
-        while {![eof $opts(-channel)]} {
-            CksumUpdate $tok [read $opts(-channel) $opts(-chunksize)]
-        }
-        set r [CksumFinal $tok]
-
-        if {$opts(-filename) != {}} {
-            close $opts(-channel)
-        }
-    }
-
-    return [format $opts(-format) $r]
-}
-
-# -------------------------------------------------------------------------
-
-package provide cksum 1.1.4
-
-# -------------------------------------------------------------------------
-# Local variables:
-#   mode: tcl
-#   indent-tabs-mode: nil
-# End:
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/cmdline-1.5.2.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/cmdline-1.5.2.tm
deleted file mode 100644
index 4e5e1df9..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/cmdline-1.5.2.tm
+++ /dev/null
@@ -1,933 +0,0 @@
-# cmdline.tcl --
-#
-#	This package provides a utility for parsing command line
-#	arguments that are processed by our various applications.
-#	It also includes a utility routine to determine the
-#	application name for use in command line errors.
-#
-# Copyright (c) 1998-2000 by Ajuba Solutions.
-# Copyright (c) 2001-2015 by Andreas Kupries <andreas_kupries@users.sf.net>.
-# Copyright (c) 2003      by David N. Welton  <davidw@dedasys.com>
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-
-package require Tcl 8.5-
-package provide cmdline 1.5.2
-
-namespace eval ::cmdline {
-    namespace export getArgv0 getopt getKnownOpt getfiles getoptions \
-	    getKnownOptions usage
-}
-
-# ::cmdline::getopt --
-#
-#	The cmdline::getopt works in a fashion like the standard
-#	C based getopt function.  Given an option string and a
-#	pointer to an array or args this command will process the
-#	first argument and return info on how to proceed.
-#
-# Arguments:
-#	argvVar		Name of the argv list that you
-#			want to process.  If options are found the
-#			arg list is modified and the processed arguments
-#			are removed from the start of the list.
-#	optstring	A list of command options that the application
-#			will accept.  If the option ends in ".arg" the
-#			getopt routine will use the next argument as
-#			an argument to the option.  Otherwise the option
-#			is a boolean that is set to 1 if present.
-#	optVar		The variable pointed to by optVar
-#			contains the option that was found (without the
-#			leading '-' and without the .arg extension).
-#	valVar		Upon success, the variable pointed to by valVar
-#			contains the value for the specified option.
-#			This value comes from the command line for .arg
-#			options, otherwise the value is 1.
-#			If getopt fails, the valVar is filled with an
-#			error message.
-#
-# Results:
-# 	The getopt function returns 1 if an option was found, 0 if no more
-# 	options were found, and -1 if an error occurred.
-
-proc ::cmdline::getopt {argvVar optstring optVar valVar} {
-    upvar 1 $argvVar argsList
-    upvar 1 $optVar option
-    upvar 1 $valVar value
-
-    set result [getKnownOpt argsList $optstring option value]
-
-    if {$result < 0} {
-        # Collapse unknown-option error into any-other-error result.
-        set result -1
-    }
-    return $result
-}
-
-# ::cmdline::getKnownOpt --
-#
-#	The cmdline::getKnownOpt works in a fashion like the standard
-#	C based getopt function.  Given an option string and a
-#	pointer to an array or args this command will process the
-#	first argument and return info on how to proceed.
-#
-# Arguments:
-#	argvVar		Name of the argv list that you
-#			want to process.  If options are found the
-#			arg list is modified and the processed arguments
-#			are removed from the start of the list.  Note that
-#			unknown options and the args that follow them are
-#			left in this list.
-#	optstring	A list of command options that the application
-#			will accept.  If the option ends in ".arg" the
-#			getopt routine will use the next argument as
-#			an argument to the option.  Otherwise the option
-#			is a boolean that is set to 1 if present.
-#	optVar		The variable pointed to by optVar
-#			contains the option that was found (without the
-#			leading '-' and without the .arg extension).
-#	valVar		Upon success, the variable pointed to by valVar
-#			contains the value for the specified option.
-#			This value comes from the command line for .arg
-#			options, otherwise the value is 1.
-#			If getopt fails, the valVar is filled with an
-#			error message.
-#
-# Results:
-# 	The getKnownOpt function returns 1 if an option was found,
-#	0 if no more options were found, -1 if an unknown option was
-#	encountered, and -2 if any other error occurred.
-
-proc ::cmdline::getKnownOpt {argvVar optstring optVar valVar} {
-    upvar 1 $argvVar argsList
-    upvar 1 $optVar  option
-    upvar 1 $valVar  value
-
-    # default settings for a normal return
-    set value ""
-    set option ""
-    set result 0
-
-    # check if we're past the end of the args list
-    if {[llength $argsList] != 0} {
-
-	# if we got -- or an option that doesn't begin with -, return (skipping
-	# the --).  otherwise process the option arg.
-	switch -glob -- [set arg [lindex $argsList 0]] {
-	    "--" {
-		set argsList [lrange $argsList 1 end]
-	    }
-	    "--*" -
-	    "-*" {
-		set option [string range $arg 1 end]
-		if {[string equal [string range $option 0 0] "-"]} {
-		    set option [string range $arg 2 end]
-		}
-
-		# support for format: [-]-option=value
-		set idx [string first "=" $option 1]
-		if {$idx != -1} {
-		    set _val   [string range $option [expr {$idx+1}] end]
-		    set option [string range $option 0   [expr {$idx-1}]]
-		}
-
-		if {[lsearch -exact $optstring $option] != -1} {
-		    # Booleans are set to 1 when present
-		    set value 1
-		    set result 1
-		    set argsList [lrange $argsList 1 end]
-		} elseif {[lsearch -exact $optstring "$option.arg"] != -1} {
-		    set result 1
-		    set argsList [lrange $argsList 1 end]
-
-		    if {[info exists _val]} {
-			set value $_val
-		    } elseif {[llength $argsList]} {
-			set value [lindex $argsList 0]
-			set argsList [lrange $argsList 1 end]
-		    } else {
-			set value "Option \"$option\" requires an argument"
-			set result -2
-		    }
-		} else {
-		    # Unknown option.
-		    set value "Illegal option \"-$option\""
-		    set result -1
-		}
-	    }
-	    default {
-		# Skip ahead
-	    }
-	}
-    }
-
-    return $result
-}
-
-# ::cmdline::getoptions --
-#
-#	Process a set of command line options, filling in defaults
-#	for those not specified.  This also generates an error message
-#	that lists the allowed flags if an incorrect flag is specified.
-#
-# Arguments:
-#	argvVar		The name of the argument list, typically argv.
-#			We remove all known options and their args from it.
-#                       In other words, after the call to this command the
-#                       referenced variable contains only the non-options,
-#                       and unknown options.
-#	optlist		A list-of-lists where each element specifies an option
-#			in the form:
-#				(where flag takes no argument)
-#					flag comment
-#
-#				(or where flag takes an argument)
-#					flag default comment
-#
-#			If flag ends in ".arg" then the value is taken from the
-#			command line. Otherwise it is a boolean and appears in
-#			the result if present on the command line. If flag ends
-#			in ".secret", it will not be displayed in the usage.
-#	usage		Text to include in the usage display. Defaults to
-#			"options:"
-#
-# Results
-#	Name value pairs suitable for using with array set.
-#       A modified `argvVar`.
-
-proc ::cmdline::getoptions {argvVar optlist {usage options:}} {
-    upvar 1 $argvVar argv
-
-    set opts [GetOptionDefaults $optlist result]
-
-    set argc [llength $argv]
-    while {[set err [getopt argv $opts opt arg]]} {
-	if {$err < 0} {
-            set result(?) ""
-            break
-	}
-	set result($opt) $arg
-    }
-    if {[info exist result(?)] || [info exists result(help)]} {
-	Error [usage $optlist $usage] USAGE
-    }
-    return [array get result]
-}
-
-# ::cmdline::getKnownOptions --
-#
-#	Process a set of command line options, filling in defaults
-#	for those not specified.  This ignores unknown flags, but generates
-#	an error message that lists the correct usage if a known option
-#	is used incorrectly.
-#
-# Arguments:
-#	argvVar		The name of the argument list, typically argv.  This
-#			We remove all known options and their args from it.
-#                       In other words, after the call to this command the
-#                       referenced variable contains only the non-options,
-#                       and unknown options.
-#	optlist		A list-of-lists where each element specifies an option
-#			in the form:
-#				flag default comment
-#			If flag ends in ".arg" then the value is taken from the
-#			command line. Otherwise it is a boolean and appears in
-#			the result if present on the command line. If flag ends
-#			in ".secret", it will not be displayed in the usage.
-#	usage		Text to include in the usage display. Defaults to
-#			"options:"
-#
-# Results
-#	Name value pairs suitable for using with array set.
-#       A modified `argvVar`.
-
-proc ::cmdline::getKnownOptions {argvVar optlist {usage options:}} {
-    upvar 1 $argvVar argv
-
-    set opts [GetOptionDefaults $optlist result]
-
-    # As we encounter them, keep the unknown options and their
-    # arguments in this list.  Before we return from this procedure,
-    # we'll prepend these args to the argList so that the application
-    # doesn't lose them.
-
-    set unknownOptions [list]
-
-    set argc [llength $argv]
-    while {[set err [getKnownOpt argv $opts opt arg]]} {
-	if {$err == -1} {
-            # Unknown option.
-
-            # Skip over any non-option items that follow it.
-            # For now, add them to the list of unknownOptions.
-            lappend unknownOptions [lindex $argv 0]
-            set argv [lrange $argv 1 end]
-            while {([llength $argv] != 0) \
-                    && ![string match "-*" [lindex $argv 0]]} {
-                lappend unknownOptions [lindex $argv 0]
-                set argv [lrange $argv 1 end]
-            }
-	} elseif {$err == -2} {
-            set result(?) ""
-            break
-        } else {
-            set result($opt) $arg
-        }
-    }
-
-    # Before returning, prepend the any unknown args back onto the
-    # argList so that the application doesn't lose them.
-    set argv [concat $unknownOptions $argv]
-
-    if {[info exist result(?)] || [info exists result(help)]} {
-	Error [usage $optlist $usage] USAGE
-    }
-    return [array get result]
-}
-
-# ::cmdline::GetOptionDefaults --
-#
-#	This internal procedure processes the option list (that was passed to
-#	the getopt or getKnownOpt procedure).  The defaultArray gets an index
-#	for each option in the option list, the value of which is the option's
-#	default value.
-#
-# Arguments:
-#	optlist		A list-of-lists where each element specifies an option
-#			in the form:
-#				flag default comment
-#			If flag ends in ".arg" then the value is taken from the
-#			command line. Otherwise it is a boolean and appears in
-#			the result if present on the command line. If flag ends
-#			in ".secret", it will not be displayed in the usage.
-#	defaultArrayVar	The name of the array in which to put argument defaults.
-#
-# Results
-#	Name value pairs suitable for using with array set.
-
-proc ::cmdline::GetOptionDefaults {optlist defaultArrayVar} {
-    upvar 1 $defaultArrayVar result
-
-    set opts {? help}
-    foreach opt $optlist {
-	set name [lindex $opt 0]
-	if {[regsub -- {\.secret$} $name {} name] == 1} {
-	    # Need to hide this from the usage display and getopt
-	}
-	lappend opts $name
-	if {[regsub -- {\.arg$} $name {} name] == 1} {
-
-	    # Set defaults for those that take values.
-
-	    set default [lindex $opt 1]
-	    set result($name) $default
-	} else {
-	    # The default for booleans is false
-	    set result($name) 0
-	}
-    }
-    return $opts
-}
-
-# ::cmdline::usage --
-#
-#	Generate an error message that lists the allowed flags.
-#
-# Arguments:
-#	optlist		As for cmdline::getoptions
-#	usage		Text to include in the usage display. Defaults to
-#			"options:"
-#
-# Results
-#	A formatted usage message
-
-proc ::cmdline::usage {optlist {usage {options:}}} {
-    set str "[getArgv0] $usage\n"
-    set longest 20
-    set lines {}
-    foreach opt [concat $optlist \
-	     {{- "Forcibly stop option processing"} {help "Print this message"} {? "Print this message"}}] {
-	set name "-[lindex $opt 0]"
-	if {[regsub -- {\.secret$} $name {} name] == 1} {
-	    # Hidden option
-	    continue
-	}
-	if {[regsub -- {\.arg$} $name {} name] == 1} {
-	    append name " value"
-	    set desc "[lindex $opt 2] <[lindex $opt 1]>"
-	} else {
-	    set desc "[lindex $opt 1]"
-	}
-	set n [string length $name]
-	if {$n > $longest} { set longest $n }
-	# max not available before 8.5 - set longest [expr {max($longest, )}]
-	lappend lines $name $desc
-    }
-    foreach {name desc} $lines {
-	append str "[string trimright [format " %-*s %s" $longest $name $desc]]\n"
-    }
-
-    return $str
-}
-
-# ::cmdline::getfiles --
-#
-#	Given a list of file arguments from the command line, compute
-#	the set of valid files.  On windows, file globbing is performed
-#	on each argument.  On Unix, only file existence is tested.  If
-#	a file argument produces no valid files, a warning is optionally
-#	generated.
-#
-#	This code also uses the full path for each file.  If not
-#	given it prepends [pwd] to the filename.  This ensures that
-#	these files will never conflict with files in our zip file.
-#
-# Arguments:
-#	patterns	The file patterns specified by the user.
-#	quiet		If this flag is set, no warnings will be generated.
-#
-# Results:
-#	Returns the list of files that match the input patterns.
-
-proc ::cmdline::getfiles {patterns quiet} {
-    set result {}
-    if {$::tcl_platform(platform) == "windows"} {
-	foreach pattern $patterns {
-	    set pat [file join $pattern]
-	    set files [glob -nocomplain -- $pat]
-	    if {$files == {}} {
-		if {! $quiet} {
-		    puts stdout "warning: no files match \"$pattern\""
-		}
-	    } else {
-		foreach file $files {
-		    lappend result $file
-		}
-	    }
-	}
-    } else {
-	set result $patterns
-    }
-    set files {}
-    foreach file $result {
-	# Make file an absolute path so that we will never conflict
-	# with files that might be contained in our zip file.
-	set fullPath [file join [pwd] $file]
-
-	if {[file isfile $fullPath]} {
-	    lappend files $fullPath
-	} elseif {! $quiet} {
-	    puts stdout "warning: no files match \"$file\""
-	}
-    }
-    return $files
-}
-
-# ::cmdline::getArgv0 --
-#
-#	This command returns the "sanitized" version of argv0.  It will strip
-#	off the leading path and remove the ".bin" extensions that our apps
-#	use because they must be wrapped by a shell script.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	The application name that can be used in error messages.
-
-proc ::cmdline::getArgv0 {} {
-    global argv0
-
-    set name [file tail $argv0]
-    return [file rootname $name]
-}
-
-##
-# ### ### ### ######### ######### #########
-##
-# Now the typed versions of the above commands.
-##
-# ### ### ### ######### ######### #########
-##
-
-# typedCmdline.tcl --
-#
-#    This package provides a utility for parsing typed command
-#    line arguments that may be processed by various applications.
-#
-# Copyright (c) 2000 by Ross Palmer Mohn.
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: cmdline.tcl,v 1.28 2011/02/23 17:41:52 andreas_kupries Exp $
-
-namespace eval ::cmdline {
-    namespace export typedGetopt typedGetoptions typedUsage
-
-    # variable cmdline::charclasses --
-    #
-    #    Create regexp list of allowable character classes
-    #    from "string is" error message.
-    #
-    # Results:
-    #    String of character class names separated by "|" characters.
-
-    variable charclasses
-    #checker exclude badKey
-    catch {string is . .} charclasses
-    variable dummy
-    regexp      -- {must be (.+)$} $charclasses dummy charclasses
-    regsub -all -- {, (or )?}      $charclasses {|}   charclasses
-    unset dummy
-}
-
-# ::cmdline::typedGetopt --
-#
-#	The cmdline::typedGetopt works in a fashion like the standard
-#	C based getopt function.  Given an option string and a
-#	pointer to a list of args this command will process the
-#	first argument and return info on how to proceed. In addition,
-#	you may specify a type for the argument to each option.
-#
-# Arguments:
-#	argvVar		Name of the argv list that you want to process.
-#			If options are found, the arg list is modified
-#			and the processed arguments are removed from the
-#			start of the list.
-#
-#	optstring	A list of command options that the application
-#			will accept.  If the option ends in ".xxx", where
-#			xxx is any valid character class to the tcl
-#			command "string is", then typedGetopt routine will
-#			use the next argument as a typed argument to the
-#			option. The argument must match the specified
-#			character classes (e.g. integer, double, boolean,
-#			xdigit, etc.). Alternatively, you may specify
-#			".arg" for an untyped argument.
-#
-#	optVar		Upon success, the variable pointed to by optVar
-#			contains the option that was found (without the
-#			leading '-' and without the .xxx extension).  If
-#			typedGetopt fails the variable is set to the empty
-#			string. SOMETIMES! Different for each -value!
-#
-#	argVar		Upon success, the variable pointed to by argVar
-#			contains the argument for the specified option.
-#			If typedGetopt fails, the variable is filled with
-#			an error message.
-#
-# Argument type syntax:
-#	Option that takes no argument.
-#		foo
-#
-#	Option that takes a typeless argument.
-#		foo.arg
-#
-#	Option that takes a typed argument. Allowable types are all
-#	valid character classes to the tcl command "string is".
-#	Currently must be one of alnum, alpha, ascii, control,
-#	boolean, digit, double, false, graph, integer, lower, print,
-#	punct, space, true, upper, wordchar, or xdigit.
-#		foo.double
-#
-#	Option that takes an argument from a list.
-#		foo.(bar|blat)
-#
-# Argument quantifier syntax:
-#	Option that takes an optional argument.
-#		foo.arg?
-#
-#	Option that takes a list of arguments terminated by "--".
-#		foo.arg+
-#
-#	Option that takes an optional list of arguments terminated by "--".
-#		foo.arg*
-#
-#	Argument quantifiers work on all argument types, so, for
-#	example, the following is a valid option specification.
-#		foo.(bar|blat|blah)?
-#
-# Argument syntax miscellany:
-#	Options may be specified on the command line using a unique,
-#	shortened version of the option name. Given that program foo
-#	has an option list of {bar.alpha blah.arg blat.double},
-#	"foo -b fob" returns an error, but "foo -ba fob"
-#	successfully returns {bar fob}
-#
-# Results:
-#	The typedGetopt function returns one of the following:
-#	 1	a valid option was found
-#	 0	no more options found to process
-#	-1	invalid option
-#	-2	missing argument to a valid option
-#	-3	argument to a valid option does not match type
-#
-# Known Bugs:
-#	When using options which include special glob characters,
-#	you must use the exact option. Abbreviating it can cause
-#	an error in the "cmdline::prefixSearch" procedure.
-
-proc ::cmdline::typedGetopt {argvVar optstring optVar argVar} {
-    variable charclasses
-
-    upvar $argvVar argsList
-
-    upvar $optVar retvar
-    upvar $argVar optarg
-
-    # default settings for a normal return
-    set optarg ""
-    set retvar ""
-    set retval 0
-
-    # check if we're past the end of the args list
-    if {[llength $argsList] != 0} {
-
-        # if we got -- or an option that doesn't begin with -, return (skipping
-        # the --).  otherwise process the option arg.
-        switch -glob -- [set arg [lindex $argsList 0]] {
-            "--" {
-                set argsList [lrange $argsList 1 end]
-            }
-
-            "-*" {
-                # Create list of options without their argument extensions
-
-                set optstr ""
-                foreach str $optstring {
-                    lappend optstr [file rootname $str]
-                }
-
-                set _opt [string range $arg 1 end]
-
-                set i [prefixSearch $optstr [file rootname $_opt]]
-                if {$i != -1} {
-                    set opt [lindex $optstring $i]
-
-                    set quantifier "none"
-                    if {[regexp -- {\.[^.]+([?+*])$} $opt dummy quantifier]} {
-                        set opt [string range $opt 0 end-1]
-                    }
-
-                    if {[string first . $opt] == -1} {
-                        set retval 1
-                        set retvar $opt
-                        set argsList [lrange $argsList 1 end]
-
-                    } elseif {[regexp -- "\\.(arg|$charclasses)\$" $opt dummy charclass]
-                            || [regexp -- {\.\(([^)]+)\)} $opt dummy charclass]} {
-				if {[string equal arg $charclass]} {
-                            set type arg
-			} elseif {[regexp -- "^($charclasses)\$" $charclass]} {
-                            set type class
-                        } else {
-                            set type oneof
-                        }
-
-                        set argsList [lrange $argsList 1 end]
-                        set opt [file rootname $opt]
-
-                        while {1} {
-                            if {[llength $argsList] == 0
-                                    || [string equal "--" [lindex $argsList 0]]} {
-                                if {[string equal "--" [lindex $argsList 0]]} {
-                                    set argsList [lrange $argsList 1 end]
-                                }
-
-                                set oneof ""
-                                if {$type == "arg"} {
-                                    set charclass an
-                                } elseif {$type == "oneof"} {
-                                    set oneof ", one of $charclass"
-                                    set charclass an
-                                }
-
-                                if {$quantifier == "?"} {
-                                    set retval 1
-                                    set retvar $opt
-                                    set optarg ""
-                                } elseif {$quantifier == "+"} {
-                                    set retvar $opt
-                                    if {[llength $optarg] < 1} {
-                                        set retval -2
-                                        set optarg "Option requires at least one $charclass argument$oneof -- $opt"
-                                    } else {
-                                        set retval 1
-                                    }
-                                } elseif {$quantifier == "*"} {
-                                    set retval 1
-                                    set retvar $opt
-                                } else {
-                                    set optarg "Option requires $charclass argument$oneof -- $opt"
-                                    set retvar $opt
-                                    set retval -2
-                                }
-                                set quantifier ""
-                            } elseif {($type == "arg")
-                                    || (($type == "oneof")
-                                    && [string first "|[lindex $argsList 0]|" "|$charclass|"] != -1)
-                                    || (($type == "class")
-                                    && [string is $charclass [lindex $argsList 0]])} {
-                                set retval 1
-                                set retvar $opt
-                                lappend optarg [lindex $argsList 0]
-                                set argsList [lrange $argsList 1 end]
-                            } else {
-                                set oneof ""
-                                if {$type == "arg"} {
-                                    set charclass an
-                                } elseif {$type == "oneof"} {
-                                    set oneof ", one of $charclass"
-                                    set charclass an
-                                }
-                                set optarg "Option requires $charclass argument$oneof -- $opt"
-                                set retvar $opt
-                                set retval -3
-
-                                if {$quantifier == "?"} {
-                                    set retval 1
-                                    set optarg ""
-                                }
-                                set quantifier ""
-                            }
-                             if {![regexp -- {[+*]} $quantifier]} {
-                                break;
-                            }
-                        }
-                    } else {
-                        Error \
-			    "Illegal option type specification: must be one of $charclasses" \
-			    BAD OPTION TYPE
-                    }
-                } else {
-                    set optarg "Illegal option -- $_opt"
-                    set retvar $_opt
-                    set retval -1
-                }
-            }
-	    default {
-		# Skip ahead
-	    }
-        }
-    }
-
-    return $retval
-}
-
-# ::cmdline::typedGetoptions --
-#
-#	Process a set of command line options, filling in defaults
-#	for those not specified. This also generates an error message
-#	that lists the allowed options if an incorrect option is
-#	specified.
-#
-# Arguments:
-#	argvVar		The name of the argument list, typically argv
-#	optlist		A list-of-lists where each element specifies an option
-#			in the form:
-#
-#				option default comment
-#
-#			Options formatting is as described for the optstring
-#			argument of typedGetopt. Default is for optionally
-#			specifying a default value. Comment is for optionally
-#			specifying a comment for the usage display. The
-#			options "--", "-help", and "-?" are automatically included
-#			in optlist.
-#
-# Argument syntax miscellany:
-#	Options formatting and syntax is as described in typedGetopt.
-#	There are two additional suffixes that may be applied when
-#	passing options to typedGetoptions.
-#
-#	You may add ".multi" as a suffix to any option. For options
-#	that take an argument, this means that the option may be used
-#	more than once on the command line and that each additional
-#	argument will be appended to a list, which is then returned
-#	to the application.
-#		foo.double.multi
-#
-#	If a non-argument option is specified as ".multi", it is
-#	toggled on and off for each time it is used on the command
-#	line.
-#		foo.multi
-#
-#	If an option specification does not contain the ".multi"
-#	suffix, it is not an error to use an option more than once.
-#	In this case, the behavior for options with arguments is that
-#	the last argument is the one that will be returned. For
-#	options that do not take arguments, using them more than once
-#	has no additional effect.
-#
-#	Options may also be hidden from the usage display by
-#	appending the suffix ".secret" to any option specification.
-#	Please note that the ".secret" suffix must be the last suffix,
-#	after any argument type specification and ".multi" suffix.
-#		foo.xdigit.multi.secret
-#
-# Results
-#	Name value pairs suitable for using with array set.
-
-proc ::cmdline::typedGetoptions {argvVar optlist {usage options:}} {
-    variable charclasses
-
-    upvar 1 $argvVar argv
-
-    set opts {? help}
-    foreach opt $optlist {
-        set name [lindex $opt 0]
-        if {[regsub -- {\.secret$} $name {} name] == 1} {
-            # Remove this extension before passing to typedGetopt.
-        }
-        if {[regsub -- {\.multi$} $name {} name] == 1} {
-            # Remove this extension before passing to typedGetopt.
-
-            regsub -- {\..*$} $name {} temp
-            set multi($temp) 1
-        }
-        lappend opts $name
-        if {[regsub -- "\\.(arg|$charclasses|\\(.+).?\$" $name {} name] == 1} {
-            # Set defaults for those that take values.
-            # Booleans are set just by being present, or not
-
-            set dflt [lindex $opt 1]
-            if {$dflt != {}} {
-                set defaults($name) $dflt
-            }
-        }
-    }
-    set argc [llength $argv]
-    while {[set err [typedGetopt argv $opts opt arg]]} {
-        if {$err == 1} {
-            if {[info exists result($opt)]
-                    && [info exists multi($opt)]} {
-                # Toggle boolean options or append new arguments
-
-                if {$arg == ""} {
-                    unset result($opt)
-                } else {
-                    set result($opt) "$result($opt) $arg"
-                }
-            } else {
-                set result($opt) "$arg"
-            }
-        } elseif {($err == -1) || ($err == -3)} {
-            Error [typedUsage $optlist $usage] USAGE
-        } elseif {$err == -2 && ![info exists defaults($opt)]} {
-            Error [typedUsage $optlist $usage] USAGE
-        }
-    }
-    if {[info exists result(?)] || [info exists result(help)]} {
-        Error [typedUsage $optlist $usage] USAGE
-    }
-    foreach {opt dflt} [array get defaults] {
-        if {![info exists result($opt)]} {
-            set result($opt) $dflt
-        }
-    }
-    return [array get result]
-}
-
-# ::cmdline::typedUsage --
-#
-#	Generate an error message that lists the allowed flags,
-#	type of argument taken (if any), default value (if any),
-#	and an optional description.
-#
-# Arguments:
-#	optlist		As for cmdline::typedGetoptions
-#
-# Results
-#	A formatted usage message
-
-proc ::cmdline::typedUsage {optlist {usage {options:}}} {
-    variable charclasses
-
-    set str "[getArgv0] $usage\n"
-    set longest 20
-    set lines {}
-    foreach opt [concat $optlist \
-            {{help "Print this message"} {? "Print this message"}}] {
-        set name "-[lindex $opt 0]"
-        if {[regsub -- {\.secret$} $name {} name] == 1} {
-            # Hidden option
-	    continue
-	}
-
-	if {[regsub -- {\.multi$} $name {} name] == 1} {
-	    # Display something about multiple options
-	}
-
-	if {[regexp -- "\\.(arg|$charclasses)\$" $name dummy charclass] ||
-	    [regexp -- {\.\(([^)]+)\)} $opt dummy charclass]
-	} {
-	    regsub -- "\\..+\$" $name {} name
-	    append name " $charclass"
-	    set desc [lindex $opt 2]
-	    set default [lindex $opt 1]
-	    if {$default != ""} {
-		append desc " <$default>"
-	    }
-	} else {
-	    set desc [lindex $opt 1]
-	}
-	lappend accum $name $desc
-	set n [string length $name]
-	if {$n > $longest} { set longest $n }
-	# max not available before 8.5 - set longest [expr {max($longest, [string length $name])}]
-    }
-    foreach {name desc} $accum {
-	append str "[string trimright [format " %-*s %s" $longest $name $desc]]\n"
-    }
-    return $str
-}
-
-# ::cmdline::prefixSearch --
-#
-#	Search a Tcl list for a pattern; searches first for an exact match,
-#	and if that fails, for a unique prefix that matches the pattern
-#	(i.e, first "lsearch -exact", then "lsearch -glob $pattern*"
-#
-# Arguments:
-#	list		list of words
-#	pattern		word to search for
-#
-# Results:
-#	Index of found word is returned. If no exact match or
-#	unique short version is found then -1 is returned.
-
-proc ::cmdline::prefixSearch {list pattern} {
-    # Check for an exact match
-
-    if {[set pos [::lsearch -exact $list $pattern]] > -1} {
-        return $pos
-    }
-
-    # Check for a unique short version
-
-    set slist [lsort $list]
-    if {[set pos [::lsearch -glob $slist $pattern*]] > -1} {
-        # What if there is nothing for the check variable?
-
-        set check [lindex $slist [expr {$pos + 1}]]
-        if {[string first $pattern $check] != 0} {
-            return [::lsearch -exact $list [lindex $slist $pos]]
-        }
-    }
-    return -1
-}
-# ::cmdline::Error --
-#
-#	Internal helper to throw errors with a proper error-code attached.
-#
-# Arguments:
-#	message		text of the error message to throw.
-#	args		additional parts of the error code to use,
-#                       with CMDLINE as basic prefix added by this command.
-#
-# Results:
-#	An error is thrown, always.
-
-proc ::cmdline::Error {message args} {
-    return -code error -errorcode [linsert $args 0 CMDLINE] $message
-}
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/fileutil-1.16.1.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/fileutil-1.16.1.tm
deleted file mode 100644
index 6d5c737e..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/fileutil-1.16.1.tm
+++ /dev/null
@@ -1,2311 +0,0 @@
-# fileutil.tcl --
-#
-#	Tcl implementations of standard UNIX utilities.
-#
-# Copyright (c) 1998-2000 by Ajuba Solutions.
-# Copyright (c) 2002      by Phil Ehrens <phil@slug.org> (fileType)
-# Copyright (c) 2005-2013 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-
-package require Tcl 8.5-
-package require cmdline
-package provide fileutil 1.16.1
-
-namespace eval ::fileutil {
-    namespace export \
-	    grep find findByPattern cat touch foreachLine \
-	    jail stripPwd stripN stripPath tempdir tempfile \
-	    install fileType writeFile appendToFile \
-	    insertIntoFile removeFromFile replaceInFile \
-	    updateInPlace test tempdirReset maketempdir
-}
-
-# ::fileutil::grep --
-#
-#	Implementation of grep.  Adapted from the Tcler's Wiki.
-#
-# Arguments:
-#	pattern		pattern to search for.
-#	files		list of files to search; if NULL, uses stdin.
-#
-# Results:
-#	results		list of matches
-
-proc ::fileutil::grep {pattern {files {}}} {
-    set result [list]
-    if {[llength $files] == 0} {
-	# read from stdin
-	set lnum 0
-	while {[gets stdin line] >= 0} {
-	    incr lnum
-	    if {[regexp -- $pattern $line]} {
-		lappend result "${lnum}:${line}"
-	    }
-	}
-    } else {
-	foreach filename $files {
-	    set file [open $filename r]
-	    set lnum 0
-	    while {[gets $file line] >= 0} {
-		incr lnum
-		if {[regexp -- $pattern $line]} {
-		    lappend result "${filename}:${lnum}:${line}"
-		}
-	    }
-	    close $file
-	}
-    }
-    return $result
-}
-
-# ::fileutil::find ==
-
-# Below is the core command, which is portable across Tcl versions and
-# platforms. Functionality which is common or platform and/or Tcl
-# version dependent, has been factored out/ encapsulated into separate
-# (small) commands. Only these commands may have multiple variant
-# implementations per the available features of the Tcl core /
-# platform.
-#
-# These commands are
-#
-# FADD   - Add path result, performs filtering. Portable!
-# GLOBF  - Return files in a directory.         Tcl version/platform dependent.
-# GLOBD  - Return dirs  in a directory.         Tcl version/platform dependent.
-# ACCESS - Check directory for accessibility.   Tcl version/platform dependent.
-
-proc ::fileutil::find {{basedir .} {filtercmd {}}} {
-    set result {}
-    set filt   [string length $filtercmd]
-
-    if {[file isfile $basedir]} {
-	# The base is a file, and therefore only possible result,
-	# modulo filtering.
-
-	FADD $basedir
-
-    } elseif {[file isdirectory $basedir]} {
-	# For a directory as base we do an iterative recursion through
-	# the directory hierarchy starting at the base. We use a queue
-	# (Tcl list) of directories we have to check. We access it by
-	# index, and stop when we have reached beyond the end of the
-	# list. This is faster than removing elements from the be-
-	# ginning of the list, as that entails copying down a possibly
-	# large list of directories, making it O(n*n). The index is
-	# faster, O(n), at the expense of memory. Nothing is deleted
-	# from the list until we have processed all directories in the
-	# hierarchy.
-	#
-	# We scan each directory at least twice. First for files, then
-	# for directories. The scans may internally make several
-	# passes (normal vs hidden files).
-	#
-	# Looped directory structures due to symbolic links are
-	# handled by _fully_ normalizing directory paths and checking
-	# if we encountered the normalized form before. The array
-	# 'known' is our cache where we record the known normalized
-	# paths.
-
-	set pending [list $basedir]
-	set at      0
-	array set   parent {}
-	array set   norm   {}
-	Enter {} $basedir
-
-	while {$at < [llength $pending]} {
-	    # Get next directory not yet processed.
-	    set current [lindex $pending $at]
-	    incr at
-
-	    # Is the directory accessible? Continue if not.
-	    ACCESS $current
-
-	    # Files first, then the sub-directories ...
-
-	    foreach f [GLOBF $current] { FADD $f }
-
-	    foreach f [GLOBD $current] {
-		# Ignore current and parent directory, this needs
-		# explicit filtering outside of the filter command.
-		if {
-		    [string equal [file tail $f]  "."] ||
-		    [string equal [file tail $f] ".."]
-		} continue
-
-		# Extend result, modulo filtering.
-		FADD $f
-
-		# Detection of symlink loops via a portable path
-		# normalization computing a canonical form of the path
-		# followed by a check if that canonical form was
-		# encountered before. If ok, record directory for
-		# expansion in future iterations.
-
-		Enter $current $f
-		if {[Cycle $f]} continue
-
-		lappend pending $f
-	    }
-	}
-    } else {
-	return -code error "$basedir does not exist"
-    }
-
-    return $result
-}
-
-proc  ::fileutil::Enter {parent path} {
-    upvar 1 parent _parent norm _norm
-    set _parent($path) $parent
-    set _norm($path)   [fullnormalize $path]
-    return
-}
-
-proc  ::fileutil::Cycle {path} {
-    upvar 1 parent _parent norm _norm
-    set nform $_norm($path)
-    set paren $_parent($path)
-    while {$paren ne {}} {
-	if {$_norm($paren) eq $nform} { return yes }
-	set paren $_parent($paren)
-    }
-    return no
-}
-
-# Helper command for fileutil::find. Performs the filtering of the
-# result per a filter command for the candidates found by the
-# traversal core, see above. This is portable.
-
-proc ::fileutil::FADD {filename} {
-    upvar 1 result result filt filt filtercmd filtercmd
-    if {!$filt} {
-	lappend result $filename
-	return
-    }
-
-    set here [pwd]
-    cd [file dirname $filename]
-
-    if {[uplevel 2 [linsert $filtercmd end [file tail $filename]]]} {
-	lappend result $filename
-    }
-
-    cd $here
-    return
-}
-
-# The next three helper commands for fileutil::find depend strongly on
-# the version of Tcl, and partially on the platform.
-
-# 1. The -directory and -types switches were added to glob in Tcl
-#    8.3. This means that we have to emulate them for Tcl 8.2.
-#
-# 2. In Tcl 8.3 using -types f will return only true files, but not
-#    links to files. This changed in 8.4+ where links to files are
-#    returned as well. So for 8.3 we have to handle the links
-#    separately (-types l) and also filter on our own.
-#    Note that Windows file links are hard links which are reported by
-#    -types f, but not -types l, so we can optimize that for the two
-#    platforms.
-#
-#    Note further that we have to handle broken links on our own. They
-#    are not returned by glob yet we want them in the output.
-#
-# 3. In Tcl 8.3 we also have a crashing bug in glob (SIGABRT, "stat on
-#    a known file") when trying to perform 'glob -types {hidden f}' on
-#    a directory without e'x'ecute permissions. We code around by
-#    testing if we can cd into the directory (stat might return enough
-#    information too (mode), but possibly also not portable).
-#
-#    For Tcl 8.2 and 8.4+ glob simply delivers an empty result
-#    (-nocomplain), without crashing. For them this command is defined
-#    so that the bytecode compiler removes it from the bytecode.
-#
-#    This bug made the ACCESS helper necessary.
-#    We code around the problem by testing if we can cd into the
-#    directory (stat might return enough information too (mode), but
-#    possibly also not portable).
-
-if {[package vsatisfies [package present Tcl] 8.5]} {
-    # Tcl 8.5+.
-    # We have to check readability of "current" on our own, glob
-    # changed to error out instead of returning nothing.
-
-    proc ::fileutil::ACCESS {args} {}
-
-    proc ::fileutil::GLOBF {current} {
-	if {![file readable $current] ||
-	    [BadLink $current]} {
-	    return {}
-	}
-
-	set res [lsort -unique [concat \
-		     [glob -nocomplain -directory $current -types f          -- *] \
-		     [glob -nocomplain -directory $current -types {hidden f} -- *]]]
-
-	# Look for broken links (They are reported as neither file nor directory).
-	foreach l [lsort -unique [concat \
-		       [glob -nocomplain -directory $current -types l          -- *] \
-		       [glob -nocomplain -directory $current -types {hidden l} -- *]]] {
-	    if {[file isfile      $l]} continue
-	    if {[file isdirectory $l]} continue
-	    lappend res $l
-	}
-	return [lsort -unique $res]
-    }
-
-    proc ::fileutil::GLOBD {current} {
-	if {![file readable $current] ||
-	    [BadLink $current]} {
-	    return {}
-	}
-
-	lsort -unique [concat \
-	   [glob -nocomplain -directory $current -types d          -- *] \
-	   [glob -nocomplain -directory $current -types {hidden d} -- *]]
-    }
-
-    proc ::fileutil::BadLink {current} {
-	if {[file type $current] ne "link"} { return no }
-
-	set dst [file join [file dirname $current] [file readlink $current]]
-
-	if {![file exists   $dst] ||
-	    ![file readable $dst]} {
-	    return yes
-	}
-
-	return no
-    }
-} elseif {[package vsatisfies [package present Tcl] 8.4]} {
-    # Tcl 8.4+.
-    # (Ad 1) We have -directory, and -types,
-    # (Ad 2) Links are returned for -types f/d if they refer to files/dirs.
-    # (Ad 3) No bug to code around
-
-    proc ::fileutil::ACCESS {args} {}
-
-    proc ::fileutil::GLOBF {current} {
-	set res [lsort -unique [concat \
-		    [glob -nocomplain -directory $current -types f          -- *] \
-		    [glob -nocomplain -directory $current -types {hidden f} -- *]]]
-
-	# Look for broken links (They are reported as neither file nor directory).
-	foreach l [lsort -unique [concat \
-		       [glob -nocomplain -directory $current -types l          -- *] \
-		       [glob -nocomplain -directory $current -types {hidden l} -- *]]] {
-	    if {[file isfile      $l]} continue
-	    if {[file isdirectory $l]} continue
-	    lappend res $l
-	}
-	return [lsort -unique $res]
-    }
-
-    proc ::fileutil::GLOBD {current} {
-	lsort -unique [concat \
-	    [glob -nocomplain -directory $current -types d          -- *] \
-	    [glob -nocomplain -directory $current -types {hidden d} -- *]]
-    }
-
-} elseif {[package vsatisfies [package present Tcl] 8.3]} {
-    # 8.3.
-    # (Ad 1) We have -directory, and -types,
-    # (Ad 2) Links are NOT returned for -types f/d, collect separately.
-    #        No symbolic file links on Windows.
-    # (Ad 3) Bug to code around.
-
-    proc ::fileutil::ACCESS {current} {
-	if {[catch {
-	    set h [pwd] ; cd $current ; cd $h
-	}]} {return -code continue}
-	return
-    }
-
-    if {[string equal $::tcl_platform(platform) windows]} {
-	proc ::fileutil::GLOBF {current} {
-	    concat \
-		[glob -nocomplain -directory $current -types f          -- *] \
-		[glob -nocomplain -directory $current -types {hidden f} -- *]]
-	}
-    } else {
-	proc ::fileutil::GLOBF {current} {
-	    set l [concat \
-		       [glob -nocomplain -directory $current -types f          -- *] \
-		       [glob -nocomplain -directory $current -types {hidden f} -- *]]
-
-	    foreach x [concat \
-			   [glob -nocomplain -directory $current -types l          -- *] \
-			   [glob -nocomplain -directory $current -types {hidden l} -- *]] {
-		if {[file isdirectory $x]} continue
-		# We have now accepted files, links to files, and broken links.
-		lappend l $x
-	    }
-
-	    return $l
-	}
-    }
-
-    proc ::fileutil::GLOBD {current} {
-	set l [concat \
-		   [glob -nocomplain -directory $current -types d          -- *] \
-		   [glob -nocomplain -directory $current -types {hidden d} -- *]]
-
-	foreach x [concat \
-		       [glob -nocomplain -directory $current -types l          -- *] \
-		       [glob -nocomplain -directory $current -types {hidden l} -- *]] {
-	    if {![file isdirectory $x]} continue
-	    lappend l $x
-	}
-
-	return $l
-    }
-} else {
-    # 8.2.
-    # (Ad 1,2,3) We do not have -directory, nor -types. Full emulation required.
-
-    proc ::fileutil::ACCESS {args} {}
-
-    if {[string equal $::tcl_platform(platform) windows]} {
-	# Hidden files cannot be handled by Tcl 8.2 in glob. We have
-	# to punt.
-
-	proc ::fileutil::GLOBF {current} {
-	    set current \\[join [split $current {}] \\]
-	    set res {}
-	    foreach x [glob -nocomplain -- [file join $current *]] {
-		if {[file isdirectory $x]} continue
-		if {[catch {file type $x}]} continue
-		# We have now accepted files, links to files, and
-		# broken links. We may also have accepted a directory
-		# as well, if the current path was inaccessible. This
-		# however will cause 'file type' to throw an error,
-		# hence the second check.
-		lappend res $x
-	    }
-	    return $res
-	}
-
-	proc ::fileutil::GLOBD {current} {
-	    set current \\[join [split $current {}] \\]
-	    set res {}
-	    foreach x [glob -nocomplain -- [file join $current *]] {
-		if {![file isdirectory $x]} continue
-		lappend res $x
-	    }
-	    return $res
-	}
-    } else {
-	# Hidden files on Unix are dot-files. We emulate the switch
-	# '-types hidden' by using an explicit pattern.
-
-	proc ::fileutil::GLOBF {current} {
-	    set current \\[join [split $current {}] \\]
-	    set res {}
-	    foreach x [glob -nocomplain -- [file join $current *] [file join $current .*]] {
-		if {[file isdirectory $x]} continue
-		if {[catch {file type $x}]} continue
-		# We have now accepted files, links to files, and
-		# broken links. We may also have accepted a directory
-		# as well, if the current path was inaccessible. This
-		# however will cause 'file type' to throw an error,
-		# hence the second check.
-
-		lappend res $x
-	    }
-	    return $res
-	}
-
-	proc ::fileutil::GLOBD {current} {
-	    set current \\[join [split $current {}] \\]
-	    set res {}
-	    foreach x [glob -nocomplain -- $current/* [file join $current .*]] {
-		if {![file isdirectory $x]} continue
-		lappend res $x
-	    }
-	    return $res
-	}
-    }
-}
-
-# ::fileutil::findByPattern --
-#
-#	Specialization of find. Finds files based on their names,
-#	which have to match the specified patterns. Options are used
-#	to specify which type of patterns (regexp-, glob-style) is
-#	used.
-#
-# Arguments:
-#	basedir		Directory to start searching from.
-#	args		Options (-glob, -regexp, --) followed by a
-#			list of patterns to search for.
-#
-# Results:
-#	files		a list of interesting files.
-
-proc ::fileutil::findByPattern {basedir args} {
-    set pos 0
-    set cmd ::fileutil::FindGlob
-    foreach a $args {
-	incr pos
-	switch -glob -- $a {
-	    --      {break}
-	    -regexp {set cmd ::fileutil::FindRegexp}
-	    -glob   {set cmd ::fileutil::FindGlob}
-	    -*      {return -code error "Unknown option $a"}
-	    default {incr pos -1 ; break}
-	}
-    }
-
-    set args [lrange $args $pos end]
-
-    if {[llength $args] != 1} {
-	set pname [lindex [info level 0] 0]
-	return -code error \
-		"wrong#args for \"$pname\", should be\
-		\"$pname basedir ?-regexp|-glob? ?--? patterns\""
-    }
-
-    set patterns [lindex $args 0]
-    return [find $basedir [list $cmd $patterns]]
-}
-
-
-# ::fileutil::FindRegexp --
-#
-#	Internal helper. Filter command used by 'findByPattern'
-#	to match files based on regular expressions.
-#
-# Arguments:
-#	patterns	List of regular expressions to match against.
-#	filename	Name of the file to match against the patterns.
-# Results:
-#	interesting	A boolean flag. Set to true if the file
-#			matches at least one of the patterns.
-
-proc ::fileutil::FindRegexp {patterns filename} {
-    foreach p $patterns {
-	if {[regexp -- $p $filename]} {
-	    return 1
-	}
-    }
-    return 0
-}
-
-# ::fileutil::FindGlob --
-#
-#	Internal helper. Filter command used by 'findByPattern'
-#	to match files based on glob expressions.
-#
-# Arguments:
-#	patterns	List of glob expressions to match against.
-#	filename	Name of the file to match against the patterns.
-# Results:
-#	interesting	A boolean flag. Set to true if the file
-#			matches at least one of the patterns.
-
-proc ::fileutil::FindGlob {patterns filename} {
-    foreach p $patterns {
-	if {[string match $p $filename]} {
-	    return 1
-	}
-    }
-    return 0
-}
-
-# ::fileutil::stripPwd --
-#
-#	If the specified path references is a path in [pwd] (or [pwd] itself) it
-#	is made relative to [pwd]. Otherwise it is left unchanged.
-#	In the case of [pwd] itself the result is the string '.'.
-#
-# Arguments:
-#	path		path to modify
-#
-# Results:
-#	path		The (possibly) modified path.
-
-proc ::fileutil::stripPwd {path} {
-
-    # [file split] is used to generate a canonical form for both
-    # paths, for easy comparison, and also one which is easy to modify
-    # using list commands.
-
-    set pwd [pwd]
-    if {[string equal $pwd $path]} {
-	return "."
-    }
-
-    set pwd   [file split $pwd]
-    set npath [file split $path]
-
-    if {[string match ${pwd}* $npath]} {
-	set path [eval [linsert [lrange $npath [llength $pwd] end] 0 file join ]]
-    }
-    return $path
-}
-
-# ::fileutil::stripN --
-#
-#	Removes N elements from the beginning of the path.
-#
-# Arguments:
-#	path		path to modify
-#	n		number of elements to strip
-#
-# Results:
-#	path		The modified path
-
-proc ::fileutil::stripN {path n} {
-    set path [file split $path]
-    if {$n >= [llength $path]} {
-	return {}
-    } else {
-	return [eval [linsert [lrange $path $n end] 0 file join]]
-    }
-}
-
-# ::fileutil::stripPath --
-#
-#	If the specified path references/is a path in prefix (or prefix itself) it
-#	is made relative to prefix. Otherwise it is left unchanged.
-#	In the case of it being prefix itself the result is the string '.'.
-#
-# Arguments:
-#	prefix		prefix to strip from the path.
-#	path		path to modify
-#
-# Results:
-#	path		The (possibly) modified path.
-
-if {[string equal $tcl_platform(platform) windows]} {
-
-    # Windows. While paths are stored with letter-case preserved al
-    # comparisons have to be done case-insensitive. For reference see
-    # SF Tcllib Bug 2499641.
-
-    proc ::fileutil::stripPath {prefix path} {
-	# [file split] is used to generate a canonical form for both
-	# paths, for easy comparison, and also one which is easy to modify
-	# using list commands.
-
-	set prefix [file split $prefix]
-	set npath  [file split $path]
-
-	if {[string equal -nocase $prefix $npath]} {
-	    return "."
-	}
-
-	if {[string match -nocase "${prefix} *" $npath]} {
-	    set path [eval [linsert [lrange $npath [llength $prefix] end] 0 file join ]]
-	}
-	return $path
-    }
-} else {
-    proc ::fileutil::stripPath {prefix path} {
-	# [file split] is used to generate a canonical form for both
-	# paths, for easy comparison, and also one which is easy to modify
-	# using list commands.
-
-	set prefix [file split $prefix]
-	set npath  [file split $path]
-
-	if {[string equal $prefix $npath]} {
-	    return "."
-	}
-
-	if {[string match "${prefix} *" $npath]} {
-	    set path [eval [linsert [lrange $npath [llength $prefix] end] 0 file join ]]
-	}
-	return $path
-    }
-}
-
-# ::fileutil::jail --
-#
-#	Ensures that the input path 'filename' stays within the
-#	directory 'jail'. In this way it prevents user-supplied paths
-#	from escaping the jail.
-#
-# Arguments:
-#	jail		The path to the directory the other must
-#			not escape from.
-#	filename	The path to prevent from escaping.
-#
-# Results:
-#	path		The (possibly) modified path surely within
-#			the confines of the jail.
-
-proc fileutil::jail {jail filename} {
-    if {![string equal [file pathtype $filename]  "relative"]} {
-	# Although the path to check is absolute (or volumerelative on
-	# windows) we cannot perform a simple prefix check to see if
-	# the path is inside the jail or not. We have to normalize
-	# both path and jail and then we can check. If the path is
-	# outside we make the original path relative and prefix it
-	# with the original jail. We do make the jail pseudo-absolute
-	# by prefixing it with the current working directory for that.
-
-	# Normalized jail. Fully resolved sym links, if any. Our main
-	# complication is that normalize does not resolve symlinks in the
-	# last component of the path given to it, so we add a bogus
-	# component, resolve, and then strip it off again. That is why the
-	# code is so large and long.
-
-	set njail [eval [list file join] [lrange [file split \
-		[Normalize [file join $jail __dummy__]]] 0 end-1]]
-
-	# Normalize filename. Fully resolved sym links, if
-	# any. S.a. for an explanation of the complication.
-
-	set nfile [eval [list file join] [lrange [file split \
-		[Normalize [file join $filename __dummy__]]] 0 end-1]]
-
-	if {[string match ${njail}* $nfile]} {
-	    return $filename
-	}
-
-	# Outside the jail, put it inside. ... We normalize the input
-	# path lexically for this, to prevent escapes still lurking in
-	# the original path. (We cannot use the normalized path,
-	# symlinks may have bent it out of shape in unrecognizable ways.
-
-	return [eval [linsert [lrange [file split \
-		[lexnormalize $filename]] 1 end] 0 file join [pwd] $jail]]
-    } else {
-	# The path is relative, consider it as outside
-	# implicitly. Normalize it lexically! to prevent escapes, then
-	# put the jail in front, use PWD to ensure absoluteness.
-
-	return [eval [linsert [file split [lexnormalize $filename]] 0 \
-		file join [pwd] $jail]]
-    }
-}
-
-
-# ::fileutil::test --
-#
-#	Simple API to testing various properties of
-#	a path (read, write, file/dir, existence)
-#
-# Arguments:
-#	path	path to test
-#	codes	names of the properties to test
-#	msgvar	Name of variable to leave an error
-#		message in. Optional.
-#	label	Label for error message, optional
-#
-# Results:
-#	ok	boolean flag, set if the path passes
-#		all tests.
-
-namespace eval ::fileutil {
-    variable  test
-    array set test {
-	read   {readable    {Read access is denied}}
-	write  {writable    {Write access is denied}}
-	exec   {executable  {Is not executable}}
-	exists {exists      {Does not exist}}
-	file   {isfile      {Is not a file}}
-	dir    {isdirectory {Is not a directory}}
-    }
-}
-
-proc ::fileutil::test {path codes {msgvar {}} {label {}}} {
-    variable test
-
-    if {[string equal $msgvar ""]} {
-	set msg ""
-    } else {
-	upvar 1 $msgvar msg
-    }
-
-    if {![string equal $label ""]} {append label { }}
-
-    if {![regexp {^(read|write|exec|exists|file|dir)} $codes]} {
-	# Translate single characters into proper codes
-	set codes [string map {
-	    r read w write e exists x exec f file d dir
-	} [split $codes {}]]
-    }
-
-    foreach c $codes {
-	foreach {cmd text} $test($c) break
-	if {![file $cmd $path]} {
-	    set msg "$label\"$path\": $text"
-	    return 0
-	}
-    }
-
-    return 1
-}
-
-# ::fileutil::cat --
-#
-#	Tcl implementation of the UNIX "cat" command.  Returns the contents
-#	of the specified files.
-#
-# Arguments:
-#	args	names of the files to read, interspersed with options
-#		to set encodings, translations, or eofchar.
-#
-# Results:
-#	data	data read from the file.
-
-proc ::fileutil::cat {args} {
-    # Syntax: (?options? file)+
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    if {![llength $args]} {
-	# Argument processing stopped with arguments missing.
-	return -code error \
-		"wrong#args: should be\
-		[lindex [info level 0] 0] ?-eofchar|-translation|-encoding arg?+ file ..."
-    }
-
-    # We go through the arguments using foreach and keeping track of
-    # the index we are at. We do not shift the arguments out to the
-    # left. That is inherently quadratic, copying everything down.
-
-    set opts {}
-    set mode maybeopt
-    set channels {}
-
-    foreach a $args {
-	if {[string equal $mode optarg]} {
-	    lappend opts $a
-	    set mode maybeopt
-	    continue
-	} elseif {[string equal $mode maybeopt]} {
-	    if {[string match -* $a]} {
-		switch -exact -- $a {
-		    -encoding -
-		    -translation -
-		    -eofchar {
-			lappend opts $a
-			set mode optarg
-			continue
-		    }
-		    -- {
-			set mode file
-			continue
-		    }
-		    default {
-			return -code error \
-				"Bad option \"$a\",\
-				expected one of\
-				-encoding, -eofchar,\
-				or -translation"
-		    }
-		}
-	    }
-	    # Not an option, but a file. Change mode and fall through.
-	    set mode file
-	}
-	# Process file arguments
-
-	if {[string equal $a -]} {
-	    # Stdin reference is special.
-
-	    # Test that the current options are all ok.
-	    # For stdin we have to avoid closing it.
-
-	    set old [fconfigure stdin]
-	    set fail [catch {
-		SetOptions stdin $opts
-	    } msg] ; # {}
-	    SetOptions stdin $old
-
-	    if {$fail} {
-		return -code error $msg
-	    }
-
-	    lappend channels [list $a $opts 0]
-	} else {
-	    if {![file exists $a]} {
-		return -code error "Cannot read file \"$a\", does not exist"
-	    } elseif {![file isfile $a]} {
-		return -code error "Cannot read file \"$a\", is not a file"
-	    } elseif {![file readable $a]} {
-		return -code error "Cannot read file \"$a\", read access is denied"
-	    }
-
-	    # Test that the current options are all ok.
-	    set c [open $a r]
-	    set fail [catch {
-		SetOptions $c $opts
-	    } msg] ; # {}
-	    close $c
-	    if {$fail} {
-		return -code error $msg
-	    }
-
-	    lappend channels [list $a $opts [file size $a]]
-	}
-
-	# We may have more options and files coming after.
-	set mode maybeopt
-    }
-
-    if {![string equal $mode maybeopt]} {
-	# Argument processing stopped with arguments missing.
-	return -code error \
-		"wrong#args: should be\
-		[lindex [info level 0] 0] ?-eofchar|-translation|-encoding arg?+ file ..."
-    }
-
-    set data ""
-    foreach c $channels {
-	foreach {fname opts size} $c break
-
-	if {[string equal $fname -]} {
-	    set old [fconfigure stdin]
-	    SetOptions stdin $opts
-	    append data [read stdin]
-	    SetOptions stdin $old
-	    continue
-	}
-
-	set c [open $fname r]
-	SetOptions $c $opts
-
-	if {$size > 0} {
-	    # Used the [file size] command to get the size, which
-	    # preallocates memory, rather than trying to grow it as
-	    # the read progresses.
-	    append data [read $c $size]
-	} else {
-	    # if the file has zero bytes it is either empty, or
-	    # something where [file size] reports 0 but the file
-	    # actually has data (like the files in the /proc
-	    # filesystem on Linux).
-	    append data [read $c]
-	}
-	close $c
-    }
-
-    return $data
-}
-
-# ::fileutil::writeFile --
-#
-#	Write the specified data into the named file,
-#	creating it if necessary.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to write.
-#	data		The data to write into the file
-#
-# Results:
-#	None.
-
-proc ::fileutil::writeFile {args} {
-    # Syntax: ?options? file data
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec Writable $args opts fname data
-
-    # Now perform the requested operation.
-
-    file mkdir [file dirname $fname]
-    set              c [open $fname w]
-    SetOptions      $c $opts
-    puts -nonewline $c $data
-    close           $c
-    return
-}
-
-# ::fileutil::appendToFile --
-#
-#	Append the specified data at the end of the named file,
-#	creating it if necessary.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	data		The data to extend the file with.
-#
-# Results:
-#	None.
-
-proc ::fileutil::appendToFile {args} {
-    # Syntax: ?options? file data
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec Writable $args opts fname data
-
-    # Now perform the requested operation.
-
-    file mkdir [file dirname $fname]
-    set              c [open $fname a]
-    SetOptions      $c $opts
-    set at    [tell $c]
-    puts -nonewline $c $data
-    close           $c
-    return $at
-}
-
-# ::fileutil::insertIntoFile --
-#
-#	Insert the specified data into the named file,
-#	creating it if necessary, at the given locaton.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	data		The data to extend the file with.
-#
-# Results:
-#	None.
-
-proc ::fileutil::insertIntoFile {args} {
-
-    # Syntax: ?options? file at data
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec ReadWritable $args opts fname at data
-
-    set max [file size $fname]
-    CheckLocation $at $max insertion
-
-    if {[string length $data] == 0} {
-	# Another degenerate case, inserting nothing.
-	# Leave the file well enough alone.
-	return
-    }
-
-    foreach {c o t} [Open2 $fname $opts] break
-
-    # The degenerate cases of both appending and insertion at the
-    # beginning of the file allow more optimized implementations of
-    # the operation.
-
-    if {$at == 0} {
-	puts -nonewline    $o $data
-	fcopy           $c $o
-    } elseif {$at == $max} {
-	fcopy           $c $o
-	puts -nonewline    $o $data
-    } else {
-	fcopy           $c $o -size $at
-	puts -nonewline    $o $data
-	fcopy           $c $o
-    }
-
-    Close2 $fname $t $c $o
-    return
-}
-
-# ::fileutil::removeFromFile --
-#
-#	Remove n characters from the named file,
-#	starting at the given locaton.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	at		Location to start the removal from.
-#	n		Number of characters to remove.
-#
-# Results:
-#	None.
-
-proc ::fileutil::removeFromFile {args} {
-
-    # Syntax: ?options? file at n
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec ReadWritable $args opts fname at n
-
-    set max [file size $fname]
-    CheckLocation    $at $max removal
-    CheckLength   $n $at $max removal
-
-    if {$n == 0} {
-	# Another degenerate case, removing nothing.
-	# Leave the file well enough alone.
-	return
-    }
-
-    foreach {c o t} [Open2 $fname $opts] break
-
-    # The degenerate cases of both removal from the beginning or end
-    # of the file allow more optimized implementations of the
-    # operation.
-
-    if {$at == 0} {
-	seek  $c    $n current
-	fcopy $c $o
-    } elseif {($at + $n) == $max} {
-	fcopy $c $o -size $at
-	# Nothing further to copy.
-    } else {
-	fcopy $c $o -size $at
-	seek  $c    $n current
-	fcopy $c $o
-    }
-
-    Close2 $fname $t $c $o
-    return
-}
-
-# ::fileutil::replaceInFile --
-#
-#	Remove n characters from the named file,
-#	starting at the given locaton, and replace
-#	it with the given data.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	at		Location to start the removal from.
-#	n		Number of characters to remove.
-#	data		The replacement data.
-#
-# Results:
-#	None.
-
-proc ::fileutil::replaceInFile {args} {
-
-    # Syntax: ?options? file at n data
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec ReadWritable $args opts fname at n data
-
-    set max [file size $fname]
-    CheckLocation    $at $max replacement
-    CheckLength   $n $at $max replacement
-
-    if {
-	($n == 0) &&
-	([string length $data] == 0)
-    } {
-	# Another degenerate case, replacing nothing with
-	# nothing. Leave the file well enough alone.
-	return
-    }
-
-    foreach {c o t} [Open2 $fname $opts] break
-
-    # Check for degenerate cases and handle them separately,
-    # i.e. strip the no-op parts out of the general implementation.
-
-    if {$at == 0} {
-	if {$n == 0} {
-	    # Insertion instead of replacement.
-
-	    puts -nonewline    $o $data
-	    fcopy           $c $o
-
-	} elseif {[string length $data] == 0} {
-	    # Removal instead of replacement.
-
-	    seek  $c    $n current
-	    fcopy $c $o
-
-	} else {
-	    # General replacement at front.
-
-	    seek         $c    $n current
-	    puts -nonewline $o $data
-	    fcopy        $c $o
-	}
-    } elseif {($at + $n) == $max} {
-	if {$n == 0} {
-	    # Appending instead of replacement
-
-	    fcopy           $c $o
-	    puts -nonewline    $o $data
-
-	} elseif {[string length $data] == 0} {
-	    # Truncating instead of replacement
-
-	    fcopy $c $o -size $at
-	    # Nothing further to copy.
-
-	} else {
-	    # General replacement at end
-
-	    fcopy        $c $o -size $at
-	    puts -nonewline $o $data
-	}
-    } else {
-	if {$n == 0} {
-	    # General insertion.
-
-	    fcopy           $c $o -size $at
-	    puts -nonewline    $o $data
-	    fcopy           $c $o
-
-	} elseif {[string length $data] == 0} {
-	    # General removal.
-
-	    fcopy $c $o -size $at
-	    seek  $c    $n current
-	    fcopy $c $o
-
-	} else {
-	    # General replacement.
-
-	    fcopy        $c $o -size $at
-	    seek         $c    $n current
-	    puts -nonewline $o $data
-	    fcopy        $c $o
-	}
-    }
-
-    Close2 $fname $t $c $o
-    return
-}
-
-# ::fileutil::updateInPlace --
-#
-#	Run command prefix on the contents of the
-#	file and replace them with the result of
-#	the command.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	cmd		Command prefix to run.
-#
-# Results:
-#	None.
-
-proc ::fileutil::updateInPlace {args} {
-    # Syntax: ?options? file cmd
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec ReadWritable $args opts fname cmd
-
-    # readFile/cat inlined ...
-
-    set             c [open $fname r]
-    SetOptions     $c $opts
-    set data [read $c]
-    close          $c
-
-    # Transformation. Abort and do not modify the target file if an
-    # error was raised during this step.
-
-    lappend cmd $data
-    set code [catch {uplevel 1 $cmd} res]
-    if {$code} {
-	return -code $code $res
-    }
-
-    # writeFile inlined, with careful preservation of old contents
-    # until we are sure that the write was ok.
-
-    if {[catch {
-	file rename -force $fname ${fname}.bak
-
-	set              o [open $fname w]
-	SetOptions      $o $opts
-	puts -nonewline $o $res
-	close           $o
-
-	file delete -force ${fname}.bak
-    } msg]} {
-	if {[file exists ${fname}.bak]} {
-	    catch {
-		file rename -force ${fname}.bak $fname
-	    }
-	    return -code error $msg
-	}
-    }
-    return
-}
-
-proc ::fileutil::Writable {fname mv} {
-    upvar 1 $mv msg
-    if {[file exists $fname]} {
-	if {![file isfile $fname]} {
-	    set msg "Cannot use file \"$fname\", is not a file"
-	    return 0
-	} elseif {![file writable $fname]} {
-	    set msg "Cannot use file \"$fname\", write access is denied"
-	    return 0
-	}
-    }
-    return 1
-}
-
-proc ::fileutil::ReadWritable {fname mv} {
-    upvar 1 $mv msg
-    if {![file exists $fname]} {
-	set msg "Cannot use file \"$fname\", does not exist"
-	return 0
-    } elseif {![file isfile $fname]} {
-	set msg "Cannot use file \"$fname\", is not a file"
-	return 0
-    } elseif {![file writable $fname]} {
-	set msg "Cannot use file \"$fname\", write access is denied"
-	return 0
-    } elseif {![file readable $fname]} {
-	set msg "Cannot use file \"$fname\", read access is denied"
-	return 0
-    }
-    return 1
-}
-
-proc ::fileutil::Spec {check alist ov fv args} {
-    upvar 1 $ov opts $fv fname
-
-    set  n [llength $args] ; # Num more args
-    incr n                 ; # Count path as well
-
-    set opts {}
-    set mode maybeopt
-
-    set at 0
-    foreach a $alist {
-	if {[string equal $mode optarg]} {
-	    lappend opts $a
-	    set mode maybeopt
-	    incr at
-	    continue
-	} elseif {[string equal $mode maybeopt]} {
-	    if {[string match -* $a]} {
-		switch -exact -- $a {
-		    -encoding -
-		    -translation -
-		    -eofchar {
-			lappend opts $a
-			set mode optarg
-			incr at
-			continue
-		    }
-		    -- {
-			# Stop processing.
-			incr at
-			break
-		    }
-		    default {
-			return -code error \
-				"Bad option \"$a\",\
-				expected one of\
-				-encoding, -eofchar,\
-				or -translation"
-		    }
-		}
-	    }
-	    # Not an option, but a file.
-	    # Stop processing.
-	    break
-	}
-    }
-
-    if {([llength $alist] - $at) != $n} {
-	# Argument processing stopped with arguments missing, or too
-	# many
-	return -code error \
-		"wrong#args: should be\
-		[lindex [info level 1] 0] ?-eofchar|-translation|-encoding arg? file $args"
-    }
-
-    set fname [lindex $alist $at]
-    incr at
-    foreach \
-	    var $args \
-	    val [lrange $alist $at end] {
-	upvar 1 $var A
-	set A $val
-    }
-
-    # Check given path ...
-
-    if {![eval [linsert $check end $a msg]]} {
-	return -code error $msg
-    }
-
-    return
-}
-
-proc ::fileutil::Open2 {fname opts} {
-    set c [open $fname r]
-    set t [tempfile]
-    set o [open $t     w]
-
-    SetOptions $c $opts
-    SetOptions $o $opts
-
-    return [list $c $o $t]
-}
-
-proc ::fileutil::Close2 {f temp in out} {
-    close $in
-    close $out
-
-    file copy   -force $f ${f}.bak
-    file rename -force $temp $f
-    file delete -force ${f}.bak
-    return
-}
-
-proc ::fileutil::SetOptions {c opts} {
-    if {![llength $opts]} return
-    eval [linsert $opts 0 fconfigure $c]
-    return
-}
-
-proc ::fileutil::CheckLocation {at max label} {
-    if {![string is integer -strict $at]} {
-	return -code error \
-		"Expected integer but got \"$at\""
-    } elseif {$at < 0} {
-	return -code error \
-		"Bad $label point $at, before start of data"
-    } elseif {$at > $max} {
-	return -code error \
-		"Bad $label point $at, behind end of data"
-    }
-}
-
-proc ::fileutil::CheckLength {n at max label} {
-    if {![string is integer -strict $n]} {
-	return -code error \
-		"Expected integer but got \"$n\""
-    } elseif {$n < 0} {
-	return -code error \
-		"Bad $label size $n"
-    } elseif {($at + $n) > $max} {
-	return -code error \
-		"Bad $label size $n, going behind end of data"
-    }
-}
-
-# ::fileutil::foreachLine --
-#
-#	Executes a script for every line in a file.
-#
-# Arguments:
-#	var		name of the variable to contain the lines
-#	filename	name of the file to read.
-#	cmd		The script to execute.
-#
-# Results:
-#	None.
-
-proc ::fileutil::foreachLine {var filename cmd} {
-    upvar 1 $var line
-    set fp [open $filename r]
-
-    # -future- Use try/eval from tcllib/control
-    catch {
-	set code 0
-	set result {}
-	set return 0
-	while {[gets $fp line] >= 0} {
-	    set code [catch {uplevel 1 $cmd} result options]
-	    if {$code == 2} {
-		set return 1
-		set code [dict get $options -code]
-		break
-	    } elseif {$code != 0 && $code != 4} {
-		break
-	    }
-	}
-    }
-    close $fp
-
-    if {$return || $code == 1 || $code > 4} {
-	return -options $options $result
-    }
-    return $result
-}
-
-# ::fileutil::touch --
-#
-#	Tcl implementation of the UNIX "touch" command.
-#
-#	touch [-a] [-m] [-c] [-r ref_file] [-t time] filename ...
-#
-# Arguments:
-#	-a		change the access time only, unless -m also specified
-#	-m		change the modification time only, unless -a also specified
-#	-c		silently prevent creating a file if it did not previously exist
-#	-r ref_file	use the ref_file's time instead of the current time
-#	-t time		use the specified time instead of the current time
-#			("time" is an integer clock value, like [clock seconds])
-#	filename ...	the files to modify
-#
-# Results
-#	None.
-#
-# Errors:
-#	Both of "-r" and "-t" cannot be specified.
-
-if {[package vsatisfies [package provide Tcl] 8.3]} {
-    namespace eval ::fileutil {
-	namespace export touch
-    }
-
-    proc ::fileutil::touch {args} {
-        # Don't bother catching errors, just let them propagate up
-
-        set options {
-            {a          "set the atime only"}
-            {m          "set the mtime only"}
-            {c          "do not create non-existant files"}
-            {r.arg  ""  "use time from ref_file"}
-            {t.arg  -1  "use specified time"}
-        }
-        set usage ": [lindex [info level 0] 0]\
-                      \[options] filename ...\noptions:"
-        array set params [::cmdline::getoptions args $options $usage]
-
-        # process -a and -m options
-        set set_atime [set set_mtime "true"]
-        if {  $params(a) && ! $params(m)} {set set_mtime "false"}
-        if {! $params(a) &&   $params(m)} {set set_atime "false"}
-
-        # process -r and -t
-        set has_t [expr {$params(t) != -1}]
-        set has_r [expr {[string length $params(r)] > 0}]
-        if {$has_t && $has_r} {
-            return -code error "Cannot specify both -r and -t"
-        } elseif {$has_t} {
-            set atime [set mtime $params(t)]
-        } elseif {$has_r} {
-            file stat $params(r) stat
-            set atime $stat(atime)
-            set mtime $stat(mtime)
-        } else {
-            set atime [set mtime [clock seconds]]
-        }
-
-        # do it
-        foreach filename $args {
-            if {! [file exists $filename]} {
-                if {$params(c)} {continue}
-                close [open $filename w]
-            }
-            if {$set_atime} {file atime $filename $atime}
-            if {$set_mtime} {file mtime $filename $mtime}
-        }
-        return
-    }
-}
-
-# ::fileutil::fileType --
-#
-#	Do some simple heuristics to determine file type.
-#
-#
-# Arguments:
-#	filename        Name of the file to test.
-#
-# Results
-#	type            Type of the file.  May be a list if multiple tests
-#                       are positive (eg, a file could be both a directory
-#                       and a link).  In general, the list proceeds from most
-#                       general (eg, binary) to most specific (eg, gif), so
-#                       the full type for a GIF file would be
-#                       "binary graphic gif"
-#
-#                       At present, the following types can be detected:
-#
-#                       directory
-#                       empty
-#                       binary
-#                       text
-#                       script <interpreter>
-#                       executable [elf, dos, ne, pe]
-#                       binary graphic [gif, jpeg, png, tiff, bitmap, icns]
-#                       ps, eps, pdf
-#                       html
-#                       xml <doctype>
-#                       message pgp
-#                       compressed [bzip, gzip, zip, tar]
-#                       audio [mpeg, wave]
-#                       gravity_wave_data_frame
-#                       link
-#			doctools, doctoc, and docidx documentation files.
-#
-
-proc ::fileutil::fileType {filename} {
-    ;## existence test
-    if { ! [ file exists $filename ] } {
-        set err "file not found: '$filename'"
-        return -code error $err
-    }
-    ;## directory test
-    if { [ file isdirectory $filename ] } {
-        set type directory
-        if { ! [ catch {file readlink $filename} ] } {
-            lappend type link
-        }
-        return $type
-    }
-    ;## empty file test
-    if { ! [ file size $filename ] } {
-        set type empty
-        if { ! [ catch {file readlink $filename} ] } {
-            lappend type link
-        }
-        return $type
-    }
-    set bin_rx {[\x00-\x08\x0b\x0e-\x1f]}
-
-    if { [ catch {
-        set fid [ open $filename r ]
-        fconfigure $fid -translation binary
-        fconfigure $fid -buffersize 1024
-        fconfigure $fid -buffering full
-        set test [ read $fid 1024 ]
-        ::close $fid
-    } err ] } {
-        catch { ::close $fid }
-        return -code error "::fileutil::fileType: $err"
-    }
-
-    if { [ regexp $bin_rx $test ] } {
-        set type binary
-        set binary 1
-    } else {
-        set type text
-        set binary 0
-    }
-
-    # SF Tcllib bug [795585]. Allowing whitespace between #!
-    # and path of script interpreter
-
-    set metakit 0
-
-    if { [ regexp {^\#\!\s*(\S+)} $test -> terp ] } {
-        lappend type script $terp
-    } elseif {([regexp "\\\[manpage_begin " $test] &&
-	       !([regexp -- {--- !doctools ---} $test] || [regexp -- "!tcl\.tk//DSL doctools//EN//" $test])) ||
-                ([regexp -- {--- doctools ---} $test]  || [regexp -- "tcl\.tk//DSL doctools//EN//" $test])} {
-	lappend type doctools
-    } elseif {([regexp "\\\[toc_begin " $test] &&
-	       !([regexp -- {--- !doctoc ---} $test] || [regexp -- "!tcl\.tk//DSL doctoc//EN//" $test])) ||
-                ([regexp -- {--- doctoc ---} $test]  || [regexp -- "tcl\.tk//DSL doctoc//EN//" $test])} {
-	lappend type doctoc
-    } elseif {([regexp "\\\[index_begin " $test] &&
-	       !([regexp -- {--- !docidx ---} $test] || [regexp -- "!tcl\.tk//DSL docidx//EN//" $test])) ||
-              ([regexp -- {--- docidx ---} $test] || [regexp -- "tcl\.tk//DSL docidx//EN//" $test])} {
-	lappend type docidx
-    } elseif {[regexp -- "tcl\\.tk//DSL diagram//EN//" $test]} {
-	lappend type tkdiagram
-    } elseif { $binary && [ regexp {^[\x7F]ELF} $test ] } {
-        lappend type executable elf
-    } elseif { $binary && [string match "MZ*" $test] } {
-        if { [scan [string index $test 24] %c] < 64 } {
-            lappend type executable dos
-        } else {
-            binary scan [string range $test 60 61] s next
-            set sig [string range $test $next [expr {$next + 1}]]
-            if { $sig == "NE" || $sig == "PE" } {
-                lappend type executable [string tolower $sig]
-            } else {
-                lappend type executable dos
-            }
-        }
-    } elseif { $binary && [string match "SQLite format 3\x00*" $test] } {
-	lappend type sqlite3
-
-	# Check for various sqlite-based application file formats.
-	set appid [string range $test 68 71]
-	if {$appid eq "\x0f\x05\x51\x12"} {
-	    lappend type fossil-checkout
-	} elseif {$appid eq "\x0f\x05\x51\x13"} {
-	    lappend type fossil-global-config
-	} elseif {$appid eq "\x0f\x05\x51\x11"} {
-	    lappend type fossil-repository
-	} else {
-	    # encode the appid as hex and append that.
-	    binary scan $appid H8 aid
-	    lappend type A$aid
-	}
-
-    } elseif { $binary && [string match "BZh91AY\&SY*" $test] } {
-        lappend type compressed bzip
-    } elseif { $binary && [string match "\x1f\x8b*" $test] } {
-        lappend type compressed gzip
-    } elseif { $binary && [string range $test 257 262] == "ustar\x00" } {
-        lappend type compressed tar
-    } elseif { $binary && [string match "\x50\x4b\x03\x04*" $test] } {
-        lappend type compressed zip
-    } elseif { $binary && [string match "GIF*" $test] } {
-        lappend type graphic gif
-    } elseif { $binary && [string match "icns*" $test] } {
-        lappend type graphic icns bigendian
-    } elseif { $binary && [string match "snci*" $test] } {
-        lappend type graphic icns smallendian
-    } elseif { $binary && [string match "\x89PNG*" $test] } {
-        lappend type graphic png
-    } elseif { $binary && [string match "\xFF\xD8\xFF*" $test] } {
-        binary scan $test x3H2x2a5 marker txt
-        if { $marker == "e0" && $txt == "JFIF\x00" } {
-            lappend type graphic jpeg jfif
-        } elseif { $marker == "e1" && $txt == "Exif\x00" } {
-            lappend type graphic jpeg exif
-        }
-    } elseif { $binary && [string match "MM\x00\**" $test] } {
-        lappend type graphic tiff
-    } elseif { $binary && [string match "BM*" $test] && [string range $test 6 9] == "\x00\x00\x00\x00" } {
-        lappend type graphic bitmap
-    } elseif { ! $binary && [string match -nocase "*\<html\>*" $test] } {
-        lappend type html
-    } elseif {[string match "\%PDF\-*" $test] } {
-        lappend type pdf
-    } elseif { [string match "\%\!PS\-*" $test] } {
-       lappend type ps
-       if { [string match "* EPSF\-*" $test] } {
-           lappend type eps
-       }
-    } elseif { [string match -nocase "*\<\?xml*" $test] } {
-        lappend type xml
-        if { [ regexp -nocase {\<\!DOCTYPE\s+(\S+)} $test -> doctype ] } {
-            lappend type $doctype
-        }
-    } elseif { [string match {*BEGIN PGP MESSAGE*} $test] } {
-        lappend type message pgp
-    } elseif { $binary && [string match {IGWD*} $test] } {
-        lappend type gravity_wave_data_frame
-    } elseif {[string match "JL\x1a\x00*" $test] && ([file size $filename] >= 27)} {
-	lappend type metakit smallendian
-	set metakit 1
-    } elseif {[string match "LJ\x1a\x00*" $test] && ([file size $filename] >= 27)} {
-	lappend type metakit bigendian
-	set metakit 1
-    } elseif { $binary && [string match "RIFF*" $test] && [string range $test 8 11] == "WAVE" } {
-        lappend type audio wave
-    } elseif { $binary && [string match "ID3*" $test] } {
-        lappend type audio mpeg
-    } elseif { $binary && [binary scan $test S tmp] && [expr {$tmp & 0xFFE0}] == 65504 } {
-        lappend type audio mpeg
-    }
-
-    # Additional checks of file contents at the end of the file,
-    # possibly pointing into the middle too (attached metakit,
-    # attached zip).
-
-    ## Metakit File format: http://www.equi4.com/metakit/metakit-ff.html
-    ## Metakit database attached ? ##
-
-    if {!$metakit && ([file size $filename] >= 27)} {
-	# The offsets in the footer are in always bigendian format
-
-	if { [ catch {
-	    set fid [ open $filename r ]
-	    fconfigure $fid -translation binary
-	    fconfigure $fid -buffersize 1024
-	    fconfigure $fid -buffering full
-	    seek $fid -16 end
-	    set test [ read $fid 16 ]
-	    ::close $fid
-	} err ] } {
-	    catch { ::close $fid }
-	    return -code error "::fileutil::fileType: $err"
-	}
-
-	binary scan $test IIII __ hdroffset __ __
-	set hdroffset [expr {[file size $filename] - 16 - $hdroffset}]
-
-	# Further checks iff the offset is actually inside the file.
-
-	if {($hdroffset >= 0) && ($hdroffset < [file size $filename])} {
-	    # Seek to the specified location and try to match a metakit header
-	    # at this location.
-
-	    if { [ catch {
-		set         fid [ open $filename r ]
-		fconfigure $fid -translation binary
-		fconfigure $fid -buffersize 1024
-		fconfigure $fid -buffering full
-		seek       $fid $hdroffset start
-		set test [ read $fid 16 ]
-		::close $fid
-	    } err ] } {
-		catch { ::close $fid }
-		return -code error "::fileutil::fileType: $err"
-	    }
-
-	    if {[string match "JL\x1a\x00*" $test]} {
-		lappend type attached metakit smallendian
-		set metakit 1
-	    } elseif {[string match "LJ\x1a\x00*" $test]} {
-		lappend type attached metakit bigendian
-		set metakit 1
-	    }
-	}
-    }
-
-    ## Zip File Format: http://zziplib.sourceforge.net/zzip-parse.html
-    ## http://www.pkware.com/products/enterprise/white_papers/appnote.html
-
-
-    ;## lastly, is it a link?
-    if { ! [ catch {file readlink $filename} ] } {
-        lappend type link
-    }
-    return $type
-}
-
-# ::fileutil::tempdir --
-#
-#	Return the correct directory to use for temporary files.
-#	Python attempts this sequence, which seems logical:
-#
-#       1. The directory named by the `TMPDIR' environment variable.
-#
-#       2. The directory named by the `TEMP' environment variable.
-#
-#       3. The directory named by the `TMP' environment variable.
-#
-#       4. A platform-specific location:
-#            * On Macintosh, the `Temporary Items' folder.
-#
-#            * On Windows, the directories `C:\\TEMP', `C:\\TMP',
-#              `\\TEMP', and `\\TMP', in that order.
-#
-#            * On all other platforms, the directories `/tmp',
-#              `/var/tmp', and `/usr/tmp', in that order.
-#
-#       5. As a last resort, the current working directory.
-#
-#	The code here also does
-#
-#	0. The directory set by invoking tempdir with an argument.
-#	   If this is present it is used exclusively.
-#
-# Arguments:
-#	None.
-#
-# Side Effects:
-#	None.
-#
-# Results:
-#	The directory for temporary files.
-
-proc ::fileutil::tempdir {args} {
-    if {[llength $args] > 1} {
-	return -code error {wrong#args: should be "::fileutil::tempdir ?path?"}
-    } elseif {[llength $args] == 1} {
-	variable tempdir    [lindex $args 0]
-	variable tempdirSet 1
-	return
-    }
-    return [Normalize [TempDir]]
-}
-
-proc ::fileutil::tempdirReset {} {
-    variable tempdir    {}
-    variable tempdirSet 0
-    return
-}
-
-proc ::fileutil::TempDir {} {
-    global tcl_platform env
-    variable tempdir
-    variable tempdirSet
-
-    set attempdirs [list]
-    set problems   {}
-
-    if {$tempdirSet} {
-	lappend attempdirs $tempdir
-	lappend problems {User/Application specified tempdir}
-    } else {
-	foreach tmp {TMPDIR TEMP TMP} {
-	    if { [info exists env($tmp)] } {
-		lappend attempdirs $env($tmp)
-	    } else {
-		lappend problems "No environment variable $tmp"
-	    }
-	}
-
-	switch $tcl_platform(platform) {
-	    windows {
-		lappend attempdirs "C:\\TEMP" "C:\\TMP" "\\TEMP" "\\TMP"
-	    }
-	    macintosh {
-		lappend attempdirs $env(TRASH_FOLDER)  ;# a better place?
-	    }
-	    default {
-		lappend attempdirs \
-		    [file join / tmp] \
-		    [file join / var tmp] \
-		    [file join / usr tmp]
-	    }
-	}
-
-	lappend attempdirs [pwd]
-    }
-
-    foreach tmp $attempdirs {
-	if { [file isdirectory $tmp] && [file writable $tmp] } {
-	    return $tmp
-	} elseif { ![file isdirectory $tmp] } {
-	    lappend problems "Not a directory: $tmp"
-	} else {
-	    lappend problems "Not writable: $tmp"
-	}
-    }
-
-    # Fail if nothing worked.
-    return -code error "Unable to determine a proper directory for temporary files\n[join $problems \n]"
-}
-
-namespace eval ::fileutil {
-    variable tempdir    {}
-    variable tempdirSet 0
-}
-
-# ::fileutil::maketempdir --
-
-proc ::fileutil::maketempdir {args} {
-    return [Normalize [MakeTempDir $args]]
-}
-
-proc ::fileutil::MakeTempDir {config} {
-    # Setup of default configuration.
-    array set options {}
-    set options(-suffix) ""
-    set options(-prefix) "tmp"
-    set options(-dir)    [tempdir]
-
-    # TODO: Check for and reject options not in -suffix, -prefix, -dir
-    # Merge user configuration, overwrite defaults.
-    array set options $config
-
-    # See also "tempfile" below. Could be shareable internal configuration.
-    set chars       abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
-    set nrand_chars 10
-    set maxtries    10
-
-    for {set i 0} {$i < $maxtries} {incr i} {
-	# Build up the candidate name. See also "tempfile".
-	set directory_name $options(-prefix)
-	for {set j 0} {$j < $nrand_chars} {incr j} {
-	    append directory_name \
-		[string index $chars [expr {int(rand() * 62)}]]
-	}
-	append directory_name $options(-suffix)
-	set path [file join $options(-dir) $directory_name]
-
-	# Try to create. Try again if already exists, or trouble
-	# with creation and setting of perms.
-	#
-	# Note: The last looks as if it is able to leave partial
-	# directories behind (created, trouble with perms). But
-	# deleting ... Might pull the rug out from somebody else.
-
-	if {[file exists $path]} continue
-	if {[catch {
-	    file mkdir $path
-	    if {$::tcl_platform(platform) eq "unix"} {
-		file attributes $path -permissions 0700
-	    }
-	}]} continue
-
-	return $path
-    }
-    return -code error "Failed to find an unused temporary directory name"
-}
-
-# ::fileutil::tempfile --
-#
-#   generate a temporary file name suitable for writing to
-#   the file name will be unique, writable and will be in the
-#   appropriate system specific temp directory
-#   Code taken from http://mini.net/tcl/772 attributed to
-#    Igor Volobouev and anon.
-#
-# Arguments:
-#   prefix     - a prefix for the filename, p
-# Results:
-#   returns a file name
-#
-
-proc ::fileutil::tempfile {{prefix {}}} {
-    return [Normalize [TempFile $prefix]]
-}
-
-proc ::fileutil::TempFile {prefix} {
-    set tmpdir [tempdir]
-
-    set chars       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-    set nrand_chars 10
-    set maxtries    10
-    set access      [list RDWR CREAT EXCL]
-    set permission  0600
-    set channel ""
-    set checked_dir_writable 0
-
-    for {set i 0} {$i < $maxtries} {incr i} {
- 	set newname $prefix
- 	for {set j 0} {$j < $nrand_chars} {incr j} {
- 	    append newname [string index $chars \
-		    [expr {int(rand()*62)}]]
- 	}
-	set newname [file join $tmpdir $newname]
-
-	if {[catch {open $newname $access $permission} channel]} {
-	    if {!$checked_dir_writable} {
-		set dirname [file dirname $newname]
-		if {![file writable $dirname]} {
-		    return -code error "Directory $dirname is not writable"
-		}
-		set checked_dir_writable 1
-	    }
-	} else {
-	    # Success
-	    close $channel
-	    return $newname
-	}
-
-    }
-    if {[string compare $channel ""]} {
- 	return -code error "Failed to open a temporary file: $channel"
-    } else {
- 	return -code error "Failed to find an unused temporary file name"
-    }
-}
-
-# ::fileutil::install --
-#
-#	Tcl version of the 'install' command, which copies files from
-#	one places to another and also optionally sets some attributes
-#	such as group, owner, and permissions.
-#
-# Arguments:
-#	-m		Change the file permissions to the specified
-#                       value.  Valid arguments are those accepted by
-#			file attributes -permissions
-#
-# Results:
-#	None.
-
-# TODO - add options for group/owner manipulation.
-
-proc ::fileutil::install {args} {
-    set options {
-	{m.arg "" "Set permission mode"}
-    }
-    set usage ": [lindex [info level 0] 0]\
-\[options] source destination \noptions:"
-    array set params [::cmdline::getoptions args $options $usage]
-    # Args should now just be the source and destination.
-    if { [llength $args] < 2 } {
-	return -code error $usage
-    }
-    set src [lindex $args 0]
-    set dst [lindex $args 1]
-    file copy -force $src $dst
-    if { $params(m) != "" } {
-	set targets [::fileutil::find $dst]
-	foreach fl $targets {
-	    file attributes $fl -permissions $params(m)
-	}
-    }
-}
-
-# ### ### ### ######### ######### #########
-
-proc ::fileutil::lexnormalize {sp} {
-    set spx [file split $sp]
-
-    # Resolution of embedded relative modifiers (., and ..).
-
-    if {
-	([lsearch -exact $spx . ] < 0) &&
-	([lsearch -exact $spx ..] < 0)
-    } {
-	# Quick path out if there are no relative modifiers
-	return $sp
-    }
-
-    set absolute [expr {![string equal [file pathtype $sp] relative]}]
-    # A volumerelative path counts as absolute for our purposes.
-
-    set sp $spx
-    set np {}
-    set noskip 1
-
-    while {[llength $sp]} {
-	set ele    [lindex $sp 0]
-	set sp     [lrange $sp 1 end]
-	set islast [expr {[llength $sp] == 0}]
-
-	if {[string equal $ele ".."]} {
-	    if {
-		($absolute  && ([llength $np] >  1)) ||
-		(!$absolute && ([llength $np] >= 1))
-	    } {
-		# .. : Remove the previous element added to the
-		# new path, if there actually is enough to remove.
-		set np [lrange $np 0 end-1]
-	    }
-	} elseif {[string equal $ele "."]} {
-	    # Ignore .'s, they stay at the current location
-	    continue
-	} else {
-	    # A regular element.
-	    lappend np $ele
-	}
-    }
-    if {[llength $np] > 0} {
-	return [eval [linsert $np 0 file join]]
-	# 8.5: return [file join {*}$np]
-    }
-    return {}
-}
-
-# ### ### ### ######### ######### #########
-## Forward compatibility. Some routines require path normalization,
-## something we have supported by the builtin 'file' only since Tcl
-## 8.4. For versions of Tcl before that, to be supported by the
-## module, we implement a normalizer in Tcl itself. Slow, but working.
-
-if {[package vcompare [package provide Tcl] 8.4] < 0} {
-    # Pre 8.4. We do not have 'file normalize'. We create an
-    # approximation for it based on earlier commands.
-
-    # ... Hm. This is lexical normalization. It does not resolve
-    # symlinks in the path to their origin.
-
-    proc ::fileutil::Normalize {sp} {
-	set sp [file split $sp]
-
-	# Conversion of the incoming path to absolute.
-	if {[string equal [file pathtype [lindex $sp 0]] "relative"]} {
-	    set sp [file split [eval [list file join [pwd]] $sp]]
-	}
-
-	# Resolution of symlink components, and embedded relative
-	# modifiers (., and ..).
-
-	set np {}
-	set noskip 1
-	while {[llength $sp]} {
-	    set ele    [lindex $sp 0]
-	    set sp     [lrange $sp 1 end]
-	    set islast [expr {[llength $sp] == 0}]
-
-	    if {[string equal $ele ".."]} {
-		if {[llength $np] > 1} {
-		    # .. : Remove the previous element added to the
-		    # new path, if there actually is enough to remove.
-		    set np [lrange $np 0 end-1]
-		}
-	    } elseif {[string equal $ele "."]} {
-		# Ignore .'s, they stay at the current location
-		continue
-	    } else {
-		# A regular element. If it is not the last component
-		# then check if the combination is a symlink, and if
-		# yes, resolve it.
-
-		lappend np $ele
-
-		if {!$islast && $noskip} {
-		    # The flag 'noskip' is technically not required,
-		    # just 'file exists'. However if a path P does not
-		    # exist, then all longer paths starting with P can
-		    # not exist either, and using the flag to store
-		    # this knowledge then saves us a number of
-		    # unnecessary stat calls. IOW this a performance
-		    # optimization.
-
-		    set p [eval file join $np]
-		    set noskip [file exists $p]
-		    if {$noskip} {
-			if {[string equal link [file type $p]]} {
-			    set dst [file readlink $p]
-
-			    # We always push the destination in front of
-			    # the source path (in expanded form). So that
-			    # we handle .., .'s, and symlinks inside of
-			    # this path as well. An absolute path clears
-			    # the result, a relative one just removes the
-			    # last, now resolved component.
-
-			    set sp [eval [linsert [file split $dst] 0 linsert $sp 0]]
-
-			    if {![string equal relative [file pathtype $dst]]} {
-				# Absolute|volrelative destination, clear
-				# result, we have to start over.
-				set np {}
-			    } else {
-				# Relative link, just remove the resolved
-				# component again.
-				set np [lrange $np 0 end-1]
-			    }
-			}
-		    }
-		}
-	    }
-	}
-	if {[llength $np] > 0} {
-	    return [eval file join $np]
-	}
-	return {}
-    }
-} else {
-    proc ::fileutil::Normalize {sp} {
-	file normalize $sp
-    }
-}
-
-# ::fileutil::relative --
-#
-#	Taking two _directory_ paths, a base and a destination, computes the path
-#	of the destination relative to the base.
-#
-# Arguments:
-#	base	The path to make the destination relative to.
-#	dst	The destination path
-#
-# Results:
-#	The path of the destination, relative to the base.
-
-proc ::fileutil::relative {base dst} {
-    # Ensure that the link to directory 'dst' is properly done relative to
-    # the directory 'base'.
-
-    if {![string equal [file pathtype $base] [file pathtype $dst]]} {
-	return -code error "Unable to compute relation for paths of different pathtypes: [file pathtype $base] vs. [file pathtype $dst], ($base vs. $dst)"
-    }
-
-    set base [lexnormalize [file join [pwd] $base]]
-    set dst  [lexnormalize [file join [pwd] $dst]]
-
-    set save $dst
-    set base [file split $base]
-    set dst  [file split $dst]
-
-    while {[string equal [lindex $dst 0] [lindex $base 0]]} {
-	set dst  [lrange $dst  1 end]
-	set base [lrange $base 1 end]
-	if {![llength $dst]} {break}
-    }
-
-    set dstlen  [llength $dst]
-    set baselen [llength $base]
-
-    if {($dstlen == 0) && ($baselen == 0)} {
-	# Cases:
-	# (a) base == dst
-
-	set dst .
-    } else {
-	# Cases:
-	# (b) base is: base/sub = sub
-	#     dst  is: base     = {}
-
-	# (c) base is: base     = {}
-	#     dst  is: base/sub = sub
-
-	while {$baselen > 0} {
-	    set dst [linsert $dst 0 ..]
-	    incr baselen -1
-	}
-	# 8.5: set dst [file join {*}$dst]
-	set dst [eval [linsert $dst 0 file join]]
-    }
-
-    return $dst
-}
-
-# ::fileutil::relativeUrl --
-#
-#	Taking two _file_ paths, a base and a destination, computes the path
-#	of the destination relative to the base, from the inside of the base.
-#
-#	This is how a browser resolves relative links in a file, hence the
-#	url in the command name.
-#
-# Arguments:
-#	base	The file path to make the destination relative to.
-#	dst	The destination file path
-#
-# Results:
-#	The path of the destination file, relative to the base file.
-
-proc ::fileutil::relativeUrl {base dst} {
-    # Like 'relative', but for links from _inside_ a file to a
-    # different file.
-
-    if {![string equal [file pathtype $base] [file pathtype $dst]]} {
-	return -code error "Unable to compute relation for paths of different pathtypes: [file pathtype $base] vs. [file pathtype $dst], ($base vs. $dst)"
-    }
-
-    set base [lexnormalize [file join [pwd] $base]]
-    set dst  [lexnormalize [file join [pwd] $dst]]
-
-    set basedir [file dirname $base]
-    set dstdir  [file dirname $dst]
-
-    set dstdir  [relative $basedir $dstdir]
-
-    # dstdir == '.' on input => dstdir output has trailing './'. Strip
-    # this superfluous segment off.
-
-    if {[string equal $dstdir "."]} {
-	return [file tail $dst]
-    } elseif {[string equal [file tail $dstdir] "."]} {
-	return [file join [file dirname $dstdir] [file tail $dst]]
-    } else {
-	return [file join $dstdir [file tail $dst]]
-    }
-}
-
-# ::fileutil::fullnormalize --
-#
-#	Normalizes a path completely. I.e. a symlink in the last
-#	element is resolved as well, not only symlinks in the higher
-#	elements.
-#
-# Arguments:
-#	path	The path to normalize
-#
-# Results:
-#	The input path with all symlinks resolved.
-
-proc ::fileutil::fullnormalize {path} {
-    # When encountering symlinks in a file copy operation Tcl copies
-    # the link, not the contents of the file it references. There are
-    # situations there this is not acceptable. For these this command
-    # resolves all symbolic links in the path, including in the last
-    # element of the path. A "file copy" using the return value of
-    # this command copies an actual file, it will not encounter
-    # symlinks.
-
-    # BUG / WORKAROUND. Using the / instead of the join seems to work
-    # around a bug in the path handling on windows which can break the
-    # core 'file normalize' for symbolic links. This was exposed by
-    # the find testsuite which could not reproduced outside. I believe
-    # that there is some deep path bug in the core triggered under
-    # special circumstances. Use of / likely forces a refresh through
-    # the string rep and so avoids the problem with the path intrep.
-
-    return [file dirname [Normalize $path/__dummy__]]
-    #return [file dirname [Normalize [file join $path __dummy__]]]
-}
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/http-2.10b1.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/http-2.10b1.tm
deleted file mode 100644
index 6c3c068c..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/http-2.10b1.tm
+++ /dev/null
@@ -1,5457 +0,0 @@
-# http.tcl --
-#
-#	Client-side HTTP for GET, POST, and HEAD commands. These routines can
-#	be used in untrusted code that uses the Safesock security policy.
-#	These procedures use a callback interface to avoid using vwait, which
-#	is not defined in the safe base.
-#
-# See the file "license.terms" for information on usage and redistribution of
-# this file, and for a DISCLAIMER OF ALL WARRANTIES.
-
-package require Tcl 8.6-
-# Keep this in sync with pkgIndex.tcl and with the install directories in
-# Makefiles
-package provide http 2.10b1
-
-namespace eval http {
-    # Allow resourcing to not clobber existing data
-
-    variable http
-    if {![info exists http]} {
-	array set http {
-	    -accept */*
-	    -cookiejar {}
-	    -pipeline 1
-	    -postfresh 0
-	    -proxyhost {}
-	    -proxyport {}
-	    -proxyfilter http::ProxyRequired
-	    -proxynot {}
-	    -proxyauth {}
-	    -repost 0
-	    -threadlevel 0
-	    -urlencoding utf-8
-	    -zip 1
-	}
-	# We need a useragent string of this style or various servers will
-	# refuse to send us compressed content even when we ask for it. This
-	# follows the de-facto layout of user-agent strings in current browsers.
-	# Safe interpreters do not have ::tcl_platform(os) or
-	# ::tcl_platform(osVersion).
-	if {[interp issafe]} {
-	    set http(-useragent) "Mozilla/5.0\
-		(Windows; U;\
-		Windows NT 10.0)\
-		http/[package provide http] Tcl/[package provide Tcl]"
-	} else {
-	    set http(-useragent) "Mozilla/5.0\
-		([string totitle $::tcl_platform(platform)]; U;\
-		$::tcl_platform(os) $::tcl_platform(osVersion))\
-		http/[package provide http] Tcl/[package provide Tcl]"
-	}
-    }
-
-    proc init {} {
-	# Set up the map for quoting chars. RFC3986 Section 2.3 say percent
-	# encode all except: "... percent-encoded octets in the ranges of
-	# ALPHA (%41-%5A and %61-%7A), DIGIT (%30-%39), hyphen (%2D), period
-	# (%2E), underscore (%5F), or tilde (%7E) should not be created by URI
-	# producers ..."
-	for {set i 0} {$i <= 256} {incr i} {
-	    set c [format %c $i]
-	    if {![string match {[-._~a-zA-Z0-9]} $c]} {
-		set map($c) %[format %.2X $i]
-	    }
-	}
-	# These are handled specially
-	set map(\n) %0D%0A
-	variable formMap [array get map]
-
-	# Create a map for HTTP/1.1 open sockets
-	variable socketMapping
-	variable socketRdState
-	variable socketWrState
-	variable socketRdQueue
-	variable socketWrQueue
-	variable socketPhQueue
-	variable socketClosing
-	variable socketPlayCmd
-	variable socketCoEvent
-	variable socketProxyId
-	if {[info exists socketMapping]} {
-	    # Close open sockets on re-init.  Do not permit retries.
-	    foreach {url sock} [array get socketMapping] {
-		unset -nocomplain socketClosing($url)
-		unset -nocomplain socketPlayCmd($url)
-		CloseSocket $sock
-	    }
-	}
-
-	# CloseSocket should have unset the socket* arrays, one element at
-	# a time.  Now unset anything that was overlooked.
-	# Traces on "unset socketRdState(*)" will call CancelReadPipeline and
-	# cancel any queued responses.
-	# Traces on "unset socketWrState(*)" will call CancelWritePipeline and
-	# cancel any queued requests.
-	array unset socketMapping
-	array unset socketRdState
-	array unset socketWrState
-	array unset socketRdQueue
-	array unset socketWrQueue
-	array unset socketPhQueue
-	array unset socketClosing
-	array unset socketPlayCmd
-	array unset socketCoEvent
-	array unset socketProxyId
-	array set socketMapping {}
-	array set socketRdState {}
-	array set socketWrState {}
-	array set socketRdQueue {}
-	array set socketWrQueue {}
-	array set socketPhQueue {}
-	array set socketClosing {}
-	array set socketPlayCmd {}
-	array set socketCoEvent {}
-	array set socketProxyId {}
-	return
-    }
-    init
-
-    variable urlTypes
-    if {![info exists urlTypes]} {
-	set urlTypes(http) [list 80 ::http::socket]
-    }
-
-    variable encodings [string tolower [encoding names]]
-    # This can be changed, but iso8859-1 is the RFC standard.
-    variable defaultCharset
-    if {![info exists defaultCharset]} {
-	set defaultCharset "iso8859-1"
-    }
-
-    # Force RFC 3986 strictness in geturl url verification?
-    variable strict
-    if {![info exists strict]} {
-	set strict 1
-    }
-
-    # Let user control default keepalive for compatibility
-    variable defaultKeepalive
-    if {![info exists defaultKeepalive]} {
-	set defaultKeepalive 0
-    }
-
-    # Regular expression used to parse cookies
-    variable CookieRE {(?x)                            # EXPANDED SYNTAX
-	\s*                                            # Ignore leading spaces
-	([^][\u0000- ()<>@,;:\\""/?={}\u007f-\uffff]+) # Match the name
-	=                                              # LITERAL: Equal sign
-	([!\u0023-+\u002D-:<-\u005B\u005D-~]*)         # Match the value
-	(?:
-	 \s* ; \s*                                     # LITERAL: semicolon
-	 ([^\u0000]+)                                  # Match the options
-	)?
-    }
-
-    variable TmpSockCounter 0
-    variable ThreadCounter  0
-
-    variable reasonDict [dict create {*}{
-        100 Continue
-        101 {Switching Protocols}
-        102 Processing
-        103 {Early Hints}
-        200 OK
-        201 Created
-        202 Accepted
-        203 {Non-Authoritative Information}
-        204 {No Content}
-        205 {Reset Content}
-        206 {Partial Content}
-        207 Multi-Status
-        208 {Already Reported}
-        226 {IM Used}
-        300 {Multiple Choices}
-        301 {Moved Permanently}
-        302 Found
-        303 {See Other}
-        304 {Not Modified}
-        305 {Use Proxy}
-        306 (Unused)
-        307 {Temporary Redirect}
-        308 {Permanent Redirect}
-        400 {Bad Request}
-        401 Unauthorized
-        402 {Payment Required}
-        403 Forbidden
-        404 {Not Found}
-        405 {Method Not Allowed}
-        406 {Not Acceptable}
-        407 {Proxy Authentication Required}
-        408 {Request Timeout}
-        409 Conflict
-        410 Gone
-        411 {Length Required}
-        412 {Precondition Failed}
-        413 {Content Too Large}
-        414 {URI Too Long}
-        415 {Unsupported Media Type}
-        416 {Range Not Satisfiable}
-        417 {Expectation Failed}
-        418 (Unused)
-        421 {Misdirected Request}
-        422 {Unprocessable Content}
-        423 Locked
-        424 {Failed Dependency}
-        425 {Too Early}
-        426 {Upgrade Required}
-        428 {Precondition Required}
-        429 {Too Many Requests}
-        431 {Request Header Fields Too Large}
-        451 {Unavailable For Legal Reasons}
-        500 {Internal Server Error}
-        501 {Not Implemented}
-        502 {Bad Gateway}
-        503 {Service Unavailable}
-        504 {Gateway Timeout}
-        505 {HTTP Version Not Supported}
-        506 {Variant Also Negotiates}
-        507 {Insufficient Storage}
-        508 {Loop Detected}
-        510 {Not Extended (OBSOLETED)}
-        511 {Network Authentication Required}
-    }]
-
-    variable failedProxyValues {
-	binary
-	body
-	charset
-	coding
-	connection
-	connectionRespFlag
-	currentsize
-	host
-	http
-	httpResponse
-	meta
-	method
-	querylength
-	queryoffset
-	reasonPhrase
-	requestHeaders
-	requestLine
-	responseCode
-	state
-	status
-	tid
-	totalsize
-	transfer
-	type
-    }
-
-    namespace export geturl config reset wait formatQuery postError quoteString
-    namespace export register unregister registerError
-    namespace export requestLine requestHeaders requestHeaderValue
-    namespace export responseLine responseHeaders responseHeaderValue
-    namespace export responseCode responseBody responseInfo reasonPhrase
-    # - Legacy aliases, were never exported:
-    #     data, code, mapReply, meta, ncode
-    # - Callable from outside (e.g. from TLS) by fully-qualified name, but
-    #   not exported:
-    #     socket
-    # - Useful, but never exported (and likely to have naming collisions):
-    #     size, status, cleanup, error, init
-    #   Comments suggest that "init" can be used for re-initialisation,
-    #   although the command is undocumented.
-    # - Never exported, renamed from lower-case names:
-    #   GetTextLine, MakeTransformationChunked.
-}
-
-# http::Log --
-#
-#	Debugging output -- define this to observe HTTP/1.1 socket usage.
-#	Should echo any args received.
-#
-# Arguments:
-#     msg	Message to output
-#
-if {[info command http::Log] eq {}} {proc http::Log {args} {}}
-
-# http::register --
-#
-#     See documentation for details.
-#
-# Arguments:
-#     proto	URL protocol prefix, e.g. https
-#     port	Default port for protocol
-#     command	Command to use to create socket
-# Results:
-#     list of port and command that was registered.
-
-proc http::register {proto port command} {
-    variable urlTypes
-    set urlTypes([string tolower $proto]) [list $port $command]
-}
-
-# http::unregister --
-#
-#     Unregisters URL protocol handler
-#
-# Arguments:
-#     proto	URL protocol prefix, e.g. https
-# Results:
-#     list of port and command that was unregistered.
-
-proc http::unregister {proto} {
-    variable urlTypes
-    set lower [string tolower $proto]
-    if {![info exists urlTypes($lower)]} {
-	return -code error "unsupported url type \"$proto\""
-    }
-    set old $urlTypes($lower)
-    unset urlTypes($lower)
-    return $old
-}
-
-# http::config --
-#
-#	See documentation for details.
-#
-# Arguments:
-#	args		Options parsed by the procedure.
-# Results:
-#        TODO
-
-proc http::config {args} {
-    variable http
-    set options [lsort [array names http -*]]
-    set usage [join $options ", "]
-    if {[llength $args] == 0} {
-	set result {}
-	foreach name $options {
-	    lappend result $name $http($name)
-	}
-	return $result
-    }
-    set options [string map {- ""} $options]
-    set pat ^-(?:[join $options |])$
-    if {[llength $args] == 1} {
-	set flag [lindex $args 0]
-	if {![regexp -- $pat $flag]} {
-	    return -code error "Unknown option $flag, must be: $usage"
-	}
-	return $http($flag)
-    } elseif {[llength $args] % 2} {
-	return -code error "If more than one argument is supplied, the\
-		number of arguments must be even"
-    } else {
-	foreach {flag value} $args {
-	    if {![regexp -- $pat $flag]} {
-		return -code error "Unknown option $flag, must be: $usage"
-	    }
-	    if {($flag eq {-threadlevel}) && ($value ni {0 1 2})} {
-		return -code error {Option -threadlevel must be 0, 1 or 2}
-	    }
-	    set http($flag) $value
-	}
-	return
-    }
-}
-
-# ------------------------------------------------------------------------------
-#  Proc http::reasonPhrase
-# ------------------------------------------------------------------------------
-# Command to return the IANA-recommended "reason phrase" for a HTTP Status Code.
-# Information obtained from:
-# https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-#
-# Arguments:
-# code        - A valid HTTP Status Code (integer from 100 to 599)
-#
-# Return Value: the reason phrase
-# ------------------------------------------------------------------------------
-
-proc http::reasonPhrase {code} {
-    variable reasonDict
-    if {![regexp -- {^[1-5][0-9][0-9]$} $code]} {
-        set msg {argument must be a three-digit integer from 100 to 599}
-        return -code error $msg
-    }
-    if {[dict exists $reasonDict $code]} {
-        set reason [dict get $reasonDict $code]
-    } else {
-        set reason Unassigned
-    }
-    return $reason
-}
-
-# http::Finish --
-#
-#	Clean up the socket and eval close time callbacks
-#
-# Arguments:
-#	token	    Connection token.
-#	errormsg    (optional) If set, forces status to error.
-#	skipCB      (optional) If set, don't call the -command callback. This
-#		    is useful when geturl wants to throw an exception instead
-#		    of calling the callback. That way, the same error isn't
-#		    reported to two places.
-#
-# Side Effects:
-#        May close the socket.
-
-proc http::Finish {token {errormsg ""} {skipCB 0}} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    global errorInfo errorCode
-    set closeQueue 0
-    if {$errormsg ne ""} {
-	set state(error) [list $errormsg $errorInfo $errorCode]
-	set state(status) "error"
-    }
-    if {[info commands ${token}--EventCoroutine] ne {}} {
-	rename ${token}--EventCoroutine {}
-    }
-    if {[info commands ${token}--SocketCoroutine] ne {}} {
-	rename ${token}--SocketCoroutine {}
-    }
-    if {[info exists state(socketcoro)]} {
-        Log $token Cancel socket after-idle event (Finish)
-        after cancel $state(socketcoro)
-        unset state(socketcoro)
-    }
-
-    # Is this an upgrade request/response?
-    set upgradeResponse \
-	[expr {    [info exists state(upgradeRequest)]
-		&& $state(upgradeRequest)
-		&& [info exists state(http)]
-		&& ([ncode $token] eq {101})
-		&& [info exists state(connection)]
-		&& ("upgrade" in $state(connection))
-		&& [info exists state(upgrade)]
-		&& ("" ne $state(upgrade))
-	}]
-
-    if {  ($state(status) eq "timeout")
-       || ($state(status) eq "error")
-       || ($state(status) eq "eof")
-    } {
-	set closeQueue 1
-	set connId $state(socketinfo)
-	if {[info exists state(sock)]} {
-	    set sock $state(sock)
-	    CloseSocket $state(sock) $token
-	} else {
-            # When opening the socket and calling http::reset
-            # immediately, the socket may not yet exist.
-            # Test http-4.11 may come here.
-	}
-	if {$state(tid) ne {}} {
-            # When opening the socket in a thread, and calling http::reset
-            # immediately, the thread may still exist.
-            # Test http-4.11 may come here.
-	    thread::release $state(tid)
-	    set state(tid) {}
-	} else {
-	}
-    } elseif {$upgradeResponse} {
-	# Special handling for an upgrade request/response.
-	# - geturl ensures that this is not a "persistent" socket used for
-	#   multiple HTTP requests, so a call to KeepSocket is not needed.
-	# - Leave socket open, so a call to CloseSocket is not needed either.
-	# - Remove fileevent bindings.  The caller will set its own bindings.
-	# - THE CALLER MUST PROCESS THE UPGRADED SOCKET IN THE CALLBACK COMMAND
-	#   PASSED TO http::geturl AS -command callback.
-	catch {fileevent $state(sock) readable {}}
-	catch {fileevent $state(sock) writable {}}
-    } elseif {
-          ([info exists state(-keepalive)] && !$state(-keepalive))
-       || ([info exists state(connection)] && ("close" in $state(connection)))
-    } {
-	set closeQueue 1
-	set connId $state(socketinfo)
-	if {[info exists state(sock)]} {
-	    set sock $state(sock)
-	    CloseSocket $state(sock) $token
-	} else {
-            # When opening the socket and calling http::reset
-            # immediately, the socket may not yet exist.
-            # Test http-4.11 may come here.
-	}
-    } elseif {
-	  ([info exists state(-keepalive)] && $state(-keepalive))
-       && ([info exists state(connection)] && ("close" ni $state(connection)))
-    } {
-	KeepSocket $token
-    }
-    if {[info exists state(after)]} {
-	after cancel $state(after)
-	unset state(after)
-    }
-    if {[info exists state(-command)] && (!$skipCB)
-	    && (![info exists state(done-command-cb)])} {
-	set state(done-command-cb) yes
-	if {    [catch {namespace eval :: $state(-command) $token} err]
-	     && ($errormsg eq "")
-	} {
-	    set state(error) [list $err $errorInfo $errorCode]
-	    set state(status) error
-	}
-    }
-
-    if {    $closeQueue
-	 && [info exists socketMapping($connId)]
-	 && ($socketMapping($connId) eq $sock)
-    } {
-	http::CloseQueuedQueries $connId $token
-	# This calls Unset.  Other cases do not need the call.
-    }
-    return
-}
-
-# http::KeepSocket -
-#
-#	Keep a socket in the persistent sockets table and connect it to its next
-#	queued task if possible.  Otherwise leave it idle and ready for its next
-#	use.
-#
-#	If $socketClosing(*), then ("close" in $state(connection)) and therefore
-#	this command will not be called by Finish.
-#
-# Arguments:
-#	token	    Connection token.
-
-proc http::KeepSocket {token} {
-    variable http
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    # Keep this socket open for another request ("Keep-Alive").
-    # React if the server half-closes the socket.
-    # Discussion is in http::geturl.
-    catch {fileevent $state(sock) readable [list http::CheckEof $state(sock)]}
-
-    # The line below should not be changed in production code.
-    # It is edited by the test suite.
-    set TEST_EOF 0
-    if {$TEST_EOF} {
-	# ONLY for testing reaction to server eof.
-	# No server timeouts will be caught.
-	catch {fileevent $state(sock) readable {}}
-    }
-
-    if {    [info exists state(socketinfo)]
-	 && [info exists socketMapping($state(socketinfo))]
-    } {
-	set connId $state(socketinfo)
-	# The value "Rready" is set only here.
-	set socketRdState($connId) Rready
-
-	if {    $state(-pipeline)
-	     && [info exists socketRdQueue($connId)]
-	     && [llength $socketRdQueue($connId)]
-	} {
-	    # The usual case for pipelined responses - if another response is
-	    # queued, arrange to read it.
-	    set token3 [lindex $socketRdQueue($connId) 0]
-	    set socketRdQueue($connId) [lrange $socketRdQueue($connId) 1 end]
-
-	    #Log pipelined, GRANT read access to $token3 in KeepSocket
-	    set socketRdState($connId) $token3
-	    ReceiveResponse $token3
-
-	    # Other pipelined cases.
-	    # - The test above ensures that, for the pipelined cases in the two
-	    #   tests below, the read queue is empty.
-	    # - In those two tests, check whether the next write will be
-	    #   nonpipeline.
-	} elseif {
-		$state(-pipeline)
-	     && [info exists socketWrState($connId)]
-	     && ($socketWrState($connId) eq "peNding")
-
-	     && [info exists socketWrQueue($connId)]
-	     && [llength $socketWrQueue($connId)]
-	     && (![set token3 [lindex $socketWrQueue($connId) 0]
-		   set ${token3}(-pipeline)
-		  ]
-		)
-	} {
-	    # This case:
-	    # - Now it the time to run the "pending" request.
-	    # - The next token in the write queue is nonpipeline, and
-	    #   socketWrState has been marked "pending" (in
-	    #   http::NextPipelinedWrite or http::geturl) so a new pipelined
-	    #   request cannot jump the queue.
-	    #
-	    # Tests:
-	    # - In this case the read queue (tested above) is empty and this
-	    #   "pending" write token is in front of the rest of the write
-	    #   queue.
-	    # - The write state is not Wready and therefore appears to be busy,
-	    #   but because it is "pending" we know that it is reserved for the
-	    #   first item in the write queue, a non-pipelined request that is
-	    #   waiting for the read queue to empty.  That has now happened: so
-	    #   give that request read and write access.
-	    set conn [set ${token3}(connArgs)]
-	    #Log nonpipeline, GRANT r/w access to $token3 in KeepSocket
-	    set socketRdState($connId) $token3
-	    set socketWrState($connId) $token3
-	    set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	    # Connect does its own fconfigure.
-	    fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
-	    #Log ---- $state(sock) << conn to $token3 for HTTP request (c)
-
-	} elseif {
-		$state(-pipeline)
-	     && [info exists socketWrState($connId)]
-	     && ($socketWrState($connId) eq "peNding")
-
-	} {
-	    # Should not come here.  The second block in the previous "elseif"
-	    # test should be tautologous (but was needed in an earlier
-	    # implementation) and will be removed after testing.
-	    # If we get here, the value "pending" was assigned in error.
-	    # This error would block the queue for ever.
-	    Log ^X$tk <<<<< Error in queueing of requests >>>>> - token $token
-
-	} elseif {
-		$state(-pipeline)
-	     && [info exists socketWrState($connId)]
-	     && ($socketWrState($connId) eq "Wready")
-
-	     && [info exists socketWrQueue($connId)]
-	     && [llength $socketWrQueue($connId)]
-	     && (![set token3 [lindex $socketWrQueue($connId) 0]
-		   set ${token3}(-pipeline)
-		  ]
-		)
-	} {
-	    # This case:
-	    # - The next token in the write queue is nonpipeline, and
-	    #   socketWrState is Wready.  Get the next event from socketWrQueue.
-	    # Tests:
-	    # - In this case the read state (tested above) is Rready and the
-	    #   write state (tested here) is Wready - there is no "pending"
-	    #   request.
-	    # Code:
-	    # - The code is the same as the code below for the nonpipelined
-	    #   case with a queued request.
-	    set conn [set ${token3}(connArgs)]
-	    #Log nonpipeline, GRANT r/w access to $token3 in KeepSocket
-	    set socketRdState($connId) $token3
-	    set socketWrState($connId) $token3
-	    set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	    # Connect does its own fconfigure.
-	    fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
-	    #Log ---- $state(sock) << conn to $token3 for HTTP request (c)
-
-	} elseif {
-		(!$state(-pipeline))
-	     && [info exists socketWrQueue($connId)]
-	     && [llength $socketWrQueue($connId)]
-	     && ("close" ni $state(connection))
-	} {
-	    # If not pipelined, (socketRdState eq Rready) tells us that we are
-	    # ready for the next write - there is no need to check
-	    # socketWrState. Write the next request, if one is waiting.
-	    # If the next request is pipelined, it receives premature read
-	    # access to the socket. This is not a problem.
-	    set token3 [lindex $socketWrQueue($connId) 0]
-	    set conn [set ${token3}(connArgs)]
-	    #Log nonpipeline, GRANT r/w access to $token3 in KeepSocket
-	    set socketRdState($connId) $token3
-	    set socketWrState($connId) $token3
-	    set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	    # Connect does its own fconfigure.
-	    fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
-	    #Log ---- $state(sock) << conn to $token3 for HTTP request (d)
-
-	} elseif {(!$state(-pipeline))} {
-	    set socketWrState($connId) Wready
-	    # Rready and Wready and idle: nothing to do.
-	}
-
-    } else {
-	CloseSocket $state(sock) $token
-	# There is no socketMapping($state(socketinfo)), so it does not matter
-	# that CloseQueuedQueries is not called.
-    }
-    return
-}
-
-# http::CheckEof -
-#
-#	Read from a socket and close it if eof.
-#	The command is bound to "fileevent readable" on an idle socket, and
-#	"eof" is the only event that should trigger the binding, occurring when
-#	the server times out and half-closes the socket.
-#
-#	A read is necessary so that [eof] gives a meaningful result.
-#	Any bytes sent are junk (or a bug).
-
-proc http::CheckEof {sock} {
-    set junk [read $sock]
-    set n [string length $junk]
-    if {$n} {
-	Log "WARNING: $n bytes received but no HTTP request sent"
-    }
-
-    if {[catch {eof $sock} res] || $res} {
-	# The server has half-closed the socket.
-	# If a new write has started, its transaction will fail and
-	# will then be error-handled.
-	CloseSocket $sock
-    }
-    return
-}
-
-# http::CloseSocket -
-#
-#	Close a socket and remove it from the persistent sockets table.  If
-#	possible an http token is included here but when we are called from a
-#	fileevent on remote closure we need to find the correct entry - hence
-#	the "else" block of the first "if" command.
-
-proc http::CloseSocket {s {token {}}} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set tk [namespace tail $token]
-
-    catch {fileevent $s readable {}}
-    set connId {}
-    if {$token ne ""} {
-	variable $token
-	upvar 0 $token state
-	if {[info exists state(socketinfo)]} {
-	    set connId $state(socketinfo)
-	}
-    } else {
-	set map [array get socketMapping]
-	set ndx [lsearch -exact $map $s]
-	if {$ndx >= 0} {
-	    incr ndx -1
-	    set connId [lindex $map $ndx]
-	}
-    }
-    if {    ($connId ne {})
-	 && [info exists socketMapping($connId)]
-	 && ($socketMapping($connId) eq $s)
-    } {
-	Log "Closing connection $connId (sock $socketMapping($connId))"
-	if {[catch {close $socketMapping($connId)} err]} {
-	    Log "Error closing connection: $err"
-	} else {
-	}
-	if {$token eq {}} {
-	    # Cases with a non-empty token are handled by Finish, so the tokens
-	    # are finished in connection order.
-	    http::CloseQueuedQueries $connId
-	} else {
-	}
-    } else {
-	Log "Closing socket $s (no connection info)"
-	if {[catch {close $s} err]} {
-	    Log "Error closing socket: $err"
-	} else {
-	}
-    }
-    return
-}
-
-# http::CloseQueuedQueries
-#
-#	connId  - identifier "domain:port" for the connection
-#	token   - (optional) used only for logging
-#
-# Called from http::CloseSocket and http::Finish, after a connection is closed,
-# to clear the read and write queues if this has not already been done.
-
-proc http::CloseQueuedQueries {connId {token {}}} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    ##Log CloseQueuedQueries $connId $token
-    if {![info exists socketMapping($connId)]} {
-	# Command has already been called.
-	# Don't come here again - especially recursively.
-	return
-    }
-
-    # Used only for logging.
-    if {$token eq {}} {
-	set tk {}
-    } else {
-	set tk [namespace tail $token]
-    }
-
-    if {    [info exists socketPlayCmd($connId)]
-	 && ($socketPlayCmd($connId) ne {ReplayIfClose Wready {} {}})
-    } {
-	# Before unsetting, there is some unfinished business.
-	# - If the server sent "Connection: close", we have stored the command
-	#   for retrying any queued requests in socketPlayCmd, so copy that
-	#   value for execution below.  socketClosing(*) was also set.
-	# - Also clear the queues to prevent calls to Finish that would set the
-	#   state for the requests that will be retried to "finished with error
-	#   status".
-	# - At this stage socketPhQueue is empty.
-	set unfinished $socketPlayCmd($connId)
-	set socketRdQueue($connId) {}
-	set socketWrQueue($connId) {}
-    } else {
-	set unfinished {}
-    }
-
-    Unset $connId
-
-    if {$unfinished ne {}} {
-	Log ^R$tk Any unfinished transactions (excluding $token) failed \
-		- token $token - unfinished $unfinished
-	{*}$unfinished
-	# Calls ReplayIfClose.
-    }
-    return
-}
-
-# http::Unset
-#
-#	The trace on "unset socketRdState(*)" will call CancelReadPipeline
-#	and cancel any queued responses.
-#	The trace on "unset socketWrState(*)" will call CancelWritePipeline
-#	and cancel any queued requests.
-
-proc http::Unset {connId} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    unset socketMapping($connId)
-    unset socketRdState($connId)
-    unset socketWrState($connId)
-    unset -nocomplain socketRdQueue($connId)
-    unset -nocomplain socketWrQueue($connId)
-    unset -nocomplain socketClosing($connId)
-    unset -nocomplain socketPlayCmd($connId)
-    unset -nocomplain socketProxyId($connId)
-    return
-}
-
-# http::reset --
-#
-#	See documentation for details.
-#
-# Arguments:
-#	token	Connection token.
-#	why	Status info.
-#
-# Side Effects:
-#        See Finish
-
-proc http::reset {token {why reset}} {
-    variable $token
-    upvar 0 $token state
-    set state(status) $why
-    catch {fileevent $state(sock) readable {}}
-    catch {fileevent $state(sock) writable {}}
-    Finish $token
-    if {[info exists state(error)]} {
-	set errorlist $state(error)
-	unset state
-	eval ::error $errorlist
-	# i.e. error msg errorInfo errorCode
-    }
-    return
-}
-
-# http::geturl --
-#
-#	Establishes a connection to a remote url via http.
-#
-# Arguments:
-#	url		The http URL to goget.
-#	args		Option value pairs. Valid options include:
-#				-blocksize, -validate, -headers, -timeout
-# Results:
-#	Returns a token for this connection. This token is the name of an
-#	array that the caller should unset to garbage collect the state.
-
-proc http::geturl {url args} {
-    variable urlTypes
-
-    # - If ::tls::socketCmd has its default value "::socket", change it to the
-    #   new value ::http::socketForTls.
-    # - If the old value is different, then it has been modified either by the
-    #   script or by the Tcl installation, and replaced by a new command.  The
-    #   script or installation that modified ::tls::socketCmd is also
-    #   responsible for integrating ::http::socketForTls into its own "new"
-    #   command, if it wishes to do so.
-    # - Commands that open a socket:
-    #   - ::socket             - basic
-    #   - ::http::socket       - can use a thread to avoid blockage by slow DNS
-    #                            lookup.  See http::config option -threadlevel.
-    #   - ::http::socketForTls - as ::http::socket, but can also open a socket
-    #                            for HTTPS/TLS through a proxy.
-
-    if {[info exists ::tls::socketCmd] && ($::tls::socketCmd eq {::socket})} {
-        set ::tls::socketCmd ::http::socketForTls
-    }
-
-    set token [CreateToken $url {*}$args]
-    variable $token
-    upvar 0 $token state
-
-    AsyncTransaction $token
-
-    # --------------------------------------------------------------------------
-    # Synchronous Call to http::geturl
-    # --------------------------------------------------------------------------
-    # - If the call to http::geturl is asynchronous, it is now complete (apart
-    #   from delivering the return value).
-    # - If the call to http::geturl is synchronous, the command must now wait
-    #   for the HTTP transaction to be completed.  The call to http::wait uses
-    #   vwait, which may be inappropriate if the caller makes other HTTP
-    #   requests in the background.
-    # --------------------------------------------------------------------------
-
-    if {![info exists state(-command)]} {
-	# geturl does EVERYTHING asynchronously, so if the user
-	# calls it synchronously, we just do a wait here.
-	http::wait $token
-
-	if {![info exists state]} {
-	    # If we timed out then Finish has been called and the users
-	    # command callback may have cleaned up the token. If so we end up
-	    # here with nothing left to do.
-	    return $token
-	} elseif {$state(status) eq "error"} {
-	    # Something went wrong while trying to establish the connection.
-	    # Clean up after events and such, but DON'T call the command
-	    # callback (if available) because we're going to throw an
-	    # exception from here instead.
-	    set err [lindex $state(error) 0]
-	    cleanup $token
-	    return -code error $err
-	}
-    }
-
-    return $token
-}
-
-# ------------------------------------------------------------------------------
-#  Proc http::CreateToken
-# ------------------------------------------------------------------------------
-# Command to convert arguments into an initialised request token.
-# The return value is the variable name of the token.
-#
-# Other effects:
-# - Sets ::http::http(usingThread) if not already done
-# - Sets ::http::http(uid) if not already done
-# - Increments ::http::http(uid)
-# - May increment ::http::TmpSockCounter
-# - Alters ::http::socketPlayCmd, ::http::socketWrQueue if a -keepalive 1
-#   request is appended to the queue of a persistent socket that is already
-#   scheduled to close.
-#   This also sets state(alreadyQueued) to 1.
-# - Alters ::http::socketPhQueue if a -keepalive 1 request is appended to the
-#   queue of a persistent socket that has not yet been created (and is therefore
-#   represented by a placeholder).
-#   This also sets state(ReusingPlaceholder) to 1.
-# ------------------------------------------------------------------------------
-
-proc http::CreateToken {url args} {
-    variable http
-    variable urlTypes
-    variable defaultCharset
-    variable defaultKeepalive
-    variable strict
-    variable TmpSockCounter
-
-    # Initialize the state variable, an array. We'll return the name of this
-    # array as the token for the transaction.
-
-    if {![info exists http(usingThread)]} {
-	set http(usingThread) 0
-    }
-    if {![info exists http(uid)]} {
-	set http(uid) 0
-    }
-    set token [namespace current]::[incr http(uid)]
-    ##Log Starting http::geturl - token $token
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    reset $token
-    Log ^A$tk URL $url - token $token
-
-    # Process command options.
-
-    array set state {
-	-binary		false
-	-blocksize	8192
-	-queryblocksize 8192
-	-validate	0
-	-headers	{}
-	-timeout	0
-	-type		application/x-www-form-urlencoded
-	-queryprogress	{}
-	-protocol	1.1
-	-guesstype      0
-	binary		0
-	state		created
-	meta		{}
-	method		{}
-	coding		{}
-	currentsize	0
-	totalsize	0
-	querylength	0
-	queryoffset	0
-	type		application/octet-stream
-	body		{}
-	status		""
-	http		""
-	httpResponse    {}
-	responseCode    {}
-	reasonPhrase    {}
-	connection	keep-alive
-	tid             {}
-	requestHeaders  {}
-	requestLine     {}
-	transfer        {}
-	proxyUsed       none
-    }
-    set state(-keepalive) $defaultKeepalive
-    set state(-strict) $strict
-    # These flags have their types verified [Bug 811170]
-    array set type {
-	-binary		boolean
-	-blocksize	integer
-	-guesstype      boolean
-	-queryblocksize integer
-	-strict		boolean
-	-timeout	integer
-	-validate	boolean
-	-headers	list
-    }
-    set state(charset)	$defaultCharset
-    set options {
-	-binary -blocksize -channel -command -guesstype -handler -headers -keepalive
-	-method -myaddr -progress -protocol -query -queryblocksize
-	-querychannel -queryprogress -strict -timeout -type -validate
-    }
-    set usage [join [lsort $options] ", "]
-    set options [string map {- ""} $options]
-    set pat ^-(?:[join $options |])$
-    foreach {flag value} $args {
-	if {[regexp -- $pat $flag]} {
-	    # Validate numbers
-	    if {    [info exists type($flag)]
-	        && (![string is $type($flag) -strict $value])
-	    } {
-		unset $token
-		return -code error \
-		    "Bad value for $flag ($value), must be $type($flag)"
-	    }
-	    if {($flag eq "-headers") && ([llength $value] % 2 != 0)} {
-		unset $token
-		return -code error "Bad value for $flag ($value), number\
-			of list elements must be even"
-	    }
-	    set state($flag) $value
-	} else {
-	    unset $token
-	    return -code error "Unknown option $flag, can be: $usage"
-	}
-    }
-
-    # Make sure -query and -querychannel aren't both specified
-
-    set isQueryChannel [info exists state(-querychannel)]
-    set isQuery [info exists state(-query)]
-    if {$isQuery && $isQueryChannel} {
-	unset $token
-	return -code error "Can't combine -query and -querychannel options!"
-    }
-
-    # Validate URL, determine the server host and port, and check proxy case
-    # Recognize user:pass@host URLs also, although we do not do anything with
-    # that info yet.
-
-    # URLs have basically four parts.
-    # First, before the colon, is the protocol scheme (e.g. http)
-    # Second, for HTTP-like protocols, is the authority
-    #	The authority is preceded by // and lasts up to (but not including)
-    #	the following / or ? and it identifies up to four parts, of which
-    #	only one, the host, is required (if an authority is present at all).
-    #	All other parts of the authority (user name, password, port number)
-    #	are optional.
-    # Third is the resource name, which is split into two parts at a ?
-    #	The first part (from the single "/" up to "?") is the path, and the
-    #	second part (from that "?" up to "#") is the query. *HOWEVER*, we do
-    #	not need to separate them; we send the whole lot to the server.
-    #	Both, path and query are allowed to be missing, including their
-    #	delimiting character.
-    # Fourth is the fragment identifier, which is everything after the first
-    #	"#" in the URL. The fragment identifier MUST NOT be sent to the server
-    #	and indeed, we don't bother to validate it (it could be an error to
-    #	pass it in here, but it's cheap to strip).
-    #
-    # An example of a URL that has all the parts:
-    #
-    #     http://jschmoe:xyzzy@www.bogus.net:8000/foo/bar.tml?q=foo#changes
-    #
-    # The "http" is the protocol, the user is "jschmoe", the password is
-    # "xyzzy", the host is "www.bogus.net", the port is "8000", the path is
-    # "/foo/bar.tml", the query is "q=foo", and the fragment is "changes".
-    #
-    # Note that the RE actually combines the user and password parts, as
-    # recommended in RFC 3986. Indeed, that RFC states that putting passwords
-    # in URLs is a Really Bad Idea, something with which I would agree utterly.
-    # RFC 9110 Sec 4.2.4 goes further than this, and deprecates the format
-    # "user:password@".  It is retained here for backward compatibility,
-    # but its use is not recommended.
-    #
-    # From a validation perspective, we need to ensure that the parts of the
-    # URL that are going to the server are correctly encoded.  This is only
-    # done if $state(-strict) is true (inherited from $::http::strict).
-
-    set URLmatcher {(?x)		# this is _expanded_ syntax
-	^
-	(?: (\w+) : ) ?			# <protocol scheme>
-	(?: //
-	    (?:
-		(
-		    [^@/\#?]+		# <userinfo part of authority>
-		) @
-	    )?
-	    (				# <host part of authority>
-		[^/:\#?]+ |		# host name or IPv4 address
-		\[ [^/\#?]+ \]		# IPv6 address in square brackets
-	    )
-	    (?: : (\d+) )?		# <port part of authority>
-	)?
-	( [/\?] [^\#]*)?		# <path> (including query)
-	(?: \# (.*) )?			# <fragment>
-	$
-    }
-
-    # Phase one: parse
-    if {![regexp -- $URLmatcher $url -> proto user host port srvurl]} {
-	unset $token
-	return -code error "Unsupported URL: $url"
-    }
-    # Phase two: validate
-    set host [string trim $host {[]}]; # strip square brackets from IPv6 address
-    if {$host eq ""} {
-	# Caller has to provide a host name; we do not have a "default host"
-	# that would enable us to handle relative URLs.
-	unset $token
-	return -code error "Missing host part: $url"
-	# Note that we don't check the hostname for validity here; if it's
-	# invalid, we'll simply fail to resolve it later on.
-    }
-    if {$port ne "" && $port > 65535} {
-	unset $token
-	return -code error "Invalid port number: $port"
-    }
-    # The user identification and resource identification parts of the URL can
-    # have encoded characters in them; take care!
-    if {$user ne ""} {
-	# Check for validity according to RFC 3986, Appendix A
-	set validityRE {(?xi)
-	    ^
-	    (?: [-\w.~!$&'()*+,;=:] | %[0-9a-f][0-9a-f] )+
-	    $
-	}
-	if {$state(-strict) && ![regexp -- $validityRE $user]} {
-	    unset $token
-	    # Provide a better error message in this error case
-	    if {[regexp {(?i)%(?![0-9a-f][0-9a-f]).?.?} $user bad]} {
-		return -code error \
-			"Illegal encoding character usage \"$bad\" in URL user"
-	    }
-	    return -code error "Illegal characters in URL user"
-	}
-    }
-    if {$srvurl ne ""} {
-	# RFC 3986 allows empty paths (not even a /), but servers
-	# return 400 if the path in the HTTP request doesn't start
-	# with / , so add it here if needed.
-	if {[string index $srvurl 0] ne "/"} {
-	    set srvurl /$srvurl
-	}
-	# Check for validity according to RFC 3986, Appendix A
-	set validityRE {(?xi)
-	    ^
-	    # Path part (already must start with / character)
-	    (?:	      [-\w.~!$&'()*+,;=:@/]  | %[0-9a-f][0-9a-f] )*
-	    # Query part (optional, permits ? characters)
-	    (?: \? (?: [-\w.~!$&'()*+,;=:@/?] | %[0-9a-f][0-9a-f] )* )?
-	    $
-	}
-	if {$state(-strict) && ![regexp -- $validityRE $srvurl]} {
-	    unset $token
-	    # Provide a better error message in this error case
-	    if {[regexp {(?i)%(?![0-9a-f][0-9a-f])..} $srvurl bad]} {
-		return -code error \
-		    "Illegal encoding character usage \"$bad\" in URL path"
-	    }
-	    return -code error "Illegal characters in URL path"
-	}
-	if {![regexp {^[^?#]+} $srvurl state(path)]} {
-	    set state(path) /
-	}
-    } else {
-	set srvurl /
-	set state(path) /
-    }
-    if {$proto eq ""} {
-	set proto http
-    }
-    set lower [string tolower $proto]
-    if {![info exists urlTypes($lower)]} {
-	unset $token
-	return -code error "Unsupported URL type \"$proto\""
-    }
-    set defport [lindex $urlTypes($lower) 0]
-    set defcmd [lindex $urlTypes($lower) 1]
-
-    if {$port eq ""} {
-	set port $defport
-    }
-    if {![catch {$http(-proxyfilter) $host} proxy]} {
-	set phost [lindex $proxy 0]
-	set pport [lindex $proxy 1]
-    } else {
-	set phost {}
-	set pport {}
-    }
-
-    # OK, now reassemble into a full URL
-    set url ${proto}://
-    if {$user ne ""} {
-	append url $user
-	append url @
-    }
-    append url $host
-    if {$port != $defport} {
-	append url : $port
-    }
-    append url $srvurl
-    # Don't append the fragment! RFC 7230 Sec 5.1
-    set state(url) $url
-
-    # Proxy connections aren't shared among different hosts.
-    set state(socketinfo) $host:$port
-
-    # Save the accept types at this point to prevent a race condition. [Bug
-    # c11a51c482]
-    set state(accept-types) $http(-accept)
-
-    # Check whether this is an Upgrade request.
-    set connectionValues [SplitCommaSeparatedFieldValue \
-			      [GetFieldValue $state(-headers) Connection]]
-    set connectionValues [string tolower $connectionValues]
-    set upgradeValues [SplitCommaSeparatedFieldValue \
-			   [GetFieldValue $state(-headers) Upgrade]]
-    set state(upgradeRequest) [expr {    "upgrade" in $connectionValues
-				      && [llength $upgradeValues] >= 1}]
-    set state(connectionValues) $connectionValues
-
-    if {$isQuery || $isQueryChannel} {
-	# It's a POST.
-	# A client wishing to send a non-idempotent request SHOULD wait to send
-	# that request until it has received the response status for the
-	# previous request.
-	if {$http(-postfresh)} {
-	    # Override -keepalive for a POST.  Use a new connection, and thus
-	    # avoid the small risk of a race against server timeout.
-	    set state(-keepalive) 0
-	} else {
-	    # Allow -keepalive but do not -pipeline - wait for the previous
-	    # transaction to finish.
-	    # There is a small risk of a race against server timeout.
-	    set state(-pipeline) 0
-	}
-    } elseif {$state(upgradeRequest)} {
-	# It's an upgrade request.  Method must be GET (untested).
-	# Force -keepalive to 0 so the connection is not made over a persistent
-	# socket, i.e. one used for multiple HTTP requests.
-	set state(-keepalive) 0
-    } else {
-	# It's a non-upgrade GET or HEAD.
-	set state(-pipeline) $http(-pipeline)
-    }
-
-    # We cannot handle chunked encodings with -handler, so force HTTP/1.0
-    # until we can manage this.
-    if {[info exists state(-handler)]} {
-	set state(-protocol) 1.0
-    }
-
-    # RFC 7320 A.1 - HTTP/1.0 Keep-Alive is problematic. We do not support it.
-    if {$state(-protocol) eq "1.0"} {
-	set state(connection) close
-	set state(-keepalive) 0
-    }
-
-    # Handle proxy requests here for http:// but not for https://
-    # The proxying for https is done in the ::http::socketForTls command.
-    # A proxy request for http:// needs the full URL in the HTTP request line,
-    # including the server name.
-    # The *tls* test below attempts to describe protocols in addition to
-    # "https on port 443" that use HTTP over TLS.
-    if {($phost ne "") && (![string match -nocase *tls* $defcmd])} {
-	set srvurl $url
-	set targetAddr [list $phost $pport]
-	set state(proxyUsed) HttpProxy
-	# The value of state(proxyUsed) none|HttpProxy depends only on the
-	# all-transactions http::config settings and on the target URL.
-	# Even if this is a persistent socket there is no need to change the
-	# value of state(proxyUsed) for other transactions that use the socket:
-	# they have the same value already.
-    } else {
-	set targetAddr [list $host $port]
-    }
-
-    set sockopts [list -async]
-
-    # Pass -myaddr directly to the socket command
-    if {[info exists state(-myaddr)]} {
-	lappend sockopts -myaddr $state(-myaddr)
-    }
-
-    set state(connArgs) [list $proto $phost $srvurl]
-    set state(openCmd) [list {*}$defcmd {*}$sockopts -type $token {*}$targetAddr]
-
-    # See if we are supposed to use a previously opened channel.
-    # - In principle, ANY call to http::geturl could use a previously opened
-    #   channel if it is available - the "Connection: keep-alive" header is a
-    #   request to leave the channel open AFTER completion of this call.
-    # - In fact, we try to use an existing channel only if -keepalive 1 -- this
-    #   means that at most one channel is left open for each value of
-    #   $state(socketinfo). This property simplifies the mapping of open
-    #   channels.
-    set reusing 0
-    set state(alreadyQueued) 0
-    set state(ReusingPlaceholder) 0
-    if {$state(-keepalive)} {
-	variable socketMapping
-	variable socketRdState
-	variable socketWrState
-	variable socketRdQueue
-	variable socketWrQueue
-	variable socketPhQueue
-	variable socketClosing
-	variable socketPlayCmd
-	variable socketCoEvent
-	variable socketProxyId
-
-	if {[info exists socketMapping($state(socketinfo))]} {
-	    # - If the connection is idle, it has a "fileevent readable" binding
-	    #   to http::CheckEof, in case the server times out and half-closes
-	    #   the socket (http::CheckEof closes the other half).
-	    # - We leave this binding in place until just before the last
-	    #   puts+flush in http::Connected (GET/HEAD) or http::Write (POST),
-	    #   after which the HTTP response might be generated.
-
-	    if {    [info exists socketClosing($state(socketinfo))]
-		       && $socketClosing($state(socketinfo))
-	    } {
-		# socketClosing(*) is set because the server has sent a
-		# "Connection: close" header.
-		# Do not use the persistent socket again.
-		# Since we have only one persistent socket per server, and the
-		# old socket is not yet dead, add the request to the write queue
-		# of the dying socket, which will be replayed by ReplayIfClose.
-		# Also add it to socketWrQueue(*) which is used only if an error
-		# causes a call to Finish.
-		set reusing 1
-		set sock $socketMapping($state(socketinfo))
-		set state(proxyUsed) $socketProxyId($state(socketinfo))
-		Log "reusing closing socket $sock for $state(socketinfo) - token $token"
-
-		set state(alreadyQueued) 1
-		lassign $socketPlayCmd($state(socketinfo)) com0 com1 com2 com3
-		lappend com3 $token
-		set socketPlayCmd($state(socketinfo)) [list $com0 $com1 $com2 $com3]
-		lappend socketWrQueue($state(socketinfo)) $token
-		##Log socketPlayCmd($state(socketinfo)) is $socketPlayCmd($state(socketinfo))
-		##Log socketWrQueue($state(socketinfo)) is $socketWrQueue($state(socketinfo))
-	    } elseif {
-		   [catch {fconfigure $socketMapping($state(socketinfo))}]
-		&& (![SockIsPlaceHolder $socketMapping($state(socketinfo))])
-	    } {
-		###Log "Socket $socketMapping($state(socketinfo)) for $state(socketinfo)"
-		# FIXME Is it still possible for this code to be executed? If
-		#       so, this could be another place to call TestForReplay,
-		#       rather than discarding the queued transactions.
-		Log "WARNING: socket for $state(socketinfo) was closed\
-			- token $token"
-		Log "WARNING - if testing, pay special attention to this\
-			case (GH) which is seldom executed - token $token"
-
-		# This will call CancelReadPipeline, CancelWritePipeline, and
-		# cancel any queued requests, responses.
-		Unset $state(socketinfo)
-	    } else {
-		# Use the persistent socket.
-		# - The socket may not be ready to write: an earlier request might
-		#   still be still writing (in the pipelined case) or
-		#   writing/reading (in the nonpipeline case). This possibility
-		#   is handled by socketWrQueue later in this command.
-		# - The socket may not yet exist, and be defined with a placeholder.
-		set reusing 1
-		set sock $socketMapping($state(socketinfo))
-		set state(proxyUsed) $socketProxyId($state(socketinfo))
-		if {[SockIsPlaceHolder $sock]} {
-		    set state(ReusingPlaceholder) 1
-		    lappend socketPhQueue($sock) $token
-		} else {
-		}
-		Log "reusing open socket $sock for $state(socketinfo) - token $token"
-	    }
-	    # Do not automatically close the connection socket.
-	    set state(connection) keep-alive
-	}
-    }
-
-    set state(reusing) $reusing
-    unset reusing
-
-    if {![info exists sock]} {
-        # N.B. At this point ([info exists sock] == $state(reusing)).
-        # This will no longer be true after we set a value of sock here.
-	# Give the socket a placeholder name.
-	set sock HTTP_PLACEHOLDER_[incr TmpSockCounter]
-    }
-    set state(sock) $sock
-
-    if {$state(reusing)} {
-	# Define these for use (only) by http::ReplayIfDead if the persistent
-	# connection has died.
-	set state(tmpConnArgs) $state(connArgs)
-	set state(tmpState) [array get state]
-	set state(tmpOpenCmd) $state(openCmd)
-    }
-    return $token
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc ::http::SockIsPlaceHolder
-# ------------------------------------------------------------------------------
-# Command to return 0 if the argument is a genuine socket handle, or 1 if is a
-# placeholder value generated by geturl or ReplayCore before the real socket is
-# created.
-#
-# Arguments:
-# sock        - either a valid socket handle or a placeholder value
-#
-# Return Value: 0 or 1
-# ------------------------------------------------------------------------------
-
-proc http::SockIsPlaceHolder {sock} {
-    expr {[string range $sock 0 16] eq {HTTP_PLACEHOLDER_}}
-}
-
-
-# ------------------------------------------------------------------------------
-# state(reusing)
-# ------------------------------------------------------------------------------
-# - state(reusing) is set by geturl, ReplayCore
-# - state(reusing) is used by geturl, AsyncTransaction, OpenSocket,
-#   ConfigureNewSocket, and ScheduleRequest when creating and configuring the
-#   connection.
-# - state(reusing) is used by Connect, Connected, Event x 2 when deciding
-#   whether to call TestForReplay.
-# - Other places where state(reusing) is used:
-#   - Connected   - if reusing and not pipelined, start the state(-timeout)
-#                   timeout (when writing).
-#   - DoneRequest - if reusing and pipelined, send the next pipelined write
-#   - Event       - if reusing and pipelined, start the state(-timeout)
-#                   timeout (when reading).
-#   - Event       - if (not reusing) and pipelined, send the next pipelined
-#                   write.
-# ------------------------------------------------------------------------------
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::AsyncTransaction
-# ------------------------------------------------------------------------------
-# This command is called by geturl and ReplayCore to prepare the HTTP
-# transaction prescribed by a suitably prepared token.
-#
-# Arguments:
-# token         - connection token (name of an array)
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::AsyncTransaction {token} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set sock $state(sock)
-
-    # See comments above re the start of this timeout in other cases.
-    if {(!$state(reusing)) && ($state(-timeout) > 0)} {
-	set state(after) [after $state(-timeout) \
-		[list http::reset $token timeout]]
-    }
-
-    if {    $state(-keepalive)
-	 && (![info exists socketMapping($state(socketinfo))])
-    } {
-	# This code is executed only for the first -keepalive request on a
-	# socket.  It makes the socket persistent.
-	##Log "  PreparePersistentConnection" $token -- $sock -- DO
-        set DoLater [PreparePersistentConnection $token]
-    } else {
-        ##Log "  PreparePersistentConnection" $token -- $sock -- SKIP
-        set DoLater {-traceread 0 -tracewrite 0}
-    }
-
-    if {$state(ReusingPlaceholder)} {
-        # - This request was added to the socketPhQueue of a persistent
-        #   connection.
-        # - But the connection has not yet been created and is a placeholder;
-        # - And the placeholder was created by an earlier request.
-        # - When that earlier request calls OpenSocket, its placeholder is
-        #   replaced with a true socket, and it then executes the equivalent of
-        #   OpenSocket for any subsequent requests that have
-        #   $state(ReusingPlaceholder).
-        Log >J$tk after idle coro NO - ReusingPlaceholder
-    } elseif {$state(alreadyQueued)} {
-        # - This request was added to the socketWrQueue and socketPlayCmd
-        #   of a persistent connection that will close at the end of its current
-        #   read operation.
-        Log >J$tk after idle coro NO - alreadyQueued
-    } else {
-        Log >J$tk after idle coro YES
-        set CoroName ${token}--SocketCoroutine
-        set cancel [after idle [list coroutine $CoroName ::http::OpenSocket \
-                $token $DoLater]]
-        dict set socketCoEvent($state(socketinfo)) $token $cancel
-        set state(socketcoro) $cancel
-    }
-
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::PreparePersistentConnection
-# ------------------------------------------------------------------------------
-# This command is called by AsyncTransaction to initialise a "persistent
-# connection" based upon a socket placeholder.  It is called the first time the
-# socket is associated with a "-keepalive" request.
-#
-# Arguments:
-# token         - connection token (name of an array)
-#
-# Return Value: - DoLater, a dictionary of boolean values listing unfinished
-#                 tasks; to be passed to ConfigureNewSocket via OpenSocket.
-# ------------------------------------------------------------------------------
-
-proc http::PreparePersistentConnection {token} {
-    variable $token
-    upvar 0 $token state
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set DoLater {-traceread 0 -tracewrite 0}
-    set socketMapping($state(socketinfo)) $state(sock)
-    set socketProxyId($state(socketinfo)) $state(proxyUsed)
-    # - The value of state(proxyUsed) was set in http::CreateToken to either
-    #   "none" or "HttpProxy".
-    # - $token is the first transaction to use this placeholder, so there are
-    #   no other tokens whose (proxyUsed) must be modified.
-
-    if {![info exists socketRdState($state(socketinfo))]} {
-        set socketRdState($state(socketinfo)) {}
-        # set varName ::http::socketRdState($state(socketinfo))
-        # trace add variable $varName unset ::http::CancelReadPipeline
-        dict set DoLater -traceread 1
-    }
-    if {![info exists socketWrState($state(socketinfo))]} {
-        set socketWrState($state(socketinfo)) {}
-        # set varName ::http::socketWrState($state(socketinfo))
-        # trace add variable $varName unset ::http::CancelWritePipeline
-        dict set DoLater -tracewrite 1
-    }
-
-    if {$state(-pipeline)} {
-        #Log new, init for pipelined, GRANT write access to $token in geturl
-        # Also grant premature read access to the socket. This is OK.
-        set socketRdState($state(socketinfo)) $token
-        set socketWrState($state(socketinfo)) $token
-    } else {
-        # socketWrState is not used by this non-pipelined transaction.
-        # We cannot leave it as "Wready" because the next call to
-        # http::geturl with a pipelined transaction would conclude that the
-        # socket is available for writing.
-        #Log new, init for nonpipeline, GRANT r/w access to $token in geturl
-        set socketRdState($state(socketinfo)) $token
-        set socketWrState($state(socketinfo)) $token
-    }
-
-    # Value of socketPhQueue() may have already been set by ReplayCore.
-    if {![info exists socketPhQueue($state(sock))]} {
-        set socketPhQueue($state(sock))   {}
-    }
-    set socketRdQueue($state(socketinfo)) {}
-    set socketWrQueue($state(socketinfo)) {}
-    set socketClosing($state(socketinfo)) 0
-    set socketPlayCmd($state(socketinfo)) {ReplayIfClose Wready {} {}}
-    set socketCoEvent($state(socketinfo)) {}
-    set socketProxyId($state(socketinfo)) {}
-
-    return $DoLater
-}
-
-# ------------------------------------------------------------------------------
-#  Proc ::http::OpenSocket
-# ------------------------------------------------------------------------------
-# This command is called as a coroutine idletask to start the asynchronous HTTP
-# transaction in most cases.  For the exceptions, see the calling code in
-# command AsyncTransaction.
-#
-# Arguments:
-# token       - connection token (name of an array)
-# DoLater     - dictionary of boolean values listing unfinished tasks
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::OpenSocket {token DoLater} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    Log >K$tk Start OpenSocket coroutine
-
-    if {![info exists state(-keepalive)]} {
-        # The request has already been cancelled by the calling script.
-        return
-    }
-
-    set sockOld $state(sock)
-
-    dict unset socketCoEvent($state(socketinfo)) $token
-    unset -nocomplain state(socketcoro)
-
-    if {[catch {
-        if {$state(reusing)} {
-	    # If ($state(reusing)) is true, then we do not need to create a new
-	    # socket, even if $sockOld is only a placeholder for a socket.
-            set sock $sockOld
-        } else {
-	    # set sock in the [catch] below.
-	    set pre [clock milliseconds]
-	    ##Log pre socket opened, - token $token
-	    ##Log $state(openCmd) - token $token
-	    set sock [namespace eval :: $state(openCmd)]
-	    set state(sock) $sock
-	    # Normal return from $state(openCmd) always returns a valid socket.
-	    # A TLS proxy connection with 407 or other failure from the
-	    # proxy server raises an error.
-
-	    # Initialisation of a new socket.
-	    ##Log post socket opened, - token $token
-	    ##Log socket opened, now fconfigure - token $token
-	    set delay [expr {[clock milliseconds] - $pre}]
-	    if {$delay > 3000} {
-		Log socket delay $delay - token $token
-	    }
-	    fconfigure $sock -translation {auto crlf} \
-			     -buffersize $state(-blocksize)
-	    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-		fconfigure $sock -profile tcl8
-	    }
-	    ##Log socket opened, DONE fconfigure - token $token
-        }
-
-        Log "Using $sock for $state(socketinfo) - token $token" \
-	    [expr {$state(-keepalive)?"keepalive":""}]
-
-        # Code above has set state(sock) $sock
-        ConfigureNewSocket $token $sockOld $DoLater
-        ##Log OpenSocket success $sock - token $token
-    } result errdict]} {
-	##Log OpenSocket failed $result - token $token
-	# There may be other requests in the socketPhQueue.
-	# Prepare socketPlayCmd so that Finish will replay them.
-	if {    ($state(-keepalive)) && (!$state(reusing))
-	     && [info exists socketPhQueue($sockOld)]
-	     && ($socketPhQueue($sockOld) ne {})
-	} {
-	    if {$socketMapping($state(socketinfo)) ne $sockOld} {
-		Log "WARNING: this code should not be reached.\
-			{$socketMapping($state(socketinfo)) ne $sockOld}"
-	    }
-	    set socketPlayCmd($state(socketinfo)) [list ReplayIfClose Wready {} $socketPhQueue($sockOld)]
-	    set socketPhQueue($sockOld) {}
-	}
-        if {[string range $result 0 20] eq {proxy connect failed:}} {
-	    # - The HTTPS proxy did not create a socket.  The pre-existing value
-	    #   (a "placeholder socket") is unchanged.
-	    # - The proxy returned a valid HTTP response to the failed CONNECT
-	    #   request, and http::SecureProxyConnect copied this to $token,
-	    #   and also set ${token}(connection) set to "close".
-	    # - Remove the error message $result so that Finish delivers this
-	    #   HTTP response to the caller.
-	    set result {}
-	}
-	Finish $token $result
-	# Because socket creation failed, the placeholder "socket" must be
-	# "closed" and (if persistent) removed from the persistent sockets
-	# table.  In the {proxy connect failed:} case Finish does this because
-	# the value of ${token}(connection) is "close". In the other cases here,
-	# it does so because $result is non-empty.
-    }
-    ##Log Leaving http::OpenSocket coroutine [info coroutine] - token $token
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc ::http::ConfigureNewSocket
-# ------------------------------------------------------------------------------
-# Command to initialise a newly-created socket.  Called only from OpenSocket.
-#
-# This command is called by OpenSocket whenever a genuine socket (sockNew) has
-# been opened for for use by HTTP.  It does two things:
-# (1) If $token uses a placeholder socket, this command replaces the placeholder
-#     socket with the real socket, not only in $token but in all other requests
-#     that use the same placeholder.
-# (2) It calls ScheduleRequest to schedule each request that uses the socket.
-#
-#
-# Value of sockOld/sockNew can be "sock" (genuine socket) or "ph" (placeholder).
-# sockNew is ${token}(sock)
-# sockOld   sockNew  CASES
-#  sock       sock   (if $reusing, and sockOld is sock)
-#  ph         sock   (if (not $reusing), and sockOld is ph)
-#  ph         ph     (if $reusing, and sockOld is ph) - not called in this case
-#  sock       ph     (cannot occur unless a bug)      - not called in this case
-#                    (if (not $reusing), and sockOld is sock) - illogical
-#
-# Arguments:
-# token         - connection token (name of an array)
-# sockOld       - handle or placeholder used for a socket before the call to
-#                 OpenSocket
-# DoLater       - dictionary of boolean values listing unfinished tasks
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::ConfigureNewSocket {token sockOld DoLater} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set reusing $state(reusing)
-    set sock $state(sock)
-    set proxyUsed $state(proxyUsed)
-    ##Log "  ConfigureNewSocket" $token $sockOld ... -- $reusing $sock $proxyUsed
-
-    if {(!$reusing) && ($sock ne $sockOld)} {
-        # Replace the placeholder value sockOld with sock.
-
-        if {    [info exists socketMapping($state(socketinfo))]
-             && ($socketMapping($state(socketinfo)) eq $sockOld)
-        } {
-            set socketMapping($state(socketinfo)) $sock
-            set socketProxyId($state(socketinfo)) $proxyUsed
-            # tokens that use the placeholder $sockOld are updated below.
-            ##Log set socketMapping($state(socketinfo)) $sock
-        }
-
-        # Now finish any tasks left over from PreparePersistentConnection on
-        # the connection.
-        #
-        # The "unset" traces are fired by init (clears entire arrays), and
-        # by http::Unset.
-        # Unset is called by CloseQueuedQueries and (possibly never) by geturl.
-        #
-        # CancelReadPipeline, CancelWritePipeline call http::Finish for each
-        # token.
-        #
-        # FIXME If Finish is placeholder-aware, these traces can be set earlier,
-        # in PreparePersistentConnection.
-
-        if {[dict get $DoLater -traceread]} {
-	    set varName ::http::socketRdState($state(socketinfo))
-	    trace add variable $varName unset ::http::CancelReadPipeline
-        }
-        if {[dict get $DoLater -tracewrite]} {
-	    set varName ::http::socketWrState($state(socketinfo))
-	    trace add variable $varName unset ::http::CancelWritePipeline
-        }
-    }
-
-    # Do this in all cases.
-    ScheduleRequest $token
-
-    # Now look at all other tokens that use the placeholder $sockOld.
-    if {    (!$reusing)
-         && ($sock ne $sockOld)
-         && [info exists socketPhQueue($sockOld)]
-    } {
-        ##Log "  ConfigureNewSocket" $token scheduled, now do $socketPhQueue($sockOld)
-        foreach tok $socketPhQueue($sockOld) {
-	    # 1. Amend the token's (sock).
-	    ##Log set ${tok}(sock) $sock
-	    set ${tok}(sock) $sock
-	    set ${tok}(proxyUsed) $proxyUsed
-
-	    # 2. Schedule the token's HTTP request.
-	    # Every token in socketPhQueue(*) has reusing 1 alreadyQueued 0.
-	    set ${tok}(reusing) 1
-	    set ${tok}(alreadyQueued) 0
-	    ScheduleRequest $tok
-	}
-	set socketPhQueue($sockOld) {}
-    }
-    ##Log "  ConfigureNewSocket" $token DONE
-
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-# The values of array variables socketMapping etc.
-# ------------------------------------------------------------------------------
-# connId                 "$host:$port"
-# socketMapping($connId) the handle or placeholder for the socket that is used
-#                        for "-keepalive 1" requests to $connId.
-# socketRdState($connId) the token that is currently reading from the socket.
-#                        Other values: Rready (ready for next token to read).
-# socketWrState($connId) the token that is currently writing to the socket.
-#                        Other values: Wready (ready for next token to write),
-#                        peNding (would be ready for next write, except that
-#                        the integrity of a non-pipelined transaction requires
-#                        waiting until the read(s) in progress are finished).
-# socketRdQueue($connId) List of tokens that are queued for reading later.
-# socketWrQueue($connId) List of tokens that are queued for writing later.
-# socketPhQueue($sock)   List of tokens that are queued to use a placeholder
-#                        socket, when the real socket has not yet been created.
-# socketClosing($connId) (boolean) true iff a server response header indicates
-#                        that the server will close the connection at the end of
-#                        the current response.
-# socketPlayCmd($connId) The command to execute to replay pending and
-#                        part-completed transactions if the socket closes early.
-# socketCoEvent($connId) Identifier for the "after idle" event that will launch
-#                        an OpenSocket coroutine to open or re-use a socket.
-# socketProxyId($connId) The type of proxy that this socket uses: values are
-#                        those of state(proxyUsed) i.e. none, HttpProxy,
-#                        SecureProxy, and SecureProxyFailed.
-#                        The value is not used for anything by http, its purpose
-#                        is to set the value of state() for caller information.
-# ------------------------------------------------------------------------------
-
-
-# ------------------------------------------------------------------------------
-# Using socketWrState(*), socketWrQueue(*), socketRdState(*), socketRdQueue(*)
-# ------------------------------------------------------------------------------
-# The element socketWrState($connId) has a value which is either the name of
-# the token that is permitted to write to the socket, or "Wready" if no
-# token is permitted to write.
-#
-# The code that sets the value to Wready immediately calls
-# http::NextPipelinedWrite, which examines socketWrQueue($connId) and
-# processes the next request in the queue, if there is one.  The value
-# Wready is not found when the interpreter is in the event loop unless the
-# socket is idle.
-#
-# The element socketRdState($connId) has a value which is either the name of
-# the token that is permitted to read from the socket, or "Rready" if no
-# token is permitted to read.
-#
-# The code that sets the value to Rready then examines
-# socketRdQueue($connId) and processes the next request in the queue, if
-# there is one.  The value Rready is not found when the interpreter is in
-# the event loop unless the socket is idle.
-# ------------------------------------------------------------------------------
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::ScheduleRequest
-# ------------------------------------------------------------------------------
-# Command to either begin the HTTP request, or add it to the appropriate queue.
-# Called from two places in ConfigureNewSocket.
-#
-# Arguments:
-# token         - connection token (name of an array)
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::ScheduleRequest {token} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    Log >L$tk ScheduleRequest
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set Unfinished 0
-
-    set reusing $state(reusing)
-    set sockNew $state(sock)
-
-    # The "if" tests below: must test against the current values of
-    # socketWrState, socketRdState, and so the tests must be done here,
-    # not earlier in PreparePersistentConnection.
-
-    if {$state(alreadyQueued)} {
-	# The request has been appended to the queue of a persistent socket
-	# (that is scheduled to close and have its queue replayed).
-	#
-	# A write may or may not be in progress.  There is no need to set
-	# socketWrState to prevent another call stealing write access - all
-	# subsequent calls on this socket will come here because the socket
-	# will close after the current read, and its
-	# socketClosing($connId) is 1.
-	##Log "HTTP request for token $token is queued"
-
-    } elseif {    $reusing
-	       && $state(-pipeline)
-	       && ($socketWrState($state(socketinfo)) ne "Wready")
-    } {
-	##Log "HTTP request for token $token is queued for pipelined use"
-	lappend socketWrQueue($state(socketinfo)) $token
-
-    } elseif {    $reusing
-	       && (!$state(-pipeline))
-	       && ($socketWrState($state(socketinfo)) ne "Wready")
-    } {
-	# A write is queued or in progress.  Lappend to the write queue.
-	##Log "HTTP request for token $token is queued for nonpipeline use"
-	lappend socketWrQueue($state(socketinfo)) $token
-
-    } elseif {    $reusing
-	       && (!$state(-pipeline))
-	       && ($socketWrState($state(socketinfo)) eq "Wready")
-	       && ($socketRdState($state(socketinfo)) ne "Rready")
-    } {
-	# A read is queued or in progress, but not a write.  Cannot start the
-	# nonpipeline transaction, but must set socketWrState to prevent a
-	# pipelined request jumping the queue.
-	##Log "HTTP request for token $token is queued for nonpipeline use"
-	#Log re-use nonpipeline, GRANT delayed write access to $token in geturl
-	set socketWrState($state(socketinfo)) peNding
-	lappend socketWrQueue($state(socketinfo)) $token
-
-    } else {
-        if {$reusing && $state(-pipeline)} {
-	    #Log new, init for pipelined, GRANT write access to $token in geturl
-	    # DO NOT grant premature read access to the socket.
-            # set socketRdState($state(socketinfo)) $token
-            set socketWrState($state(socketinfo)) $token
-        } elseif {$reusing} {
-	    # socketWrState is not used by this non-pipelined transaction.
-	    # We cannot leave it as "Wready" because the next call to
-	    # http::geturl with a pipelined transaction would conclude that the
-	    # socket is available for writing.
-	    #Log new, init for nonpipeline, GRANT r/w access to $token in geturl
-            set socketRdState($state(socketinfo)) $token
-            set socketWrState($state(socketinfo)) $token
-        } else {
-        }
-
-	# Process the request now.
-	# - Command is not called unless $state(sock) is a real socket handle
-	#   and not a placeholder.
-	# - All (!$reusing) cases come here.
-	# - Some $reusing cases come here too if the connection is
-	#   marked as ready.  Those $reusing cases are:
-	#   $reusing && ($socketWrState($state(socketinfo)) eq "Wready") &&
-	#   EITHER !$pipeline && ($socketRdState($state(socketinfo)) eq "Rready")
-	#   OR      $pipeline
-	#
-	#Log ---- $state(socketinfo) << conn to $token for HTTP request (a)
-	##Log "  ScheduleRequest" $token -- fileevent $state(sock) writable for $token
-	# Connect does its own fconfigure.
-
-        lassign $state(connArgs) proto phost srvurl
-
-	if {[catch {
-		fileevent $state(sock) writable \
-			[list http::Connect $token $proto $phost $srvurl]
-	} res opts]} {
-	    # The socket no longer exists.
-	    ##Log bug -- socket gone -- $res -- $opts
-	}
-
-    }
-
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::SendHeader
-# ------------------------------------------------------------------------------
-# Command to send a request header, and keep a copy in state(requestHeaders)
-# for debugging purposes.
-#
-# Arguments:
-# token       - connection token (name of an array)
-# key         - header name
-# value       - header value
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::SendHeader {token key value} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    set sock $state(sock)
-    lappend state(requestHeaders) [string tolower $key] $value
-    puts $sock "$key: $value"
-    return
-}
-
-# http::Connected --
-#
-#	Callback used when the connection to the HTTP server is actually
-#	established.
-#
-# Arguments:
-#	token	State token.
-#	proto	What protocol (http, https, etc.) was used to connect.
-#	phost	Are we using keep-alive? Non-empty if yes.
-#	srvurl	Service-local URL that we're requesting
-# Results:
-#	None.
-
-proc http::Connected {token proto phost srvurl} {
-    variable http
-    variable urlTypes
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    if {$state(reusing) && (!$state(-pipeline)) && ($state(-timeout) > 0)} {
-	set state(after) [after $state(-timeout) \
-		[list http::reset $token timeout]]
-    }
-
-    # Set back the variables needed here.
-    set sock $state(sock)
-    set isQueryChannel [info exists state(-querychannel)]
-    set isQuery [info exists state(-query)]
-    regexp {^(.+):([^:]+)$} $state(socketinfo) {} host port
-
-    set lower [string tolower $proto]
-    set defport [lindex $urlTypes($lower) 0]
-
-    # Send data in cr-lf format, but accept any line terminators.
-    # Initialisation to {auto *} now done in geturl, KeepSocket and DoneRequest.
-    # We are concerned here with the request (write) not the response (read).
-    lassign [fconfigure $sock -translation] trRead trWrite
-    fconfigure $sock -translation [list $trRead crlf] \
-		     -buffersize $state(-blocksize)
-    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-	fconfigure $sock -profile tcl8
-    }
-
-    # The following is disallowed in safe interpreters, but the socket is
-    # already in non-blocking mode in that case.
-
-    catch {fconfigure $sock -blocking off}
-    set how GET
-    if {$isQuery} {
-	set state(querylength) [string length $state(-query)]
-	if {$state(querylength) > 0} {
-	    set how POST
-	    set contDone 0
-	} else {
-	    # There's no query data.
-	    unset state(-query)
-	    set isQuery 0
-	}
-    } elseif {$state(-validate)} {
-	set how HEAD
-    } elseif {$isQueryChannel} {
-	set how POST
-	# The query channel must be blocking for the async Write to
-	# work properly.
-	fconfigure $state(-querychannel) -blocking 1 -translation binary
-	set contDone 0
-    }
-    if {[info exists state(-method)] && ($state(-method) ne "")} {
-	set how $state(-method)
-    }
-    set accept_types_seen 0
-
-    Log ^B$tk begin sending request - token $token
-
-    if {[catch {
-	if {[info exists state(bypass)]} {
-	    set state(method) [lindex [split $state(bypass) { }] 0]
-	    set state(requestHeaders) {}
-	    set state(requestLine) $state(bypass)
-	} else {
-	    set state(method) $how
-	    set state(requestHeaders) {}
-	    set state(requestLine) "$how $srvurl HTTP/$state(-protocol)"
-	}
-	puts $sock $state(requestLine)
-	set hostValue [GetFieldValue $state(-headers) Host]
-	if {$hostValue ne {}} {
-	    # Allow Host spoofing. [Bug 928154]
-	    regexp {^[^:]+} $hostValue state(host)
-	    SendHeader $token Host $hostValue
-	} elseif {$port == $defport} {
-	    # Don't add port in this case, to handle broken servers. [Bug
-	    # #504508]
-	    set state(host) $host
-	    SendHeader $token Host $host
-	} else {
-	    set state(host) $host
-	    SendHeader $token Host "$host:$port"
-	}
-	SendHeader $token User-Agent $http(-useragent)
-	if {($state(-protocol) > 1.0) && $state(-keepalive)} {
-	    # Send this header, because a 1.1 server is not compelled to treat
-	    # this as the default.
-	    set ConnVal keep-alive
-	} elseif {($state(-protocol) > 1.0)} {
-	    # RFC2616 sec 8.1.2.1
-	    set ConnVal close
-	} else {
-	    # ($state(-protocol) <= 1.0)
-	    # RFC7230 A.1
-	    # Some server implementations of HTTP/1.0 have a faulty
-	    # implementation of RFC 2068 Keep-Alive.
-	    # Don't leave this to chance.
-	    # For HTTP/1.0 we have already "set state(connection) close"
-	    # and "state(-keepalive) 0".
-	    set ConnVal close
-	}
-        # Proxy authorisation (cf. mod by Anders Ramdahl to autoproxy by
-        # Pat Thoyts).
-        if {($http(-proxyauth) ne {}) && ($state(proxyUsed) eq {HttpProxy})} {
-	    SendHeader $token Proxy-Authorization $http(-proxyauth)
-        }
-	# RFC7230 A.1 - "clients are encouraged not to send the
-	# Proxy-Connection header field in any requests"
-	set accept_encoding_seen 0
-	set content_type_seen 0
-	set connection_seen 0
-	foreach {key value} $state(-headers) {
-	    set value [string map [list \n "" \r ""] $value]
-	    set key [string map {" " -} [string trim $key]]
-	    if {[string equal -nocase $key "host"]} {
-		continue
-	    }
-	    if {[string equal -nocase $key "accept-encoding"]} {
-		set accept_encoding_seen 1
-	    }
-	    if {[string equal -nocase $key "accept"]} {
-		set accept_types_seen 1
-	    }
-	    if {[string equal -nocase $key "content-type"]} {
-		set content_type_seen 1
-	    }
-	    if {[string equal -nocase $key "content-length"]} {
-		set contDone 1
-		set state(querylength) $value
-	    }
-	    if {    [string equal -nocase $key "connection"]
-	         && [info exists state(bypass)]
-	    } {
-		# Value supplied in -headers overrides $ConnVal.
-		set connection_seen 1
-	    } elseif {[string equal -nocase $key "connection"]} {
-		# Remove "close" or "keep-alive" and use our own value.
-		# In an upgrade request, the upgrade is not guaranteed.
-		# Value "close" or "keep-alive" tells the server what to do
-		# if it refuses the upgrade.  We send a single "Connection"
-		# header because some websocket servers, e.g. civetweb, reject
-		# multiple headers. Bug [d01de3281f] of tcllib/websocket.
-		set connection_seen 1
-		set listVal $state(connectionValues)
-		if {[set pos [lsearch $listVal close]] != -1} {
-		    set listVal [lreplace $listVal $pos $pos]
-		}
-		if {[set pos [lsearch $listVal keep-alive]] != -1} {
-		    set listVal [lreplace $listVal $pos $pos]
-		}
-		lappend listVal $ConnVal
-		set value [join $listVal {, }]
-	    }
-	    if {[string length $key]} {
-		SendHeader $token $key $value
-	    }
-	}
-	# Allow overriding the Accept header on a per-connection basis. Useful
-	# for working with REST services. [Bug c11a51c482]
-	if {!$accept_types_seen} {
-	    SendHeader $token Accept $state(accept-types)
-	}
-	if {    (!$accept_encoding_seen)
-	     && (![info exists state(-handler)])
-	     && $http(-zip)
-	} {
-	    SendHeader $token Accept-Encoding gzip,deflate
-	} elseif {!$accept_encoding_seen} {
-	    SendHeader $token Accept-Encoding identity
-	} else {
-	}
-	if {!$connection_seen} {
-	    SendHeader $token Connection $ConnVal
-	}
-	if {$isQueryChannel && ($state(querylength) == 0)} {
-	    # Try to determine size of data in channel. If we cannot seek, the
-	    # surrounding catch will trap us
-
-	    set start [tell $state(-querychannel)]
-	    seek $state(-querychannel) 0 end
-	    set state(querylength) \
-		    [expr {[tell $state(-querychannel)] - $start}]
-	    seek $state(-querychannel) $start
-	}
-
-	# Note that we don't do Cookie2; that's much nastier and not normally
-	# observed in practice either. It also doesn't fix the multitude of
-	# bugs in the basic cookie spec.
-	if {$http(-cookiejar) ne ""} {
-	    set cookies ""
-	    set separator ""
-	    foreach {key value} [{*}$http(-cookiejar) \
-		    getCookies $proto $host $state(path)] {
-		append cookies $separator $key = $value
-		set separator "; "
-	    }
-	    if {$cookies ne ""} {
-		SendHeader $token Cookie $cookies
-	    }
-	}
-
-	# Flush the request header and set up the fileevent that will either
-	# push the POST data or read the response.
-	#
-	# fileevent note:
-	#
-	# It is possible to have both the read and write fileevents active at
-	# this point. The only scenario it seems to affect is a server that
-	# closes the connection without reading the POST data. (e.g., early
-	# versions TclHttpd in various error cases). Depending on the
-	# platform, the client may or may not be able to get the response from
-	# the server because of the error it will get trying to write the post
-	# data. Having both fileevents active changes the timing and the
-	# behavior, but no two platforms (among Solaris, Linux, and NT) behave
-	# the same, and none behave all that well in any case. Servers should
-	# always read their POST data if they expect the client to read their
-	# response.
-
-	if {$isQuery || $isQueryChannel} {
-	    # POST method.
-	    if {!$content_type_seen} {
-		SendHeader $token Content-Type $state(-type)
-	    }
-	    if {!$contDone} {
-		SendHeader $token Content-Length $state(querylength)
-	    }
-	    puts $sock ""
-	    flush $sock
-	    # Flush flushes the error in the https case with a bad handshake:
-	    # else the socket never becomes writable again, and hangs until
-	    # timeout (if any).
-
-	    lassign [fconfigure $sock -translation] trRead trWrite
-	    fconfigure $sock -translation [list $trRead binary]
-	    fileevent $sock writable [list http::Write $token]
-	    # The http::Write command decides when to make the socket readable,
-	    # using the same test as the GET/HEAD case below.
-	} else {
-	    # GET or HEAD method.
-	    if {    (![catch {fileevent $sock readable} binding])
-		 && ($binding eq [list http::CheckEof $sock])
-	    } {
-		# Remove the "fileevent readable" binding of an idle persistent
-		# socket to http::CheckEof.  We can no longer treat bytes
-		# received as junk. The server might still time out and
-		# half-close the socket if it has not yet received the first
-		# "puts".
-		fileevent $sock readable {}
-	    }
-	    puts $sock ""
-	    flush $sock
-	    Log ^C$tk end sending request - token $token
-	    # End of writing (GET/HEAD methods).  The request has been sent.
-
-	    DoneRequest $token
-	}
-
-    } err]} {
-	# The socket probably was never connected, OR the connection dropped
-	# later, OR https handshake error, which may be discovered as late as
-	# the "flush" command above...
-	Log "WARNING - if testing, pay special attention to this\
-		case (GI) which is seldom executed - token $token"
-	if {[info exists state(reusing)] && $state(reusing)} {
-	    # The socket was closed at the server end, and closed at
-	    # this end by http::CheckEof.
-    	    if {[TestForReplay $token write $err a]} {
-		return
-	    } else {
-		Finish $token {failed to re-use socket}
-	    }
-
-	    # else:
-	    # This is NOT a persistent socket that has been closed since its
-	    # last use.
-	    # If any other requests are in flight or pipelined/queued, they will
-	    # be discarded.
-	} elseif {$state(status) eq ""} {
-	    # https handshake errors come here, for
-	    # Tcl 8.7 without http::SecureProxyConnect, and for Tcl 8.6.
-	    set msg [registerError $sock]
-	    registerError $sock {}
-	    if {$msg eq {}} {
-		set msg {failed to use socket}
-	    }
-	    Finish $token $msg
-	} elseif {$state(status) ne "error"} {
-	    Finish $token $err
-	}
-    }
-    return
-}
-
-# http::registerError
-#
-#	Called (for example when processing TclTLS activity) to register
-#	an error for a connection on a specific socket.  This helps
-#	http::Connected to deliver meaningful error messages, e.g. when a TLS
-#	certificate fails verification.
-#
-#	Usage: http::registerError socket ?newValue?
-#
-#	"set" semantics, except that a "get" (a call without a new value) for a
-#	non-existent socket returns {}, not an error.
-
-proc http::registerError {sock args} {
-    variable registeredErrors
-
-    if {    ([llength $args] == 0)
-	 && (![info exists registeredErrors($sock)])
-    } {
-	return
-    } elseif {    ([llength $args] == 1)
-	       && ([lindex $args 0] eq {})
-    } {
-	unset -nocomplain registeredErrors($sock)
-	return
-    }
-    set registeredErrors($sock) {*}$args
-}
-
-# http::DoneRequest --
-#
-#	Command called when a request has been sent.  It will arrange the
-#	next request and/or response as appropriate.
-#
-#	If this command is called when $socketClosing(*), the request $token
-#	that calls it must be pipelined and destined to fail.
-
-proc http::DoneRequest {token} {
-    variable http
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    set sock $state(sock)
-
-    # If pipelined, connect the next HTTP request to the socket.
-    if {$state(reusing) && $state(-pipeline)} {
-	# Enable next token (if any) to write.
-	# The value "Wready" is set only here, and
-	# in http::Event after reading the response-headers of a
-	# non-reusing transaction.
-	# Previous value is $token. It cannot be pending.
-	set socketWrState($state(socketinfo)) Wready
-
-	# Now ready to write the next pipelined request (if any).
-	http::NextPipelinedWrite $token
-    } else {
-	# If pipelined, this is the first transaction on this socket.  We wait
-	# for the response headers to discover whether the connection is
-	# persistent.  (If this is not done and the connection is not
-	# persistent, we SHOULD retry and then MUST NOT pipeline before knowing
-	# that we have a persistent connection
-	# (rfc2616 8.1.2.2)).
-    }
-
-    # Connect to receive the response, unless the socket is pipelined
-    # and another response is being sent.
-    # This code block is separate from the code below because there are
-    # cases where socketRdState already has the value $token.
-    if {    $state(-keepalive)
-	 && $state(-pipeline)
-	 && [info exists socketRdState($state(socketinfo))]
-	 && ($socketRdState($state(socketinfo)) eq "Rready")
-    } {
-	#Log pipelined, GRANT read access to $token in Connected
-	set socketRdState($state(socketinfo)) $token
-    }
-
-    if {    $state(-keepalive)
-	 && $state(-pipeline)
-	 && [info exists socketRdState($state(socketinfo))]
-	 && ($socketRdState($state(socketinfo)) ne $token)
-    } {
-	# Do not read from the socket until it is ready.
-	##Log "HTTP response for token $token is queued for pipelined use"
-	# If $socketClosing(*), then the caller will be a pipelined write and
-	# execution will come here.
-	# This token has already been recorded as "in flight" for writing.
-	# When the socket is closed, the read queue will be cleared in
-	# CloseQueuedQueries and so the "lappend" here has no effect.
-	lappend socketRdQueue($state(socketinfo)) $token
-    } else {
-	# In the pipelined case, connection for reading depends on the
-	# value of socketRdState.
-	# In the nonpipeline case, connection for reading always occurs.
-	ReceiveResponse $token
-    }
-    return
-}
-
-# http::ReceiveResponse
-#
-#	Connects token to its socket for reading.
-
-proc http::ReceiveResponse {token} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    set sock $state(sock)
-
-    #Log ---- $state(socketinfo) >> conn to $token for HTTP response
-    lassign [fconfigure $sock -translation] trRead trWrite
-    fconfigure $sock -translation [list auto $trWrite] \
-		     -buffersize $state(-blocksize)
-    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-	fconfigure $sock -profile tcl8
-    }
-    Log ^D$tk begin receiving response - token $token
-
-    coroutine ${token}--EventCoroutine http::Event $sock $token
-    if {[info exists state(-handler)] || [info exists state(-progress)]} {
-        fileevent $sock readable [list http::EventGateway $sock $token]
-    } else {
-        fileevent $sock readable ${token}--EventCoroutine
-    }
-    return
-}
-
-
-# http::EventGateway
-#
-#	Bug [c2dc1da315].
-#	- Recursive launch of the coroutine can occur if a -handler or -progress
-#	  callback is used, and the callback command enters the event loop.
-#	- To prevent this, the fileevent "binding" is disabled while the
-#	  coroutine is in flight.
-#	- If a recursive call occurs despite these precautions, it is not
-#	  trapped and discarded here, because it is better to report it as a
-#	  bug.
-#	- Although this solution is believed to be sufficiently general, it is
-#	  used only if -handler or -progress is specified.  In other cases,
-#	  the coroutine is called directly.
-
-proc http::EventGateway {sock token} {
-    variable $token
-    upvar 0 $token state
-    fileevent $sock readable {}
-    catch {${token}--EventCoroutine} res opts
-    if {[info commands ${token}--EventCoroutine] ne {}} {
-        # The coroutine can be deleted by completion (a non-yield return), by
-        # http::Finish (when there is a premature end to the transaction), by
-        # http::reset or http::cleanup, or if the caller set option -channel
-        # but not option -handler: in the last case reading from the socket is
-        # now managed by commands ::http::Copy*, http::ReceiveChunked, and
-        # http::MakeTransformationChunked.
-        #
-        # Catch in case the coroutine has closed the socket.
-        catch {fileevent $sock readable [list http::EventGateway $sock $token]}
-    }
-
-    # If there was an error, re-throw it.
-    return -options $opts $res
-}
-
-
-# http::NextPipelinedWrite
-#
-# - Connecting a socket to a token for writing is done by this command and by
-#   command KeepSocket.
-# - If another request has a pipelined write scheduled for $token's socket,
-#   and if the socket is ready to accept it, connect the write and update
-#   the queue accordingly.
-# - This command is called from http::DoneRequest and http::Event,
-#   IF $state(-pipeline) AND (the current transfer has reached the point at
-#   which the socket is ready for the next request to be written).
-# - This command is called when a token has write access and is pipelined and
-#   keep-alive, and sets socketWrState to Wready.
-# - The command need not consider the case where socketWrState is set to a token
-#   that does not yet have write access.  Such a token is waiting for Rready,
-#   and the assignment of the connection to the token will be done elsewhere (in
-#   http::KeepSocket).
-# - This command cannot be called after socketWrState has been set to a
-#   "pending" token value (that is then overwritten by the caller), because that
-#   value is set by this command when it is called by an earlier token when it
-#   relinquishes its write access, and the pending token is always the next in
-#   line to write.
-
-proc http::NextPipelinedWrite {token} {
-    variable http
-    variable socketRdState
-    variable socketWrState
-    variable socketWrQueue
-    variable socketClosing
-    variable $token
-    upvar 0 $token state
-    set connId $state(socketinfo)
-
-    if {    [info exists socketClosing($connId)]
-	 && $socketClosing($connId)
-    } {
-	# socketClosing(*) is set because the server has sent a
-	# "Connection: close" header.
-	# Behave as if the queues are empty - so do nothing.
-    } elseif {    $state(-pipeline)
-	 && [info exists socketWrState($connId)]
-	 && ($socketWrState($connId) eq "Wready")
-
-	 && [info exists socketWrQueue($connId)]
-	 && [llength $socketWrQueue($connId)]
-	 && ([set token2 [lindex $socketWrQueue($connId) 0]
-	      set ${token2}(-pipeline)
-	     ]
-	    )
-    } {
-	# - The usual case for a pipelined connection, ready for a new request.
-	#Log pipelined, GRANT write access to $token2 in NextPipelinedWrite
-	set conn [set ${token2}(connArgs)]
-	set socketWrState($connId) $token2
-	set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	# Connect does its own fconfigure.
-	fileevent $state(sock) writable [list http::Connect $token2 {*}$conn]
-	#Log ---- $connId << conn to $token2 for HTTP request (b)
-
-	# In the tests below, the next request will be nonpipeline.
-    } elseif {    $state(-pipeline)
-	       && [info exists socketWrState($connId)]
-	       && ($socketWrState($connId) eq "Wready")
-
-	       && [info exists socketWrQueue($connId)]
-	       && [llength $socketWrQueue($connId)]
-	       && (![ set token3 [lindex $socketWrQueue($connId) 0]
-		      set ${token3}(-pipeline)
-		    ]
-		  )
-
-	       && [info exists socketRdState($connId)]
-	       && ($socketRdState($connId) eq "Rready")
-    } {
-	# The case in which the next request will be non-pipelined, and the read
-	# and write queues is ready: which is the condition for a non-pipelined
-	# write.
-	set conn [set ${token3}(connArgs)]
-	#Log nonpipeline, GRANT r/w access to $token3 in NextPipelinedWrite
-	set socketRdState($connId) $token3
-	set socketWrState($connId) $token3
-	set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	# Connect does its own fconfigure.
-	fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
-	#Log ---- $state(sock) << conn to $token3 for HTTP request (c)
-
-    } elseif {    $state(-pipeline)
-	 && [info exists socketWrState($connId)]
-	 && ($socketWrState($connId) eq "Wready")
-
-	 && [info exists socketWrQueue($connId)]
-	 && [llength $socketWrQueue($connId)]
-	 && (![set token2 [lindex $socketWrQueue($connId) 0]
-	      set ${token2}(-pipeline)
-	     ]
-	    )
-    } {
-	# - The case in which the next request will be non-pipelined, but the
-	#   read queue is NOT ready.
-	# - A read is queued or in progress, but not a write.  Cannot start the
-	#   nonpipeline transaction, but must set socketWrState to prevent a new
-	#   pipelined request (in http::geturl) jumping the queue.
-	# - Because socketWrState($connId) is not set to Wready, the assignment
-	#   of the connection to $token2 will be done elsewhere - by command
-	#   http::KeepSocket when $socketRdState($connId) is set to "Rready".
-
-	#Log re-use nonpipeline, GRANT delayed write access to $token in NextP..
-	set socketWrState($connId) peNding
-    }
-    return
-}
-
-# http::CancelReadPipeline
-#
-#	Cancel pipelined responses on a closing "Keep-Alive" socket.
-#
-#	- Called by a variable trace on "unset socketRdState($connId)".
-#	- The variable relates to a Keep-Alive socket, which has been closed.
-#	- Cancels all pipelined responses. The requests have been sent,
-#	  the responses have not yet been received.
-#	- This is a hard cancel that ends each transaction with error status,
-#	  and closes the connection. Do not use it if you want to replay failed
-#	  transactions.
-#	- N.B. Always delete ::http::socketRdState($connId) before deleting
-#	  ::http::socketRdQueue($connId), or this command will do nothing.
-#
-# Arguments
-#	As for a trace command on a variable.
-
-proc http::CancelReadPipeline {name1 connId op} {
-    variable socketRdQueue
-    ##Log CancelReadPipeline $name1 $connId $op
-    if {[info exists socketRdQueue($connId)]} {
-	set msg {the connection was closed by CancelReadPipeline}
-	foreach token $socketRdQueue($connId) {
-	    set tk [namespace tail $token]
-	    Log ^X$tk end of response "($msg)" - token $token
-	    set ${token}(status) eof
-	    Finish $token ;#$msg
-	}
-	set socketRdQueue($connId) {}
-    }
-    return
-}
-
-# http::CancelWritePipeline
-#
-#	Cancel queued events on a closing "Keep-Alive" socket.
-#
-#	- Called by a variable trace on "unset socketWrState($connId)".
-#	- The variable relates to a Keep-Alive socket, which has been closed.
-#	- In pipelined or nonpipeline case: cancels all queued requests.  The
-#	  requests have not yet been sent, the responses are not due.
-#	- This is a hard cancel that ends each transaction with error status,
-#	  and closes the connection. Do not use it if you want to replay failed
-#	  transactions.
-#	- N.B. Always delete ::http::socketWrState($connId) before deleting
-#	  ::http::socketWrQueue($connId), or this command will do nothing.
-#
-# Arguments
-#	As for a trace command on a variable.
-
-proc http::CancelWritePipeline {name1 connId op} {
-    variable socketWrQueue
-
-    ##Log CancelWritePipeline $name1 $connId $op
-    if {[info exists socketWrQueue($connId)]} {
-	set msg {the connection was closed by CancelWritePipeline}
-	foreach token $socketWrQueue($connId) {
-	    set tk [namespace tail $token]
-	    Log ^X$tk end of response "($msg)" - token $token
-	    set ${token}(status) eof
-	    Finish $token ;#$msg
-	}
-	set socketWrQueue($connId) {}
-    }
-    return
-}
-
-# http::ReplayIfDead --
-#
-# - A query on a re-used persistent socket failed at the earliest opportunity,
-#   because the socket had been closed by the server.  Keep the token, tidy up,
-#   and try to connect on a fresh socket.
-# - The connection is monitored for eof by the command http::CheckEof.  Thus
-#   http::ReplayIfDead is needed only when a server event (half-closing an
-#   apparently idle connection), and a client event (sending a request) occur at
-#   almost the same time, and neither client nor server detects the other's
-#   action before performing its own (an "asynchronous close event").
-# - To simplify testing of http::ReplayIfDead, set TEST_EOF 1 in
-#   http::KeepSocket, and then http::ReplayIfDead will be called if http::geturl
-#   is called at any time after the server timeout.
-#
-# Arguments:
-#	token	Connection token.
-#
-# Side Effects:
-#	Use the same token, but try to open a new socket.
-
-proc http::ReplayIfDead {token doing} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-
-    Log running http::ReplayIfDead for $token $doing
-
-    # 1. Merge the tokens for transactions in flight, the read (response) queue,
-    #    and the write (request) queue.
-
-    set InFlightR {}
-    set InFlightW {}
-
-    # Obtain the tokens for transactions in flight.
-    if {$state(-pipeline)} {
-	# Two transactions may be in flight.  The "read" transaction was first.
-	# It is unlikely that the server would close the socket if a response
-	# was pending; however, an earlier request (as well as the present
-	# request) may have been sent and ignored if the socket was half-closed
-	# by the server.
-
-	if {    [info exists socketRdState($state(socketinfo))]
-	     && ($socketRdState($state(socketinfo)) ne "Rready")
-	} {
-	    lappend InFlightR $socketRdState($state(socketinfo))
-	} elseif {($doing eq "read")} {
-	    lappend InFlightR $token
-	}
-
-	if {    [info exists socketWrState($state(socketinfo))]
-	     && $socketWrState($state(socketinfo)) ni {Wready peNding}
-	} {
-	    lappend InFlightW $socketWrState($state(socketinfo))
-	} elseif {($doing eq "write")} {
-	    lappend InFlightW $token
-	}
-
-	# Report any inconsistency of $token with socket*state.
-	if {    ($doing eq "read")
-	     && [info exists socketRdState($state(socketinfo))]
-	     && ($token ne $socketRdState($state(socketinfo)))
-	} {
-	    Log WARNING - ReplayIfDead pipelined token $token $doing \
-		    ne socketRdState($state(socketinfo)) \
-		      $socketRdState($state(socketinfo))
-
-	} elseif {
-		($doing eq "write")
-	     && [info exists socketWrState($state(socketinfo))]
-	     && ($token ne $socketWrState($state(socketinfo)))
-	} {
-	    Log WARNING - ReplayIfDead pipelined token $token $doing \
-		    ne socketWrState($state(socketinfo)) \
-		      $socketWrState($state(socketinfo))
-	}
-    } else {
-	# One transaction should be in flight.
-	# socketRdState, socketWrQueue are used.
-	# socketRdQueue should be empty.
-
-	# Report any inconsistency of $token with socket*state.
-	if {$token ne $socketRdState($state(socketinfo))} {
-	    Log WARNING - ReplayIfDead nonpipeline token $token $doing \
-		    ne socketRdState($state(socketinfo)) \
-		      $socketRdState($state(socketinfo))
-	}
-
-	# Report the inconsistency that socketRdQueue is non-empty.
-	if {    [info exists socketRdQueue($state(socketinfo))]
-	     && ($socketRdQueue($state(socketinfo)) ne {})
-	} {
-	    Log WARNING - ReplayIfDead nonpipeline token $token $doing \
-		    has read queue socketRdQueue($state(socketinfo)) \
-		    $socketRdQueue($state(socketinfo)) ne {}
-	}
-
-	lappend InFlightW $socketRdState($state(socketinfo))
-	set socketRdQueue($state(socketinfo)) {}
-    }
-
-    set newQueue {}
-    lappend newQueue {*}$InFlightR
-    lappend newQueue {*}$socketRdQueue($state(socketinfo))
-    lappend newQueue {*}$InFlightW
-    lappend newQueue {*}$socketWrQueue($state(socketinfo))
-
-
-    # 2. Tidy up token.  This is a cut-down form of Finish/CloseSocket.
-    #    Do not change state(status).
-    #    No need to after cancel state(after) - either this is done in
-    #    ReplayCore/ReInit, or Finish is called.
-
-    catch {close $state(sock)}
-    Unset $state(socketinfo)
-
-    # 2a. Tidy the tokens in the queues - this is done in ReplayCore/ReInit.
-    # - Transactions, if any, that are awaiting responses cannot be completed.
-    #   They are listed for re-sending in newQueue.
-    # - All tokens are preserved for re-use by ReplayCore, and their variables
-    #   will be re-initialised by calls to ReInit.
-    # - The relevant element of socketMapping, socketRdState, socketWrState,
-    #   socketRdQueue, socketWrQueue, socketClosing, socketPlayCmd will be set
-    #   to new values in ReplayCore.
-
-    ReplayCore $newQueue
-    return
-}
-
-# http::ReplayIfClose --
-#
-#	A request on a socket that was previously "Connection: keep-alive" has
-#	received a "Connection: close" response header.  The server supplies
-#	that response correctly, but any later requests already queued on this
-#	connection will be lost when the socket closes.
-#
-#	This command takes arguments that represent the socketWrState,
-#	socketRdQueue and socketWrQueue for this connection.  The socketRdState
-#	is not needed because the server responds in full to the request that
-#	received the "Connection: close" response header.
-#
-#	Existing request tokens $token (::http::$n) are preserved.  The caller
-#	will be unaware that the request was processed this way.
-
-proc http::ReplayIfClose {Wstate Rqueue Wqueue} {
-    Log running http::ReplayIfClose for $Wstate $Rqueue $Wqueue
-
-    if {$Wstate in $Rqueue || $Wstate in $Wqueue} {
-	Log WARNING duplicate token in http::ReplayIfClose - token $Wstate
-	set Wstate Wready
-    }
-
-    # 1. Create newQueue
-    set InFlightW {}
-    if {$Wstate ni {Wready peNding}} {
-	lappend InFlightW $Wstate
-    }
-    ##Log $Rqueue -- $InFlightW -- $Wqueue
-    set newQueue {}
-    lappend newQueue {*}$Rqueue
-    lappend newQueue {*}$InFlightW
-    lappend newQueue {*}$Wqueue
-
-    # 2. Cleanup - none needed, done by the caller.
-
-    ReplayCore $newQueue
-    return
-}
-
-# http::ReInit --
-#
-#	Command to restore a token's state to a condition that
-#	makes it ready to replay a request.
-#
-#	Command http::geturl stores extra state in state(tmp*) so
-#	we don't need to do the argument processing again.
-#
-#	The caller must:
-#	- Set state(reusing) and state(sock) to their new values after calling
-#	  this command.
-#	- Unset state(tmpState), state(tmpOpenCmd) if future calls to ReplayCore
-#	  or ReInit are inappropriate for this token. Typically only one retry
-#	  is allowed.
-#	The caller may also unset state(tmpConnArgs) if this value (and the
-#	token) will be used immediately.  The value is needed by tokens that
-#	will be stored in a queue.
-#
-# Arguments:
-#	token	Connection token.
-#
-# Return Value: (boolean) true iff the re-initialisation was successful.
-
-proc http::ReInit {token} {
-    variable $token
-    upvar 0 $token state
-
-    if {!(
-	      [info exists state(tmpState)]
-	   && [info exists state(tmpOpenCmd)]
-	   && [info exists state(tmpConnArgs)]
-	 )
-    } {
-	Log FAILED in http::ReInit via ReplayCore - NO tmp vars for $token
-	return 0
-    }
-
-    if {[info exists state(after)]} {
-	after cancel $state(after)
-	unset state(after)
-    }
-    if {[info exists state(socketcoro)]} {
-        Log $token Cancel socket after-idle event (ReInit)
-        after cancel $state(socketcoro)
-        unset state(socketcoro)
-    }
-
-    # Don't alter state(status) - this would trigger http::wait if it is in use.
-    set tmpState    $state(tmpState)
-    set tmpOpenCmd  $state(tmpOpenCmd)
-    set tmpConnArgs $state(tmpConnArgs)
-    foreach name [array names state] {
-	if {$name ne "status"} {
-	    unset state($name)
-	}
-    }
-
-    # Don't alter state(status).
-    # Restore state(tmp*) - the caller may decide to unset them.
-    # Restore state(tmpConnArgs) which is needed for connection.
-    # state(tmpState), state(tmpOpenCmd) are needed only for retries.
-
-    dict unset tmpState status
-    array set state $tmpState
-    set state(tmpState)    $tmpState
-    set state(tmpOpenCmd)  $tmpOpenCmd
-    set state(tmpConnArgs) $tmpConnArgs
-
-    return 1
-}
-
-# http::ReplayCore --
-#
-#	Command to replay a list of requests, using existing connection tokens.
-#
-#	Abstracted from http::geturl which stores extra state in state(tmp*) so
-#	we don't need to do the argument processing again.
-#
-# Arguments:
-#	newQueue	List of connection tokens.
-#
-# Side Effects:
-#	Use existing tokens, but try to open a new socket.
-
-proc http::ReplayCore {newQueue} {
-    variable TmpSockCounter
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    if {[llength $newQueue] == 0} {
-	# Nothing to do.
-	return
-    }
-
-    ##Log running ReplayCore for {*}$newQueue
-    set newToken [lindex $newQueue 0]
-    set newQueue [lrange $newQueue 1 end]
-
-    # 3. Use newToken, and restore its values of state(*).  Do not restore
-    #    elements tmp* - we try again only once.
-
-    set token $newToken
-    variable $token
-    upvar 0 $token state
-
-    if {![ReInit $token]} {
-	Log FAILED in http::ReplayCore - NO tmp vars
-	Log ReplayCore reject $token
-	Finish $token {cannot send this request again}
-	return
-    }
-
-    set tmpState    $state(tmpState)
-    set tmpOpenCmd  $state(tmpOpenCmd)
-    set tmpConnArgs $state(tmpConnArgs)
-    unset state(tmpState)
-    unset state(tmpOpenCmd)
-    unset state(tmpConnArgs)
-
-    set state(reusing) 0
-    set state(ReusingPlaceholder) 0
-    set state(alreadyQueued) 0
-    Log ReplayCore replay $token
-
-    # Give the socket a placeholder name before it is created.
-    set sock HTTP_PLACEHOLDER_[incr TmpSockCounter]
-    set state(sock) $sock
-
-    # Move the $newQueue into the placeholder socket's socketPhQueue.
-    set socketPhQueue($sock) {}
-    foreach tok $newQueue {
-	if {[ReInit $tok]} {
-	    set ${tok}(reusing) 1
-	    set ${tok}(sock) $sock
-	    lappend socketPhQueue($sock) $tok
-	    Log ReplayCore replay $tok
-	} else {
-	    Log ReplayCore reject $tok
-	    set ${tok}(reusing) 1
-	    set ${tok}(sock) NONE
-	    Finish $tok {cannot send this request again}
-	}
-    }
-
-    AsyncTransaction $token
-
-    return
-}
-
-# Data access functions:
-# Data - the URL data
-# Status - the transaction status: ok, reset, eof, timeout, error
-# Code - the HTTP transaction code, e.g., 200
-# Size - the size of the URL data
-
-proc http::responseBody {token} {
-    variable $token
-    upvar 0 $token state
-    return $state(body)
-}
-proc http::status {token} {
-    if {![info exists $token]} {
-	return "error"
-    }
-    variable $token
-    upvar 0 $token state
-    return $state(status)
-}
-proc http::responseLine {token} {
-    variable $token
-    upvar 0 $token state
-    return $state(http)
-}
-proc http::requestLine {token} {
-    variable $token
-    upvar 0 $token state
-    return $state(requestLine)
-}
-proc http::responseCode {token} {
-    variable $token
-    upvar 0 $token state
-    if {[regexp {[0-9]{3}} $state(http) numeric_code]} {
-	return $numeric_code
-    } else {
-	return $state(http)
-    }
-}
-proc http::size {token} {
-    variable $token
-    upvar 0 $token state
-    return $state(currentsize)
-}
-proc http::requestHeaders {token args} {
-    set lenny  [llength $args]
-    if {$lenny > 1} {
-        return -code error {usage: ::http::requestHeaders token ?headerName?}
-    } else {
-        return [Meta $token request {*}$args]
-    }
-}
-proc http::responseHeaders {token args} {
-    set lenny  [llength $args]
-    if {$lenny > 1} {
-        return -code error {usage: ::http::responseHeaders token ?headerName?}
-    } else {
-        return [Meta $token response {*}$args]
-    }
-}
-proc http::requestHeaderValue {token header} {
-    Meta $token request $header VALUE
-}
-proc http::responseHeaderValue {token header} {
-    Meta $token response $header VALUE
-}
-proc http::Meta {token who args} {
-    variable $token
-    upvar 0 $token state
-
-    if {$who eq {request}} {
-        set whom requestHeaders
-    } elseif {$who eq {response}} {
-        set whom meta
-    } else {
-        return -code error {usage: ::http::Meta token request|response ?headerName ?VALUE??}
-    }
-
-    set header [string tolower [lindex $args 0]]
-    set how    [string tolower [lindex $args 1]]
-    set lenny  [llength $args]
-    if {$lenny == 0} {
-        return $state($whom)
-    } elseif {($lenny > 2) || (($lenny == 2) && ($how ne {value}))} {
-        return -code error {usage: ::http::Meta token request|response ?headerName ?VALUE??}
-    } else {
-        set result {}
-        set combined {}
-        foreach {key value} $state($whom) {
-            if {$key eq $header} {
-                lappend result $key $value
-                append combined $value {, }
-            }
-        }
-        if {$lenny == 1} {
-            return $result
-        } else {
-            return [string range $combined 0 end-2]
-        }
-    }
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::responseInfo
-# ------------------------------------------------------------------------------
-# Command to return a dictionary of the most useful metadata of a HTTP
-# response.
-#
-# Arguments:
-# token       - connection token (name of an array)
-#
-# Return Value: a dict. See man page http(n) for a description of each item.
-# ------------------------------------------------------------------------------
-
-proc http::responseInfo {token} {
-    variable $token
-    upvar 0 $token state
-    set result {}
-    foreach {key origin name} {
-        stage                 STATE  state
-        status                STATE  status
-        responseCode          STATE  responseCode
-        reasonPhrase          STATE  reasonPhrase
-        contentType           STATE  type
-        binary                STATE  binary
-        redirection           RESP   location
-        upgrade               STATE  upgrade
-        error                 ERROR  -
-        postError             STATE  posterror
-        method                STATE  method
-        charset               STATE  charset
-        compression           STATE  coding
-        httpRequest           STATE  -protocol
-        httpResponse          STATE  httpResponse
-        url                   STATE  url
-        connectionRequest     REQ    connection
-        connectionResponse    RESP   connection
-        connectionActual      STATE  connection
-        transferEncoding      STATE  transfer
-        totalPost             STATE  querylength
-        currentPost           STATE  queryoffset
-        totalSize             STATE  totalsize
-        currentSize           STATE  currentsize
-        proxyUsed             STATE  proxyUsed
-    } {
-        if {$origin eq {STATE}} {
-            if {[info exists state($name)]} {
-                dict set result $key $state($name)
-            } else {
-                # Should never come here
-                dict set result $key {}
-            }
-        } elseif {$origin eq {REQ}} {
-            dict set result $key [requestHeaderValue $token $name]
-        } elseif {$origin eq {RESP}} {
-            dict set result $key [responseHeaderValue $token $name]
-        } elseif {$origin eq {ERROR}} {
-            # Don't flood the dict with data.  The command ::http::error is
-            # available.
-            if {[info exists state(error)]} {
-                set msg [lindex $state(error) 0]
-            } else {
-                set msg {}
-            }
-            dict set result $key $msg
-        } else {
-            # Should never come here
-            dict set result $key {}
-        }
-    }
-    return $result
-}
-proc http::error {token} {
-    variable $token
-    upvar 0 $token state
-    if {[info exists state(error)]} {
-	return $state(error)
-    }
-    return
-}
-proc http::postError {token} {
-    variable $token
-    upvar 0 $token state
-    if {[info exists state(postErrorFull)]} {
-	return $state(postErrorFull)
-    }
-    return
-}
-
-# http::cleanup
-#
-#	Garbage collect the state associated with a transaction
-#
-# Arguments
-#	token	The token returned from http::geturl
-#
-# Side Effects
-#	Unsets the state array.
-
-proc http::cleanup {token} {
-    variable $token
-    upvar 0 $token state
-    if {[info commands ${token}--EventCoroutine] ne {}} {
-	rename ${token}--EventCoroutine {}
-    }
-    if {[info commands ${token}--SocketCoroutine] ne {}} {
-	rename ${token}--SocketCoroutine {}
-    }
-    if {[info exists state(after)]} {
-	after cancel $state(after)
-	unset state(after)
-    }
-    if {[info exists state(socketcoro)]} {
-        Log $token Cancel socket after-idle event (cleanup)
-        after cancel $state(socketcoro)
-        unset state(socketcoro)
-    }
-    if {[info exists state]} {
-	unset state
-    }
-    return
-}
-
-# http::Connect
-#
-#	This callback is made when an asynchronous connection completes.
-#
-# Arguments
-#	token	The token returned from http::geturl
-#
-# Side Effects
-#	Sets the status of the connection, which unblocks
-# 	the waiting geturl call
-
-proc http::Connect {token proto phost srvurl} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    if {[catch {eof $state(sock)} tmp] || $tmp} {
-        set err "due to unexpected EOF"
-    } elseif {[set err [fconfigure $state(sock) -error]] ne ""} {
-        # set err is done in test
-    } else {
-        # All OK
-	set state(state) connecting
-	fileevent $state(sock) writable {}
-	::http::Connected $token $proto $phost $srvurl
-	return
-    }
-
-    # Error cases.
-	Log "WARNING - if testing, pay special attention to this\
-		case (GJ) which is seldom executed - token $token"
-	if {[info exists state(reusing)] && $state(reusing)} {
-	    # The socket was closed at the server end, and closed at
-	    # this end by http::CheckEof.
-	    if {[TestForReplay $token write $err b]} {
-		return
-	    }
-
-	    # else:
-	    # This is NOT a persistent socket that has been closed since its
-	    # last use.
-	    # If any other requests are in flight or pipelined/queued, they will
-	    # be discarded.
-	}
-	Finish $token "connect failed: $err"
-    return
-}
-
-# http::Write
-#
-#	Write POST query data to the socket
-#
-# Arguments
-#	token	The token for the connection
-#
-# Side Effects
-#	Write the socket and handle callbacks.
-
-proc http::Write {token} {
-    variable http
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    set sock $state(sock)
-
-    # Output a block.  Tcl will buffer this if the socket blocks
-    set done 0
-    if {[catch {
-	# Catch I/O errors on dead sockets
-
-	if {[info exists state(-query)]} {
-	    # Chop up large query strings so queryprogress callback can give
-	    # smooth feedback.
-	    if {    $state(queryoffset) + $state(-queryblocksize)
-		 >= $state(querylength)
-	    } {
-		# This will be the last puts for the request-body.
-		if {    (![catch {fileevent $sock readable} binding])
-		     && ($binding eq [list http::CheckEof $sock])
-		} {
-		    # Remove the "fileevent readable" binding of an idle
-		    # persistent socket to http::CheckEof.  We can no longer
-		    # treat bytes received as junk. The server might still time
-		    # out and half-close the socket if it has not yet received
-		    # the first "puts".
-		    fileevent $sock readable {}
-		}
-	    }
-	    puts -nonewline $sock \
-		[string range $state(-query) $state(queryoffset) \
-		     [expr {$state(queryoffset) + $state(-queryblocksize) - 1}]]
-	    incr state(queryoffset) $state(-queryblocksize)
-	    if {$state(queryoffset) >= $state(querylength)} {
-		set state(queryoffset) $state(querylength)
-		set done 1
-	    }
-	} else {
-	    # Copy blocks from the query channel
-
-	    set outStr [read $state(-querychannel) $state(-queryblocksize)]
-	    if {[eof $state(-querychannel)]} {
-		# This will be the last puts for the request-body.
-		if {    (![catch {fileevent $sock readable} binding])
-		     && ($binding eq [list http::CheckEof $sock])
-		} {
-		    # Remove the "fileevent readable" binding of an idle
-		    # persistent socket to http::CheckEof.  We can no longer
-		    # treat bytes received as junk. The server might still time
-		    # out and half-close the socket if it has not yet received
-		    # the first "puts".
-		    fileevent $sock readable {}
-		}
-	    }
-	    puts -nonewline $sock $outStr
-	    incr state(queryoffset) [string length $outStr]
-	    if {[eof $state(-querychannel)]} {
-		set done 1
-	    }
-	}
-    } err opts]} {
-	# Do not call Finish here, but instead let the read half of the socket
-	# process whatever server reply there is to get.
-	set state(posterror) $err
-	set info [dict get $opts -errorinfo]
-	set code [dict get $opts -code]
-	set state(postErrorFull) [list $err $info $code]
-	set done 1
-    }
-
-    if {$done} {
-	catch {flush $sock}
-	fileevent $sock writable {}
-	Log ^C$tk end sending request - token $token
-	# End of writing (POST method).  The request has been sent.
-
-	DoneRequest $token
-    }
-
-    # Callback to the client after we've completely handled everything.
-
-    if {[string length $state(-queryprogress)]} {
-	namespace eval :: $state(-queryprogress) \
-	    [list $token $state(querylength) $state(queryoffset)]
-    }
-    return
-}
-
-# http::Event
-#
-#	Handle input on the socket. This command is the core of
-#	the coroutine commands ${token}--EventCoroutine that are
-#	bound to "fileevent $sock readable" and process input.
-#
-# Arguments
-#	sock	The socket receiving input.
-#	token	The token returned from http::geturl
-#
-# Side Effects
-#	Read the socket and handle callbacks.
-
-proc http::Event {sock token} {
-    variable http
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    while 1 {
-	yield
-	##Log Event call - token $token
-
-	if {![info exists state]} {
-	    Log "Event $sock with invalid token '$token' - remote close?"
-	    if {!([catch {eof $sock} tmp] || $tmp)} {
-		if {[set d [read $sock]] ne ""} {
-		    Log "WARNING: additional data left on closed socket\
-			    - token $token"
-		} else {
-		}
-	    } else {
-	    }
-	    Log ^X$tk end of response (token error) - token $token
-	    CloseSocket $sock
-	    return
-	} else {
-	}
-	if {$state(state) eq "connecting"} {
-	    ##Log - connecting - token $token
-	    if {    $state(reusing)
-		 && $state(-pipeline)
-		 && ($state(-timeout) > 0)
-		 && (![info exists state(after)])
-	    } {
-		set state(after) [after $state(-timeout) \
-			[list http::reset $token timeout]]
-	    } else {
-	    }
-
-	    if {[catch {gets $sock state(http)} nsl]} {
-		Log "WARNING - if testing, pay special attention to this\
-			case (GK) which is seldom executed - token $token"
-		if {[info exists state(reusing)] && $state(reusing)} {
-		    # The socket was closed at the server end, and closed at
-		    # this end by http::CheckEof.
-
-		    if {[TestForReplay $token read $nsl c]} {
-			return
-		    } else {
-		    }
-		    # else:
-		    # This is NOT a persistent socket that has been closed since
-		    # its last use.
-		    # If any other requests are in flight or pipelined/queued,
-		    # they will be discarded.
-		} else {
-		    # https handshake errors come here, for
-		    # Tcl 8.7 with http::SecureProxyConnect.
-		    set msg [registerError $sock]
-		    registerError $sock {}
-		    if {$msg eq {}} {
-			set msg $nsl
-		    }
-		    Log ^X$tk end of response (error) - token $token
-		    Finish $token $msg
-		    return
-		}
-	    } elseif {$nsl >= 0} {
-		##Log - connecting 1 - token $token
-		set state(state) "header"
-	    } elseif {    ([catch {eof $sock} tmp] || $tmp)
-		       && [info exists state(reusing)]
-		       && $state(reusing)
-	    } {
-		# The socket was closed at the server end, and we didn't notice.
-		# This is the first read - where the closure is usually first
-		# detected.
-
-		if {[TestForReplay $token read {} d]} {
-		    return
-		} else {
-		}
-
-		# else:
-		# This is NOT a persistent socket that has been closed since its
-		# last use.
-		# If any other requests are in flight or pipelined/queued, they
-		# will be discarded.
-	    } else {
-	    }
-	} elseif {$state(state) eq "header"} {
-	    if {[catch {gets $sock line} nhl]} {
-		##Log header failed - token $token
-		Log ^X$tk end of response (error) - token $token
-		Finish $token $nhl
-		return
-	    } elseif {$nhl == 0} {
-		##Log header done - token $token
-		Log ^E$tk end of response headers - token $token
-		# We have now read all headers
-		# We ignore HTTP/1.1 100 Continue returns. RFC2616 sec 8.2.3
-		if {    ($state(http) == "")
-		     || ([regexp {^\S+\s(\d+)} $state(http) {} x] && $x == 100)
-		} {
-		    set state(state) "connecting"
-		    continue
-		    # This was a "return" in the pre-coroutine code.
-		} else {
-		}
-
-		# We have $state(http) so let's split it into its components.
-		if {[regexp {^HTTP/(\S+) ([0-9]{3}) (.*)$} $state(http) \
-			-> httpResponse responseCode reasonPhrase]
-		} {
-		    set state(httpResponse) $httpResponse
-		    set state(responseCode) $responseCode
-		    set state(reasonPhrase) $reasonPhrase
-		} else {
-		    set state(httpResponse) $state(http)
-		    set state(responseCode) $state(http)
-		    set state(reasonPhrase) $state(http)
-		}
-
-		if {    ([info exists state(connection)])
-		     && ([info exists socketMapping($state(socketinfo))])
-		     && ("keep-alive" in $state(connection))
-		     && ($state(-keepalive))
-		     && (!$state(reusing))
-		     && ($state(-pipeline))
-		} {
-		    # Response headers received for first request on a
-		    # persistent socket.  Now ready for pipelined writes (if
-		    # any).
-		    # Previous value is $token. It cannot be "pending".
-		    set socketWrState($state(socketinfo)) Wready
-		    http::NextPipelinedWrite $token
-		} else {
-		}
-
-		# Once a "close" has been signaled, the client MUST NOT send any
-		# more requests on that connection.
-		#
-		# If either the client or the server sends the "close" token in
-		# the Connection header, that request becomes the last one for
-		# the connection.
-
-		if {    ([info exists state(connection)])
-		     && ([info exists socketMapping($state(socketinfo))])
-		     && ("close" in $state(connection))
-		     && ($state(-keepalive))
-		} {
-		    # The server warns that it will close the socket after this
-		    # response.
-		    ##Log WARNING - socket will close after response for $token
-		    # Prepare data for a call to ReplayIfClose.
-		    Log $token socket will close after this transaction
-		    # 1. Cancel socket-assignment coro events that have not yet
-		    # launched, and add the tokens to the write queue.
-		    if {[info exists socketCoEvent($state(socketinfo))]} {
-			foreach {tok can} $socketCoEvent($state(socketinfo)) {
-			    lappend socketWrQueue($state(socketinfo)) $tok
-			    unset -nocomplain ${tok}(socketcoro)
-			    after cancel $can
-			    Log $tok Cancel socket after-idle event (Event)
-			    Log Move $tok from socketCoEvent to socketWrQueue and cancel its after idle coro
-			}
-			set socketCoEvent($state(socketinfo)) {}
-		    } else {
-		    }
-
-		    if {    ($socketRdQueue($state(socketinfo)) ne {})
-			 || ($socketWrQueue($state(socketinfo)) ne {})
-			 || ($socketWrState($state(socketinfo)) ni
-						[list Wready peNding $token])
-		    } {
-			set InFlightW $socketWrState($state(socketinfo))
-			if {$InFlightW in [list Wready peNding $token]} {
-			    set InFlightW Wready
-			} else {
-			    set msg "token ${InFlightW} is InFlightW"
-			    ##Log $msg - token $token
-			}
-			set socketPlayCmd($state(socketinfo)) \
-				[list ReplayIfClose $InFlightW \
-				$socketRdQueue($state(socketinfo)) \
-				$socketWrQueue($state(socketinfo))]
-
-			# - All tokens are preserved for re-use by ReplayCore.
-			# - Queues are preserved in case of Finish with error,
-			#   but are not used for anything else because
-			#   socketClosing(*) is set below.
-			# - Cancel the state(after) timeout events.
-			foreach tokenVal $socketRdQueue($state(socketinfo)) {
-			    if {[info exists ${tokenVal}(after)]} {
-				after cancel [set ${tokenVal}(after)]
-				unset ${tokenVal}(after)
-			    } else {
-			    }
-			    # Tokens in the read queue have no (socketcoro) to
-			    # cancel.
-			}
-		    } else {
-			set socketPlayCmd($state(socketinfo)) \
-				{ReplayIfClose Wready {} {}}
-		    }
-
-		    # Do not allow further connections on this socket (but
-		    # geturl can add new requests to the replay).
-		    set socketClosing($state(socketinfo)) 1
-		} else {
-		}
-
-		set state(state) body
-
-		# According to
-		# https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Connection
-		# any comma-separated "Connection:" list implies keep-alive, but I
-		# don't see this in the RFC so we'll play safe and
-		# scan any list for "close".
-		# Done here to support combining duplicate header field's values.
-		if {   [info exists state(connection)]
-		    && ("close" ni $state(connection))
-		    && ("keep-alive" ni $state(connection))
-		} {
-		    lappend state(connection) "keep-alive"
-		} else {
-		}
-
-		# If doing a HEAD, then we won't get any body
-		if {$state(-validate)} {
-		    Log ^F$tk end of response for HEAD request - token $token
-		    set state(state) complete
-		    Eot $token
-		    return
-		} elseif {
-			($state(method) eq {CONNECT})
-		     && [string is integer -strict $state(responseCode)]
-		     && ($state(responseCode) >= 200)
-		     && ($state(responseCode) < 300)
-		} {
-		    # A successful CONNECT response has no body.
-		    # (An unsuccessful CONNECT has headers and body.)
-		    # The code below is abstracted from Eot/Finish, but
-		    # keeps the socket open.
-		    catch {fileevent $state(sock) readable {}}
-		    catch {fileevent $state(sock) writable {}}
-		    set state(state) complete
-		    set state(status) ok
-		    if {[info commands ${token}--EventCoroutine] ne {}} {
-			rename ${token}--EventCoroutine {}
-		    }
-		    if {[info commands ${token}--SocketCoroutine] ne {}} {
-			rename ${token}--SocketCoroutine {}
-		    }
-		    if {[info exists state(socketcoro)]} {
-		        Log $token Cancel socket after-idle event (Finish)
-		        after cancel $state(socketcoro)
-		        unset state(socketcoro)
-		    }
-		    if {[info exists state(after)]} {
-			after cancel $state(after)
-			unset state(after)
-		    }
-		    if {    [info exists state(-command)]
-			 && (![info exists state(done-command-cb)])
-		    } {
-			set state(done-command-cb) yes
-			if {[catch {namespace eval :: $state(-command) $token} err]} {
-			    set state(error) [list $err $errorInfo $errorCode]
-			    set state(status) error
-			}
-		    }
-		    return
-		} else {
-		}
-
-		# - For non-chunked transfer we may have no body - in this case
-		#   we may get no further file event if the connection doesn't
-		#   close and no more data is sent. We can tell and must finish
-		#   up now - not later - the alternative would be to wait until
-		#   the server times out.
-		# - In this case, the server has NOT told the client it will
-		#   close the connection, AND it has NOT indicated the resource
-		#   length EITHER by setting the Content-Length (totalsize) OR
-		#   by using chunked Transfer-Encoding.
-		# - Do not worry here about the case (Connection: close) because
-		#   the server should close the connection.
-		# - IF (NOT Connection: close) AND (NOT chunked encoding) AND
-		#      (totalsize == 0).
-
-		if {    (!(    [info exists state(connection)]
-			    && ("close" in $state(connection))
-			  )
-			)
-		     && ($state(transfer) eq {})
-		     && ($state(totalsize) == 0)
-		} {
-		    set msg {body size is 0 and no events likely - complete}
-		    Log "$msg - token $token"
-		    set msg {(length unknown, set to 0)}
-		    Log ^F$tk end of response body {*}$msg - token $token
-		    set state(state) complete
-		    Eot $token
-		    return
-		} else {
-		}
-
-		# We have to use binary translation to count bytes properly.
-		lassign [fconfigure $sock -translation] trRead trWrite
-		fconfigure $sock -translation [list binary $trWrite]
-
-		if {
-		    $state(-binary) || [IsBinaryContentType $state(type)]
-		} {
-		    # Turn off conversions for non-text data.
-		    set state(binary) 1
-		} else {
-		}
-		if {[info exists state(-channel)]} {
-		    if {$state(binary) || [llength [ContentEncoding $token]]} {
-			fconfigure $state(-channel) -translation binary
-		    } else {
-		    }
-		    if {![info exists state(-handler)]} {
-			# Initiate a sequence of background fcopies.
-			fileevent $sock readable {}
-			rename ${token}--EventCoroutine {}
-			CopyStart $sock $token
-			return
-		    } else {
-		    }
-		} else {
-		}
-	    } elseif {$nhl > 0} {
-		# Process header lines.
-		##Log header - token $token - $line
-		if {[regexp -nocase {^([^:]+):(.+)$} $line x key value]} {
-		    set key [string tolower $key]
-		    switch -- $key {
-			content-type {
-			    set state(type) [string trim [string tolower $value]]
-			    # Grab the optional charset information.
-			    if {[regexp -nocase \
-				    {charset\s*=\s*\"((?:[^""]|\\\")*)\"} \
-				    $state(type) -> cs]} {
-				set state(charset) [string map {{\"} \"} $cs]
-			    } else {
-				regexp -nocase {charset\s*=\s*(\S+?);?} \
-					$state(type) -> state(charset)
-			    }
-			}
-			content-length {
-			    set state(totalsize) [string trim $value]
-			}
-			content-encoding {
-			    set state(coding) [string trim $value]
-			}
-			transfer-encoding {
-			    set state(transfer) \
-				    [string trim [string tolower $value]]
-			}
-			proxy-connection -
-			connection {
-			    # RFC 7230 Section 6.1 states that a comma-separated
-			    # list is an acceptable value.
-			    if {![info exists state(connectionRespFlag)]} {
-				# This is the first "Connection" response header.
-				# Scrub the earlier value set by iniitialisation.
-				set state(connectionRespFlag) {}
-				set state(connection) {}
-			    }
-			    foreach el [SplitCommaSeparatedFieldValue $value] {
-				lappend state(connection) [string tolower $el]
-			    }
-			}
-			upgrade {
-			    set state(upgrade) [string trim $value]
-			}
-			set-cookie {
-			    if {$http(-cookiejar) ne ""} {
-				ParseCookie $token [string trim $value]
-			    } else {
-			    }
-			}
-		    }
-		    lappend state(meta) $key [string trim $value]
-		} else {
-		}
-	    } else {
-	    }
-	} else {
-	    # Now reading body
-	    ##Log body - token $token
-	    if {[catch {
-		if {[info exists state(-handler)]} {
-		    set n [namespace eval :: $state(-handler) [list $sock $token]]
-		    ##Log handler $n - token $token
-		    # N.B. the protocol has been set to 1.0 because the -handler
-		    # logic is not expected to handle chunked encoding.
-		    # FIXME Allow -handler with 1.1 on dechunked stacked chan.
-		    if {$state(totalsize) == 0} {
-			# We know the transfer is complete only when the server
-			# closes the connection - i.e. eof is not an error.
-			set state(state) complete
-		    } else {
-		    }
-		    if {![string is integer -strict $n]} {
-			if 1 {
-			    # Do not tolerate bad -handler - fail with error
-			    # status.
-			    set msg {the -handler command for http::geturl must\
-				    return an integer (the number of bytes\
-				    read)}
-			    Log ^X$tk end of response (handler error) -\
-				    token $token
-			    Eot $token $msg
-			} else {
-			    # Tolerate the bad -handler, and continue.  The
-			    # penalty:
-			    # (a) Because the handler returns nonsense, we know
-			    #     the transfer is complete only when the server
-			    #     closes the connection - i.e. eof is not an
-			    #     error.
-			    # (b) http::size will not be accurate.
-			    # (c) The transaction is already downgraded to 1.0
-			    #     to avoid chunked transfer encoding.  It MUST
-			    #     also be forced to "Connection: close" or the
-			    #     HTTP/1.0 equivalent; or it MUST fail (as
-			    #     above) if the server sends
-			    #     "Connection: keep-alive" or the HTTP/1.0
-			    #     equivalent.
-			    set n 0
-			    set state(state) complete
-			}
-		    } else {
-		    }
-		} elseif {[info exists state(transfer_final)]} {
-		    # This code forgives EOF in place of the final CRLF.
-		    set line [GetTextLine $sock]
-		    set n [string length $line]
-		    set state(state) complete
-		    if {$n > 0} {
-			# - HTTP trailers (late response headers) are permitted
-			#   by Chunked Transfer-Encoding, and can be safely
-			#   ignored.
-			# - Do not count these bytes in the total received for
-			#   the response body.
-			Log "trailer of $n bytes after final chunk -\
-				token $token"
-			append state(transfer_final) $line
-			set n 0
-		    } else {
-			Log ^F$tk end of response body (chunked) - token $token
-			Log "final chunk part - token $token"
-			Eot $token
-		    }
-		} elseif {    [info exists state(transfer)]
-			   && ($state(transfer) eq "chunked")
-		} {
-		    ##Log chunked - token $token
-		    set size 0
-		    set hexLenChunk [GetTextLine $sock]
-		    #set ntl [string length $hexLenChunk]
-		    if {[string trim $hexLenChunk] ne ""} {
-			scan $hexLenChunk %x size
-			if {$size != 0} {
-			    ##Log chunk-measure $size - token $token
-			    set chunk [BlockingRead $sock $size]
-			    set n [string length $chunk]
-			    if {$n >= 0} {
-				append state(body) $chunk
-				incr state(log_size) [string length $chunk]
-				##Log chunk $n cumul $state(log_size) -\
-					token $token
-			    } else {
-			    }
-			    if {$size != [string length $chunk]} {
-				Log "WARNING: mis-sized chunk:\
-				    was [string length $chunk], should be\
-				    $size - token $token"
-				set n 0
-				set state(connection) close
-				Log ^X$tk end of response (chunk error) \
-					- token $token
-				set msg {error in chunked encoding - fetch\
-					terminated}
-				Eot $token $msg
-			    } else {
-			    }
-			    # CRLF that follows chunk.
-			    # If eof, this is handled at the end of this proc.
-			    GetTextLine $sock
-			} else {
-			    set n 0
-			    set state(transfer_final) {}
-			}
-		    } else {
-			# Line expected to hold chunk length is empty, or eof.
-			##Log bad-chunk-measure - token $token
-			set n 0
-			set state(connection) close
-			Log ^X$tk end of response (chunk error) - token $token
-			Eot $token {error in chunked encoding -\
-				fetch terminated}
-		    }
-		} else {
-		    ##Log unchunked - token $token
-		    if {$state(totalsize) == 0} {
-			# We know the transfer is complete only when the server
-			# closes the connection.
-			set state(state) complete
-			set reqSize $state(-blocksize)
-		    } else {
-			# Ask for the whole of the unserved response-body.
-			# This works around a problem with a tls::socket - for
-			# https in keep-alive mode, and a request for
-			# $state(-blocksize) bytes, the last part of the
-			# resource does not get read until the server times out.
-			set reqSize [expr {  $state(totalsize)
-					   - $state(currentsize)}]
-
-			# The workaround fails if reqSize is
-			# capped at $state(-blocksize).
-			# set reqSize [expr {min($reqSize, $state(-blocksize))}]
-		    }
-		    set c $state(currentsize)
-		    set t $state(totalsize)
-		    ##Log non-chunk currentsize $c of totalsize $t -\
-			    token $token
-		    set block [read $sock $reqSize]
-		    set n [string length $block]
-		    if {$n >= 0} {
-			append state(body) $block
-			##Log non-chunk [string length $state(body)] -\
-				token $token
-		    } else {
-		    }
-		}
-		# This calculation uses n from the -handler, chunked, or
-		# unchunked case as appropriate.
-		if {[info exists state]} {
-		    if {$n >= 0} {
-			incr state(currentsize) $n
-			set c $state(currentsize)
-			set t $state(totalsize)
-			##Log another $n currentsize $c totalsize $t -\
-				token $token
-		    } else {
-		    }
-		    # If Content-Length - check for end of data.
-		    if {
-			   ($state(totalsize) > 0)
-			&& ($state(currentsize) >= $state(totalsize))
-		    } {
-			Log ^F$tk end of response body (unchunked) -\
-				token $token
-			set state(state) complete
-			Eot $token
-		    } else {
-		    }
-		} else {
-		}
-	    } err]} {
-		Log ^X$tk end of response (error ${err}) - token $token
-		Finish $token $err
-		return
-	    } else {
-		if {[info exists state(-progress)]} {
-		    namespace eval :: $state(-progress) \
-			[list $token $state(totalsize) $state(currentsize)]
-		} else {
-		}
-	    }
-	}
-
-	# catch as an Eot above may have closed the socket already
-	# $state(state) may be connecting, header, body, or complete
-	if {(![catch {eof $sock} eof]) && $eof} {
-	    # [eof sock] succeeded and the result was 1
-	    ##Log eof - token $token
-	    if {[info exists $token]} {
-		set state(connection) close
-		if {$state(state) eq "complete"} {
-		    # This includes all cases in which the transaction
-		    # can be completed by eof.
-		    # The value "complete" is set only in http::Event, and it is
-		    # used only in the test above.
-		    Log ^F$tk end of response body (unchunked, eof) -\
-			    token $token
-		    Eot $token
-		} else {
-		    # Premature eof.
-		    Log ^X$tk end of response (unexpected eof) - token $token
-		    Eot $token eof
-		}
-	    } else {
-		# open connection closed on a token that has been cleaned up.
-		Log ^X$tk end of response (token error) - token $token
-		CloseSocket $sock
-	    }
-	} else {
-	    # EITHER [eof sock] failed - presumed done by Eot
-	    # OR     [eof sock] succeeded and the result was 0
-	}
-    }
-    return
-}
-
-# http::TestForReplay
-#
-#	Command called if eof is discovered when a socket is first used for a
-#	new transaction.  Typically this occurs if a persistent socket is used
-#	after a period of idleness and the server has half-closed the socket.
-#
-# token  - the connection token returned by http::geturl
-# doing  - "read" or "write"
-# err    - error message, if any
-# caller - code to identify the caller - used only in logging
-#
-# Return Value: boolean, true iff the command calls http::ReplayIfDead.
-
-proc http::TestForReplay {token doing err caller} {
-    variable http
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    if {$doing eq "read"} {
-	set code Q
-	set action response
-	set ing reading
-    } else {
-	set code P
-	set action request
-	set ing writing
-    }
-
-    if {$err eq {}} {
-	set err "detect eof when $ing (server timed out?)"
-    }
-
-    if {$state(method) eq "POST" && !$http(-repost)} {
-	# No Replay.
-	# The present transaction will end when Finish is called.
-	# That call to Finish will abort any other transactions
-	# currently in the write queue.
-	# For calls from http::Event this occurs when execution
-	# reaches the code block at the end of that proc.
-	set msg {no retry for POST with http::config -repost 0}
-	Log reusing socket failed "($caller)" - $msg - token $token
-	Log error - $err - token $token
-	Log ^X$tk end of $action (error) - token $token
-	return 0
-    } else {
-	# Replay.
-	set msg {try a new socket}
-	Log reusing socket failed "($caller)" - $msg - token $token
-	Log error - $err - token $token
-	Log ^$code$tk Any unfinished (incl this one) failed - token $token
-	ReplayIfDead $token $doing
-	return 1
-    }
-}
-
-# http::IsBinaryContentType --
-#
-#	Determine if the content-type means that we should definitely transfer
-#	the data as binary. [Bug 838e99a76d]
-#
-# Arguments
-#	type	The content-type of the data.
-#
-# Results:
-#	Boolean, true if we definitely should be binary.
-
-proc http::IsBinaryContentType {type} {
-    lassign [split [string tolower $type] "/;"] major minor
-    if {$major eq "text"} {
-	return false
-    }
-    # There's a bunch of XML-as-application-format things about. See RFC 3023
-    # and so on.
-    if {$major eq "application"} {
-	set minor [string trimright $minor]
-	if {$minor in {"json" "xml" "xml-external-parsed-entity" "xml-dtd"}} {
-	    return false
-	}
-    }
-    # Not just application/foobar+xml but also image/svg+xml, so let us not
-    # restrict things for now...
-    if {[string match "*+xml" $minor]} {
-	return false
-    }
-    return true
-}
-
-proc http::ParseCookie {token value} {
-    variable http
-    variable CookieRE
-    variable $token
-    upvar 0 $token state
-
-    if {![regexp $CookieRE $value -> cookiename cookieval opts]} {
-	# Bad cookie! No biscuit!
-	return
-    }
-
-    # Convert the options into a list before feeding into the cookie store;
-    # ugly, but quite easy.
-    set realopts {hostonly 1 path / secure 0 httponly 0}
-    dict set realopts origin $state(host)
-    dict set realopts domain $state(host)
-    foreach option [split [regsub -all {;\s+} $opts \u0000] \u0000] {
-	regexp {^(.*?)(?:=(.*))?$} $option -> optname optval
-	switch -exact -- [string tolower $optname] {
-	    expires {
-		if {[catch {
-		    #Sun, 06 Nov 1994 08:49:37 GMT
-		    dict set realopts expires \
-			[clock scan $optval -format "%a, %d %b %Y %T %Z"]
-		}] && [catch {
-		    # Google does this one
-		    #Mon, 01-Jan-1990 00:00:00 GMT
-		    dict set realopts expires \
-			[clock scan $optval -format "%a, %d-%b-%Y %T %Z"]
-		}] && [catch {
-		    # This is in the RFC, but it is also in the original
-		    # Netscape cookie spec, now online at:
-		    # <URL:http://curl.haxx.se/rfc/cookie_spec.html>
-		    #Sunday, 06-Nov-94 08:49:37 GMT
-		    dict set realopts expires \
-			[clock scan $optval -format "%A, %d-%b-%y %T %Z"]
-		}]} {catch {
-		    #Sun Nov  6 08:49:37 1994
-		    dict set realopts expires \
-			[clock scan $optval -gmt 1 -format "%a %b %d %T %Y"]
-		}}
-	    }
-	    max-age {
-		# Normalize
-		if {[string is integer -strict $optval]} {
-		    dict set realopts expires [expr {[clock seconds] + $optval}]
-		}
-	    }
-	    domain {
-		# From the domain-matches definition [RFC 2109, section 2]:
-		#   Host A's name domain-matches host B's if [...]
-		#	A is a FQDN string and has the form NB, where N is a
-		#	non-empty name string, B has the form .B', and B' is a
-		#	FQDN string. (So, x.y.com domain-matches .y.com but
-		#	not y.com.)
-		if {$optval ne "" && ![string match *. $optval]} {
-		    dict set realopts domain [string trimleft $optval "."]
-		    dict set realopts hostonly [expr {
-			! [string match .* $optval]
-		    }]
-		}
-	    }
-	    path {
-		if {[string match /* $optval]} {
-		    dict set realopts path $optval
-		}
-	    }
-	    secure - httponly {
-		dict set realopts [string tolower $optname] 1
-	    }
-	}
-    }
-    dict set realopts key $cookiename
-    dict set realopts value $cookieval
-    {*}$http(-cookiejar) storeCookie $realopts
-}
-
-# http::GetTextLine --
-#
-#	Get one line with the stream in crlf mode.
-#	Used if Transfer-Encoding is chunked, to read the line that
-#	reports the size of the following chunk.
-#	Empty line is not distinguished from eof.  The caller must
-#	be able to handle this.
-#
-# Arguments
-#	sock	The socket receiving input.
-#
-# Results:
-#	The line of text, without trailing newline
-
-proc http::GetTextLine {sock} {
-    set tr [fconfigure $sock -translation]
-    lassign $tr trRead trWrite
-    fconfigure $sock -translation [list crlf $trWrite]
-    set r [BlockingGets $sock]
-    fconfigure $sock -translation $tr
-    return $r
-}
-
-# http::BlockingRead
-#
-#	Replacement for a blocking read.
-#	The caller must be a coroutine.
-#	Used when we expect to read a chunked-encoding
-#	chunk of known size.
-
-proc http::BlockingRead {sock size} {
-    if {$size < 1} {
-	return
-    }
-    set result {}
-    while 1 {
-	set need [expr {$size - [string length $result]}]
-	set block [read $sock $need]
-	set eof [expr {[catch {eof $sock} tmp] || $tmp}]
-	append result $block
-	if {[string length $result] >= $size || $eof} {
-	    return $result
-	} else {
-	    yield
-	}
-    }
-}
-
-# http::BlockingGets
-#
-#	Replacement for a blocking gets.
-#	The caller must be a coroutine.
-#	Empty line is not distinguished from eof.  The caller must
-#	be able to handle this.
-
-proc http::BlockingGets {sock} {
-    while 1 {
-	set count [gets $sock line]
-	set eof [expr {[catch {eof $sock} tmp] || $tmp}]
-	if {$count >= 0 || $eof} {
-	    return $line
-	} else {
-	    yield
-	}
-    }
-}
-
-# http::CopyStart
-#
-#	Error handling wrapper around fcopy
-#
-# Arguments
-#	sock	The socket to copy from
-#	token	The token returned from http::geturl
-#
-# Side Effects
-#	This closes the connection upon error
-
-proc http::CopyStart {sock token {initial 1}} {
-    upvar 0 $token state
-    if {[info exists state(transfer)] && $state(transfer) eq "chunked"} {
-	foreach coding [ContentEncoding $token] {
-	    if {$coding eq {deflateX}} {
-		# Use the standards-compliant choice.
-		set coding2 decompress
-	    } else {
-		set coding2 $coding
-	    }
-	    lappend state(zlib) [zlib stream $coding2]
-	}
-	MakeTransformationChunked $sock [namespace code [list CopyChunk $token]]
-    } else {
-	if {$initial} {
-	    foreach coding [ContentEncoding $token] {
-		if {$coding eq {deflateX}} {
-		    # Use the standards-compliant choice.
-		    set coding2 decompress
-		} else {
-		    set coding2 $coding
-		}
-		zlib push $coding2 $sock
-	    }
-	}
-	if {[catch {
-	    # FIXME Keep-Alive on https tls::socket with unchunked transfer
-	    # hangs until the server times out. A workaround is possible, as for
-	    # the case without -channel, but it does not use the neat "fcopy"
-	    # solution.
-	    fcopy $sock $state(-channel) -size $state(-blocksize) -command \
-		[list http::CopyDone $token]
-	} err]} {
-	    Finish $token $err
-	}
-    }
-    return
-}
-
-proc http::CopyChunk {token chunk} {
-    upvar 0 $token state
-    if {[set count [string length $chunk]]} {
-	incr state(currentsize) $count
-	if {[info exists state(zlib)]} {
-	    foreach stream $state(zlib) {
-		set chunk [$stream add $chunk]
-	    }
-	}
-	puts -nonewline $state(-channel) $chunk
-	if {[info exists state(-progress)]} {
-	    namespace eval :: [linsert $state(-progress) end \
-		      $token $state(totalsize) $state(currentsize)]
-	}
-    } else {
-	Log "CopyChunk Finish - token $token"
-	if {[info exists state(zlib)]} {
-	    set excess ""
-	    foreach stream $state(zlib) {
-		catch {
-		    $stream put -finalize $excess
-		    set excess ""
-		    set overflood ""
-		    while {[set overflood [$stream get]] ne ""} { append excess $overflood }
-		}
-	    }
-	    puts -nonewline $state(-channel) $excess
-	    foreach stream $state(zlib) { $stream close }
-	    unset state(zlib)
-	}
-	Eot $token ;# FIX ME: pipelining.
-    }
-    return
-}
-
-# http::CopyDone
-#
-#	fcopy completion callback
-#
-# Arguments
-#	token	The token returned from http::geturl
-#	count	The amount transferred
-#
-# Side Effects
-#	Invokes callbacks
-
-proc http::CopyDone {token count {error {}}} {
-    variable $token
-    upvar 0 $token state
-    set sock $state(sock)
-    incr state(currentsize) $count
-    if {[info exists state(-progress)]} {
-	namespace eval :: $state(-progress) \
-	    [list $token $state(totalsize) $state(currentsize)]
-    }
-    # At this point the token may have been reset.
-    if {[string length $error]} {
-	Finish $token $error
-    } elseif {[catch {eof $sock} iseof] || $iseof} {
-	Eot $token
-    } else {
-	CopyStart $sock $token 0
-    }
-    return
-}
-
-# http::Eot
-#
-#	Called when either:
-#	a. An eof condition is detected on the socket.
-#	b. The client decides that the response is complete.
-#	c. The client detects an inconsistency and aborts the transaction.
-#
-#	Does:
-#	1. Set state(status)
-#	2. Reverse any Content-Encoding
-#	3. Convert charset encoding and line ends if necessary
-#	4. Call http::Finish
-#
-# Arguments
-#	token	The token returned from http::geturl
-#	force	(previously) optional, has no effect
-#	reason	- "eof" means premature EOF (not EOF as the natural end of
-#		  the response)
-#		- "" means completion of response, with or without EOF
-#		- anything else describes an error condition other than
-#		  premature EOF.
-#
-# Side Effects
-#	Clean up the socket
-
-proc http::Eot {token {reason {}}} {
-    variable $token
-    upvar 0 $token state
-    if {$reason eq "eof"} {
-	# Premature eof.
-	set state(status) eof
-	set reason {}
-    } elseif {$reason ne ""} {
-	# Abort the transaction.
-	set state(status) $reason
-    } else {
-	# The response is complete.
-	set state(status) ok
-    }
-
-    if {[string length $state(body)] > 0} {
-	if {[catch {
-	    foreach coding [ContentEncoding $token] {
-		if {$coding eq {deflateX}} {
-		    # First try the standards-compliant choice.
-		    set coding2 decompress
-		    if {[catch {zlib $coding2 $state(body)} result]} {
-			# If that fails, try the MS non-compliant choice.
-			set coding2 inflate
-			set state(body) [zlib $coding2 $state(body)]
-		    } else {
-			# error {failed at standards-compliant deflate}
-			set state(body) $result
-		    }
-		} else {
-		    set state(body) [zlib $coding $state(body)]
-		}
-	    }
-	} err]} {
-	    Log "error doing decompression for token $token: $err"
-	    Finish $token $err
-	    return
-	}
-
-	if {!$state(binary)} {
-	    # If we are getting text, set the incoming channel's encoding
-	    # correctly.  iso8859-1 is the RFC default, but this could be any
-	    # IANA charset.  However, we only know how to convert what we have
-	    # encodings for.
-
-	    set enc [CharsetToEncoding $state(charset)]
-	    if {$enc ne "binary"} {
-		if {[package vsatisfies [package provide Tcl] 9.0-]} {
-		    set state(body) [encoding convertfrom -profile tcl8 $enc $state(body)]
-		} else {
-		    set state(body) [encoding convertfrom $enc $state(body)]
-		}
-	    }
-
-	    # Translate text line endings.
-	    set state(body) [string map {\r\n \n \r \n} $state(body)]
-	}
-	if {[info exists state(-guesstype)] && $state(-guesstype)} {
-	    GuessType $token
-	}
-    }
-    Finish $token $reason
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::GuessType
-# ------------------------------------------------------------------------------
-# Command to attempt limited analysis of a resource with undetermined
-# Content-Type, i.e. "application/octet-stream".  This value can be set for two
-# reasons:
-# (a) by the server, in a Content-Type header
-# (b) by http::geturl, as the default value if the server does not supply a
-#     Content-Type header.
-#
-# This command converts a resource if:
-# (1) it has type application/octet-stream
-# (2) it begins with an XML declaration "<?xml name="value" ... >?"
-# (3) one tag is named "encoding" and has a recognised value; or no "encoding"
-#     tag exists (defaulting to utf-8)
-#
-# RFC 9110 Sec. 8.3 states:
-# "If a Content-Type header field is not present, the recipient MAY either
-# assume a media type of "application/octet-stream" ([RFC2046], Section 4.5.1)
-# or examine the data to determine its type."
-#
-# The RFC goes on to describe the pitfalls of "MIME sniffing", including
-# possible security risks.
-#
-# Arguments:
-# token       - connection token
-#
-# Return Value: (boolean) true iff a change has been made
-# ------------------------------------------------------------------------------
-
-proc http::GuessType {token} {
-    variable $token
-    upvar 0 $token state
-
-    if {$state(type) ne {application/octet-stream}} {
-        return 0
-    }
-
-    set body $state(body)
-    # e.g. {<?xml version="1.0" encoding="utf-8"?> ...}
-
-    if {![regexp -nocase -- {^<[?]xml[[:space:]][^>?]*[?]>} $body match]} {
-        return 0
-    }
-    # e.g. {<?xml version="1.0" encoding="utf-8"?>}
-
-    set contents [regsub -- {[[:space:]]+} $match { }]
-    set contents [string range [string tolower $contents] 6 end-2]
-    # e.g. {version="1.0" encoding="utf-8"}
-    # without excess whitespace or upper-case letters
-
-    if {![regexp -- {^([^=" ]+="[^"]+" )+$} "$contents "]} {
-        return 0
-    }
-    # The application/xml default encoding:
-    set res utf-8
-
-    set tagList [regexp -all -inline -- {[^=" ]+="[^"]+"} $contents]
-    foreach tag $tagList {
-        regexp -- {([^=" ]+)="([^"]+)"} $tag -> name value
-        if {$name eq {encoding}} {
-            set res $value
-        }
-    }
-    set enc [CharsetToEncoding $res]
-    if {$enc eq "binary"} {
-        return 0
-    }
-    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-	set state(body) [encoding convertfrom -profile tcl8 $enc $state(body)]
-    } else {
-	set state(body) [encoding convertfrom $enc $state(body)]
-    }
-    set state(body) [string map {\r\n \n \r \n} $state(body)]
-    set state(type) application/xml
-    set state(binary) 0
-    set state(charset) $res
-    return 1
-}
-
-
-# http::wait --
-#
-#	See documentation for details.
-#
-# Arguments:
-#	token	Connection token.
-#
-# Results:
-#	The status after the wait.
-
-proc http::wait {token} {
-    variable $token
-    upvar 0 $token state
-
-    if {![info exists state(status)] || $state(status) eq ""} {
-	# We must wait on the original variable name, not the upvar alias
-	vwait ${token}(status)
-    }
-
-    return [status $token]
-}
-
-# http::formatQuery --
-#
-#	See documentation for details.  Call http::formatQuery with an even
-#	number of arguments, where the first is a name, the second is a value,
-#	the third is another name, and so on.
-#
-# Arguments:
-#	args	A list of name-value pairs.
-#
-# Results:
-#	TODO
-
-proc http::formatQuery {args} {
-    if {[llength $args] % 2} {
-        return \
-            -code error \
-            -errorcode [list HTTP BADARGCNT $args] \
-            {Incorrect number of arguments, must be an even number.}
-    }
-    set result ""
-    set sep ""
-    foreach i $args {
-	append result $sep [quoteString $i]
-	if {$sep eq "="} {
-	    set sep &
-	} else {
-	    set sep =
-	}
-    }
-    return $result
-}
-
-# http::quoteString --
-#
-#	Do x-www-urlencoded character mapping
-#
-# Arguments:
-#	string	The string the needs to be encoded
-#
-# Results:
-#       The encoded string
-
-proc http::quoteString {string} {
-    variable http
-    variable formMap
-
-    # The spec says: "non-alphanumeric characters are replaced by '%HH'". Use
-    # a pre-computed map and [string map] to do the conversion (much faster
-    # than [regsub]/[subst]). [Bug 1020491]
-
-    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-	set string [encoding convertto -profile tcl8 $http(-urlencoding) $string]
-    } else {
-	set string [encoding convertto $http(-urlencoding) $string]
-    }
-    return [string map $formMap $string]
-}
-
-# http::ProxyRequired --
-#	Default proxy filter.
-#
-# Arguments:
-#	host	The destination host
-#
-# Results:
-#       The current proxy settings
-
-proc http::ProxyRequired {host} {
-    variable http
-    if {(![info exists http(-proxyhost)]) || ($http(-proxyhost) eq {})} {
-        return
-    }
-    if {![info exists http(-proxyport)] || ($http(-proxyport) eq {})} {
-	set port 8080
-    } else {
-	set port $http(-proxyport)
-    }
-
-    # Simple test (cf. autoproxy) for hosts that must be accessed directly,
-    # not through the proxy server.
-    foreach domain $http(-proxynot) {
-        if {[string match -nocase $domain $host]} {
-            return {}
-        }
-    }
-    return [list $http(-proxyhost) $port]
-}
-
-# http::CharsetToEncoding --
-#
-#	Tries to map a given IANA charset to a tcl encoding.  If no encoding
-#	can be found, returns binary.
-#
-
-proc http::CharsetToEncoding {charset} {
-    variable encodings
-
-    set charset [string tolower $charset]
-    if {[regexp {iso-?8859-([0-9]+)} $charset -> num]} {
-	set encoding "iso8859-$num"
-    } elseif {[regexp {iso-?2022-(jp|kr)} $charset -> ext]} {
-	set encoding "iso2022-$ext"
-    } elseif {[regexp {shift[-_]?jis} $charset]} {
-	set encoding "shiftjis"
-    } elseif {[regexp {(?:windows|cp)-?([0-9]+)} $charset -> num]} {
-	set encoding "cp$num"
-    } elseif {$charset eq "us-ascii"} {
-	set encoding "ascii"
-    } elseif {[regexp {(?:iso-?)?lat(?:in)?-?([0-9]+)} $charset -> num]} {
-	switch -- $num {
-	    5 {set encoding "iso8859-9"}
-	    1 - 2 - 3 {
-		set encoding "iso8859-$num"
-	    }
-	    default {
-		set encoding "binary"
-	    }
-	}
-    } else {
-	# other charset, like euc-xx, utf-8,...  may directly map to encoding
-	set encoding $charset
-    }
-    set idx [lsearch -exact $encodings $encoding]
-    if {$idx >= 0} {
-	return $encoding
-    } else {
-	return "binary"
-    }
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::ContentEncoding
-# ------------------------------------------------------------------------------
-# Return the list of content-encoding transformations we need to do in order.
-#
-    # --------------------------------------------------------------------------
-    # Options for Accept-Encoding, Content-Encoding: the switch command
-    # --------------------------------------------------------------------------
-    # The symbol deflateX allows http to attempt both versions of "deflate",
-    # unless there is a -channel - for a -channel, only "decompress" is tried.
-    # Alternative/extra lines for switch:
-    # The standards-compliant version of "deflate" can be chosen with:
-    #		deflate { lappend r decompress }
-    # The Microsoft non-compliant version of "deflate" can be chosen with:
-    #		deflate { lappend r inflate }
-    # The previously used implementation of "compress", which appears to be
-    # incorrect and is rarely used by web servers, can be chosen with:
-    #		compress - x-compress { lappend r decompress }
-    # --------------------------------------------------------------------------
-#
-# Arguments:
-# token  - Connection token.
-#
-# Return Value: list
-# ------------------------------------------------------------------------------
-
-proc http::ContentEncoding {token} {
-    upvar 0 $token state
-    set r {}
-    if {[info exists state(coding)]} {
-	foreach coding [split $state(coding) ,] {
-	    switch -exact -- $coding {
-		deflate { lappend r deflateX }
-		gzip - x-gzip { lappend r gunzip }
-		identity {}
-		br {
-		    return -code error\
-			    "content-encoding \"br\" not implemented"
-		}
-		default {
-		    Log "unknown content-encoding \"$coding\" ignored"
-		}
-	    }
-	}
-    }
-    return $r
-}
-
-proc http::ReceiveChunked {chan command} {
-    set data ""
-    set size -1
-    yield
-    while {1} {
-	chan configure $chan -translation {crlf binary}
-	while {[gets $chan line] < 1} { yield }
-	chan configure $chan -translation {binary binary}
-	if {[scan $line %x size] != 1} {
-	    return -code error "invalid size: \"$line\""
-	}
-	set chunk ""
-	while {$size && ![chan eof $chan]} {
-	    set part [chan read $chan $size]
-	    incr size -[string length $part]
-	    append chunk $part
-	}
-	if {[catch {
-	    uplevel #0 [linsert $command end $chunk]
-	}]} {
-	    http::Log "Error in callback: $::errorInfo"
-	}
-	if {[string length $chunk] == 0} {
-	    # channel might have been closed in the callback
-	    catch {chan event $chan readable {}}
-	    return
-	}
-    }
-}
-
-# http::SplitCommaSeparatedFieldValue --
-# 	Return the individual values of a comma-separated field value.
-#
-# Arguments:
-#	fieldValue	Comma-separated header field value.
-#
-# Results:
-#       List of values.
-proc http::SplitCommaSeparatedFieldValue {fieldValue} {
-    set r {}
-    foreach el [split $fieldValue ,] {
-	lappend r [string trim $el]
-    }
-    return $r
-}
-
-
-# http::GetFieldValue --
-# 	Return the value of a header field.
-#
-# Arguments:
-#	headers	Headers key-value list
-#	fieldName	Name of header field whose value to return.
-#
-# Results:
-#       The value of the fieldName header field
-#
-# Field names are matched case-insensitively (RFC 7230 Section 3.2).
-#
-# If the field is present multiple times, it is assumed that the field is
-# defined as a comma-separated list and the values are combined (by separating
-# them with commas, see RFC 7230 Section 3.2.2) and returned at once.
-proc http::GetFieldValue {headers fieldName} {
-    set r {}
-    foreach {field value} $headers {
-	if {[string equal -nocase $fieldName $field]} {
-	    if {$r eq {}} {
-		set r $value
-	    } else {
-		append r ", $value"
-	    }
-	}
-    }
-    return $r
-}
-
-proc http::MakeTransformationChunked {chan command} {
-    coroutine [namespace current]::dechunk$chan ::http::ReceiveChunked $chan $command
-    chan event $chan readable [namespace current]::dechunk$chan
-    return
-}
-
-interp alias {} http::data {} http::responseBody
-interp alias {} http::code {} http::responseLine
-interp alias {} http::mapReply {} http::quoteString
-interp alias {} http::meta {} http::responseHeaders
-interp alias {} http::metaValue {} http::responseHeaderValue
-interp alias {} http::ncode {} http::responseCode
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::socketForTls
-# ------------------------------------------------------------------------------
-# Command to use in place of ::socket as the value of ::tls::socketCmd.
-# This command does the same as http::socket, and also handles https connections
-# through a proxy server.
-#
-# Notes.
-# - The proxy server works differently for https and http.  This implementation
-#   is for https.  The proxy for http is implemented in http::CreateToken (in
-#   code that was previously part of http::geturl).
-# - This code implicitly uses the tls options set for https in a call to
-#   http::register, and does not need to call commands tls::*.  This simple
-#   implementation is possible because tls uses a callback to ::socket that can
-#   be redirected by changing the value of ::tls::socketCmd.
-#
-# Arguments:
-# args        - as for ::socket
-#
-# Return Value: a socket identifier
-# ------------------------------------------------------------------------------
-
-proc http::socketForTls {args} {
-    variable http
-    set host [lindex $args end-1]
-    set port [lindex $args end]
-    if {    ($http(-proxyfilter) ne {})
-         && (![catch {$http(-proxyfilter) $host} proxy])
-    } {
-        set phost [lindex $proxy 0]
-        set pport [lindex $proxy 1]
-    } else {
-        set phost {}
-        set pport {}
-    }
-    if {$phost eq ""} {
-        set sock [::http::socket {*}$args]
-    } else {
-        set sock [::http::SecureProxyConnect {*}$args $phost $pport]
-    }
-    return $sock
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::SecureProxyConnect
-# ------------------------------------------------------------------------------
-# Command to open a socket through a proxy server to a remote server for use by
-# tls. The caller must perform the tls handshake.
-#
-# Notes
-# - Based on patch supplied by Melissa Chawla in ticket 1173760, and
-#   Proxy-Authorization header cf. autoproxy by Pat Thoyts.
-# - Rewritten as a call to http::geturl, because response headers and body are
-#   needed if the CONNECT request fails.  CONNECT is implemented for this case
-#   only, by state(bypass).
-# - FUTURE WORK: give http::geturl a -connect option for a general CONNECT.
-# - The request header Proxy-Connection is discouraged in RFC 7230 (June 2014),
-#   RFC 9112 (June 2022).
-#
-# Arguments:
-# args        - as for ::socket, ending in host, port; with proxy host, proxy
-#               port appended.
-#
-# Return Value: a socket identifier
-# ------------------------------------------------------------------------------
-
-proc http::SecureProxyConnect {args} {
-    variable http
-    variable ConnectVar
-    variable ConnectCounter
-    variable failedProxyValues
-    set varName ::http::ConnectVar([incr ConnectCounter])
-
-    # Extract (non-proxy) target from args.
-    set host [lindex $args end-3]
-    set port [lindex $args end-2]
-    set args [lreplace $args end-3 end-2]
-
-    # Proxy server URL for connection.
-    # This determines where the socket is opened.
-    set phost [lindex $args end-1]
-    set pport [lindex $args end]
-    if {[string first : $phost] != -1} {
-        # IPv6 address, wrap it in [] so we can append :pport
-        set phost "\[${phost}\]"
-    }
-    set url http://${phost}:${pport}
-    # Elements of args other than host and port are not used when
-    # AsyncTransaction opens a socket.  Those elements are -async and the
-    # -type $tokenName for the https transaction.  Option -async is used by
-    # AsyncTransaction anyway, and -type $tokenName should not be propagated:
-    # the proxy request adds its own -type value.
-
-    set targ [lsearch -exact $args -type]
-    if {$targ != -1} {
-        # Record in the token that this is a proxy call.
-        set token [lindex $args $targ+1]
-        upvar 0 ${token} state
-        set tim $state(-timeout)
-        set state(proxyUsed) SecureProxyFailed
-        # This value is overwritten with "SecureProxy" below if the CONNECT is
-        # successful.  If it is unsuccessful, the socket will be closed
-        # below, and so in this unsuccessful case there are no other transactions
-        # whose (proxyUsed) must be updated.
-    } else {
-        set tim 0
-    }
-    if {$tim == 0} {
-        # Do not use infinite timeout for the proxy.
-        set tim 30000
-    }
-
-    # Prepare and send a CONNECT request to the proxy, using
-    # code similar to http::geturl.
-    set requestHeaders [list Host $host]
-    lappend requestHeaders Connection keep-alive
-    if {$http(-proxyauth) != {}} {
-        lappend requestHeaders Proxy-Authorization $http(-proxyauth)
-    }
-
-    set token2 [CreateToken $url -keepalive 0 -timeout $tim \
-            -headers $requestHeaders -command [list http::AllDone $varName]]
-    variable $token2
-    upvar 0 $token2 state2
-
-    # Kludges:
-    # Setting this variable overrides the HTTP request line and also allows
-    # -headers to override the Connection: header set by -keepalive.
-    # The arguments "-keepalive 0" ensure that when Finish is called for an
-    # unsuccessful request, the socket is always closed.
-    set state2(bypass) "CONNECT $host:$port HTTP/1.1"
-
-    AsyncTransaction $token2
-
-    if {[info coroutine] ne {}} {
-        # All callers in the http package are coroutines launched by
-        # the event loop.
-        # The cwait command requires a coroutine because it yields
-        # to the caller; $varName is traced and the coroutine resumes
-        # when the variable is written.
-        cwait $varName
-    } else {
-        return -code error {code must run in a coroutine}
-        # For testing with a non-coroutine caller outside the http package.
-        # vwait $varName
-    }
-    unset $varName
-
-    if {    ($state2(state) ne "complete")
-         || ($state2(status) ne "ok")
-         || (![string is integer -strict $state2(responseCode)])
-    } {
-        set msg {the HTTP request to the proxy server did not return a valid\
-                and complete response}
-        if {[info exists state2(error)]} {
-            append msg ": " [lindex $state2(error) 0]
-        }
-        cleanup $token2
-        return -code error $msg
-    }
-
-    set code $state2(responseCode)
-
-    if {($code >= 200) && ($code < 300)} {
-        # All OK.  The caller in package tls will now call "tls::import $sock".
-        # The cleanup command does not close $sock.
-        # Other tidying was done in http::Event.
-
-        # If this is a persistent socket, any other transactions that are
-        # already marked to use the socket will have their (proxyUsed) updated
-        # when http::OpenSocket calls http::ConfigureNewSocket.
-        set state(proxyUsed) SecureProxy
-        set sock $state2(sock)
-        cleanup $token2
-        return $sock
-    }
-
-    if {$targ != -1} {
-        # Non-OK HTTP status code; token is known because option -type
-        # (cf. targ) was passed through tcltls, and so the useful
-        # parts of the proxy's response can be copied to state(*).
-        # Do not copy state2(sock).
-        # Return the proxy response to the caller of geturl.
-        foreach name $failedProxyValues {
-            if {[info exists state2($name)]} {
-                set state($name) $state2($name)
-            }
-        }
-        set state(connection) close
-        set msg "proxy connect failed: $code"
-	# - This error message will be detected by http::OpenSocket and will
-	#   cause it to present the proxy's HTTP response as that of the
-	#   original $token transaction, identified only by state(proxyUsed)
-	#   as the response of the proxy.
-	# - The cases where this would mislead the caller of http::geturl are
-	#   given a different value of msg (below) so that http::OpenSocket will
-	#   treat them as errors, but will preserve the $token array for
-	#   inspection by the caller.
-	# - Status code 305 (Proxy Required) was deprecated for security reasons
-	#   in RFC 2616 (June 1999) and in any case should never be served by a
-	#   proxy.
-	# - Other 3xx responses from the proxy are inappropriate, and should not
-	#   occur.
-	# - A 401 response from the proxy is inappropriate, and should not
-	#   occur.  It would be confusing if returned to the caller.
-
-	if {($code >= 300) && ($code < 400)} {
-	    set msg "the proxy server responded to the HTTP request with an\
-		    inappropriate $code redirect"
-	    set loc [responseHeaderValue $token2 location]
-	    if {$loc ne {}} {
-		append msg "to " $loc
-	    }
-	} elseif {($code == 401)} {
-	    set msg "the proxy server responded to the HTTP request with an\
-		    inappropriate 401 request for target-host credentials"
-	} else {
-	}
-    } else {
-	set msg "connection to proxy failed with status code $code"
-    }
-
-    # - ${token2}(sock) has already been closed because -keepalive 0.
-    # - Error return does not pass the socket ID to the
-    #   $token transaction, which retains its socket placeholder.
-    cleanup $token2
-    return -code error $msg
-}
-
-proc http::AllDone {varName args} {
-    set $varName done
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::socket
-# ------------------------------------------------------------------------------
-# This command is a drop-in replacement for ::socket.
-# Arguments and return value as for ::socket.
-#
-# Notes.
-# - http::socket is specified in place of ::socket by the definition of urlTypes
-#   in the namespace header of this file (http.tcl).
-# - The command makes a simple call to ::socket unless the user has called
-#   http::config to change the value of -threadlevel from the default value 0.
-# - For -threadlevel 1 or 2, if the Thread package is available, the command
-#   waits in the event loop while the socket is opened in another thread.  This
-#   is a workaround for bug [824251] - it prevents http::geturl from blocking
-#   the event loop if the DNS lookup or server connection is slow.
-# - FIXME Use a thread pool if connections are very frequent.
-# - FIXME The peer thread can transfer the socket only to the main interpreter
-#   in the present thread.  Therefore this code works only if this script runs
-#   in the main interpreter.  In a child interpreter, the parent must alias a
-#   command to ::http::socket in the child, run http::socket in the parent,
-#   and then transfer the socket to the child.
-# - The http::socket command is simple, and can easily be replaced with an
-#   alternative command that uses a different technique to open a socket while
-#   entering the event loop.
-# - Unexpected behaviour by thread::send -async (Thread 2.8.6).
-#   An error in thread::send -async causes return of just the error message
-#   (not the expected 3 elements), and raises a bgerror in the main thread.
-#   Hence wrap the command with catch as a precaution.
-# ------------------------------------------------------------------------------
-
-proc http::socket {args} {
-    variable ThreadVar
-    variable ThreadCounter
-    variable http
-
-    LoadThreadIfNeeded
-
-    set targ [lsearch -exact $args -type]
-    if {$targ != -1} {
-        set token [lindex $args $targ+1]
-        set args [lreplace $args $targ $targ+1]
-        upvar 0 $token state
-    }
-
-    if {!$http(usingThread)} {
-        # Use plain "::socket".  This is the default.
-        return [eval ::socket $args]
-    }
-
-    set defcmd ::socket
-    set sockargs $args
-    set script "
-        set code \[catch {
-            [list proc ::SockInThread {caller defcmd sockargs} [info body ::http::SockInThread]]
-            [list ::SockInThread [thread::id] $defcmd $sockargs]
-        } result opts\]
-        list \$code \$opts \$result
-    "
-
-    set state(tid) [thread::create]
-    set varName ::http::ThreadVar([incr ThreadCounter])
-    thread::send -async $state(tid) $script $varName
-    Log >T Thread Start Wait $args -- coro [info coroutine] $varName
-    if {[info coroutine] ne {}} {
-        # All callers in the http package are coroutines launched by
-        # the event loop.
-        # The cwait command requires a coroutine because it yields
-        # to the caller; $varName is traced and the coroutine resumes
-        # when the variable is written.
-        cwait $varName
-    } else {
-        return -code error {code must run in a coroutine}
-        # For testing with a non-coroutine caller outside the http package.
-        # vwait $varName
-    }
-    Log >U Thread End Wait $args -- coro [info coroutine] $varName [set $varName]
-    thread::release $state(tid)
-    set state(tid) {}
-    set result [set $varName]
-    unset $varName
-    if {(![string is list $result]) || ([llength $result] != 3)} {
-        return -code error "result from peer thread is not a list of\
-                length 3: it is \n$result"
-    }
-    lassign $result threadCode threadDict threadResult
-    if {($threadCode != 0)} {
-        # This is an error in thread::send.  Return the lot.
-        return -options $threadDict -code error $threadResult
-    }
-
-    # Now the results of the catch in the peer thread.
-    lassign $threadResult catchCode errdict sock
-
-    if {($catchCode == 0) && ($sock ni [chan names])} {
-        return -code error {Transfer of socket from peer thread failed.\
-		Check that this script is not running in a child interpreter.}
-    }
-    return -options $errdict -code $catchCode $sock
-}
-
-# The commands below are dependencies of http::socket and
-# http::SecureProxyConnect and are not used elsewhere.
-
-# ------------------------------------------------------------------------------
-#  Proc http::LoadThreadIfNeeded
-# ------------------------------------------------------------------------------
-# Command to load the Thread package if it is needed.  If it is needed and not
-# loadable, the outcome depends on $http(-threadlevel):
-# value 0 => Thread package not required, no problem
-# value 1 => operate as if -threadlevel 0
-# value 2 => error return
-#
-# Arguments: none
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::LoadThreadIfNeeded {} {
-    variable http
-    if {$http(usingThread) || ($http(-threadlevel) == 0)} {
-        return
-    }
-    if {[catch {package require Thread}]} {
-        if {$http(-threadlevel) == 2} {
-            set msg {[http::config -threadlevel] has value 2,\
-                     but the Thread package is not available}
-            return -code error $msg
-        }
-        return
-    }
-    set http(usingThread) 1
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::SockInThread
-# ------------------------------------------------------------------------------
-# Command http::socket is a ::socket replacement.  It defines and runs this
-# command, http::SockInThread, in a peer thread.
-#
-# Arguments:
-# caller
-# defcmd
-# sockargs
-#
-# Return value: list of values that describe the outcome.  The return is
-# intended to be a normal (non-error) return in all cases.
-# ------------------------------------------------------------------------------
-
-proc http::SockInThread {caller defcmd sockargs} {
-    package require Thread
-
-    set catchCode [catch {eval $defcmd $sockargs} sock errdict]
-    if {$catchCode == 0} {
-        set catchCode [catch {thread::transfer $caller $sock; set sock} sock errdict]
-    }
-    return [list $catchCode $errdict $sock]
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::cwaiter::cwait
-# ------------------------------------------------------------------------------
-# Command to substitute for vwait, without the ordering issues.
-# A command that uses cwait must be a coroutine that is launched by an event,
-# e.g. fileevent or after idle, and has no calling code to be resumed upon
-# "yield".  It cannot return a value.
-#
-# Arguments:
-# varName      - fully-qualified name of the variable that the calling script
-#                will write to resume the coroutine.  Any scalar variable or
-#                array element is permitted.
-# coroName     - (optional) name of the coroutine to be called when varName is
-#                written - defaults to this coroutine
-# timeout      - (optional) timeout value in ms
-# timeoutValue - (optional) value to assign to varName if there is a timeout
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-namespace eval http::cwaiter {
-    namespace export cwait
-    variable log   {}
-    variable logOn 0
-}
-
-proc http::cwaiter::cwait {
-    varName {coroName {}} {timeout {}} {timeoutValue {}}
-} {
-    set thisCoro [info coroutine]
-    if {$thisCoro eq {}} {
-        return -code error {cwait cannot be called outside a coroutine}
-    }
-    if {$coroName eq {}} {
-        set coroName $thisCoro
-    }
-    if {[string range $varName 0 1] ne {::}} {
-        return -code error {argument varName must be fully qualified}
-    }
-    if {$timeout eq {}} {
-        set toe {}
-    } elseif {[string is integer -strict $timeout] && ($timeout > 0)} {
-        set toe [after $timeout [list set $varName $timeoutValue]]
-    } else {
-        return -code error {if timeout is supplied it must be a positive integer}
-    }
-
-    set cmd [list ::http::cwaiter::CwaitHelper $varName $coroName $toe]
-    trace add variable $varName write $cmd
-    CoLog "Yield $varName $coroName"
-    yield
-    CoLog "Resume $varName $coroName"
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::cwaiter::CwaitHelper
-# ------------------------------------------------------------------------------
-# Helper command called by the trace set by cwait.
-# - Ignores the arguments added by trace.
-# - A simple call to $coroName works, and in error cases gives a suitable stack
-#   trace, but because it is inside a trace the headline error message is
-#   something like {can't set "::Result(6)": error}, not the actual
-#   error.  So let the trace command return.
-# - Remove the trace immediately.  We don't want multiple calls.
-# ------------------------------------------------------------------------------
-
-proc http::cwaiter::CwaitHelper {varName coroName toe args} {
-    CoLog "got $varName for $coroName"
-    set cmd [list ::http::cwaiter::CwaitHelper $varName $coroName $toe]
-    trace remove variable $varName write $cmd
-    after cancel $toe
-
-    after 0 $coroName
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::cwaiter::LogInit
-# ------------------------------------------------------------------------------
-# Call this command to initiate debug logging and clear the log.
-# ------------------------------------------------------------------------------
-
-proc http::cwaiter::LogInit {} {
-    variable log
-    variable logOn
-    set log {}
-    set logOn 1
-    return
-}
-
-proc http::cwaiter::LogRead {} {
-    variable log
-    return $log
-}
-
-proc http::cwaiter::CoLog {msg} {
-    variable log
-    variable logOn
-    if {$logOn} {
-        append log $msg \n
-    }
-    return
-}
-
-namespace eval http {
-    namespace import ::http::cwaiter::*
-}
-
-# Local variables:
-# indent-tabs-mode: t
-# End:
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/natsort-0.1.1.5.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/natsort-0.1.1.5.tm
deleted file mode 100644
index 0dcf57e7..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/natsort-0.1.1.5.tm
+++ /dev/null
@@ -1,1886 +0,0 @@
-#! /usr/bin/env tclsh
-
-
-package require flagfilter
-namespace import ::flagfilter::check_flags
-
-namespace eval natsort {
-     proc scriptdir {} {
-        set possibly_linked_script [file dirname [file normalize [file join [info script] ...]]]
-        if {[file isdirectory $possibly_linked_script]} {
-            return $possibly_linked_script
-        } else {
-            return [file dirname $possibly_linked_script]
-        }
-    }
-    tcl::tm::add [scriptdir]    
-}
-
-
-namespace eval natsort {
-    variable stacktrace_on 0
-
-    proc do_error {msg {then error}} {
-        #note we exit or error out even if debug selected - as every do_error call is meant to interrupt code processing at the site of call
-        #this is not just a 'logging' call even though it has log-like descriptors
-        lassign $then type code
-        if {$code eq ""} {
-          set code 1
-        }
-        set type [string tolower $type]
-        set levels [list debug info notice warn error critical]
-        if {$type in [concat $levels exit]} {
-            puts stderr "|$type> $msg"
-        } else {
-            puts stderr "|>natsort_call_err> unable to interpret 2nd argument to do_error: '$then' should be one of '$levels'  or 'exit <numericcode>'"
-        }
-        if {$::tcl_interactive} {
-            #may not always be desirable - but assumed to be more useful not to exit despite request, to aid in debugging
-            if {[string tolower $type] eq "exit"} {
-              puts stderr "    (exit suppressed due to tcl_interactive - raising error instead)"
-              if {![string is digit -strict $code]} {
-                puts stderr "|>natsort_call_err> unable to interpret 2nd argument to do_error: '$then' should be: 'exit <numericcode>'"
-              }
-            } 
-            return -code error $msg
-        } else {
-            if {$type ne "exit"} {
-              return -code error $msg
-            } else {
-              if {[string is digit -strict $code]} {
-                exit $code
-              } else {
-                puts stderr "|>natsort_call_err> unable to interpret 2nd argument to do_error: '$then' should be 'error' or 'exit <numericcode>'"
-                return -code error $msg
-              }
-            }
-        }
-    }
-
-
-
-
-
- 
-    variable debug 0
-    variable testlist
-    set testlist {
-        00.test-firstposition.txt
-        0001.blah.txt
-        1.test-sorts-after-all-leadingzero-number-one-equivs.txt
-        1010.thousand-and-ten.second.txt
-        01010.thousand-and-ten.first.txt
-        0001.aaa.txt
-        001.zzz.txt
-        08.octal.txt-last-octal
-        008.another-octal-first-octal.txt
-        08.again-second-octal.txt
-        001.a.txt
-        0010.reconfig.txt
-        010.etc.txt
-        005.etc.01.txt
-        005.Etc.02.txt
-        005.123.abc.txt
-        200.somewhere.txt
-        2zzzz.before-somewhere.txt
-        00222-after-somewhere.txt
-        005.00010.abc.txt
-        005.a3423bc.00010.abc.txt
-        005.001.abc.txt
-        005.etc.1010.txt
-        005.etc.010.txt
-        005.etc.10.txt
-        " 005.etc.10.txt"
-        005.etc.001.txt
-        20.somewhere.txt
-        4611686018427387904999999999-bignum.txt 
-        4611686018427387903-bigishnum.txt
-        9223372036854775807-bigint.txt
-        etca-a
-        etc-a
-        etc2-a
-        a0001blah.txt    
-        a010.txt
-        winlike-sort-difference-0.1.txt
-        winlike-sort-difference-0.1.1.txt
-        a1.txt
-        b1-a0001blah.txt    
-        b1-a010.txt
-        b1-a1.txt
-        -a1.txt
-        --a1.txt
-        --a10.txt
-        2.high-two.yml
-        02.higher-two.yml
-        reconfig.txt
-        _common.stuff.txt
-        CASETEST.txt
-        casetest.txt
-        something.txt
-        some~thing.txt
-        someathing.txt
-        someThing.txt
-        thing.txt
-        thing_revised.txt
-        thing-revised.txt
-        "thing revised.txt"
-        "spacetest.txt"
-        " spacetest.txt"
-        "  spacetest.txt"
-        "spacetest2.txt"
-        "spacetest 2.txt"
-        "spacetest02.txt"
-        name.txt
-        name2.txt
-        "name .txt"
-        "name2 .txt"
-        blah.txt
-        combined.txt
-        a001.txt
-        .test
-        .ssh
-        "Feb 10.txt"
-        "Feb  8.txt"
-        1ab23v23v3r89ad8a8a8a9d.txt
-        "Folder (10)/file.tar.gz"
-        "Folder/file.tar.gz"
-        "Folder (1)/file (1).tar.gz"
-        "Folder (1)/file.tar.gz"
-        "Folder (01)/file.tar.gz"
-        "Folder1/file.tar.gz"
-        "Folder(1)/file.tar.gz"
-        
-    }
-    lappend testlist "Some file.txt"
-    lappend testlist "  Some extra file1.txt"
-    lappend testlist "  Some extra file01.txt"
-    lappend testlist "  some extra file1.txt"
-    lappend testlist "  Some extra file003.txt"
-    lappend testlist " Some file.txt"
-    lappend testlist "Some extra file02.txt"
-    lappend testlist "Program Files (x86)"
-    lappend testlist "01999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991-bigger-pathologically-bignum.txt"
-    lappend testlist "199999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999-pathologically-bignum.txt"
-    lappend testlist "29999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999-smaller-pathologically-bignum.txt"
-    lappend testlist "199999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999-pathologically-bignum.txt with (more 1.txt"
-    lappend testlist "199999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999-pathologically-bignum.txt with (more 01.txt"
-    lappend testlist "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1.pathological-num-nonnum-swapping-leadzero-should-be-first.txt"
-    lappend testlist "a1a1a1a1a1a1a1a1a1a1a1a01a1a1a1a1a1a1a1a1a1a1a1a1.pathological-num-nonnum-swapping-leadzero-should-be-first.txt"
-    lappend testlist "b1b1b1b1.txt"
-    lappend testlist "b1b01z1z1.txt"
-    lappend testlist "c1c111c1.txt"
-    lappend testlist "c1c1c1c1.txt"
-
-    namespace eval overtype {
-        proc right {args} {
-            # @d !todo - implement overflow, length checks etc
-
-            if {[llength $args] < 2} {
-                error {usage: ?-overflow [1|0]? undertext overtext}
-            }
-            foreach {undertext overtext} [lrange $args end-1 end] break
-
-            set opt(-overflow)	0
-            array set opt [lrange $args 0 end-2]
-
-
-            set olen [string length $overtext]
-            set ulen [string length $undertext]
-
-            if {$opt(-overflow)} {
-                return [string range $undertext 0 end-$olen]$overtext
-            } else {
-                if {$olen > $ulen} {	
-                    set diff [expr {$olen - $ulen}]
-                    return [string range $undertext 0 end-$olen][string range $overtext 0 end-$diff]
-                } else {
-                    return [string range $undertext 0 end-$olen]$overtext
-                }
-            }
-        }
-        proc left {args} {
-            # @c overtype starting at left (overstrike) 
-            # @c can/should we use something like this?: 'format "%-*s" $len $overtext 
-
-            if {[llength $args] < 2} {
-                error {usage: ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
-            }
-            foreach {undertext overtext} [lrange $args end-1 end] break
-
-            set opt(-ellipsis)		0
-            set opt(-ellipsistext)	{...}
-            set opt(-overflow)	0
-            array set opt [lrange $args 0 end-2]
-
-            
-            set len [string length $undertext]
-            set overlen [string length $overtext]
-            set diff [expr {$overlen - $len}]
-
-            #puts stdout "====================>overtype: datalen:$len  overlen:$overlen diff:$diff"
-            #puts stdout "====================>overtype: data: $overtext"
-            if {$diff > 0} {
-                if {$opt(-overflow)} {
-                    return $overtext
-                } else {
-                    if {$opt(-ellipsis)} {
-                        return [overtype::left [string range $overtext 0 [expr {$len -1}]] $opt(-ellipsistext)]
-                    } else {
-                        return [string range $overtext 0 [expr {$len -1}]]
-                    }
-                }
-            } else {
-                return "$overtext[string range $undertext $overlen end]"
-            }
-        }
-        
-    }
-
-    #considered using hex to make large numbers more compact for viewing in debug output - but it's not that much shorter and probably obscures more than it helps.
-    proc hex2dec {largeHex} {
-        set res 0
-        set largeHex [string map [list _ ""] $largeHex]
-        foreach hexDigit [split $largeHex {}] {
-            set new 0x$hexDigit
-            set res [expr {16*$res + $new}]
-        }
-        return $res
-    }
-    proc dec2hex {decimalNumber} {
-        format %4.4llX $decimalNumber
-    }
-    proc trimzero {number} {
-        set trimmed [string trimleft $number 0]
-        if {[string length $trimmed] == 0} {
-            set trimmed 0
-        }
-        return $trimmed
-    }
-    #todo - consider human numeric split
-    #e.g consider SI suffixes k|KMGTPEZY in that order
-
-    #in this context, for natural sorting - numeric segments don't contain underscores or other punctuation such as . - + etc.
-    #review - what about unicode equivalents such as wide numerals \UFF10 to \UFF19?  unicode normalization?
-    proc split_numeric_segments {name} {
-        set segments [list]
-        while {[string length $name]} {
-            if {[scan $name {%[0-9]%n} chunk len] == 2} {
-                lappend segments $chunk 
-                set name [string range $name $len end]
-            }
-            if {[scan $name {%[^0-9]%n} chunk len] == 2} {
-                lappend segments $chunk
-                set name [string range $name $len end]
-            }
-        }
-        return $segments
-    }
-
-    proc padleft {str count {ch " "}} {
-        set val [string repeat $ch $count]
-        append val $str 
-        set diff [expr {max(0,$count - [string length $str])}]
-        set offset [expr {max(0,$count - $diff)}]
-        set val [string range $val $offset end]
-    }
-
-
-    # Sqlite may have limited collation sequences available in default builds.
-    # with custom builds - there may be others such as 'natsort' - see https://sqlite.org/forum/forumpost/e4dc6f3331
-    # This is of limited use with the few builtin collations available in 2023 ie binary,nocase & rtrim
-    #  but may provide a quicker,flexible sort option, especially if/when more collation sequences are added to sqlite
-    # There are also prebuilt packages such as sqlite3-icu  which allows things like "SELECT icu_load_collation('en_AU', 'australian');"
-    proc sort_sqlite {stringlist args} {
-        package require sqlite3
-
-    
-        set args [check_flags -caller natsort_sqlite -defaults [list -db :memory: -collate nocase  -winlike 0 -topchars "\uFFFF" -debug 0 -splitchars [list / . - _] -extras {all}] -values $args]
-        set db          [string trim [dict get $args -db]]
-        set collate     [string trim [dict get $args -collate]]
-        set debug       [string trim [dict get $args -debug]]
-        set topchars    [string trim [dict get $args -topchars]]
-
-        set topdot [expr {"." in $topchars}]
-        set topunderscore [expr {"_" in $topchars}]
-        
-        
-        sqlite3 db_sort_basic $db
-        set orderedlist [list]
-        db_sort_basic eval [string map [list %collate% $collate] {create table sqlitesort(index0 text COLLATE %collate%, name text COLLATE %collate%)}]
-        foreach nm $stringlist {
-            set segments [split_numeric_segments $nm]
-            set index ""
-            set s 0
-            foreach seg $segments {
-                if {($s == 0) && ![string length [string trim $seg]]} {
-                    #don't index leading space
-                } elseif {($s == 0) && ($topunderscore) && [string match _* [string trim $seg]]} {
-                    append index "[padleft "0" 5]-d -100 topunderscore "
-                    append index [string trim $seg]
-                } elseif {($s == 0) && ($topdot) && [string match .* [string trim $seg]]} {
-                    append index "[padleft "0" 5]-d -50 topdot "
-                    append index [string trim $seg]
-                } else {
-                    if {[string is digit [string trim $seg]]} {
-                        set basenum [trimzero [string trim $seg]]
-                        set lengthindex "[padleft [string length $basenum] 5]-d"
-                        append index "$lengthindex "
-                        #append index [padleft $basenum 40]
-                        append index $basenum
-                    } else {
-                        append index [string trim $seg]
-                    }
-                }
-                incr s
-            }
-            puts stdout ">>$index"
-            db_sort_basic eval {insert into sqlitesort values($index,$nm)} 
-        }
-        db_sort_basic eval [string map [list %collate% $collate] {select name from sqlitesort order by index0 COLLATE %collate% ASC, name COLLATE %collate% ASC }] {
-            lappend orderedlist $name
-        }
-        db_sort_basic close
-        return $orderedlist
-    }
-
-    proc get_leading_char_count {str char} {
-        #todo - something more elegant? regex?
-        set count 0
-        foreach c [split $str "" ] {
-            if {$c eq $char} {
-                incr count
-            } else {
-                break
-            }
-        }
-        return $count
-    }
-    proc stacktrace {} {
-        set stack "Stack trace:\n"
-        for {set i 1} {$i < [info level]} {incr i} {
-            set lvl [info level -$i]
-            set pname [lindex $lvl 0]
-            append stack [string repeat " " $i]$pname
-
-            if {![catch {info args $pname} pargs]} {
-                foreach value [lrange $lvl 1 end] arg $pargs {
-
-                    if {$value eq ""} {
-                        if {$arg != 0} {
-                            info default $pname $arg value
-                        }
-                    }
-                    append stack " $arg='$value'"
-                }
-            } else {
-                append stack " !unknown vars for $pname"
-            }
-
-            append stack \n
-        }
-        return $stack
-    }
-
-    proc get_char_count {str char} {
-        expr {[string length $str]-[string length [string map [list $char {}] $str]]}
-    }
-    
-    proc build_key {chunk  splitchars topdict tagconfig debug} {
-        variable stacktrace_on
-        if {$stacktrace_on} {
-            puts stderr "+++>[stacktrace]"
-        }
-
-        set index_map [list - "" _ ""]
-        #e.g - need to maintain the order
-        #a b.txt
-        #a book.txt
-        #ab.txt
-        #abacus.txt
-    
-
-        set original_splitchars [dict get $tagconfig original_splitchars]
-
-        # tag_dashes test moved from loop - review
-        set tag_dashes 0
-        if {![string length [dict get $tagconfig last_part_text_tag]]} {
-            #winlike
-            set tag_dashes 1
-        }
-        if {("-" ni $original_splitchars)} {
-            set tag_dashes 1 
-        }
-        if {$debug >= 3} {
-            puts stdout "START build_key chunk        : $chunk"
-            puts stdout "START build_key splitchars   : $splitchars $topdict $tagconfig  NO tag dashes"
-        }
-
-
-        ## index_map will have no effect if we've already split on the char anyway(?)
-        #foreach m [dict keys $index_map] {
-        #    if {$m in $original_splitchars} {
-        #        dict unset index_map $m
-        #    }
-        #}
-
-        #if {![string length $chunk]} return 
-        
-        set result ""
-        if {![llength $splitchars]} {
-            #no more structural splits - but we need to examine numeric/non-numeric segments at the lowest level.    
-            # we are at a leaf in the recursive split hierarchy 
-
-            set s "" ;#we never actually split on "" (unless that was put in splitchars.. but it probably shouldn't be)
-            set parts [list $chunk] ;#important to treat as list or leading/trailing whitespace lost
-
-        
-        } else {
-            set s [lindex $splitchars 0]
-            if {"spudbucket$s" in "[split $chunk {}]"} {
-                error "dead-branch spudbucket"
-                set partindex [build_key $chunk  [lrange $splitchars 1 end] $topdict $tagconfig $debug] 
-                if {[dict get $tagconfig showsplits]} {
-                    set pfx "(1${s}=)"  ;# = sorts before _ 
-                    set partindex ${pfx}$partindex
-                }
-
-                return $partindex
-            } else {
-                set parts_below_index ""
-
-                if {$s ni [split $chunk ""]} {
-                    #$s can be an empty string 
-                    set parts [list $chunk]
-                } else {
-                    set parts [split $chunk $s] ;#whitespace preserved - even if splitting on s that is not in string.
-                }
-                #assert - we have a splitchar $s that is in the chunk - so at least one part
-                if {(![string length $s] || [llength $parts] == 0)} {
-                    error "buld_key assertion false empty split char and/or no parts"
-                } 
-
-                set pnum 1 ;# 1 based for clarity of reading index in debug output
-                set subpart_count [llength $parts] 
-
-                set sub_splits [lrange $splitchars 1 end] ;#pass same splitchars to each subpart
-                foreach p $parts {
-                    set partindex [build_key $p  $sub_splits $topdict $tagconfig $debug] 
-                    set lastpart [expr {$pnum == $subpart_count}]
-
-
-                    #######################
-                    set showsplits [dict get $tagconfig showsplits]
-                    #split prefixing experiment - maybe not suitable for general use - as it affects sort order 
-                    #note that pfx must be consistent until last one, no matter how many partnumbers there are in total.
-                    # we don't want to influence sort order before reaching end.
-                    #e.g for:
-                    #(1.=)...
-                    #(1._)...(2._)...(3.=)
-                    #(1._)...(2.=)
-                    #Note that this is probably more suitable for highly structure dependant sorts where the results are maybe less.. natural.
-                    if {$showsplits} {
-                        if {$lastpart} {
-                            set pfx "(${pnum}${s}_"
-                            #set pfx "(${pnum}${s}=)"  ;# = sorts before _
-                        } else {
-                            set pfx "(${pnum}${s}_"
-                        }
-                        append parts_below_index $pfx
-                    } 
-                    #######################
-
-                    if {$lastpart} {
-                        if {[string length $p] && [string is digit $p]} {
-                            set last_part_tag "<22${s}>"
-                        } else {
-                            set last_part_tag "<33${s}>"
-                        }
-
-                        set last_part_text_tag [dict get $tagconfig last_part_text_tag]
-                        #for -winlike 1 there is no tag configured. Windows explorer likes to put things in the  order:
-                        #  module-0.1.1.tm
-                        #  module-0.1.1.2.tm
-                        #  module-0.1.tm
-                        # arguably -winlike 0 is more natural/human
-                        #  module-0.1.tm
-                        #  module-0.1.1.tm
-                        #  module-0.1.1.2.tm
-
-                        if {[string length $last_part_text_tag]} {
-                            #replace only the first text-tag (<30>) from the subpart_index 
-                            if {[string match "<30?>*" $partindex]} {
-                                #give textual string index  a specific tag   for last part in split only. e.g <130> for lower than integers
-                                set partindex "<130>[string range $partindex 5 end]" 
-                            }
-                            #append parts_below_index $last_part_tag
-                        }
-                        #set partindex $last_part_tag$partindex
-
-
-                    }
-                    append parts_below_index $partindex
-                    
-
-
-                    if {$showsplits} {
-                        if {$lastpart} {
-                            set suffix "${pnum}${s}=)"  ;# = sorts before _
-                        } else {
-                            set suffix "${pnum}${s}_)"
-                        }
-                        append parts_below_index $suffix
-                    } 
-
-
-                    incr pnum
-                }
-                append parts_below_index "" ;# don't add anything at the tail that may perturb sort order
-
-                if {$debug >= 3} {
-                    set pad [string repeat " " 20]
-                    puts stdout "END build_key chunk          : $chunk "
-                    puts stdout "END build_key splitchars     : $splitchars $topdict $tagconfig  NO tag dashes"
-                    puts stdout "END build_key ret below_index: $parts_below_index"
-                }
-                return $parts_below_index
-
-
-            }
-        }
-
-        
-
-        #puts stdout ">>>chunk:'$chunk'<<< split-on:$s parts: '$parts'   splitchars: $splitchars -topdict:$topdict"
-        
-            
-        
-
-       
-        #if {$chunk eq ""} {
-        #   puts "___________________________________________!!!____"
-        #}
-        #puts stdout "-->chunk:$chunk $s parts:$parts"
-
-        #puts stdout "---chunk:'$chunk' part:'$part' parts:'$parts' s:'$s'"
-        
-     
-
-
-            set segments [split_numeric_segments $chunk] ;#!  
-            set stringindex ""
-            set segnum 0
-            foreach seg $segments {
-                    #puts stdout "=================---->seg:$seg segments:$segments"
-                #-strict ?
-                if {[string length $seg] && [string is digit $seg]} {
-                    set basenum [trimzero [string trim $seg]]
-                    set lengthindex "[padleft [string length $basenum] 4]d" 
-                    #append stringindex "<20>$lengthindex $basenum $seg"
-                } else {
-                    set c1 [string range $seg 0 0]
-                    #puts stdout "==============> c1'$c1' topdict: $topdict stringindex:$stringindex"
-                    
-                    if {$c1 in [dict keys $topdict]} {
-                        set tag [dict get $topdict $c1]
-                        #append stringindex "${tag}$c1"
-                        #set seg [string range $seg 1 end]
-                    } 
-                    #textindex 
-                    set leader "<30>"
-                    set idx $seg 
-                    set idx [string trim $idx]
-                    set idx [string tolower $idx]
-                    set idx [string map $index_map $idx]
-
-
-                    
-
-                    
-                    #set the X-c count to match the length of the index - not the raw data      
-                    set lengthindex "[padleft [string length $idx] 4]c"
-                    
-                    #append stringindex "${leader}$idx $lengthindex $texttail"
-                }
-            } 
-
-            if {[llength $parts] != 1} {
-                error "build_key assertion fail llength parts != 1 parts:$parts"
-            }
-
-            set segtail_clearance_buffer " " ;#space to clear other split indicators if using showsplits
-            set segtail $segtail_clearance_buffer
-            append segtail "\["
-            set grouping ""
-            set pnum 0
-            foreach p $parts {
-                set sublen_list [list]
-                set subsegments [split_numeric_segments $p]
-                set i 0
-
-                set partsorter ""
-                foreach sub $subsegments {
-                    ##don't trim spaces here - it would be inconsistent. Some subs are pure whitespace - others have internal whitespace. e.g "a4 400b a b2" becomes "a 4 { } 400 {b a b} 2"
-                    #mapping away all whitespace would be consistent, but not necessarily desirable. If it's in the index_map it'll happen anyway - so we don't do it manually here except for evaluating conditions.
-                    set test_trim [string trim $sub]
-                    set str $sub 
-                    set str [string tolower $str]
-                    set str [string map $index_map $str]
-                    if {[string length $test_trim] && [string is digit $test_trim]} {
-                        append partsorter [trimzero $str]
-                    } else {
-                        append partsorter "$str"
-                    }
-                    append partsorter 
-                }
-
-
-                foreach sub $subsegments { 
-
-                    if {[string length $sub] && [string is digit $sub]} {
-                        set basenum [trimzero [string trim $sub]]
-                        set subequivs $basenum
-                        set lengthindex "[padleft [string length $subequivs] 4]d "
-                        set idx "$lengthindex [padleft $basenum 10]" ;#todo - cycle through data and determine longest 
-                        set tail [overtype::left [string repeat " " 10] $sub]
-                        #set tail ""
-                    } else {
-                        set idx ""
-                        
-
-                        set lookahead [lindex $subsegments $i+1]
-                        if {![string length $lookahead]} {
-                            set zeronum "[padleft 0 4]d0"
-                        } else {
-                            set zeronum ""
-                        }
-                        set subequivs $sub
-                        #set subequivs [string trim $subequivs]
-                        set subequivs [string tolower $subequivs]
-                        set subequivs [string map $index_map $subequivs]
-
-                        append idx $subequivs
-                        append idx $zeronum
-
-                        set idx $subequivs
-                        
-
-                        #<removed tag_dashes test put above - review>
-                        
-                        set ch "-"
-                        if {$tag_dashes} {    
-                            #puts stdout "____TAG DASHES"
-                            #winlike
-                            set numleading [get_leading_char_count $seg $ch]
-                            if {$numleading > 0} {
-                                set texttail "<31-leading[padleft $numleading 4]$ch>"
-                            } else {
-                                set texttail "<30>"
-                            }
-                            set numothers [expr {[get_char_count $seg $ch] - $numleading}]
-                            if {$debug >= 2} {
-                              puts stdout "____dashcount: [get_char_count $seg $ch] numothers: $numothers"
-                            }
-                            if {$numothers > 0} {
-                                append texttail "<31-others[padleft $numothers 4]$ch>"
-                            }  else {
-                                append textail "<30>"
-                            }
-                        } else {
-                            set texttail "<30>" 
-                        }
-
-
-
-
-                        #set idx $partsorter
-                        set tail ""
-                        #set tail [string tolower $sub] ;#raw
-                        #set tail $partsorter
-                        #append tail ":[string tolower $p]" ;#we need the whole part - even though it makes the index much larger. !todo - tagconfig switch to toggle case sensitive sorting
-                    }
-
-                    append grouping "$idx $tail<end>|$s"
-                    incr i
-                }
-
-
-
-
-
-                if {$p eq ""} {
-                    # no subsegments.. 
-                    set zeronum "[padleft 0 4]d0"
-                    #append grouping "\u000$zerotail"
-                    append grouping ".$zeronum"
-                }
-
-                #append grouping |
-                #append grouping $s
-                #foreach len $sublen_list {
-                #    append segtail "<[padleft $len 3]>"
-                #}
-                incr pnum
-            }
-            set grouping [string trimright $grouping $s]
-            append grouping "[padleft [llength $parts] 4]"
-            append segtail $grouping
-            
-
-            #append segtail " <[padleft [llength $parts] 4]>"
-            
-            append segtail "\]"
-
-
-            #if {[string length $seg] && [string is digit $seg]} {
-            #    append segtail "<20>"
-            #} else {
-            #    append segtail "<30>"
-            #}
-            append stringindex $segtail
-
-            incr segnum
-            
-     
-       
-        
-        lappend indices  $stringindex
-
-        if {[llength $indices] > 1} {
-            puts stderr "INDICES [llength $indices]: $stringindex"        
-            error "build_key assertion error deadconcept indices"
-        }
-
-        #topchar handling on splitter characters
-        #set c1 [string range $chunk 0 0]
-        if {$s  in [dict keys $topdict]} {
-            set tag [dict get $topdict $s]
-            set joiner [string map [list ">" "$s>"] ${tag}]
-            #we have split on this character $s so if the first part is empty string then $s was a leading character
-            # we need to bring a tag out front for this, or it will be dominated by the leading sections-remaing tag <S..> 
-            # (since the empty string produces no tag of it's own - ?)
-            if {[string length [lindex $parts 0]] == 0} {
-                set prefix ${joiner} 
-            } else {
-                set prefix ""
-            }
-        } else {
-            #use standard character-data positioning tag if no override from topdict
-            set joiner "<30J>$s"
-            set prefix ""
-        }
-
-
-        set  contentindex   $prefix[join $indices $joiner]
-        if {[string length $s]} {
-            set split_indicator "<split$s $chunk>"
-        } else {
-            set split_indicator "<split$s $chunk>"
-
-        }
-        if {![string length $s]} {
-            set s ~
-        }
-
-        #return  "[overtype::left [string repeat { } 80] $contentindex][overtype::left [string repeat { } 10] [list $s $chunk]]"
-        #return $contentindex$split_indicator
-        #return [overtype::left [string repeat - 40] $contentindex]
-
-        if {$debug >= 3} {
-            puts stdout "END build_key chunk          : $chunk"
-            puts stdout "END build_key splitchars     : $splitchars $topdict $tagconfig  NO tag dashes"
-            puts stdout "END build_key ret contentidx : $contentindex"
-        }
-        return $contentindex
-    }
-
-    #----------------------------------------
-    #line-processors - data always last argument - opts can be empty string
-    #all processor should accept empty opts and ignore opts if they don't use them 
-    proc _lineinput_as_tcl1 {opts line} {
-        set out ""
-        foreach i $line {
-            append out "$i "
-        }
-        set out [string range $out 0 end-1]
-        return $out
-    }
-    #should be equivalent to above
-    proc _lineinput_as_tcl {opts line} {
-        return [concat {*}$line]
-    }
-    #will put extra tcl quoting if it was already tcl-shaped  e.g text  "a" -> {"a"}
-    proc _lineoutput_as_tcl {opts line} {
-        return [regexp -inline -all {\S+} $line]
-    }
-
-    proc _lineinput_as_raw {opts line} {
-        return $line
-    }
-    proc _lineoutput_as_raw {opts line} {
-        return $line
-    }
-
-    #words is opposite of tcl
-    proc _lineinput_as_words {opts line} {
-        #wordlike_parts
-        return [regexp -inline -all {\S+} $line]
-    }
-    proc _lineoutput_as_words {opts line} {
-        return [concat {*}$line]
-    }
-
-    #opts same as tcllib csv::split - except without the 'line' element
-    #?-alternate? ?sepChar? ?delChar?
-    proc _lineinput_as_csv {opts line} {
-        package require csv
-        if {[lindex $opts 0] eq "-alternate"} {
-            return [csv::split -alternate $line {*}[lrange $opts 1 end]]
-        } else {
-            return [csv::split $line {*}$opts]
-        }
-    }
-    #opts same as tcllib csv::join 
-    #?sepChar? ?delChar? ?delMode?
-    proc _lineoutput_as_csv {opts line} {
-        package require csv
-        return [csv::join $line {*}$opts]
-    }
-    #----------------------------------------
-    proc sort {stringlist args} {
-        #puts stdout "natsort::sort args: $args"
-        variable debug
-        if {![llength $stringlist]} return
-        
-        #allow pass through of the check_flags flag -debugargs so it can be set by the caller
-        set debugargs 0
-        if {[set posn [lsearch $args -debugargs]] >=0} {
-            if {$posn == [llength $args]-1} {
-                #-debugargs at tail of list
-                set debugargs 1
-            } else {
-                set debugargs [lindex $args $posn+1]
-            }
-        }
-
-        #-return flagged|defaults doesn't work Review.
-        #flagfilter global processor/allocator not working 2023-08
-        set args [check_flags \
-          -caller natsort::sort \
-          -return supplied|defaults \
-          -debugargs $debugargs \
-          -defaults [list -collate nocase \
-                    -winlike 0 \
-                    -splits "\uFFFF" \
-                    -topchars {. _} \
-                    -showsplits 1 \
-                    -sortmethod ascii \
-                    -collate "\uFFFF" \
-                    -inputformat raw \
-                    -inputformatapply {index data} \
-                    -inputformatoptions "" \
-                    -outputformat raw \
-                    -outputformatoptions "" \
-                    -cols "\uFFFF" \
-                    -debug 0 -db "" -stacktrace 0 -splits "\uFFFF" -showsplits 0] \
-          -required {all} \
-          -extras {none} \
-          -commandprocessors {} \
-          -values $args]
-
-       #csv unimplemented
-
-        set winlike         [dict get $args -winlike]
-        set topchars        [dict get $args -topchars]
-        set cols            [dict get $args -cols]
-        set debug           [dict get $args -debug]
-        set stacktrace      [dict get $args -stacktrace]
-        set showsplits      [dict get $args -showsplits]
-        set splits          [dict get $args -splits]
-        set sortmethod      [dict get $args -sortmethod]
-        set opt_collate         [dict get $args -collate]
-        set opt_inputformat     [dict get $args -inputformat]
-        set opt_inputformatapply     [dict get $args -inputformatapply]
-        set opt_inputformatoptions     [dict get $args -inputformatoptions]
-        set opt_outputformat    [dict get $args -outputformat]
-        set opt_outputformatoptions    [dict get $args -outputformatoptions]
-        dict unset args -showsplits
-        dict unset args -splits 
-        if {$debug} {
-            puts stdout "natsort::sort processed_args: $args"
-            if {$debug == 1} {
-                puts stdout "natsort::sort - try also -debug 2, -debug 3"
-            }
-        }
-        
-        #set sortmethod "-dictionary" ;# sorts a2b before a001b   - possibly other strangenesses that are hard to reason about
-
-        if {$sortmethod in [list dictionary ascii]} {
-            set sortmethod "-$sortmethod"
-            # -ascii is default for tcl lsort.
-        } else {
-            set sortmethod "-ascii"
-        }
-
-        set allowed_collations [list nocase]
-        if {$opt_collate ne "\uFFFF"} {
-            if {$opt_collate ni $allowed_collations} {
-                error "natsort::sort unknown value for -collate option. Only acceptable value(s): $allowed_collations"
-            }
-            set nocaseopt "-$opt_collate"
-        } else {
-            set nocaseopt ""
-        }
-        set allowed_inputformats [list tcl raw csv words]
-        if {$opt_inputformat ni $allowed_inputformats} {
-            error "natsort::sort unknown value for -inputformat option. Only acceptable value(s): $allowed_inputformats"
-        }
-        set allowed_outputformats [list tcl raw csv words]
-        if {$opt_inputformat ni $allowed_outputformats} {
-            error "natsort::sort unknown value for -outputformat option. Only acceptable value(s): $allowed_outputformats"
-        }
-
-        #
-        set winsplits [list / . _]
-        set commonsplits [list / . _ -]
-        #set commonsplits [list]
-
-        set tagconfig [dict create]
-        dict set tagconfig last_part_text_tag "<19>"        
-        if {$winlike} {
-            set splitchars $winsplits 
-            #windows explorer sorts leading spaces at the top - which doesn't seem very helpful for keeping things together - but the explorer doesn't seem able to create leading spaces anyway.
-            set wintop [list "(" ")" { }  {.} {_}] ;#windows specific order  
-            foreach t $topchars {
-                if {$t ni $wintop} {
-                    lappend wintop $t
-                }
-            }
-            set topchars $wintop 
-            dict set tagconfig last_part_text_tag ""
-        } else {
-            set splitchars $commonsplits
-        }
-        if {$splits ne "\uFFFF"} {
-            set splitchars $splits 
-        }
-        dict set tagconfig original_splitchars $splitchars
-        dict set tagconfig showsplits $showsplits
-
-        #create topdict
-        set i 0
-        set topdict [dict create]
-        foreach c $topchars {   
-            incr i ;#start at 01 so that 00 reserved for final-split tag (allows x-0.1.txt to sort above x-0.1.1.txt  by default. Use tagconfig to change, or choose -winlike 1 for explorer-like sorting)
-            dict set topdict $c "<0$i>"
-        }
-        set keylist [list]    
-
-
-        if {$opt_inputformat eq "tcl"} {
-            set lineinput_transform [list  _lineinput_as_tcl $opt_inputformatoptions]
-        } elseif {$opt_inputformat eq "csv"} {
-            set lineinput_transform [list  _lineinput_as_csv $opt_inputformatoptions]
-        } elseif {$opt_inputformat eq "raw"} {
-            set lineinput_transform [list _lineinput_as_raw $opt_inputformatoptions] 
-        } elseif {$opt_inputformat eq "words"} {
-            set lineinput_transform [list _lineinput_as_words $opt_inputformatoptions] 
-        }
-        if {$opt_outputformat eq "tcl"} {
-            set lineoutput_transform [list  _lineoutput_as_tcl $opt_outputformatoptions]
-        } elseif {$opt_outputformat eq "csv"} {
-            set lineoutput_transform [list  _lineoutput_as_csv $opt_outputformatoptions]
-        } elseif {$opt_outputformat eq "raw"} {
-            set lineoutput_transform [list _lineoutput_as_raw $opt_outputformatoptions] 
-        } elseif {$opt_outputformat eq "words"} {
-            set lineoutput_transform [list _lineoutput_as_words $opt_outputformatoptions] 
-        }
-
-        
-        if {("data" in $opt_inputformatapply) || ("index" in $opt_inputformatapply)} {
-            if {$opt_inputformat eq "raw"} {
-                set tf_stringlist $stringlist
-            } else {
-                set tf_stringlist [list]
-                foreach v $stringlist {
-                    lappend tf_stringlist [{*}$lineinput_transform $v]
-                }
-            }
-            if {"data" in $opt_inputformatapply} {
-                set tf_data_stringlist $tf_stringlist
-            } else {
-                set tf_data_stringlist $stringlist
-            }
-            if {"index" in $opt_inputformatapply} {
-                set tf_index_stringlist $tf_stringlist
-            } else {
-                set tf_index_stringlist $stringlist
-            }
-        } else {
-            set tf_data_stringlist $stringlist
-            set tf_index_stringlist $stringlist
-        }
-
-
-
-        if {$stacktrace} {
-            puts stdout [natsort::stacktrace]
-            set natsort::stacktrace_on 1
-        }
-        if {$cols eq "\uFFFF"} {
-            set colkeys [lmap v $stringlist {}]
-        } else {
-            set colkeys [list]
-            foreach v $tf_index_stringlist {
-                set lineparts $v
-                set k [list]
-                foreach c $cols {
-                    lappend k [lindex $lineparts $c]
-                }
-                lappend colkeys [join $k "_"] ;#use a common-split char - Review
-            }
-        }
-        #puts stdout "colkeys: $colkeys"
-       
-        if {$opt_inputformat eq "raw"} {
-            #no inputformat was applied - can just use stringlist
-            foreach value $stringlist ck $colkeys {
-                set contentindex   [build_key $value $splitchars $topdict $tagconfig $debug]
-                set colindex       [build_key $ck $splitchars $topdict $tagconfig $debug]
-                lappend keylist ${colindex}-${contentindex}-$value ;#note: entire raw value  used for final sort disambiguation (can be whitespace that was ignored in indexing)
-            }
-        } else {
-            foreach keyinput $tf_index_stringlist datavalue  $tf_data_stringlist ck $colkeys {
-                #data may or may not have been transformed
-                #column index may or may not have been built with transformed data
-                
-                set contentindex   [build_key $keyinput $splitchars $topdict $tagconfig $debug]
-                set colindex       [build_key $ck $splitchars $topdict $tagconfig $debug]
-                lappend keylist ${colindex}-${contentindex}-$datavalue ;#note: entire value  used for final sort disambiguation (can be whitespace that was ignored in indexing)
-            }
-        }
-        #puts stderr "keylist: $keylist"
-
-        ###################################################################################################
-        #  Use the generated keylist to do the actual sorting
-        #  select either the transformed or raw data as the corresponding output
-        ###################################################################################################
-        if {[string length $nocaseopt]} {
-            set sortcommand [list lsort $sortmethod $nocaseopt -indices $keylist]
-        } else {
-            set sortcommand [list lsort $sortmethod -indices $keylist]
-        }
-        if {$opt_outputformat eq "raw"} {
-            #raw output means no further transformations - it doesn't mean there wasn't a transform applied on the input side
-            #use the tf_data_stringlist in the output - which will be the same as the input stringlist if no input transform applied for data.
-            #(Also - it may or may not have been *sorted* on transformed data depending on whether 'index' was in $opt_inputformatapply)
-            foreach idx [{*}$sortcommand] {
-                lappend result [lindex $tf_data_stringlist $idx]
-            }
-        } else {
-            #we need to apply an output format
-            #The data may or may not have been transformed at input
-            foreach idx [{*}$sortcommand] {
-                lappend result [{*}$lineoutput_transform [lindex $tf_data_stringlist $idx]]
-            }
-        }
-        ###################################################################################################
-       
-
-
-
-        
-        if {$debug >= 2} {
-            set screen_width 250
-            set max_val 0
-            set max_idx 0
-            #####  calculate colum widths
-            foreach i [{*}$sortcommand] {
-                set len_val [string length [lindex $stringlist $i]] 
-                if {$len_val > $max_val} {
-                    set max_val $len_val
-                }
-                set len_idx [string length [lindex $keylist $i]]
-                if {$len_idx > $max_idx} {
-                    set max_idx $len_idx
-                }
-            }
-            ####
-            set l_width [expr {$max_val + 1}]
-            set leftcol [string repeat " " $l_width]
-            set r_width [expr {$screen_width - $l_width - 1}]
-            set rightcol [string repeat " " $r_width]
-            set str [overtype::left $leftcol RAW]
-            puts stdout "  $str Index with possibly transformed data at tail"
-            foreach i [{*}$sortcommand] {
-                #puts stdout "|d> [overtype::left  $leftcol [lindex $stringlist $i] ]  [lindex $keylist $i]" 
-                set index [lindex $keylist $i]
-                set len_idx [string length $index]
-                set rowcount [expr {$len_idx / $r_width}]
-                if {($len_idx % $r_width) > 0} {
-                    incr rowcount
-                }
-                set rows [list]
-                for {set r 0} {$r < $rowcount} {incr r} {
-                    lappend rows [string range $index 0 $r_width-$r]
-                    set index [string range $index $r_width end]
-                }
-
-                set r 0
-                foreach idxpart $rows {
-                    if {$r == 0} {
-                        #use the untransformed stringlist 
-                        set str [overtype::left  $leftcol [lindex $stringlist $i]]
-                    } else {
-                        set str [overtype::left  $leftcol ...]]
-                    }
-                    puts stdout "  $str $idxpart" 
-                    incr r
-                }
-                #puts stdout "|> '[lindex $stringlist $i]'"
-                #puts stdout "|>    [lindex $keylist $i]"
-            }
-        
-            puts stdout "|debug> topdict:    $topdict"
-            puts stdout "|debug> splitchars: $splitchars"
-        }
-        return $result
-    }
-
-
-
-    #Note that although leading whitespace isn't a commonly used feature of filesystem names - it's possible at least on  FreeBSD,windows and linux so we should try to handle it sensibly.
-    proc sort_experiment {stringlist args} {
-        package require sqlite3
-
-        variable debug
-        set args [check_flags -caller natsort::sort \
-          -defaults [dict create -db :memory:  -collate nocase -nullvalue "->NULL<"  -winlike 0  -topchars [list] -debug 0] \
-          -extras {all} \
-          -values $args]
-        set db              [string trim [dict get $args -db]]
-        set collate         [string trim [dict get $args -collate]]
-        set winlike     [string trim [dict get $args -winlike]]
-        set debug           [string trim [dict get $args -debug]]
-        set nullvalue       [string trim [dict get $args -nullvalue]]
-
-
-        set topchars        [string trim [dict get $args -topchars]]
-        
-        set topdot [expr {"." in $topchars}]
-        set topunderscore [expr {"_" in $topchars}]
-        
-        
-        sqlite3 db_natsort2 $db
-        #--
-        #our table must handle the name with the greatest number of numeric/non-numeric splits.
-        #This means a single list member with pathological naming e.g a1a1a1a1a1a1a1a1a1a1a1.txt could greatly extend the number of columns and indices and affect performance.
-        #review: could be optimised to aggregate the tail into a single index, as the the extra columns won't assist in ordering, but make the table and query bigger.
-        # we should probably determine the longest common sequence of splits in the input list and add only one more index for the segment after that.
-        set maxsegments 0 
-        #--
-        set prefix "idx"
-        
-        #note - there will be more columns in the sorting table than segments.
-        # (a segment equals one of the numeric & non-numeric string portions returned from 'split_numeric_sgements')
-        #---------------------------
-        # consider 
-        #   a123b.v1.2.txt 
-        #   a123b.v1.3beta1.txt
-        # these have the following segments:
-        #   a 123 b.v 1 . 2 .txt
-        #   a 123 b.v 1 . 3 beta 1 .txt
-        #---------------------------
-        # The first string has 7 segments  (numbered 0 to 6)
-        # the second string has 9 segments
-        #
-        # for example when the data has any elements in a segment position that are numeric (e.g 0001 123)
-        #  - then an index column with numeric equivalents will be created (e.g 0001 becomes 1), and any non-numeric values in that column will get mapped to a negative value (for special cases) or a high value such as NULL  (with  NULLS LAST sql support)
-        # 
-        # when a segment 
-        
-        #cycle through all strings - we cannot build tabledef as we go because the column type depends on whether all segments for a particular column are text vs int-equivalent.
-        array set segmentinfo {}
-        foreach nm $stringlist {
-            set segments [split_numeric_segments $nm]
-            if {![string length [string trim [lindex $segments 0]]]} {
-                if {[string is digit [string trim [lindex $segments 1]]]} {
-                    #name is whitespace followed by a digit - special case - ignore the whitespace for numbers only. (whitespace still goes through to name column though)
-                    set segments [lrange $segments 1 end]
-                }
-            }
-            
-            
-            set c 0 ;#start of index columns
-            if {[llength $segments] > $maxsegments} {
-                set maxsegments [llength $segments]
-            }
-            foreach seg $segments {
-                set seg [string trim $seg]
-                set column_exists [info exists segmentinfo($c,type)]
-                if {[string is digit $seg]} {
-                    if {$column_exists} {
-                        #override it  (may currently be text or int)
-                        set segmentinfo($c,type) "int"
-                    } else {
-                        #new column
-                        set segmentinfo($c,name) ${prefix}$c
-                        set segmentinfo($c,type) "int"
-                    }
-                } else {
-                    #text never overrides int 
-                    if {!$column_exists} {
-                        set segmentinfo($c,name) ${prefix}$c
-                        set segmentinfo($c,type) "text"
-                    }
-                }
-                incr c
-            }
-        }
-        if {$debug} {
-            puts stdout "Largest number of num/non-num segments in data: $maxsegments"
-            #parray segmentinfo
-        }
-
-        #
-        set tabledef ""
-        set ordered_column_names [list]
-        set ordered_segmentinfo_tags [lsort -dictionary [array names segmentinfo *]]
-        foreach k $ordered_segmentinfo_tags {
-            lassign [split $k ,] c tag
-            if {$tag eq "type"} {
-                set type [set segmentinfo($k)]
-                if {$type eq "int"} {
-                    append tabledef "$segmentinfo($c,name) int,"
-                } else {
-                    append tabledef "$segmentinfo($c,name) text COLLATE $collate,"
-                }
-                append tabledef "raw$c text COLLATE $collate,"
-                lappend ordered_column_names $segmentinfo($c,name)
-                lappend ordered_column_names raw$c  ;#additional index column not in segmentinfo
-            }
-            if {$tag eq "name"} {
-                #lappend ordered_column_names $segmentinfo($k)
-            }
-        }
-        append tabledef "name text"
-        
-        #puts stdout "tabledef:$tabledef"
-
-
-        db_natsort2 eval [string map [list %tabledef% $tabledef] {create table natsort(%tabledef%)}]
-        
-        
-        foreach nm $stringlist {
-            array unset intdata
-            array set intdata {}
-            array set rawdata {}
-            #init array and build sql values string
-            set sql_insert "insert into natsort values("
-            for {set i 0} {$i < $maxsegments} {incr i} {
-                set intdata($i) ""
-                set rawdata($i) ""
-                append sql_insert "\$intdata($i),\$rawdata($i),"
-            }
-            append sql_insert "\$nm"  ;#don't manipulate name value in any way - e.g must leave all whitespace as the sort must return exactly the same elements as in the original list.
-            append sql_insert ")"
-            
-            set segments [split_numeric_segments $nm]
-            if {![string length [string trim [lindex $segments 0]]]} {
-                if {[string is digit [string trim [lindex $segments 1]]]} {
-                    #name is whitespace followed by a digit - special case - ignore the whitespace for numbers only. (whitespace still goes through to name column though)
-                    set segments [lrange $segments 1 end]
-                }
-            }
-            set values ""
-            set c 0
-            foreach seg $segments {
-                if {[set segmentinfo($c,type)] eq "int"} {
-                    if {[string is digit [string trim $seg]]} {
-                        set intdata($c) [trimzero [string trim $seg]]
-                    } else {
-                        catch {unset intdata($c)} ;#set NULL - sorts last
-                        if {($c == 0) && ($topunderscore) && [string match _* [string trim $seg]]} {
-                            set intdata($c) -100
-                        }
-                        if {($c == 0) && ($topdot) && [string match .* [string trim $seg]]} {
-                            set intdata($c) -50
-                        }
-                    }
-                    set rawdata($c)  [string trim $seg]
-                } else {
-                    #pure text column 
-                    #set intdata($c) [string trim $seg] ;#ignore leading/trailing whitespace - we sort first on trimmed version, then refine with the sort on rawdata index
-                    #catch {unset indata($c)}
-                    set indata($c) [string trim $seg]
-                    set rawdata($c)  $seg
-                }
-                #set rawdata($c) [string trim $seg]#
-                #set rawdata($c)  $seg
-                incr c
-            }
-            db_natsort2 eval $sql_insert
-        }
-
-        set orderedlist [list]
-   
-        if {$debug} {        
-            db_natsort2 eval {select * from pragma_table_info('natsort')} rowdata {
-                parray rowdata
-            }
-        }
-        set orderby "order by "
-        
-        foreach cname $ordered_column_names {
-            if {[string match "idx*" $cname]} {
-                append orderby "$cname ASC  NULLS LAST,"
-            } else {
-                append orderby "$cname ASC,"
-            }
-        }
-        append orderby " name ASC"
-        #append orderby " NULLS LAST" ;#??
-        
-        #e.g "order by idx0 ASC, raw0 ASC, idx1 ASC ....   name ASC"
-        if {$debug} {
-            puts stdout "orderby clause: $orderby"
-        }
-        db_natsort2 eval [string map [list %orderby% $orderby] {select * from natsort %orderby%}] rowdata {
-            set line "- "
-            #parray rowdata
-            set columnnames $rowdata(*)
-            #puts stdout "columnnames: $columnnames"
-            #[lsort -dictionary [array names rowdata]
-            append line "$rowdata(name) \n"
-            foreach nm $columnnames {
-                if {$nm ne "name"} {
-                    append line "$nm: $rowdata($nm) "
-                }
-            }
-            #puts stdout $line
-            #puts stdout "$rowdata(name)"
-            lappend orderedlist $rowdata(name)
-        }
-        
-        db_natsort2 close
-        return $orderedlist
-    }
-}
-
-
-#application section  e.g this file might be linked from /usr/local/bin/natsort 
-namespace eval natsort {
-    namespace import ::flagfilter::check_flags
-
-    proc called_directly_namematch {} {
-        global argv0
-        #see https://wiki.tcl-lang.org/page/main+script  
-        #trailing ... let's us resolve symlinks in last component of the path (could be something else like ___ but ... seems unlikely to collide with anything in the filesystem)
-        if {[info exists argv0] 
-        &&
-            [file dirname [file normalize [file join [info script] ...]]]
-            eq
-            [file dirname [file normalize [file join $argv0 ...]]]
-        } {
-            return 1
-        } else {
-            #puts stdout "norm info script: [file dirname [file normalize [file join [info script] ...]]]"
-            #puts stdout "norm argv0      : [file dirname [file normalize [file join $argv0 ...]]]"
-            return 0
-        }
-    }
-    #Review issues around comparing names vs using inodes (esp with respect to samba shares)
-    proc called_directly_inodematch {} {
-        global argv0
-        if {[info exists argv0]
-         && [file exists [info script]] && [file exists $argv0]} {
-            file stat $argv0        argv0Info
-            file stat [info script] scriptInfo
-            expr {$argv0Info(dev) == $scriptInfo(dev)
-               && $argv0Info(ino) == $scriptInfo(ino)}
-        } else {
-            return 0
-        }
-    }
-    
-    set is_namematch [called_directly_namematch]
-    set is_inodematch [called_directly_inodematch]
-    ####
-    #review - reliability of mechanisms to determine direct calls 
-    # we don't want application being called when being used as a library, but we need it to run if called directly or from symlinks etc 
-    #-- choose a policy and leave the others commented.
-    #set is_called_directly $is_namematch 
-    #set is_called_directly $is_inodematch 
-    set is_called_directly [expr {$is_namematch || $is_inodematch}] 
-    #set is_called_directly [expr {$is_namematch && $is_inodematch}] 
-    ###
-    
-    
-    #puts stdout "called_directly_name: [called_directly_namematch]  called_directly_inode: [called_directly_inodematch]"
-
-
-    #
-
-    
-    proc test_pass_fail_message {pass {additional ""}} {
-        variable test_fail_msg
-        variable test_pass_msg
-        if {$pass} {
-            puts stderr $test_pass_msg
-        } else {
-            puts stderr $test_fail_msg
-        }
-        puts stderr $additional
-    }
-
-    variable test_fail_msg "XXXXXXXXXXXX   FAIL   XXXXXXXXXXXXX"
-    variable test_pass_msg "------------   PASS   -------------"
-    proc test_sort_1 {args} {
-        package require struct::list
-        puts stderr "---$args"
-        set args [check_flags -caller natsort:test_sort_1 -defaults [list  -collate nocase -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0 ] -values $args]
-
-        puts stderr "test_sort_1 got args: $args"
-
-            set unsorted_input {
-                2.2.2
-                2.2.2.2
-                1a.1.1
-                1a.2.1.1
-                1.12.1
-                1.2.1.1
-                1.02.1.1
-                1.002b.1.1
-                1.1.1.2
-                1.1.1.1
-            }
-            set input {
-1.1.1
-1.1.1.2
-1.002b.1.1
-1.02.1.1
-1.2.1.1
-1.12.1
-1a.1.1
-1a.2.1.1
-2.2.2
-2.2.2.2
-            }
-
-            set sorted [natsort::sort $input {*}$args]
-            set is_match [struct::list equal $input $sorted]
-            
-            set msg "windows-explorer order"
-
-            test_pass_fail_message $is_match $msg  
-            puts stdout [string repeat - 40]
-            puts stdout INPUT
-            puts stdout [string repeat - 40]
-            foreach item $input {
-                puts stdout $item
-            }
-            puts stdout [string repeat - 40]
-            puts stdout OUTPUT
-            puts stdout [string repeat - 40]
-            foreach item $sorted {
-                puts stdout $item
-            }
-            test_pass_fail_message $is_match  $msg
-            return [expr {!$is_match}]
-    }
-    proc test_sort_showsplits {args} {
-        package require struct::list
-
-        set args [check_flags -caller natsort:test_sort_1 \
-          -defaults [list  -collate nocase -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 1 ] \
-          -extras {all} \
-          -values $args]
-
-        set input1 {
-            a-b.txt
-            a.b.c.txt
-            b.c-txt
-        }
-
-
-        set input2 {
-            a.b.c.txt
-            a-b.txt
-            b.c-text
-        }
-
-        foreach {msg testlist } [list "custom-order" $input1  "windows-explorer (should work with -winlike 1)" $input2] {
-            set sorted [natsort::sort $testlist {*}$args]
-            set is_match [struct::list equal $testlist $sorted]
-        
-            test_pass_fail_message $is_match  $msg
-            puts stderr "INPUT"
-            puts stderr "[string repeat - 40]"
-            foreach item $testlist {
-                puts stdout $item
-            }
-            puts stderr "[string repeat - 40]"
-            puts stderr "OUTPUT"
-            puts stderr "[string repeat - 40]"
-            foreach item $sorted {
-                puts stdout $item
-            }
-            
-            test_pass_fail_message $is_match  $msg
-        }
-
-        #return [expr {!$is_match}]
-
-    }
-
-    #tcl dispatch order - non flag items up front
-    #trailing flags are paired even if supplied as solo flags e.g -l becomes -l 1
-    proc commandline_ls {args} {
-        set operands [list]
-        set posn 0
-        foreach a $args {
-          if {![string match -* $a]} {
-            lappend operands $a
-          } else {
-            set flag1_posn $posn
-            break
-          }
-          incr posn
-        }
-        set args [lrange $args $flag1_posn end]
-
-
-        set debug 0
-        set posn [lsearch $args -debug]
-        if {$posn > 0} {
-          if {[lindex $args $posn+1]} {
-              set debug [lindex $args $posn+1] 
-          }
-        }
-        if {$debug} {
-           puts stderr "|debug>commandline_ls got $args"
-        }
-
-        #if first operand not supplied - replace it with current working dir
-        if {[lindex $operands 0] eq "\uFFFF"} {
-            lset operands 0 [pwd]
-        }
-
-        set targets [list]
-        foreach op $operands {
-          if {$op ne "\uFFFF"} {
-              set opchars [split [file tail $op] ""]
-              if {"?" in $opchars || "*" in $opchars} {
-                lappend targets $op
-              } else {
-                #actual file or dir
-                set targetitem $op
-                set targetitem [file normalize $op]
-                if {![file exists $targetitem]} {
-                    if {$debug} {
-                      puts stderr "|debug>commandline_ls Unable to access path '$targetitem'"
-                    }
-                }
-                lappend targets $targetitem
-                if {$debug} {
-                  puts stderr "|debug>commandline_ls  listing for $targetitem"    
-                }
-             }
-          }
-        }
-        set args [check_flags -caller commandline_ls \
-          -return flagged|defaults \
-          -debugargs 0 \
-          -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0 -algorithm sort] \
-          -required {all} \
-          -extras {all} \
-          -soloflags {-v -l} \
-          -commandprocessors {} \
-          -values $args ]
-        if {$debug} {
-            puts stderr "|debug>args: $args"
-        }
-
-
-        set algorithm [dict get $args -algorithm]
-        dict unset args -algorithm
-
-        set allfolders [list]
-        set allfiles [list]
-        foreach item $targets {
-            if {[file exists $item]} {
-                if {[file type $item] eq "directory"} {
-                  set dotfolders [glob -nocomplain -directory $item -type {d} -tail .*]
-                  set folders [glob -nocomplain -directory $item -type {d} -tail *]
-                  set allfolders [concat $allfolders $dotfolders $folders]
-
-                  set dotfiles [glob -nocomplain -directory $item -type {f} -tail .*]
-                  set files [glob -nocomplain -directory $item -type {f} -tail *]
-                  set allfiles [concat $allfiles $dotfiles $files]
-                } else {
-                  #file (or link?)
-                  set files [glob -nocomplain -directory [file dirname $item] -tail [file tail $item]]
-                  set allfiles [concat $allfiles $files]
-                }
-            } else {
-                 set folders [glob -nocomplain -directory $item -type {d} -tail [file tail $item]]
-                 set allfolders [concat $allfolders $folders]
-                 set files [glob -nocomplain -directory [file dirname $item] -tail [file tail $item]]
-                 set allfiles [concat $allfiles $files]
-            }
-        }
-
-
-        set sorted_folders [natsort::sort $allfolders {*}$args]
-        set sorted_files [natsort::sort $allfiles {*}$args]
-        
-        foreach fold $sorted_folders {
-            puts stdout $fold
-        }
-        foreach file $sorted_files {
-            puts stdout $file
-        }
-        
-        return "-- ok printed to stdout [llength $sorted_folders] folders and [llength $sorted_files] files --"
-    }
-
-    package require argp
-    argp::registerArgs commandline_test {
-      { -showsplits     boolean   0}
-      { -stacktrace     boolean   0}
-      { -debug          boolean   0}
-      { -winlike        boolean   0}
-      { -db             string   ":memory:"}
-      { -collate        string   "nocase"}
-      { -algorithm      string   "sort"}
-      { -topchars       string   "\uFFFF"}
-      { -testlist       string   {10 1 30 3}}
-    }
-    argp::setArgsNeeded commandline_test {-stacktrace}
-    proc commandline_test {test args} {
-      variable testlist
-      puts stdout "commandline_test got $args"
-      argp::parseArgs opts
-      puts stdout "commandline_test got [array get opts]"
-      set args [check_flags -caller natsort_commandline \
-        -return flagged|defaults \
-        -defaults [list -db :memory: -collate nocase -testlist $testlist -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] \
-        -values $args]
-
-      if {[string tolower $test] in [list "1" "true"]} {
-          set test "sort"
-      } else {
-        if {![llength [info commands $test]]} {
-          error "test $test not found"
-        }
-      }
-      dict unset args -test
-      set stacktrace [dict get $args -stacktrace]
-      # dict unset args -stacktrace
-
-      set argtestlist [dict get $args -testlist]
-      dict unset args -testlist 
-
-
-      set debug [dict get $args -debug]
-
-      set collate [dict get $args -collate]
-      set db      [dict get $args -db]
-      set winlike [dict get $args -winlike]
-      set topchars      [dict get $args -topchars]
-
-
-      puts stderr "|test>-----start natsort::$test--- input list size : [llength $argtestlist]"
-      #set resultlist [$test $argtestlist -db $db -collate $collate -topchars $topchars  -winlike $winlike]
-      set resultlist [$test  $argtestlist {*}$args]
-      foreach nm $resultlist {
-          puts stdout $nm
-      }
-      puts stdout "|test>-----end   natsort::$test--- sorted list size: [llength $resultlist]"
-      return "test end"
-    }
-    proc commandline_runtests {runtests args} {
-        set argvals [check_flags -caller commandline_runtests \
-          -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits "\uFFFF" -runtests 1] \
-          -values $args]
-
-        puts stderr "runtests args: $argvals"
-
-        #set runtests [dict get $argvals -runtests]
-        dict unset argvals -runtests
-        dict unset argvals -algorithm
-
-        puts stderr "runtests args: $argvals"
-        #exit 0
-
-        set test_prefix "::natsort::test_sort_"
-
-        if {$runtests eq "1"} {
-            set runtests "*"
-        }
-        
-
-        set testcommands [info commands ${test_prefix}${runtests}] 
-        if {![llength $testcommands]} {
-            puts stderr "No test commands matched -runtests argument '$runtests'"
-            puts stderr "Use 1 to run all tests"
-            set alltests [info commands ${test_prefix}*]
-            puts stderr "Valid tests are:"
-
-            set prefixlen [string length $test_prefix]
-            foreach t $alltests {
-                set shortname [string range $t $prefixlen end]
-                puts stderr "$t   =  -runtests  $shortname"
-            }
-
-        } else {
-            foreach cmd $testcommands {
-                puts stderr [string repeat - 40]
-                puts stderr "calling $cmd with args: '$argvals'"
-                puts stderr [string repeat - 40]
-                $cmd {*}$argvals
-            }
-        }
-        exit 0
-    }
-    proc help {args} {
-        puts stdout "natsort::help got '$args'"
-        return "Help not implemented"
-    }
-    proc natsort_pipe {args} {
-          #PIPELINE to take input list on stdin and write sorted list to stdout 
-          #strip - from arglist
-          #set args [check_flags -caller natsort_pipeline \
-          #  -return all \
-          #  -defaults [list -db :memory: -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] \
-          #  -values $args]
-
-          
-          set debug [dict get $args -debug]
-          if {$debug} {
-            puts stderr "|debug> natsort_pipe got args:'$args'"
-          }
-          set algorithm [dict get $args -algorithm]
-          dict unset args -algorithm 
-          
-          set proclist [info commands ::natsort::sort*]
-          set algos [list]
-          foreach p $proclist {
-              lappend algos [namespace tail $p]
-          }
-          if {$algorithm ni [list {*}$proclist {*}$algos]} {    
-              do_error "valid sort mechanisms: $algos" 2
-          }
-          
-          
-          set input_list [list]
-          while {![eof stdin]} {
-              if {[gets stdin line] > 0} {
-                  lappend input_list $line
-              } else {
-                  if {[eof stdin]} {
-                      
-                  } else {
-                      after 10
-                  }
-              }
-          }
-          
-          if {$debug} {
-              puts stderr "|debug> received [llength $input_list] list elements"
-          }
-              
-          set resultlist [$algorithm $input_list {*}$args]
-          if {$debug} {
-              puts stderr "|debug> returning [llength $resultlist] list elements"
-          }
-          foreach r $resultlist {
-              puts stdout $r
-          }
-          #exit 0    
-
-    } 
-    if {($is_called_directly)} {
-            set cmdprocessors {
-                {helpfinal {match "^help$" dispatch natsort::help}}
-                {helpfinal {sub -topic default "NONE"}}
-            }
-            #set args [check_flags \
-            #  -caller test1 \
-            #  -debugargs 2 \
-            #  -return arglist \
-            #  -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] \
-            #  -required {none} \
-            #  -extras {all} \
-            #  -commandprocessors $cmdprocessors \
-            #  -values $::argv ]
-            interp alias {} do_filter {} ::flagfilter::check_flags
-
-            #mashopts are generally single-letter opts that can be run together e.g -l -d  as -ld
-            set cmdprocessors {
-                {helpcmd {match "^help$" dispatch natsort::help singleopts {-v}}}
-                {helpcmd {sub -operand default \uFFFF singleopts {-l}}}
-                {lscmd  {match "^ls$" dispatch natsort::commandline_ls dispatchtype tcl dispatchglobal 1 mashopts {-l -a} singleopts {-l -a} pairopts {} longopts {--color=always}}}
-                {lscmd {sub dir default "\uFFFF"}}
-                {lscmd {sub dir2 default "\uFFFF"}}
-                {lscmd {sub dir3 default "\uFFFF"}}
-                {lscmd {sub dir4 default "\uFFFF"}}
-                {lscmd {sub dir5 default "\uFFFF"}}
-                {lscmd {sub dir6 default "\uFFFF"}}
-                {runtests {match "^-tests$" dispatch natsort::commandline_runtests singleopts {-l}}}
-                {runtests {sub testname  default "1" singleopts {-l}}}
-                {pipecmd {match "^-$"    dispatch natsort::natsort_pipe dispatchtype tcl}}
-            } 
-            set arglist [do_filter \
-              -debugargs 0 \
-              -debugargsonerror 2 \
-              -caller cline_dispatch1 \
-              -return all \
-              -soloflags {-v -x} \
-              -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0 ] \
-              -required {all} \
-              -extras {all} \
-              -commandprocessors $cmdprocessors \
-              -values $::argv ]
-
-
-            #mashopts are generally single-letter opts that can be run together e.g -l -d  as -ld
-            set cmdprocessors {
-                {testcmd {match "^test$" dispatch natsort::commandline_test singleopts {-l}}}
-                {testcmd {sub testname  default "1" singleopts {-l}}}
-            } 
-            set arglist [check_flags \
-              -debugargs 0 \
-              -caller cline_dispatch2 \
-              -return all \
-              -soloflags {-v -l} \
-              -defaults [list  -collate nocase -algorithm sort -testlist "1 2 3 10" -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0 ] \
-              -required {all} \
-              -extras {all} \
-              -commandprocessors $cmdprocessors \
-              -values $::argv ]
-
-
-
-
-            #set cmdprocessors [list]
-            #set args [check_flags -caller test1 -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] -required {all} -extras {none} -commandprocessors $cmdprocessors -values $::argv ]
-
-            #set args [check_flags -caller test1 -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] -required {all} -extras {none} -commandprocessors {-cmd {-cmd -cmdarg1 -default "."} {-cmd -cmdarg2 -default j}} -values $::argv ]
-            #set args [check_flags -caller test1 -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] -required {all} -extras {none} -commandprocessors {{-cmd -default help} {-cmd -cmdarg1 -default "."} {-cmd -cmdarg2 -default j}} -values $::argv ]
-            #set args [check_flags -caller test1 -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] -required {all} -extras {none} -commandprocessors {ls {ls lsdir -default "\uFFFF"}} -values $::argv ]
-
-            exit 0
-
-        if {$::argc} {
-            
-        }
-    }
-}
-
-
-package provide natsort [namespace eval natsort {
-    variable version
-    set version 0.1.1.5
-}]
-
-
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/oolib-0.1.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/oolib-0.1.tm
deleted file mode 100644
index 3756fceb..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/oolib-0.1.tm
+++ /dev/null
@@ -1,195 +0,0 @@
-#JMN - api should be kept in sync with package patternlib where possible
-#
-package provide oolib [namespace eval oolib {
-    variable version
-    set version 0.1
-}]
-
-namespace eval oolib {
-    oo::class create collection {
-        variable o_data ;#dict
-        variable o_alias
-        constructor {} {
-            set o_data [dict create]
-        }
-        method info {} {
-            return [dict info $o_data]
-        }
-        method count {} {
-            return [dict size $o_data]
-        }
-        method isEmpty {} {
-            expr {[dict size $o_data] == 0}
-        }
-        method names {{globOrIdx {}}} {
-            if {[llength $globOrIdx]} {
-                if {[string is integer -strict $globOrIdx]} {
-                    if {$idx < 0} {
-                        set idx "end-[expr {abs($idx + 1)}]"
-                    }
-                    if {[catch {lindex [dict keys $o_data] $idx} result]} {
-                        error "[self object] no such index : '$idx'"
-                    } else {
-                        return $result
-                    }
-                } else {
-                    #glob
-                    return [lsearch -glob -all -inline [dict keys $o_data] $globOrIdx]
-                }
-            } else {
-                return [dict keys $o_data]
-            }
-        }
-        #like names but without globbing
-        method keys {} {
-            dict keys $o_data
-        }
-        method key {{posn 0}} {
-            if {$posn < 0} {
-                set posn "end-[expr {abs($posn + 1)}]"
-            }
-            if {[catch {lindex [dict keys $o_data] $posn} result]} {
-                error "[self object] no such index : '$posn'"
-            } else {
-                return $result
-            }
-        }
-        method hasKey {key} {
-            dict exists $o_data $key
-        }
-        method get {} {
-            return $o_data
-        }
-        method items {} {
-            return [dict values $o_data]
-        }
-        method item {key} {
-            if {[string is integer -strict $key]} {
-                if {$key > 0} {
-                    set valposn [expr {(2*$key) +1}]
-                    return [lindex $o_data $valposn]
-                } else {
-                    set key "end-[expr {abs($key + 1)}]"
-                    return [lindex [dict keys $o_data] $key]
-                }
-            }
-            if {[dict exists $o_data $key]} {
-                return [dict get $o_data $key]
-            }
-        }
-        #inverse lookup
-        method itemKeys {value} {
-            set value_indices [lsearch -all [dict values $o_data] $value]
-            set keylist [list]
-            foreach i $value_indices {
-                set idx [expr {(($i + 1) *2) -2}]
-                lappend keylist [lindex $o_data $idx]
-            }
-            return $keylist
-        }
-        method search {value args} {
-            set matches [lsearch {*}$args [dict values $o_data] $value]
-            if {"-inline" in $args} {
-                return $matches
-            } else {
-                set keylist [list]
-                foreach i $matches {
-                    set idx [expr {(($i + 1) *2) -2}]
-                    lappend keylist [lindex $o_data $idx]
-                }
-                return $keylist
-            }
-        }
-        #review - see patternlib. Is the intention for aliases to be configurable independent of whether the target exists?
-        method alias {newAlias existingKeyOrAlias} {
-            if {[string is integer -strict $newAlias]} {
-                error "[self object] collection key alias cannot be integer"
-            }
-            if {[string length $existingKeyOrAlias]} {
-                set o_alias($newAlias) $existingKeyOrAlias
-            } else {
-                unset o_alias($newAlias)
-            }
-        }
-        method aliases {{key ""}} {
-            if {[string length $key]} {
-                set result [list]
-                foreach {n v} [array get o_alias] {
-                    if {$v eq $key} {
-                        lappend result $n $v
-                    }
-                }		
-                return $result
-            } else {
-                return [array get o_alias]
-            }
-        }
-        #if the supplied index is an alias, return the underlying key; else return the index supplied.
-        method realKey {idx} {
-            if {[catch {set o_alias($idx)} key]} {
-                return $idx
-            } else {
-                return $key
-            }
-        }
-        method add {value key} {
-            if {[string is integer -strict $key]} {
-                error "[self object] collection key must not be an integer. Use another structure if integer keys required"
-            }
-            if {[dict exists $o_data $key]} {
-                error "[self object] col_processors object error: key '$key' already exists in collection"
-            }
-            dict set o_data $key $value
-            return [expr {[dict size $o_data] - 1}] ;#return index of item
-        }
-        method remove {idx {endRange ""}} {
-            if {[string length $endRange]} {
-                error "[self object] collection error: ranged removal not yet implemented.. remove one item at a time"
-            }
-            if {[string is integer -strict $idx]} {
-                if {$idx < 0} {
-                    set idx "end-[expr {abs($idx+1)}]"
-                }
-                set key [lindex [dict keys $o_data] $idx]
-                set posn $idx
-            } else {
-                set key $idx
-                set posn [lsearch -exact [dict keys $o_data] $key]
-                if {$posn < 0} {
-                    error "[self object] no such index: '$idx' in this collection"
-                }
-            }
-            dict unset o_data $key
-            return
-        }
-        method clear {} {
-            set o_data [dict create]
-            return
-        }
-        method reverse {} {
-            set dictnew [dict create]
-            foreach k [lreverse [dict keys $o_data]] {
-                dict set dictnew $k [dict get $o_data $k]
-            }
-            set o_data $dictnew
-            return
-        }
-        #review - cmd as list vs cmd as script?
-        method map {cmd} {
-            set seed [list]
-            dict for {k v} $o_data {
-                lappend seed [uplevel #0 [list {*}$cmd $v]]
-            }
-            return $seed
-        }
-        method objectmap {cmd} {
-            set seed [list]
-            dict for {k v} $o_data {
-                lappend seed [uplevel #0 [list $v {*}$cmd]]
-            }
-            return $seed
-        }
-    }
-
-}
-
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap-0.1.0.tm
deleted file mode 100644
index 1c70a227..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap-0.1.0.tm
+++ /dev/null
@@ -1,663 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::cap 0.1.0
-# Meta platform     tcl
-# Meta description  pkg capability register
-# Meta license      BSD
-# @@ Meta End
-
-
-#*** !doctools
-#[manpage_begin punkshell_module_punk::cap 0 0.1.0]
-#[copyright "2023 JMNoble - BSD licensed"]
-#[titledesc {capability provider and handler plugin system}]
-#[moddesc {punk capabilities plugin system}]
-#[require punk::cap]
-#[description]
-#[keywords module capability plugin]
-#[section Overview]
-#[para]punk::cap provides management of named capabilities and the provider packages and handler packages that implement a pluggable capability.
-#[para]see also [uri https://core.tcl-lang.org/tcllib/doc/trunk/embedded/md/tcllib/files/modules/pluginmgr/pluginmgr.md {tcllib pluginmgr}] for an alternative which uses safe interpreters
-#[subsection Concepts]
-#[para]A [term capability] may be something like providing a folder of files, or just a data dictionary, and/or an API 
-#
-#[para][term {capability handler}] - a package/namespace which may provide validation and standardised ways of looking up provider data
-# registered (or not) using register_capabilityname <capname> <capnamespace>
-#
-#[para][term {capability provider}] - a package which registers as providing one or more capablities.
-#[para]registered using register_package <pkg> <capabilitylist>
-#the capabilitylist is a list of 2-element lists where the first element is the capabilityname and the second element is a (possibly empty) dict of data relevant to that capability
-#A capabilityname may appear multiple times. ie a package may register that it provides the capability with multiple datasets.
-
-
-#*** !doctools
-#[section API]
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require oolib
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::cap {
-    variable pkgcapsdeclared [dict create] 
-    variable pkgcapsaccepted [dict create]
-    variable caps [dict create]
-    namespace eval class {
-        if {[info commands [namespace current]::interface_caphandler.registry] eq ""} {
-            #*** !doctools
-            #[subsection {Namespace punk::cap::class}]
-            #[para] class definitions
-            #[list_begin itemized] [comment {- punk::cap::class groupings -}]
-            #  [item]
-            #  [para] [emph {handler_classes}]
-            #  [list_begin enumerated]
-
-            oo::class create [namespace current]::interface_caphandler.registry {
-                #*** !doctools
-                #[enum] CLASS [class interface_caphandler.registry]
-                #[list_begin definitions]
-                #    [para] [emph METHODS]
-                method pkg_register {pkg capname capdict fullcapabilitylist} {
-                    #*** !doctools
-                    #[call class::interface_caphandler.registry [method pkg_register] [arg pkg] [arg capname] [arg capdict] [arg fullcapabilitylist]]
-                    #handler may override and return 0 (indicating don't register)e.g if pkg capdict data wasn't valid
-                    #overridden handler must be able to handle multiple calls for same pkg - but it may return 1 or 0 as it wishes. 
-                    return 1 ;#default to permit 
-                }
-                method pkg_unregister {pkg} {
-                    #*** !doctools
-                    #[call class::interface_caphandler.registry [method pkg_unregister] [arg pkg]]
-                    return ;#unregistration return is ignored - review
-                }
-                #*** !doctools
-                #[list_end]
-            }
-
-            oo::class create [namespace current]::interface_caphandler.sysapi {
-                #*** !doctools
-                #[enum] CLASS [class interface_caphandler.sysapi]
-                #[list_begin definitions]
-                #    [para] [emph METHODS]
-
-
-                #*** !doctools
-                #[list_end]
-            }
-
-            #*** !doctools
-            #  [list_end] [comment {- end enumeration handler classes -}]
-
-            #*** !doctools
-            #  [item]
-            #  [para] [emph {provider_classes}]
-            #  [list_begin enumerated]
-
-            #Provider classes
-            oo::class create [namespace current]::interface_capprovider.registration {
-                #*** !doctools
-                #    [enum] CLASS [class interface_cappprovider.registration]
-                #    [para]Your provider package will need to instantiate this object under a sub-namespace called [namespace capsystem] within your package namespace. 
-                #    [para]If your package namespace is mypackages::providerpkg then the object command would be at mypackages::providerpkg::capsystem::capprovider.registration
-                #    [para]Example code for your provider package to evaluate within its namespace: 
-                #    [example {
-                #namespace eval capsystem {
-                #    if {[info commands capprovider.registration] eq ""} {
-                #        punk::cap::class::interface_capprovider.registration create capprovider.registration
-                #        oo::objdefine capprovider.registration {
-                #            method get_declarations {} {
-                #                set decls [list]
-                #                lappend decls [list punk.templates {relpath ../templates}]
-                #                lappend decls [list another_capability_name {somekey blah key2 etc}]
-                #                return $decls
-                #            }
-                #        }
-                #    }
-                #}
-                #}]
-                #[para] The above example declares that your package can be registered as a provider for the capabilities named 'punk.templates' and 'another_capability_name'
-                #    [list_begin definitions]
-                #    [para] [emph METHODS]
-                method get_declarations {} {
-                    #***
-                    #[call class::interface_capprovider.registration [method get_declarations]]
-                    #[para] This method must be overridden by your provider using oo::objdefine cappprovider.registration as in the example above.
-                    # There must be at least one 2-element list in the result for the provider to be registerable.
-                    #[para]The first element of the list is the capabilityname - which can be custom to your provider/handler packages - or a well-known name that other authors may use/implement.
-                    #[para]The second element is a dictionary of keys specific to the capability being implemented. It may be empty if the any potential capability handlers for the named capability don't require registration data.  
-                    error "interface_capprovider.registration not implemented by provider"
-                }
-                #*** !doctools
-                #    [list_end]
-            }
-
-            oo::class create [namespace current]::interface_capprovider.provider {
-                #*** !doctools
-                #    [enum] CLASS [class interface_capprovider.provider] 
-                #    [para] Your provider package will need to instantiate this directly under it's own namespace with the command name of [emph {provider}] 
-                #    [example {
-                #       namespace eval mypackages::providerpkg { 
-                #           punk::cap::class::interface_capprovider.provider create provider mypackages::providerpkg 
-                #       }
-                #    }]
-                #    [list_begin definitions]
-                #    [para] [emph METHODS]
-                variable provider_pkg
-                variable registrationobj
-                constructor {providerpkg} {
-                    #*** !doctools
-                    #[call class::interface_capprovider.provider [method constructor] [arg providerpkg]]
-                    variable provider_pkg
-                    if {$providerpkg in [list "" "::"]} {
-                        error "interface_capprovider.provider constructor error. Invalid provider '$providerpkg'"
-                    }
-                    if {![namespace exists ::$providerpkg]} {
-                        error "interface_capprovider.provider constructor error. Invalid provider '$providerpkg' - matching namespace not found"
-                    }
-
-                    set registrationobj ::${providerpkg}::capsystem::capprovider.registration
-                    if {[info commands $registrationobj] eq ""} {
-                        error "capprovider.provider constructor error. Missing capprovider.registration interface at '$obj' (command not found) interface_capprovider.regstration instantiation must precede interface_capprovider.provider"
-                    }
-
-                    set provider_pkg [string trim $providerpkg ""]
-
-                }
-                method register {{capabilityname_glob *}} {
-                    #*** !doctools
-                    #[comment {- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---}]
-                    #[call class::interface_capprovider.provider [method register] [opt capabilityname_glob]]
-                    #
-                    #[para]This is the mechanism by which a user of your provider package will register your package as a provider of the capability named.
-                    #
-                    #[para]A user of your provider may elect to register all your declared capabilities:
-                    #[example {
-                    #  package require mypackages::providerpkg
-                    #  mypackages::providerpkg::provider register *
-                    #}]
-                    #[para] Or a specific capability may be registered:
-                    #[example {
-                    #  package require mypackages::providerpkg
-                    #  mypackages::providerpkg::provider register another_capability_name
-                    #}]
-                    #
-                    variable provider_pkg
-                    set all_decls [$registrationobj get_declarations]
-                    set register_decls [lsearch -all -inline -index 0 $all_decls $capabilityname_glob]
-                    punk::cap::register_package $provider_pkg $register_decls
-                }
-                method capabilities {} {
-                    #*** !doctools
-                    #[comment {- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---}]
-                    #[call class::interface_capprovider.provider [method capabilities]]
-                    #[para] return a list of capabilities supported by this provider package
-                    variable provider_pkg
-                    variable registrationobj
-
-                    set capabilities [list]
-                    set decls [$registrationobj get_declarations]
-                    foreach decl $decls {
-                        lassign $decl capname capdict
-                        if {$capname ni $capabilities} {
-                            lappend capabilities $capname
-                        }
-                    }
-                    return $capabilities
-                }
-                #*** !doctools
-                #    [list_end] [comment {- end class definitions -}]
-            }
-            #*** !doctools
-            #  [list_end] [comment {- end enumeration provider_classes }]
-            #[list_end] [comment {- end itemized list punk::cap::class groupings -}]
-        }
-    } ;# end namespace class
-
-    #*** !doctools
-    #[subsection {Namespace punk::cap}]
-    #[para] Main punk::cap API for client programs interested in using capability handler packages and associated (registered) provider packages
-    #[list_begin definitions]
-
-    #Not all capability names have to be registered.
-    #A package registering as a provider using register_package can include capabilitynames in it's capabilitylist which have no associated handler.
-    #such unregistered capabilitynames may be used just to flag something, or have datamembers significant to callers cooperatively interested in that capname. 
-    #we allow registering a capability with an empty handler (capnamespace) - but this means another handler could be registered later.
-    proc register_capabilityname {capname capnamespace} {
-        variable caps
-        variable pkgcapsdeclared
-        variable pkgcapsaccepted
-        if {$capnamespace ne ""} {
-            #normalize with leading :: in case caller passed in package name rather than fully qualified namespace
-            if {![string match ::* $capnamespace]} {
-                set capnamespace ::$capnamespace
-            }
-        }
-        #allow register of existing capname iff there is no current handler
-        #as handlers can be used to validate during provider registration - ideally handlers should be registered before any pkgs call register_package 
-        #we allow loading a handler later though - but will need to validate existing data from pkgs that have already registered as providers 
-        if {[set hdlr [capability_get_handler $capname]] ne ""} {
-            error "register_capabilityname cannot register capability:$capname with handler:$capnamespace. There is already a registered handler:$hdlr" 
-        }
-        #assert: capnamespace may or may not be empty string, capname may or may not already exist in caps dict, caps $capname providers may have existing entries.
-        dict set caps $capname handler $capnamespace
-        if {![dict exists $caps $capname providers]} {
-            dict set caps $capname providers [list]
-        }
-        if {[llength [set providers [dict get $caps $capname providers]]]} {
-            #some provider(s) were in place before the handler was registered
-            if {[set capreg [punk::cap::capsystem::get_caphandler_registry $capname]] ne ""} {
-                foreach pkg $providers {
-                    set fullcapabilitylist [dict get $pkgcapsdeclared $pkg]
-                    foreach capspec $fullcapabilitylist {
-                        lassign $capspec cn capdict
-                        if {$cn ne $capname} {
-                            continue
-                        }
-                        set do_register [$capreg pkg_register $pkg $capdict $fullcapabilitylist]
-                        set list_accepted [dict get $pkgcapsaccepted $pkg]
-                        if {$do_register} {
-                            if {$capspec ni $list_accepted} {
-                                dict lappend pkgcapsaccepted $pkg $capspec
-                            }
-                        } else {
-                            set posn [lsearch $list_accepted $capspec]
-                            if {$posn >=0} {
-                                set list_accepted [lreplace $list_accepted $posn $posn]
-                                dict set pkgcapsaccepted $pkg $list_accepted
-                            }
-                        }
-                    }
-                    #check if any accepted for this cap and remove from caps as necessary
-                    set count 0
-                    foreach accepted_capspec [dict get $pkgcapsaccepted $pkg] {
-                        if {[lindex $accepted_capspec 0] eq $capname} {
-                            incr count
-                        }
-                    }
-                    if {$count == 0} {
-                        set pkgposn [lsearch $providers $pkg]
-                        if {$pkgposn >= 0} {
-                           set updated_providers [lreplace $providers $posn $posn] 
-                           dict set caps $capname providers $updated_providers
-                        }
-                    }
-                }
-
-            }
-            
-        }
-    }
-    proc capability_exists {capname} {
-        #*** !doctools
-        # [call [fun capability_exists] [arg capname]]
-        # Return a boolean indicating if the named capability exists  (0|1)
-        variable caps
-        return [dict exists $caps $capname]
-    }
-    proc capability_has_handler {capname} {
-        #*** !doctools
-        # [call [fun capability_has_handler] [arg capname]]
-        #Return a boolean indicating if the named capability has a handler package installed (0|1)
-        variable caps
-        return [expr {[dict exists $caps $capname handler] && [dict get $caps $capname handler] ne ""}]
-    }
-    proc capability_get_handler {capname} {
-        #*** !doctools
-        # [call [fun capability_get_handler] [arg capname]]
-        #Return the base namespace of the active handler package for the named capability.
-        #[para] The base namespace for a handler will always be the package name, but prefixed with ::
-        variable caps
-        if {[dict exists $caps $capname]} {
-            return [dict get $caps $capname handler]
-        }
-        return "" 
-    }
-    proc call_handler {capname args} {
-        if {[set handler [capability_get_handler $capname]] eq ""} {
-            error "punk::cap::call_handler $capname $args - no handler registered for capability $capname"
-        }
-        set obj ${handler}::api_$capname
-        $obj [lindex $args 0] {*}[lrange $args 1 end]
-    }
-    proc get_providers {capname} {
-        variable caps
-        if {[dict exists $caps $capname]} {
-            return [dict get $caps $capname providers]
-        }
-        return [list]
-    }
-
-    #register package with arbitrary capnames from capabilitylist
-    #The registered pkg is a module that provides some service to that capname. Possibly just data members, that the capability will use.
-    proc register_package {pkg capabilitylist args} {
-        variable pkgcapsdeclared
-        variable pkgcapsaccepted
-        variable caps
-        set defaults [dict create\
-            -nowarnings false
-        ]
-        dict for {k v} $args {
-            if {$k ni $defaults} {
-                error "Unrecognized option $k. Known options [dict keys $defaults]"
-            }
-        }
-        set opts [dict merge $defaults $args]
-        set warnings [expr {! [dict get $opts -nowarnings]}]
-
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {[dict exists $pkgcapsaccepted $pkg]} {
-            set pkg_already_accepted [dict get $pkgcapsaccepted $pkg]
-        } else {
-            set pkg_already_accepted [list]
-        }
-        package require $pkg
-        set providerapi ::${pkg}::provider
-        if {[info commands $providerapi] eq ""} {
-            error "register_package error. pkg '$pkg' doesn't seem to be a punk::cap capability provider (no object found at $providerapi)"
-        }
-        set defined_caps [$providerapi capabilities]
-        #for each capability
-        # - ensure 1st element is a single word
-        # - ensure that if 2nd element (capdict) is present - it is dict shaped
-        foreach capspec $capabilitylist {
-            lassign $capspec capname capdict
-
-            if {$warnings} {
-                if {$capname ni $defined_caps} {
-                    puts stderr "WARNING: pkg '$pkg' doesn't declare support for capability '$capname'."
-                }
-            }
-            if {[llength $capname] !=1} {
-                error "register_package error. pkg: '$pkg' An entry in the capability list doesn't appear to have a single-word name. Problematic entry:'$capspec'"
-            }
-            if {[expr {[llength $capdict] %2 != 0}]} {
-                error "register_package error. pkg:'$pkg' The second element for capname:'$capname' doesn't appear to be a valid dict. Problematic entry: '$capspec'"
-            }
-            if {$capspec in $pkg_already_accepted} {
-                #review - multiple handlers? if so - will need to record which handler(s) accepted the capspec
-                if {$warnings} {
-                    puts stderr "WARNING: register_package pkg $pkg already has capspec marked as accepted: $capspec"
-                }
-                continue
-            }
-            if {[dict exists $caps $capname]} {
-                set cap_pkgs [dict get $caps $capname providers]
-            } else {
-                dict set caps $capname [dict create handler "" providers [list]]
-                set cap_pkgs [list]
-            }
-            #todo  - if there's a caphandler - call it's init/validation callback for the pkg
-            set do_register 1 ;#default assumption unless vetoed by handler
-            if {[set capreg [punk::cap::capsystem::get_caphandler_registry $capname]] ne ""} {
-                #Note that the interface_caphandler.registry instance must be able to handle multiple calls for same pkg
-                set do_register [$capreg pkg_register $pkg $capname $capdict $capabilitylist]
-            }
-            if {$do_register} {
-                if {$pkg ni $cap_pkgs} {
-                    lappend cap_pkgs $pkg
-                    dict set caps $capname providers $cap_pkgs
-                }
-                dict lappend pkgcapsaccepted $pkg $capspec ;#if pkg is being registered prior to handler-registration - the handler may undo this entry
-            }
-        }
-        #another call to register_pkg with same pkg may have been made (most likely with different capname) so we must append - but check not already present
-        #dict lappend pkgcapsdeclared $pkg $capabilitylist
-        if {[dict exists $pkgcapsdeclared $pkg]} {
-            set capspecs [dict get $pkgcapsdeclared $pkg]
-            foreach spec $capspecs {
-                if {$spec ni $capspecs} {
-                    lappend capspecs $spec
-                }
-            }
-            dict set pkgcapsdeclared $pkg $capspecs
-        } else {
-            dict set pkgcapsdeclared $pkg $capabilitylist
-        }
-    }
-
-    #todo!
-    proc unregister_package {pkg {capname *}} {
-        variable pkgcapsdeclared	
-        variable caps
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {[dict exists $pkgcapsdeclared $pkg]} {
-            #remove corresponding entries in caps
-            set capabilitylist [dict get $pkgcapsdeclared $pkg]
-            foreach c $capabilitylist {
-                set do_unregister 1
-                lassign $c capname _capdict 
-                set cap_info [dict get $caps $capname]
-                set pkglist [dict get $cap_info providers]
-                set posn [lsearch $pkglist $pkg]
-                if {$posn >= 0} {
-                    if {[set capreg [punk::cap::capsystem::get_caphandler_registry $capname]] ne ""} {
-                        #review
-                        # it seems not useful to allow the callback to block this unregister action
-                        #the pkg may have multiple datasets for each capname so callback will only be called for first dataset we encounter  
-                        #vetoing unregister would make this more complex for no particular advantage 
-                        #if per dataset deregistration required this should probably be a separate thing 
-                        $capreg pkg_unregister $pkg $capname
-                    }
-                    set pkglist [lreplace $pkglist $posn $posn]
-                    dict set caps $capname providers $pkglist
-                }
-            }
-            #delete the main registration record
-            dict unset pkgcapsdeclared $pkg
-        }
-    }
-
-    proc pkgcap {pkg} {
-        variable pkgcapsdeclared
-        variable pkgcapsaccepted
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {[dict exists $pkgcapsdeclared $pkg]} {
-            set accepted ""
-            if {[dict exists $pkgcapsaccepted $pkg]} {
-                set accepted [dict get $pkgcapsaccepted $pkg]
-            }
-            return [dict create declared [dict get $pkgcapsdeclared $pkg] accepted $accepted]
-        } else {
-            return
-        }
-    }
-    proc pkgcaps {} {
-        variable pkgcapsdeclared	
-        variable pkgcapsaccepted
-        set result [dict create]
-        foreach {pkg capsdeclared} $pkgcapsdeclared {
-            set accepted ""
-            if {[dict exists $pkgcapsaccepted $pkg]} {
-                set accepted [dict get $pkgcapsaccepted $pkg]
-            }
-            dict set result $pkg declared $capsdeclared
-            dict set result $pkg accepted $accepted
-        }
-        return $result
-    }	
-
-    proc capability {capname} {
-        variable caps
-        if {[dict exists $caps $capname]} {
-            return [dict get $caps $capname]
-        }
-        return ""
-    }
-    proc capabilities {{glob *}} {
-        variable caps
-        set capnames [lsort [dict keys $caps $glob]]
-        set cap_list [list]
-        foreach capname $capnames {
-            lappend cap_list [list $capname [dict get $caps $capname]]
-        }
-        return $cap_list
-    }
-
-    proc capabilitynames {{glob *}} {
-        variable caps
-        return [lsort [dict keys $caps $glob]]
-    }
-    #return only those capnames which have at least one provider
-    proc capabilitynames_provided {{glob *}} {
-        variable caps
-        set keys [lsort [dict keys $caps $glob]]
-        set cap_list [list]
-        foreach k $keys {
-            if {[llength [dict get $caps $k providers]] > 0} {
-                lappend cap_list $k
-            }
-        }
-        return $cap_list
-    }
-    #*** !doctools
-    #[list_end] [comment {- end definitions for namespace punk::cap -}]
-
-    namespace eval advanced {
-    #*** !doctools
-    #[subsection {Namespace punk::cap::advanced}]
-    #[para] punk::cap::advanced API. Functions here are generally not the preferred way to interact with punk::cap.
-    #[para] In some cases they may allow interaction in less safe ways or may allow use of features that are unavailable in the base namespace.
-    #[para] Some functions are here because they are only marginally or rarely useful, and they are here to keep the base API simple.  
-    #[list_begin definitions]
-
-    proc promote_provider {pkg} {
-        #*** !doctools
-        # [call advanced::[fun promote_provider] [arg pkg]]
-        #[para]Move the named provider package to the preferred end of the list (tail).
-        #[para]The active handler may or may not utilise this for preferencing. See documentation for the specific handler package to confirm. 
-        #[para]
-        #[para] promote/demote doesn't always make a lot of sense ..  should preferably be configurable per capapbility for multicap provider pkgs
-        #[para]The idea is to provide a crude way to preference/depreference packages independently of order the packages were loaded
-        #e.g a caller or cap-handler can ascribe some meaning to the order of the 'providers' key returned from punk::cap::capabilities <capname>
-        #[para]The order of providers will be the order the packages were loaded & registered
-        #[para]the naming: "promote vs demote" operates on a latest-package-in-list has higher preference assumption (matching last pkg loaded)
-        #[para]Each capability handler could and should implement specific preferencing methods within its own API if finer control needed.
-        #In some cases the preference/loading order may be inapplicable/irrelevant to a particular capability anyway.
-        #[para]As this is just a basic mechanism, which can't support independent per-cap preferencing for multi-cap packages -
-        # it only allows putting the pkgs to the head or tail of the lists.
-        #[para]Whether particular caps or users of caps do anything with this ordering is dependent on the cap-handler and/or calling code.
-        variable pkgcapsdeclared
-        variable caps
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {![dict exists $pkgcapsdeclared $pkg]} {
-            error "punk::cap::promote_package error pkg'$pkg' not registered. Use register_package \$pkg first"
-        }
-        if {[dict size $pkgcapsdeclared] > 1} {
-            set pkginfo [dict get $pkgcapsdeclared $pkg]
-            #remove and re-add at end of dict
-            dict unset pkgcapsdeclared $pkg
-            dict set pkgcapsdeclared $pkg $pkginfo
-            dict for {cap cap_info} $caps {
-                set cap_pkgs [dict get $cap_info providers]
-                if {$pkg in $cap_pkgs} {
-                    set posn [lsearch $cap_pkgs $pkg]
-                    if {$posn >=0} {
-                        #rewrite package list with pkg at tail of list for this capability
-                        set cap_pkgs [lreplace $cap_pkgs $posn $posn]
-                        lappend cap_pkgs $pkg
-                        dict set caps $cap providers $cap_pkgs
-                    }
-                }
-            }
-        }
-    }
-    proc demote_provider {pkg} {
-        #*** !doctools
-        # [call advanced::[fun demote_provider] [arg pkg]]
-        #[para]Move the named provider package to the preferred end of the list (tail).
-        #[para]The active handler may or may not utilise this for preferencing. See documentation for the specific handler package to confirm. 
-        variable pkgcapsdeclared
-        variable caps
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {![dict exists $pkgcapsdeclared $pkg]} {
-            error "punk::cap::promote_package error pkg'$pkg' not registered. Use register_package \$pkg first"
-        }
-        if {[dict size $pkgcapsdeclared] > 1} {
-            set pkginfo [dict get $pkgcapsdeclared $pkg]
-            #remove and re-add at start of dict
-            dict unset pkgcapsdeclared $pkg
-            dict set pkgcapsdeclared $pkg $pkginfo
-            set pkgcapsdeclared [dict merge [dict create $pkg $pkginfo] $pkgcapsdeclared]
-            dict for {cap cap_info} $caps {
-                set cap_pkgs [dict get $cap_info providers]
-                if {$pkg in $cap_pkgs} {
-                    set posn [lsearch $cap_pkgs $pkg]
-                    if {$posn >=0} {
-                        #rewrite package list with pkg at head of list for this capability
-                        set cap_pkgs [lreplace $cap_pkgs $posn $posn]
-                        set cap_pkgs [list $pkg {*}$cap_pkgs]
-                        dict set caps $cap providers $cap_pkgs
-                    }
-                }
-            }
-        }
-    }
-
-    #*** !doctools
-    #[list_end]
-    }
-
-
-#*** !doctools
-#[section Internal]
-
-    namespace eval capsystem {
-        #*** !doctools
-        #[subsection {Namespace punk::cap::capsystem}]
-        #[para] Internal functions used to communicate between punk::cap and capability handlers
-        #[list_begin definitions]
-        proc get_caphandler_registry {capname} {
-            set ns [::punk::cap::capability_get_handler $capname]::capsystem
-            if {[namespace exists ${ns}]} {
-                if {[info command ${ns}::caphandler.registry] ne ""} {
-                    if {[info object isa object ${ns}::caphandler.registry]} {
-                        return ${ns}::caphandler.registry
-                    }
-                }
-            }
-            return ""
-        }
-        #*** !doctools
-        #[list_end]
-    }
-}
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::cap [namespace eval punk::cap {
-    variable version
-    variable pkg punk::cap
-    set version 0.1.0 
-    variable README.md  [string map [list %pkg% $pkg %ver% $version] {
-        # punk capabilities system
-        ## pkg: %pkg% version: %ver%
-
-        punk::cap base namespace
-    }]
-    return $version
-}]
-return
-
-#*** !doctools
-#[manpage_end]
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap/handlers/caphandler-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap/handlers/caphandler-0.1.0.tm
deleted file mode 100644
index 8fdce944..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap/handlers/caphandler-0.1.0.tm
+++ /dev/null
@@ -1,52 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::cap::handlers::caphandler 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::cap::handlers::caphandler {
-
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::cap::handlers::caphandler [namespace eval punk::cap::handlers::caphandler {
-    variable pkg punk::cap::handlers::caphandler
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap/handlers/scriptlibs-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap/handlers/scriptlibs-0.1.0.tm
deleted file mode 100644
index 8298ec18..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap/handlers/scriptlibs-0.1.0.tm
+++ /dev/null
@@ -1,52 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::cap::handlers::scriptlibs 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::cap::handlers::scriptlibs {
-
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::cap::handlers::scriptlibs [namespace eval punk::cap::handlers::scriptlibs {
-    variable pkg punk::cap::handlers::scriptlibs
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm
deleted file mode 100644
index 75a925dd..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm
+++ /dev/null
@@ -1,145 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::cap::handlers::templates 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#register using:
-# punk::cap::register_capabilityname templates ::punk::cap::handlers::templates 
-
-#By convention and for consistency, we don't register here during package loading - but require the calling app to do it.
-# (even if it tends to be done immediately after package require anyway)
-# registering capability handlers can involve validating existing provider data and is best done explicitly as required.
-# It is also possible for a capability handler to be registered to handle more than one capabilityname
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::cap::handlers::templates {
-    namespace eval capsystem {
-        #interfaces for punk::cap to call into
-        if {[info commands caphandler.registry] eq ""} {
-            punk::cap::class::interface_caphandler.registry create caphandler.registry
-            oo::objdefine caphandler.registry {
-                method pkg_register {pkg capname capdict caplist} {
-                    #caplist may not be complete set - which somewhat reduces its utility here regarding any decisions based on the context of this capname/capdict (review - remove this arg?)
-
-                    # -- --- --- --- --- --- --- ---- ---
-                    # validation of capdict
-                    # -- --- --- --- --- --- --- ---- ---
-                    if {![dict exists $capdict relpath]} {
-                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg'  is attempting to register with punk::cap as a provider of '$capname' capability, but is missing 'relpath' key"
-                        return 0
-                    }
-                    set provide_statement [package ifneeded $pkg [package require $pkg]]
-                    set tmfile [lindex $provide_statement end]
-                    if {![file exists $tmfile]} {
-                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - unable to determine base folder for package '$pkg' which is attempting to register with punk::cap as a provider of '$capname' capability"
-                        return 0
-                    }
-                    set tpath [file normalize [file join $tmfile [dict get $capdict relpath]]] ;#relpath is relative to the tm *file* - not it's containing folder
-                    if {![file isdirectory $tpath]} {
-                        puts stderr "punk::cap::handlers::templates::capsystem pkg_register WARNING - unable to validate relpath location [dict get $capdict relpath] ($tpath) for package '$pkg' which is attempting to register with punk::cap as a provider of '$capname' capability"
-                        return 0
-                    }
-
-
-                    # -- --- --- --- --- --- --- ---- ---
-                    # update package internal data 
-                    # -- --- --- --- --- --- --- ---- ---
-                    if {$capname ni $::punk::cap::handlers::templates::handled_caps} {
-                        lappend ::punk::cap::handlers::templates::handled_caps $capname
-                    }
-                    set cname [string map [list . _] $capname]
-                    upvar ::punk::cap::handlers::templates::pkg_folders_$cname pfolders
-                    dict lappend pfolders $pkg $tpath
-
-
-                    # -- --- --- --- --- --- --- ---- ---
-                    # instantiation of api at punk::cap::handlers::templates::api_$capname 
-                    # -- --- --- --- --- --- --- ---- ---
-                    if {[info commands ::punk::cap::handlers::templates::$capname] eq ""} {
-                        punk::cap::handlers::templates::class::api create ::punk::cap::handlers::templates::api_$capname $capname
-                    }
-
-                    return 1
-                }
-                method pkg_unregister {pkg} {
-                    upvar ::punk::cap::handlers::templates::handled_caps hcaps
-                    foreach capname $hcaps {
-                        set cname [string map [list . _] $capname]
-                        upvar ::punk::cap::handlers::templates::pkg_folders_$cname pfolders
-                        dict unset pfolders $pkg
-                        #destroy api objects?
-                    }
-                }
-            } 
-        }
-    }
-
-    variable handled_caps [list]
-    #variable pkg_folders [dict create]
-
-    # -- --- --- --- --- --- ---
-    #handler api for clients of this capability - called via punk::cap::call_handler <capname> <method> ?args?
-    # -- --- --- --- --- --- ---
-    namespace export *
-    namespace eval class {
-        oo::class create api {
-            #return a dict keyed on folder with source pkg as value
-            constructor {capname} {
-                variable capabilityname
-                variable cname
-                set cname [string map [list . _] $capname]
-                set capabilityname $capname
-            }
-            method folders {} {
-                variable capabilityname
-                variable cname
-                upvar punk::cap::handlers::templates::pkg_folders_$cname pkg_folders
-                package require punk::cap
-                set capinfo [punk::cap::capability $capabilityname]
-                # e.g {punk.templates {handler punk::mix::templates providers ::somepkg}}
-
-                #use the order of pkgs as registered with punk::cap - may have been modified with punk::cap::promote_package/demote_package
-                set pkgs [dict get $capinfo providers]
-                set folderdict [dict create]
-                foreach pkg $pkgs { 
-                    foreach pfolder [dict get $pkg_folders $pkg] {
-                        dict set folderdict $pfolder [list source $pkg sourcetype package]
-                    }
-                }
-                return $folderdict
-            }
-        }
-    }
-
-
-
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::cap::handlers::templates [namespace eval punk::cap::handlers::templates {
-    variable pkg punk::cap::handlers::templates
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/docgen-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/docgen-0.1.0.tm
deleted file mode 100644
index f4d26342..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/docgen-0.1.0.tm
+++ /dev/null
@@ -1,71 +0,0 @@
-
-# -*- tcl -*
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::docgen 0.1.0
-# Meta platform     tcl
-# Meta license      BSD
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-package require punk::repo
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::docgen {
-    proc get_doctools_comments {fname} {
-        #does no validation of doctools commands
-        #existence of string match #\**!doctools is taken as evidence enough that the file has inline doctools - review
-        if {![file exists $fname]} {
-            error "get_doctools_comments file '$fname' not found"
-        }
-        set fd [open $fname r]
-        set data [read $fd]
-        close $fd
-        if {![string match "*#\**!doctools*" $data]} {
-            return
-        }
-        set data [string map [list \r\n \n] $data]
-        set in_doctools 0
-        set doctools ""
-        foreach ln [split $data \n] {
-            set ln [string trim $ln]
-            if {$in_doctools && [string index $ln 0] != "#"} {
-                set in_doctools 0
-            } elseif {[string range $ln 0 1] == "#*"} {
-                #todo - process doctools ordering hints in tail of line
-                set in_doctools 1
-            } elseif {$in_doctools} {
-                append doctools [string range $ln 1 end] \n
-            }
-        }
-        return $doctools
-    }
-    #todo - proc autogen_doctools_comments {fname} {}
-    # - will probably need to use something like parsetcl - as we won't be able to reliably source in an interp without side-effects and use info body etc.
-    # - mechanism will be to autodocument namespaces, procs, methods where no #*** doctools indication present - but use existing doctools comments for that particular item if it is present.
-
-
-
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::docgen [namespace eval punk::docgen {
-    variable pkg punk::docgen
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/du-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/du-0.1.0.tm
deleted file mode 100644
index fa02b3a9..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/du-0.1.0.tm
+++ /dev/null
@@ -1,1284 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::du 0.1.0
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require punk::mix::base
-
-
-namespace eval punk::du {
-    variable has_twapi 0
-}
-if {"windows" eq $::tcl_platform(platform)} {
-    package require zzzload
-    zzzload::pkg_require twapi
-
-    if {[catch {package require twapi}]} {
-        puts stderr "Warning: punk::du - unable to load twapi. Disk operations may be much slower on windows without the twapi package"
-    } else {
-        set punk::du::has_twapi 1
-    }
-    #package require punk::winpath
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::du {
-    
-
-    proc dirlisting {folderpath args} {
-        set defaults [dict create\
-            -glob *\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_glob            [dict get $opts -glob]
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        if {[lib::pathcharacterlen $folderpath] == 0} {
-           set folderpath [pwd]
-        } elseif {[file pathtype $folderpath] ne "absolute"} {
-            #file normalize relativelly slow - avoid in inner loops
-            #set folderpath [file normalize $folderpath]
-            
-        }
-        #run whichever of du_dirlisting_twapi, du_dirlisting_generic, du_dirlisting_unix has been activated
-        set dirinfo [active::du_dirlisting $folderpath {*}$opts]
-    }
-
-    
-
-    #Note that unix du seems to do depth-first - which makese sense when piping.. as output can be emitted as we go rather than requiring sort at end.
-    #breadth-first with sort can be quite fast .. but memory usage can easily get out of control
-    proc du { args } {
-        variable has_twapi
-        package require struct::set
-
-
-        if 0 {
-        switch -exact [llength $args] {
-            0 {
-                set dir .
-                set switch -k
-            }
-            1 {
-                set dir $args
-                set switch -k
-            }
-            2 {
-                set switch [lindex $args 0]
-                set dir [lindex $args 1]
-            }
-            default {
-                set msg "only one switch and one dir "
-                append msg "currently supported"
-                return -code error $msg
-            }
-        }
-
-        set switch [string tolower $switch]
-
-        set -b 1
-        set -k 1024
-        set -m [expr 1024*1024]
-        }
-
-
-        set opts $args
-        # flags in args are solos (or longopts --something=somethingelse) or sometimes pairopts
-        # we don't currently support mashopts  (ie -xy  vs separate -x -y)
-
-
-        #-------------------------------------------------------
-        # process any pairopts first and remove the pair
-        # (may also process some solo-opts)
-
-        set opt_depth -1
-        if {[set posn [lsearch $opts -d]] >= 0} {
-            set opt_depth [lindex $opts $posn+1]
-            set opts [lreplace $opts $posn $posn+1]
-        }
-        foreach o $opts {
-            if {[string match --max-depth=* $o]} {
-                set opt_depth [lindex [split $o =] 1]
-                if {![string is integer -strict $opt_depth]} {
-                    error "--max-depth=n  n must be an integer"
-                }
-            }
-        }
-        #-------------------------------------------------------
-        #only solos and longopts remain in the opts now
-        
-
-        set lastarg [lindex $opts end]
-        if {[string length $lastarg] && (![string match -* $lastarg])} {
-            set dir $lastarg
-            set opts [lrange $opts 0 end-1]
-        } else {
-            set dir . 
-            set opts $opts
-        }
-        foreach a $opts {
-            if {![string match -* $a]} {
-                error "unrecognized option '$a'"
-            } 
-        }
-
-        set -b 1
-        set -k 1024
-        set -m [expr 1024*1024]
-        set switch -k ;#default (same as unix)
-        set lc_opts [string tolower $opts] 
-
-
-
-        if {"-b" in $lc_opts} {
-            set switch -b
-        } elseif {"-k" in $lc_opts} {
-            set switch -k
-        } elseif {"-m" in $lc_opts} {
-            set switch -m
-        }
-        set opt_progress 0
-        if {"--prog" in $lc_opts || "--progress" in $lc_opts} {
-            set opt_progress 1
-        }
-        set opt_extra 0
-        if {"--extra" in $lc_opts} {
-            set opt_extra 1
-        }
-        set opt_vfs 0
-        #This configures whether to enter a vfsmount point 
-        #It will have no effect if cwd already with a vfs mount point - as then opt_vfs will be set to 1 automatically anyway.
-        if {"--vfs" in $lc_opts} {
-            set opt_vfs 1
-        }
-
-
-
-        set result [list]
-
-        set dir_depths_remaining [list]
-
-        set is_windows [expr {$::tcl_platform(platform) eq "windows"}]
-        set zero [expr {0}]
-
-        # ## ### ### ### ###
-        # containerid and itemid
-        set folders [list] ;#we lookup string by index
-        lappend folders [file dirname $dir]
-        lappend folders $dir ;#itemindex 1
-        # ## ### ### ### ###
-        if {![file isdirectory $dir]} {
-            lappend dir_depths_remaining [list $zero $zero [expr {1}] [lib::du_lit [file tail $dir]] [file size $dir]]
-            #set ary($dir,bytes) [file size $dir]
-            set leveldircount 0
-        } else {
-            lappend dir_depths_remaining [list $zero $zero [expr {1}] [lib::du_lit [file tail $dir]] $zero]
-            set leveldircount 1
-        }
-        set level [expr {0}] 
-        set nextlevel [expr {1}]
-        #dir_depths list structure
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        #0          1               2           3       4       5
-        #i_depth    i_containerid   i_itemid    i_item  i_size  i_index
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set i_depth         [expr {0}]
-        set i_containerid   [expr {1}]
-        set i_itemid        [expr {2}]
-        set i_item          [expr {3}]
-        set i_size          [expr {4}]
-        set i_index         [expr {5}]
-
-
-        set listlength [llength $dir_depths_remaining] 
-        set diridx 0
-        #this is a breadth-first algorithm
-        while {$leveldircount > 0} {
-            set leveldirs 0
-            set levelfiles 0
-            for {set i $diridx} {$i < $listlength} {incr i} {
-                #lassign [lindex $dir_depths_remaining $i] _d containeridx folderidx itm bytecount
-                set folderidx [lindex $dir_depths_remaining $i $i_itemid]
-                set folderpath [lindex $folders $folderidx] 
-                #puts stderr ->$folderpath
-                #if {$i >= 20} {
-                #return
-                #}
-
-                #twapi supports gathering file sizes during directory contents traversal
-                #for dirlisting methods that return an empty list in filesizes whilst files has entries - we will need to populate it below
-                #e.g tcl glob based dirlisting doesn't support gathering file sizes at the same time
-              
-                set in_vfs 0
-                if {[package provide vfs] ne ""} {
-                    foreach vfsmount [vfs::filesystem info] {
-                        if {[file pathtype $folderpath] ne "absolute"} {
-                            set testpath [file normalize $folderpath]
-                        } else {
-                            set testpath $folderpath
-                        }
-                            
-                        if {[punk::mix::base::lib::path_a_atorbelow_b $testpath $vfsmount]} {
-                            set in_vfs 1
-                            #if already descended to or below a vfs mount point - set opt_vfs true
-                            set opt_vfs 1
-                            break
-                        }
-                    }
-                }
-
-                if {$in_vfs} {
-                    set du_info [lib::du_dirlisting_tclvfs $folderpath]
-                } else {
-                    #run the activated function (proc imported to active namespace and renamed)
-                    set du_info [active::du_dirlisting $folderpath]
-                }
-
-                
-                set dirs [dict get $du_info dirs]
-                set files [dict get $du_info files]
-                set filesizes [dict get $du_info filesizes]
-                set vfsmounts [dict get $du_info vfsmounts]
-                #puts "---> vfsmounts $vfsmounts "
-                if {$opt_vfs} {
-                    foreach vm $vfsmounts {
-                        #puts stderr "vm: $vm"
-                        #check if vfs is mounted over a file or a dir
-                        if {$vm in $files} {
-                            puts stderr "vfs mounted over file $vm"
-                            set mposn [lsearch $files $vm]
-                            set files [lreplace $files $mposn $mposn]
-                            if {[llength $filesizes]} {
-                                set filesizes [lreplace $filesizes $mposn $mposn]
-                            }
-                        }
-                        if {$vm ni $dirs} {
-                            puts stderr "treating $vm as dir"
-                            lappend dirs $vm
-                        }
-                    }
-                }
-
-
-                incr leveldirs  [llength $dirs]
-                incr levelfiles [llength $files]
-
-                #lappend dir_depths_remaining {*}[lmap d $dirs {::list $nextdepth [lib::du_lit $cont/$itm] $d $zero}]
-                #folderidx is parent index for new dirs
-                lappend dir_depths_remaining {*}[lib::du_new_eachdir $dirs $nextlevel $folderidx]
-
-                #we don't need to sort files (unless we add an option such as -a to du (?))
-                set bytecount [expr {0}]
-
-                if {[llength $files] && ![llength $filesizes]} {
-                    #listing mechanism didn't supply corresponding sizes
-                    foreach filename $files {
-                        #incr bytecount [file size [file join $folderpath $filename]
-                        incr bytecount [file size $filename]
-                    }
-                } else {
-                    set filesizes [lsearch -all -inline -not $filesizes[unset filesizes] na] ;#only legal non-number is na
-                    set bytecount [tcl::mathop::+ {*}$filesizes]
-                }
-
-
-                #we can safely assume initial count was zero
-                lset dir_depths_remaining $i $i_size $bytecount
-                #incr diridx
-            }
-            #puts stdout "level: $level dirs: $leveldirs"
-            if {$opt_extra} {
-                puts stdout "level: $level dircount: $leveldirs filecount: $levelfiles"
-            }
-            incr level ;#zero based
-            set nextlevel [expr {$level + 1}]
-            set leveldircount [expr {[llength $dir_depths_remaining] - $listlength }]; #current - previous - while loop terminates when zero
-            #puts "diridx: $diridx i: $i rem: [llength $dir_depths_remaining] listlenth:$listlength levldircount: $leveldircount"
-            set diridx $i
-            set listlength  [llength $dir_depths_remaining]
-        }
-        #puts stdout ">>> loop done"
-        #flush stdout
-        #puts stdout $dir_depths_remaining
-        set dirs_as_encountered $dir_depths_remaining ;#index is in sync with 'folders' list
-        set dir_depths_longfirst $dirs_as_encountered
-
-        #store the index before sorting
-        for {set i 0} {$i < [llength $dir_depths_remaining]} {incr i} {
-            lset dir_depths_longfirst $i $i_index $i
-        }
-        set dir_depths_longfirst [lsort -integer -index 0 -decreasing $dir_depths_longfirst[set dir_depths_longfirst {}]]
-
-        #store main index in the reducing list
-        set dir_depths_remaining $dir_depths_longfirst
-        for {set i 0} {$i < [llength $dir_depths_remaining]} {incr i} {
-            #stored index at position 3
-            lset dir_depths_remaining $i $i_index $i
-        }
-
-        #index 3
-        #dir_depths_remaining -> dir_depths_longfirst -> dirs_as_encountered
-
-        #puts stdout "initial dir_depths_remaining: $dir_depths_remaining"
-
-
-        #summing performance is not terrible but significant on large tree - the real time is for large trees in the main loop above
-        #update - on really  large trees the reverse is true especiallyl now that twapi fixed the original speed issues.. todo - rework/simplify below - review natsort
-        #
-        #TODO - reconsider sorting by depth.. lreverse dirs_as_encountered should work.. 
-        if {[llength $dir_depths_longfirst] > 1} {
-            set i 0
-            foreach dd $dir_depths_longfirst {
-                lassign $dd d parentidx folderidx item bytecount
-                #set nm $cont/$item
-                set nm [lindex $folders $folderidx]
-                set dnext [expr {$d +1}]
-                set nextdepthposns [lsearch -all -integer -index 0 $dir_depths_remaining $dnext]
-                set nextdepthposns [lsort -integer -decreasing $nextdepthposns[set nextdepthposns {}]];#remove later elements first
-                foreach posn $nextdepthposns {
-                    set id [lindex $dir_depths_remaining $posn $i_itemid]
-                    set ndirname [lindex $folders $id]
-                    #set ndirname $cont/$item
-                    #set item [lindex $dir_depths_remaining $posn $i_item]
-                    #set ndirname [lindex $ndir 1]
-                    if {[string match $nm/* $ndirname]} {
-                        #puts stdout "dir $nm adding subdir size $ndirname"
-                        #puts stdout "incr $nm from $ary($nm,bytes) plus $ary($ndirname,bytes)"
-                        incr bytecount [lindex $dir_depths_remaining $posn $i_size]
-                        set dir_depths_remaining [lreplace $dir_depths_remaining[set dir_depths_remaining {}] $posn $posn]
-                    }
-                }
-                lset dir_depths_longfirst $i $i_size $bytecount
-                set p [lsearch -index $i_index -integer $dir_depths_remaining $i]
-                lset dir_depths_remaining $p $i_size $bytecount
-                #set ary($nm,bytes) $bytecount
-                incr i
-            }
-        }
-        #set dir_depths_longfirst [lsort -index 1 -decreasing $dir_depths_longfirst]
-        #
-
-        set retval [list]
-        #copy across the bytecounts
-        for {set i 0} {$i < [llength $dir_depths_longfirst]} {incr i} {
-            set posn [lindex $dir_depths_longfirst $i $i_index]
-            set bytes [lindex $dir_depths_longfirst $i $i_size]
-            lset dirs_as_encountered $posn $i_size $bytes 
-        }
-        foreach dirinfo [lreverse $dirs_as_encountered] {
-            set id [lindex $dirinfo $i_itemid]
-            set depth [lindex $dirinfo $i_depth]
-            if {($opt_depth >= 0) && $depth > $opt_depth} {
-                continue
-            }
-            set path [lindex $folders $id]
-            #set path $cont/$item
-            set item [lindex $dirinfo $i_item]
-            set bytes [lindex $dirinfo $i_size]
-            set size [expr {$bytes / [set $switch]}]
-            lappend retval [list $size $path]
-        }
-        # copyright 2002 by The LIGO Laboratory
-        return $retval
-    }
-    namespace eval active {
-        variable functions [list du_dirlisting ""]
-        variable functions_known [dict create]
-
-        #known functions from lib namespace
-        dict set functions_known du_dirlisting [list du_dirlisting_twapi du_dirlisting_generic du_dirlisting_unix du_dirlisting_undecided]
-
-        proc show_functions {} {
-            variable functions
-            variable functions_known
-            set msg ""
-            dict for {callname implementations} $functions_known {
-                append msg "callname: $callname" \n
-                foreach imp $implementations {
-                    if {[dict get $functions $callname] eq $imp} {
-                        append msg "  $imp (active)" \n
-                    } else {
-                        append msg "  $imp" \n
-                    }
-                }
-            }
-            return $msg
-        }
-        proc set_active_function {callname implementation} {
-            variable functions
-            variable functions_known
-            if {$callname ni [dict keys $functions_known]} {
-                error "unknown function callname $callname"
-            }
-            if {$implementation ni [dict get $functions_known $callname]} {
-                error "unknown implementation $implementation for callname $callname"
-            }
-            dict set functions $callname $implementation
-
-            catch {rename ::punk::du::active::$callname ""}
-            namespace eval ::punk::du::active [string map [list %imp% $implementation %call% $callname] {
-                namespace import ::punk::du::lib::%imp%
-                rename %imp% %call% 
-            }]
-
-            return $implementation
-        }
-        proc get_active_function {callname} {
-            variable functions
-            variable functions_known
-            if {$callname ni [dict keys $functions_known]} {
-                error "unknown function callname $callname known functions: [dict keys $functions_known]"
-            }
-            return [dict get $functions $callname]
-        }
-
-
-        #where we import & the appropriate du_listing.. function for the platform
-    }
-    namespace eval lib {
-        variable du_literal
-        variable winfile_attributes [list 16 directory 32 archive 1024 reparse_point 18 [list directory hidden] 34 [list archive hidden] ]
-        #caching this is faster than calling twapi api each time.. unknown if twapi is calculating from bitmask - or calling windows api
-        #we could work out all flags and calculate from bitmask.. but it's not necessarily going to be faster than some simple caching mechanism like this
-
-        proc decode_win_attributes {bitmask} {
-            variable winfile_attributes
-            if {[dict exists $winfile_attributes $bitmask]} {
-                return [dict get $winfile_attributes $bitmask]
-            } else {
-                #list/dict shimmering?
-                return [lindex [lappend winfile_attributes $bitmask [twapi::decode_file_attributes $bitmask]] end]
-            }
-        }
-        proc attributes_twapi {path {detail basic}} {
-            try {
-                set iterator [twapi::find_file_open $path -detail $detail] ;# -detail full only adds data to the altname field
-                if {[twapi::find_file_next $iterator iteminfo]} {
-                    set attrinfo [decode_win_attributes [dict get $iteminfo attrs]]
-                    set result [dict create -archive 0 -hidden 0 -longname $path -readonly 0 -shortname {} -system 0]
-                    if {"hidden" in $attrinfo} {
-                        dict set result -hidden 1
-                    }
-                    if {"system" in $attrinfo} {
-                        dict set result -system 1
-                    }
-                    if {"readonly" in $attrinfo} {
-                        dict set result -readonly 1
-                    }
-                    dict set result -shortname [dict get $iteminfo altname]
-                    dict set result -rawflags $attrinfo
-                    set extras [list]
-                    #foreach prop {ctime atime mtime size} {
-                    #    lappend extras $prop [dict get $iteminfo $prop]
-                    #}
-                    #dict set result -extras $extras
-                    dict set result -raw $iteminfo
-                    return $result
-                } else {
-                    error "could not read attributes for $path"
-                }
-            } finally {
-                catch {twapi::find_file_close $iterator}
-            }
-        }
-
-        #todo - review 'errors' key. We have errors relating to containing folder and args vs per child-item errors - additional key needed?
-        namespace export du_dirlisting_twapi du_dirlisting_generic du_dirlisting_unix du_dirlisting_undecided
-        # get listing without using unix-tools (may not be installed on the windows system)
-        # this dirlisting is customised for du - so only retrieves dirs,files,filesizes (minimum work needed to perform du function)
-        # This also preserves path rep for elements in the dirs/folders keys etc - which can make a big difference in performance 
-        proc du_dirlisting_twapi {folderpath args} {
-            set defaults [dict create\
-                -glob *\
-                -with_sizes 1\
-                -with_times 1\
-            ]
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_glob            [dict get $opts -glob]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_sizes      [dict get $opts -with_sizes]
-            set ftypes [list f d l]
-            if {"$opt_with_sizes" in {0 1}} {
-                #don't use string is boolean - (f false vs f file!)
-                #only accept 0|1 
-                if {$opt_with_sizes} {
-                    set sized_types $ftypes
-                } else {
-                    set sized_types [list]
-                }
-            } else {
-                set sized_types $opt_with_sizes
-            }
-            if {[llength $sized_types]} {
-                foreach st $sized_types {
-                    if {$st ni $ftypes} {
-                        error "du_dirlisting_twapi unrecognized element in -with_sizes '$st'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_times      [dict get $opts -with_times]
-            if {"$opt_with_times" in {0 1}} {
-                if {$opt_with_times} {
-                    set timed_types $ftypes
-                } else {
-                    set timed_types [list]
-                }
-            } else {
-                set timed_types $opt_with_times
-            }
-            if {[llength $timed_types]} {
-                foreach item $timed_types {
-                    if {$item ni $ftypes} {
-                        error "du_dirlisting_twapi unrecognised element in -with-times '$item'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-            set errors [dict create]
-            set altname "" ;#possible we have to use a different name e.g short windows name or dos-device path //?/
-            # return it so it can be stored and tried as an alternative for problem paths
-            #puts stderr ">>> glob: $opt_glob"
-            #REVIEW! windows api pattern matchttps://www.red-gate.com/simple-talk/blogs/the-unexpected-behaviour-of-directoryinfo-getfiles-with-three-letter-extensions/hing is .. weird. partly due to 8.3 filenames
-            #https://www.red-gate.com/simple-talk/blogs/the-unexpected-behaviour-of-directoryinfo-getfiles-with-three-letter-extensions/
-            #we will certainly need to check the resulting listing with our supplied glob.. but maybe we will have to change the glob passed to find_file_open too.
-            # using * all the time may be inefficient - so we might be able to avoid that in some cases.
-            try {
-                #glob of * will return dotfiles too on windows
-                set iterator [twapi::find_file_open [file join $folderpath $opt_glob] -detail basic] ;# -detail full only adds data to the altname field
-            } on error args {
-                try {
-                    if {[string match "*denied*" $args]} {
-                        #output similar format as unixy du
-                        puts stderr "[file dirname $folderpath] '[file tail $folderpath]':$args"
-                        dict lappend errors $folderpath $::errorCode
-                        return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                    }
-                    if {[string match "*TWAPI_WIN32 59*" $::errorCode]} {
-                        puts stderr "[file dirname $folderpath] '[file tail $folderpath]':$args (possibly blocked by permissions or share config e.g follow symlinks = no on samba)"
-                        puts stderr "  (errorcode: $::errorCode)\n"
-                        dict lappend errors $folderpath $::errorCode
-                        return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                    }
-
-
-                    #errorcode TWAPI_WIN32 2 {The system cannot find the file specified.}
-                    #This can be a perfectly normal failure to match the glob.. which means we shouldn't really warn or error
-                    #The find-all glob * won't get here because it returns . & .. 
-                    #so we should return immediately only if the glob has globchars ? or *  but isn't equal to just "*" ? (review)
-                    #Note that windows glob ? seems to return more than just single char results - it includes .. - which differs to tcl glob 
-                    #also ???? seems to returns items 4 or less - not just items exactly 4 long (review - where is this documented?)
-                    if {$opt_glob ne "*" && [regexp {[?*]} $opt_glob]} {
-                        if {[string match "*TWAPI_WIN32 2 *" $::errorCode]} {
-                            #looks like an ordinary no results for chosen glob
-                            return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                        }
-                    }
-
-
-                    if {[set plen [pathcharacterlen $folderpath]] >= 250} {
-                        set errmsg "error reading folder: $folderpath (len:$plen)\n"
-                        append errmsg "error: $args" \n
-                        append errmsg "errorcode: $::errorCode" \n
-                        # re-fetch this folder with altnames 
-                        #file normalize - aside from being slow - will have problems with long paths - so this won't work.
-                        #this function should only accept absolute paths
-                        #
-                        #
-                        #Note: using -detail full  only helps if the last segment of path has an altname..
-                        #To properly shorten we need to have kept track of altname all the way from the root!
-                        #We can .. for now call Tcl's file attributes to get shortname of the whole path - it is *expensive* e.g 5ms for a long path on local ssd
-                        #### SLOW
-                        set fixedpath [dict get [file attributes $folderpath] -shortname]
-                        #### SLOW
-                        
-                        
-                        append errmsg "retrying with with windows altname '$fixedpath'"
-                        puts stderr $errmsg
-                    } else {
-                        set errmsg "error reading folder: $folderpath (len:$plen)\n"
-                        append errmsg "error: $args" \n
-                        append errmsg "errorcode: $::errorCode" \n
-                        set tmp_errors [list $::errorCode]
-                        #possibly an illegal windows filename - easily happens on a machine with WSL or with drive mapped to unix share
-                        #we can use //?/path  dos device path - but not with tcl functions
-                        #unfortunately we can't call find_file_open directly on the problem name - we have to call the parent folder and iterate through again..
-                        #this gets problematic as we go deeper unless we rewrite the .. but we can get at least one level further here
-                       
-                        set fixedtail ""
-
-                        set parent [file dirname $folderpath]
-                        set badtail [file tail $folderpath]
-                        set iterator [twapi::find_file_open [file join $parent *] -detail full] ;#retrieve with altnames
-                        while {[twapi::find_file_next $iterator iteminfo]} {
-                            set nm [dict get $iteminfo name]
-                            if {$nm eq $badtail} {
-                                set fixedtail [dict get $iteminfo altname] 
-                                break
-                            }
-                        }
-
-                        if {![string length $fixedtail]} {
-                            dict lappend errors $folderpath {*}$tmp_errors
-                            puts stderr "[file dirname $folderpath] '[file tail $folderpath]':$args (Unable to retrieve altname to progress further with path - returning no contents for this folder)"
-                            return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                        }
-
-                        #twapi as at 2023-08 doesn't seem to support //?/ dos device paths.. 
-                        #Tcl can test only get as far as testing existence of illegal name by prefixing with //?/ - but can't glob inside it
-                        #we can call file attributes on it - but we get no shortname (but we could get shortname for parent that way)
-                        #so the illegalname_fix doesn't really work here
-                        #set fixedpath [punk::winpath::illegalname_fix $parent $fixedtail]
-
-                        #this has shortpath for the tail - but it's not the canonical-shortpath because we didn't call it on the $parent part REIEW.
-                        set fixedpath [file join $parent $fixedtail]
-                        append errmsg "retrying with with windows dos device path $fixedpath\n"
-                        puts stderr $errmsg
-                        
-                    }
-
-                    if {[catch {
-                        set iterator [twapi::find_file_open $fixedpath/* -detail basic]
-                    } errMsg]} {
-                        puts stderr "[file dirname $folderpath] '[file tail $folderpath]':$args (failed to read even with fixedpath:'$fixedpath')"
-                        puts stderr "  (errorcode: $::errorCode)\n"
-                        puts stderr "$errMsg"   
-                        dict lappend errors $folderpath $::errorCode
-                        return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                    }
-
-
-                } on error args {
-                        set errmsg "error reading folder: $folderpath\n"
-                        append errmsg "error: $args" \n
-                        append errmsg "errorInfo: $::errorInfo" \n
-                        puts stderr "$errmsg"
-                        puts stderr "FAILED to collect info for folder '$folderpath'"
-                        #append errmsg "aborting.."
-                        #error $errmsg
-                        return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                    
-                }
-            }
-            set dirs [list]
-            set files [list]
-            set filesizes [list]
-            set allsizes [dict create]
-            set alltimes [dict create]
-
-            set links [list]
-            set flaggedhidden [list]
-            set flaggedsystem [list]
-            set flaggedreadonly [list]
-
-            while {[twapi::find_file_next $iterator iteminfo]} {
-                set nm [dict get $iteminfo name]
-                #recheck glob
-                #review!
-                if {![string match $opt_glob $nm]} {
-                    continue
-                }
-                set tail_altname [dict get $iteminfo altname] ;#altname of tail - not whole path
-                set attrinfo [decode_win_attributes [dict get $iteminfo attrs]]
-                #puts stderr "$iteminfo"
-                #puts stderr "$nm -> [dict get $iteminfo attrs] -> $attrinfo"
-                set ftype ""
-                #attributes applicable to any classification
-                set fullname [file_join_one $folderpath $nm]
-                
-                if {"hidden" in $attrinfo} {
-                    lappend flaggedhidden $fullname 
-                }
-                if {"system" in $attrinfo} {
-                    lappend flaggedsystem  $fullname
-                }
-                if {"readonly" in $attrinfo} {
-                    lappend flaggedreadonly  $fullname
-                }
-
-                #main classification
-                if {"reparse_point" in $attrinfo} {
-                    #this concept doesn't correspond 1-to-1 with unix links
-                    #https://learn.microsoft.com/en-us/windows/win32/fileio/reparse-points
-                    #review - and see which if any actually belong in the links key of our return
-
-
-                    #One thing it could be, is a 'mounted folder' https://learn.microsoft.com/en-us/windows/win32/fileio/determining-whether-a-directory-is-a-volume-mount-point
-                    #
-                    #we will treat as  zero sized for du purposes.. review - option -L  for symlinks like BSD du?
-                    #Note 'file readlink' can fail on windows - reporting 'invalid argument' - according to tcl docs, 'On systems that don't support symbolic links this option is undefined'
-                    #The link may be viewable ok in windows explorer, and cmd.exe /c dir and unix tools such as ls
-                    #if we need it without resorting to unix-tools that may not be installed: exec {*}[auto_execok dir] /A:L {c:\some\path}
-                    #e.g (stripped of headers/footers and other lines)
-                    #2022-10-02  04:07 AM    <SYMLINKD>     priv [\\?\c:\repo\elixir\gameportal\apps\test\priv]
-                    #Note we will have to parse beyond header fluff as /B strips the symlink info along with headers.
-                    #du includes the size of the symlink
-                    #but we can't get it with tcl's file size
-                    #twapi doesn't seem to have anything to help read it either (?)
-                    #the above was verified with a symlink that points to a non-existant folder.. mileage may vary for an actually valid link
-                    #
-                    #Note also - a shortcut created in explorer with drag and drop to an existant folder is a different animal to a symlink (file with .lnk extension) even though it looks the same in explorer window.
-                    #
-                    #links are techically files too, whether they point to a file/dir or nothing.
-
-                    lappend links $fullname
-                    set ftype "l"
-                } elseif {"directory" in $attrinfo} {
-                    if {$nm in {. ..}} {
-                        continue
-                    }
-                    lappend dirs $fullname
-                    set ftype "d"
-                } else {
-                    
-                    #review - is anything that isn't a reparse_point or a directory, some sort of 'file' in this context? What about the 'device' attribute? Can that occur in a directory listing of some sort?
-                    lappend files $fullname
-                    if {"f" in $sized_types} {
-                        lappend filesizes   [dict get $iteminfo size]
-                    }
-                    set ftype "f"
-                }
-                if {$ftype in $sized_types} {
-                    dict set allsizes $fullname [dict create bytes [dict get $iteminfo size]]
-                }
-                if {$ftype in $timed_types} {
-                    #convert time from windows (100ns units since jan 1, 1601) to Tcl time (seconds since Jan 1, 1970)
-                    #We lose some precision by not passing the boolean to the large_system_time_to_secs_since_1970 function which returns fractional seconds
-                    #but we need to maintain compatibility with other platforms and other tcl functions so if we want to return more precise times we will need another flag and/or result dict
-                    dict set alltimes $fullname [dict create\
-                        c [twapi::large_system_time_to_secs_since_1970 [dict get $iteminfo ctime]]\
-                        a [twapi::large_system_time_to_secs_since_1970 [dict get $iteminfo atime]]\
-                        m [twapi::large_system_time_to_secs_since_1970 [dict get $iteminfo mtime]]\
-                    ]
-                }
-            }
-            twapi::find_file_close $iterator
-            set vfsmounts [get_vfsmounts_in_folder $folderpath]
-
-            set effective_opts $opts
-            dict set effective_opts -with_times $timed_types
-            dict set effective_opts -with_sizes $sized_types
-
-            #also determine whether vfs.  file system x  is *much* faster than file attributes
-            #whether or not there is a corresponding file/dir add any applicable mountpoints for the containing folder
-            return [list dirs $dirs vfsmounts $vfsmounts links $links files $files filesizes $filesizes sizes $allsizes times $alltimes flaggedhidden $flaggedhidden flaggedsystem $flaggedsystem flaggedreadonly $flaggedreadonly altname $altname opts $effective_opts errors $errors]
-        }
-        proc get_vfsmounts_in_folder {folderpath} {
-            set vfsmounts [list]
-            if {![llength [package provide vfs]]} {
-               return [list] 
-            }
-            set fpath [punk::objclone $folderpath]
-            set is_rel 0
-            if {[file pathtype $fpath] ne "absolute"} {
-                set fpath [file normalize $fpath]
-                set is_rel 1
-            }
-            set known_vfs_mounts [vfs::filesystem info]
-            foreach mount $known_vfs_mounts {
-                if {[punk::mix::base::lib::path_a_above_b $fpath $mount]} {
-                    if {([llength [file split $mount]] - [llength [file split $fpath]]) == 1} {
-                        #the mount is in this folder
-                        if {$is_rel} {
-                            lappend vfsmounts [file join $folderpath [file tail $mount]]
-                        } else {
-                            lappend vfsmounts $mount
-                        }
-                    }
-                }
-            }
-            return $vfsmounts
-        }
-        #work around the horrible tilde-expansion thing (not needed for tcl 9+)
-        proc file_join_one {base newtail} {
-            if {[string index $newtail 0] ne {~}} {
-                return [file join $base $newtail]
-            }
-            return [file join $base ./$newtail]
-        }
-
-
-        #this is the cross-platform pure-tcl version - which calls glob multiple times to make sure it gets everythign it needs and can ignore everything it needs to.
-        #These repeated calls to glob will be a killer for performance  - especially on a network share or when walking a large directory structure
-        proc du_dirlisting_generic {folderpath args} {
-            set defaults [dict create\
-                -glob *\
-                -with_sizes 0\
-                -with_times 0\
-            ]
-            set errors [dict create]
-            set known_opts [dict keys $defaults] 
-            foreach k [dict keys $args] {
-                if {$k ni $known_opts} {
-                    error  "du_dirlisting_generic unknown-option $k"
-                }
-            }
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_glob            [dict get $opts -glob]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_sizes      [dict get $opts -with_sizes]
-            set ftypes [list f d l]
-            if {"$opt_with_sizes" in {0 1}} {
-                #don't use string is boolean (false vs f problem where f indicates file)
-                if {$opt_with_sizes} {
-                    set sized_types $ftypes
-                } else {
-                    set sized_types [list]
-                }
-            } else {
-                set sized_types $opt_with_sizes
-            }
-            if {[llength $sized_types]} {
-                foreach st $sized_types {
-                    if {$st ni $ftypes} {
-                        error "du_dirlisting_generic unrecognized element in -with_sizes '$st'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_times      [dict get $opts -with_times]
-            if {"$opt_with_times" in {0 1}} {
-                if {$opt_with_times} {
-                    set timed_types $ftypes
-                } else {
-                    set timed_types [list]
-                }
-            } else {
-                set timed_types $opt_with_times
-            }
-            if {[llength $timed_types]} {
-                foreach item $timed_types {
-                    if {$item ni $ftypes} {
-                        error "du_dirlisting_generic unrecognised element in -with-times '$item'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            # The repeated globs are a source of slowness for this function.
-            #TODO - we could minimize the number of globs if we know we need to do a file stat and/or file attributes on each entry anyway
-            #For the case where we don't need times,sizes or other metadata - it is faster to do multiple globs
-            #This all makes this function complicated to gather the required data efficiently.
-            
-            #note platform differences between what is considered hidden make this tricky.
-            # on windows 'glob .*' will not return some hidden dot items but will return . ..   and glob -types hidden .* will not return some dotted items
-            # glob -types hidden *  on windows will not necessarily return all dot files/folders
-            # unix-like platforms seem to consider all dot files as hidden so processing is more straightforward
-            #  we need to process * and .* in the same glob calls and remove duplicates 
-            #  if we do * and .* in separate iterations of this loop we lose the ability to filter duplicates easily
-
-            #note - with this design, we can't glob for all except dotfiles - this is for cross-platform consistency and efficiency (Review).
-            #dotfiles aren't considered hidden on all platforms
-            #some sort of antiglob is a possible enhancement and more consistent with the view that leading dot should be treated as any other filename character in this context.
-            if {$opt_glob eq "*"} {
-                #Note - glob operations seem to be faster than looped tests like 'file isdirectory' & 'file readlink' 
-                #set parent [lindex $folders $folderidx]
-                set hdirs  [glob -nocomplain -dir $folderpath -types {hidden d}  * .*]
-                #set hdirs {}
-                set dirs   [glob -nocomplain -dir $folderpath -types d           * .*]
-
-                set hlinks [glob -nocomplain -dir $folderpath -types {hidden l}  * .*]
-                #set hlinks {}
-                set links  [glob -nocomplain -dir $folderpath -types l           * .*] ;#links may have dupes - we don't care. struct::set difference will remove
-                #set links  [lsort -unique [concat $hlinks $links[unset links]]]
-
-                set hfiles [glob -nocomplain -dir $folderpath -types {hidden f}  * .*]
-                #set hfiles {}
-                set files  [glob -nocomplain -dir $folderpath -types f           * .*]
-                #set files  {}
-            } else {
-                set hdirs  [glob -nocomplain -dir $folderpath -types {hidden d}   $opt_glob]
-                set dirs   [glob -nocomplain -dir $folderpath -types d            $opt_glob]
-
-                set hlinks [glob -nocomplain -dir $folderpath -types {hidden l}   $opt_glob]
-                set links  [glob -nocomplain -dir $folderpath -types l            $opt_glob] ;#links may have dupes - we don't care. struct::set difference will remove
-
-                set hfiles [glob -nocomplain -dir $folderpath -types {hidden f}   $opt_glob]
-                set files  [glob -nocomplain -dir $folderpath -types f            $opt_glob]
-            }
-
-            #note struct::set difference produces unordered result
-            #struct::set difference removes duplicates
-            #remove links and . .. from directories, remove links from files
-            set files [struct::set difference [concat $hfiles $files[unset files]] $links]
-            set dirs  [struct::set difference [concat $hdirs $dirs[unset dirs]]    [concat $links [list [file join $folderpath .]  [file join $folderpath ..] ]]]
-            set links [lsort -unique [concat $links $hlinks]]
-
-
-            #----
-            set mdata_lists [du_get_metadata_lists $sized_types $timed_types $files $dirs $links]
-
-
-
-            if {"windows" eq $::tcl_platform(platform)} {
-                set flaggedhidden [concat $hdirs $hfiles $hlinks]
-            } else {
-                #unix dotted files/folders are not 'flagged' as such - it's a convention - so the client can use the same convention to decide if something is hidden
-                #this allows us to return less data - but more importantly - reserve flaggedhidden for systems where such a flag exists and avoid conflating the different concepts of what is hidden
-                set flaggedhidden {}
-            }
-
-            set vfsmounts [get_vfsmounts_in_folder $folderpath]
-
-            set effective_opts $opts
-            dict set effective_opts -with_times $timed_types
-            dict set effective_opts -with_sizes $sized_types
-
-            return [list dirs $dirs vfsmounts $vfsmounts links $links files $files filesizes [dict get $mdata_lists fsizes] sizes [dict get $mdata_lists allsizes] times [dict get $mdata_lists alltimes] flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $effective_opts errors $errors]
-        }
-
-        proc du_dirlisting_tclvfs {folderpath args} {
-            set defaults [dict create\
-                -glob *\
-                -with_sizes 0\
-                -with_times 0\
-            ]
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_glob            [dict get $opts -glob]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_sizes      [dict get $opts -with_sizes]
-            set ftypes [list f d l]
-            if {"$opt_with_sizes" in {0 1}} {
-                #don't use string is boolean (false vs f problem where f indicates file)
-                if {$opt_with_sizes} {
-                    set sized_types $ftypes
-                } else {
-                    set sized_types [list]
-                }
-            } else {
-                set sized_types $opt_with_sizes
-            }
-            if {[llength $sized_types]} {
-                foreach st $sized_types {
-                    if {$st ni $ftypes} {
-                        error "du_dirlisting_generic unrecognized element in -with_sizes '$st'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_times      [dict get $opts -with_times]
-            if {"$opt_with_times" in {0 1}} {
-                if {$opt_with_times} {
-                    set timed_types $ftypes
-                } else {
-                    set timed_types [list]
-                }
-            } else {
-                set timed_types $opt_with_times
-            }
-            if {[llength $timed_types]} {
-                foreach item $timed_types {
-                    if {$item ni $ftypes} {
-                        error "du_dirlisting_generic unrecognised element in -with-times '$item'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-            set errors [dict create]
-            if {$opt_glob eq "*"} {
-                set dirs   [glob -nocomplain -dir $folderpath -types d           * .*] ;# also returns links to dirs
-                #review - how are links handled in vfs? presumably if the vfs is a full implementation they should work at least within the vfs? 
-                set links  [glob -nocomplain -dir $folderpath -types l           * .*]  ;# links may have dupes - we don't care. struct::set difference will remove
-                set files  [glob -nocomplain -dir $folderpath -types f           * .*] ;# also returns links to files
-            } else {
-                set dirs   [glob -nocomplain -dir $folderpath -types d           $opt_glob]
-                set links  [glob -nocomplain -dir $folderpath -types l           $opt_glob]
-                set files  [glob -nocomplain -dir $folderpath -types f           $opt_glob]
-            }
-            #remove any links from our dirs and files collections
-            set dirs  [struct::set difference $dirs[unset dirs]    [concat $links [list [file join $folderpath .] [file join $folderpath ..] ]]]
-            set files [struct::set difference $files[unset files] $links]
-            #nested vfs mount.. REVIEW - does anything need special handling?
-            set vfsmounts [get_vfsmounts_in_folder $folderpath]
-
-            set mdata_lists [du_get_metadata_lists $sized_types $timed_types $files $dirs $links]
-
-
-            set effective_opts $opts
-            dict set effective_opts -with_times $timed_types
-            dict set effective_opts -with_sizes $sized_types
-
-            return [list dirs $dirs vfsmounts $vfsmounts links $links files $files filesizes [dict get $mdata_lists fsizes] sizes [dict get $mdata_lists allsizes] times $alltimes flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $effective_opts errors $errors]
-        }
-
-        #we can halve the number of round trips on unix-like systems, where 'hidden' always corresponds to dotted files
-        proc du_dirlisting_unix {folderpath args} {
-            set defaults [dict create\
-                -glob *\
-                -with_sizes 0\
-                -with_times 0\
-            ]
-            set errors [dict create]
-            dict lappend errors $folderpath "metadata support incomplete - prefer du_dirlisting_generic"
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_glob            [dict get $opts -glob]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_sizes      [dict get $opts -with_sizes]
-            set ftypes [list f d l]
-            if {"$opt_with_sizes" in {0 1}} {
-                #don't use string is boolean (false vs f problem where f indicates file) 
-                if {$opt_with_sizes} {
-                    set sized_types $ftypes
-                } else {
-                    set sized_types [list]
-                }
-            } else {
-                set sized_types $opt_with_sizes
-            }
-            if {[llength $sized_types]} {
-                foreach st $sized_types {
-                    if {$st ni $ftypes} {
-                        error "du_dirlisting_generic unrecognized element in -with_sizes '$st'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_times      [dict get $opts -with_times]
-            if {"$opt_with_times" in {0 1}} {
-                if {$opt_with_times} {
-                    set timed_types $ftypes
-                } else {
-                    set timed_types [list]
-                }
-            } else {
-                set timed_types $opt_with_times
-            }
-            if {[llength $timed_types]} {
-                foreach item $timed_types {
-                    if {$item ni $ftypes} {
-                        error "du_dirlisting_generic unrecognised element in -with-times '$item'"
-                    }
-                }
-            }
-            
-            #this is not consistent with standard way * works for unix folders - but it is consistent with behaviour of this facility on windows 
-            if {$opt_glob eq "*"} {
-                set dirs   [glob -nocomplain -dir $folderpath -types d           * .*] ;# also returns links to dirs
-                set links  [glob -nocomplain -dir $folderpath -types l           * .*]  ;# links may have dupes - we don't care. struct::set difference will remove
-                set files  [glob -nocomplain -dir $folderpath -types f           * .*] ;# also returns links to files
-            } else {
-                set dirs   [glob -nocomplain -dir $folderpath -types d           $opt_glob]
-                set links  [glob -nocomplain -dir $folderpath -types l           $opt_glob]
-                set files  [glob -nocomplain -dir $folderpath -types f           $opt_glob]
-            }
-            #remove any links from our dirs and files collections
-            set dirs  [struct::set difference $dirs[unset dirs]    [concat $links [list [file join $folderpath .] [file join $folderpath ..] ]]]
-            set files [struct::set difference $files[unset files] $links]
-            set vfsmounts [get_vfsmounts_in_folder $folderpath]
-
-            set mdata_lists [du_get_metadata_lists $sized_types $timed_types $files $dirs $links]
-
-            set effective_opts $opts
-            dict set effective_opts -with_times $timed_types
-            dict set effective_opts -with_sizes $sized_types
-
-
-            return [list dirs $dirs vfsmounts $vfsmounts links $links files $files filesizes [dict get $mdata_lists fsizes] sizes [dict get $mdata_lists allsizes] times [dict get $mdata_lists alltimes] flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-        }
-
-        #return fsizes,allsizes,alltimes metadata in same order as files,dirs,links lists - if specified in sized_types 
-        proc du_get_metadata_lists {sized_types timed_types files dirs links} {
-            set meta_dict [dict create]
-            set meta_types [concat $sized_types $timed_types]
-            #known tcl stat keys 2023 - review
-            set empty_stat_dict [dict create atime {} ctime {} dev {} gid {} ino {} mode {} mtime {} nlink {} size {} type {} uid {}]
-            #make sure we call file stat only once per item
-            set statkeys [list]
-            if {[llength $meta_types]} {
-                foreach ft {f d l} lvar {files dirs links} {
-                    if {"$ft" in $meta_types} {
-                        foreach path [set $lvar] {
-                            #caller may have read perm on the containing folder - but not on child item - so file stat could raise an error
-                            if {![catch {file stat $path arrstat} errM]} {
-                                dict set meta_dict $path [dict create shorttype $ft {*}[array get arrstat]]
-                            } else {
-                                dict lappend errors $path "file stat error: $errM"
-                                dict set meta_dict $path [dict create shorttype $ft {*}$empty_stat_dict]
-                            }
-                        }
-                    }
-                }
-            }
-            set fsizes [list]
-            set allsizes [dict create]
-            set alltimes [dict create]
-            #review birthtime field of stat? cross-platform differences ctime etc?
-            dict for {path pathinfo} $meta_dict {
-                set ft [dict get $pathinfo shorttype]
-                if {$ft in $sized_types} {
-                    dict set allsizes $path [dict create bytes [dict get $pathinfo size]]
-                    if {$ft eq "f"} {
-                        #subst with na if empty? 
-                        lappend fsizes [dict get $pathinfo size]
-                    }
-                }
-                if {$ft in $timed_types} {
-                    dict set alltimes $path [dict create c [dict get $pathinfo ctime] a [dict get $pathinfo atime] m [dict get $pathinfo mtime]]
-                }
-            }
-            #todo - fix . The list lengths will presumably match but have empty values if failed to stat
-            if {"f" in $sized_types} {
-                if {[llength $fsizes] ne [llength $files]} {
-                    dict lappend errors $folderpath "failed to retrieve all file sizes"
-                }
-            }
-            return [dict create fsizes $fsizes allsizes $allsizes alltimes $alltimes]
-        }
-
-
-        proc du_lit value {
-            variable du_literal
-            if {![info exists du_literal($value)]} {
-                set du_literal($value) $value
-            }
-            return $du_literal($value)
-        }
-
-        #v1
-        proc du_new_eachdirtail {dirtails depth parentfolderidx} {
-            set newlist {}
-            upvar folders folders
-            set parentpath [lindex $folders $parentfolderidx]
-            set newindex [llength $folders]
-            foreach dt $dirtails {
-                lappend folders [file join $parentpath [du_lit $dt]]; #store as a 'path' rather than a string (see tcl::unsupported::representation)
-                lappend newlist [::list $depth $parentfolderidx $newindex [du_lit $dt] [expr {0}]]
-                incr newindex
-            }
-            return $newlist
-        }
-        proc du_new_eachdir {dirpaths depth parentfolderidx} {
-            set newlist {}
-            upvar folders folders
-            set newindex [llength $folders]
-            foreach dp $dirpaths {
-                lappend folders $dp
-                #puts stdout "--->$dp"
-                lappend newlist [::list $depth $parentfolderidx $newindex [du_lit [file tail $dp]] [expr {0}]]
-                incr newindex
-            }
-            return $newlist
-        }
-
-        #same implementation as punk::strlen
-        #get length of path which has internal rep of path - maintaining path/list rep without shimmering to string representation.
-        proc pathcharacterlen {pathrep} {
-            append str2 $pathrep {}
-            string length $str2
-        }
-        #just an experiment
-        proc pathcharacterlen1 {pathrep} {
-            #This works - but is unnecessarily complex
-            set l 0
-            set parts [file split $pathrep]
-            if {[llength $parts] < 2} {
-                return [string length [lindex $parts 0]]
-            }
-            foreach seg $parts {
-                incr l [string length $seg]
-            }
-            return [expr {$l + [llength $parts] -2}]
-        }
-        #slower - doesn't work for short paths like c:/
-        proc pathcharacterlen2 {pathrep} {
-            return [tcl::mathop::+ {*}[lmap v [set plist [file split $pathrep]] {[string length $v]}] [llength $plist] -2]
-        }
-
-        #Strip using lengths without examining path components
-        #without normalization is much faster
-        proc path_strip_alreadynormalized_prefixdepth {path prefix} {
-            set tail [lrange  [file split $path] [llength [file split $prefix]] end]
-            if {[llength $tail]} {
-                return [file join {*}$tail]
-            }  else {
-                return ""
-            }
-        }
-
-        proc du_dirlisting_undecided {folderpath args} {
-            if {"windows" eq $::tcl_platform(platform)} {
-                #jmn disable twapi
-                #tailcall du_dirlisting_generic $folderpath {*}$args                        
-
-                set loadstate [zzzload::pkg_require twapi]
-                if {$loadstate ni [list loading failed]} {
-                    #either already loaded by zzload or ordinary package require
-                    package require twapi ;#should be fast once twapi dll loaded in zzzload thread
-                    set ::punk::du::has_twapi 1
-                    punk::du::active::set_active_function du_dirlisting du_dirlisting_twapi
-                    tailcall du_dirlisting_twapi $folderpath {*}$args
-                } else {
-                    if {$loadstate eq "failed"} {
-                        puts stderr "punk::du defaulting to du_dirlisting_generic because twapi load failed"
-                        punk::du::active::set_active_function du_dirlisting du_dirlisting_generic
-                    }
-                    tailcall du_dirlisting_generic $folderpath {*}$args                        
-                }
-            } else {
-                punk::du::active::set_active_function du_dirlisting du_dirlisting_unix
-                tailcall du_dirlisting_unix $folderpath {*}$args
-            }
-        }
-
-
-    }
-    package require natsort
-    #interp alias {} du {} .=args>* punk::du |> .=>1 natsort::sort -cols 1 |> list_as_lines <args|
-    #use natsort -debug 2 to see index output
-    #this works better for display of directory/file names with spaces (doesn't show curly braces)
-    interp alias {} du2 {}   .=args>* punk::du::du |> .=>1 natsort::sort -cols 1  -outputformat words |> list_as_lines <args|
-
-    #experiment with csv as easy way to get column like format..
-    #The /r is somewhat cheating however.. as it messes up redirected output .. e.g if redirected to text file
-    interp alias {} du {}  .=args>* punk::du::du |> .=>1 natsort::sort -cols 1  -outputformat csv -outputformatoptions {\r\t\t\t} |> list_as_lines <args|
-
-
-}
-
-
- namespace eval ::punk::du::active {
-    variable functions
-    variable functions_kown
-    upvar ::punk::du::has_twapi has_twapi
-
-    set_active_function du_dirlisting du_dirlisting_undecided
-
-}
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::du [namespace eval punk::du {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix-0.2.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix-0.2.tm
deleted file mode 100644
index 482c79a4..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix-0.2.tm
+++ /dev/null
@@ -1,21 +0,0 @@
-
-package require punk::cap
-
-package require punk::cap::handlers::templates ;#handler for templates cap
-punk::cap::register_capabilityname punk.templates ::punk::cap::handlers::templates 
-
-package require punk::mix::templates ;#registers as provider pkg for 'punk.templates' capability with punk::cap
-punk::mix::templates::provider register *
-
-package require punk::mix::base
-package require punk::mix::cli
-
-namespace eval punk::mix {
-    
-}
-
-package provide punk::mix [namespace eval punk::mix {
-    variable version
-    set version 0.2
-
-}]
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/base-0.1.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/base-0.1.tm
deleted file mode 100644
index 47f6c9d8..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/base-0.1.tm
+++ /dev/null
@@ -1,910 +0,0 @@
-package provide punk::mix::base [namespace eval punk::mix::base {
-	variable version
-	set version 0.1
-}]
-
-package require punk::path
-
-#base internal plumbing functions
-namespace eval punk::mix::base {
-    proc set_alias {cmdname args} {
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
- 
-        uplevel #0 [list interp alias {} $cmdname {} punk::mix::base::_cli -extension $extension]
-    }
-    proc _cli {args} {
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
-        if {![string length $extension]} {
-            set extension [namespace qualifiers [lindex [info level -1] 0]]
-        }
-        #puts stderr "punk::mix::base extension: [string trimleft $extension :]"
-        if {![string length $extension]} {
-            #if still no extension - must have been called dirctly as punk::mix::base::_cli
-            if {![llength $args]} {
-                set args "help"
-            }
-            set extension [namespace current]
-        }
-        if {![llength $args]} {
-            if {[info exists ${extension}::default_command]} {
-                tailcall $extension [set ${extension}::default_command]
-            }
-            tailcall $extension
-        } else {
-            tailcall $extension {*}$args
-        }
-    }
-    proc _unknown {ns args} {
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
-
-        if {![string length $extension]} {
-            set extension [namespace qualifiers [lindex [info level -1] 0]]
-        }
-        #puts stderr "arglen:[llength $args]"
-        #puts stdout "_unknown '$ns' '$args'"
-        
-        set d_commands [get_commands -extension $extension]
-        set all_commands [list {*}[dict get $d_commands main] {*}[dict get $d_commands base]]
-        error "Unknown subcommand \"[lindex $args 0]\": must be one of: $all_commands" "punk::mix::base _unknown $ns $args" [list unknown_ensemble_subcommand ensemble punk::mix::base]
-    }
-    proc _redirected {from_ns subcommand args} {
-        #puts stderr "_redirected from_ns: $from_ns subcommand:$subcommand args:$args"
-        set pname [namespace current]::$subcommand
-        if {$pname in [info procs $pname]} {
-            set argnames [info args $pname]
-            #puts stderr "_redirected $subcommand argnames: $argnames"
-            if {[lindex $argnames end] eq "args"} {
-                set pos_argnames [lrange $argnames 0 end-1]
-            } else {
-                set pos_argnames $argnames
-            }
-            set argvals [list]
-            set numargs [llength $pos_argnames]
-            if {$numargs > 0} {
-                set argvals [lrange $args 0 $numargs-1]
-                set args [lrange $args $numargs end]
-            }
-            if {[llength $argvals] < $numargs} {
-                error "wrong # args: $from_ns $subcommand requires args: $pos_argnames"
-            }
-            tailcall [namespace current] $subcommand {*}$argvals {*}$args -extension $from_ns
-        } else {
-            tailcall [namespace current] $subcommand {*}$args -extension $from_ns
-        }
-    }
-    proc _split_args {arglist} {
-        #don't assume arglist is fully paired.
-        set posn [lsearch $arglist -extension] 
-        set opts [list]
-        if {$posn >= 0} {
-            if {$posn+2 <= [llength $arglist]} {
-                set opts [list -extension [lindex $arglist $posn+1]]
-                set argsremaining [lreplace $arglist $posn $posn+1] 
-            } else {
-                #no value supplied to -extension
-                error "punk::mix::base::_split_args - no value found for option '-extension'. Supply a value or omit the option."
-            }
-        } else {
-            set argsremaining $arglist
-        }
-
-        return [list opts $opts args $argsremaining]
-    }
-}
-
-
-#base API (potentially overridden functions - may also be called from overriding namespace)
-#commands should either handle or silently ignore -extension <namespace/ensemble>
-namespace eval punk::mix::base {
-    namespace ensemble create
-    namespace export help dostuff get_commands set_alias
-    namespace ensemble configure [namespace current] -unknown punk::mix::base::_unknown
-    proc get_commands {args} {
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
-        if {![string length $extension]} {
-            set extension [namespace qualifiers [lindex [info level -1] 0]]
-        }
-       
-        set maincommands [list]
-        #extension may still be blank e.g if punk::mix::base::get_commands called directly
-        if {[string length $extension]} {
-            set nsmain $extension
-            #puts stdout "get_commands nsmain: $nsmain"
-            set parentpatterns [namespace eval $nsmain [list namespace export]]
-            set nscommands [list]
-            foreach p $parentpatterns {
-                lappend nscommands {*}[info commands ${nsmain}::$p]
-            }
-            foreach c $nscommands {
-                set cmd [namespace tail $c]
-                lappend maincommands $cmd 
-            }
-            set maincommands [lsort $maincommands]
-        }
-
-
-
-
-        set nsbase [namespace current]
-        set basepatterns [namespace export]
-        #puts stdout "basepatterns:$basepatterns"
-        set nscommands [list]
-        foreach p $basepatterns {
-            lappend nscommands {*}[info commands ${nsbase}::$p]
-        }
-
-        set basecommands [list]
-        foreach c $nscommands {
-            set cmd [namespace tail $c]
-            if {$cmd ni $maincommands} {
-                lappend basecommands $cmd
-            }
-        }
-        set basecommands [lsort $basecommands]
-
-
-        return [list main $maincommands base $basecommands] 
-    }
-    proc help {args} {
-        #' **%ensemblecommand% help** *args*
-        #' 
-        #'   Help for ensemble commands in the command line interface
-        #' 
-        #' 
-        #'   Arguments:
-        #' 
-        #'   * args  - first word of args is the helptopic requested - usually a command name
-        #'           - calling help with no arguments will list available commands
-        #' 
-        #'   Returns: help text (text)
-        #' 
-        #'   Examples:
-        #' 
-        #'   ```
-        #'   %ensemblecommand% help <commandname>
-        #'   ```
-        #' 
-        #' 
- 
-
-        #extension.= @@opts/@?@-extension,args@@args=>. [_split_args $args] {|
-        #    >}   inspect -label a              {|
-        #    >} .=e>end,data>end pipeswitch {
-        #        pipecase ,0/1/#= $switchargs {|
-        #            e/0
-        #            >} .=>. {set e}
-        #        pipecase /1,1/1/#= $switchargs 
-        #} |@@ok/result> <e/0| [namespace qualifiers [lindex [info level -1] 0]]
-
-
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
-
-
-
-        if {![string length $extension]} {
-            set extension [namespace qualifiers [lindex [info level -1] 0]]
-        }
-        #puts stderr "-1:[info level -1]"
-
-        set command_info [punk::mix::base::get_commands -extension $extension]
-        set subhelp1 [lindex $args 0] 
-        if {[string length $subhelp1]} {
-            if {[regexp {[*?]} $subhelp1]} {
-                set helpstr ""
-                append helpstr "matched commands:\n"
-                dict for {source cmdlist} $command_info {
-                    set matches [lsearch -all -inline -glob $cmdlist $subhelp1] 
-                    if {[llength $matches]} {
-                        append helpstr \n    "  $source"
-                        foreach cmd $matches {
-                            append helpstr \n "  - $cmd"
-                        }
-                    }
-                }
-                return $helpstr
-            } else {
-                dict for {source cmdlist} $command_info {
-                    if {$subhelp1 in $cmdlist} {
-                        if {$source eq "base"} {
-                            set ns [namespace current]
-                        } else {
-                            set ns $extension
-                        }
-                        set procname ${ns}::$subhelp1
-                        if {$procname in [info procs $procname]} {
-                            return "proc: $subhelp1 arguments: [info args $procname]"
-                        } else {
-                            set a [interp alias {} ${ns}::$subhelp1]
-                            if {[string length $a]} {
-                                return "alias: $subhelp1 target: $a"             
-                            } else {
-                                return "command: $subhelp1 (No info available)"
-                            }
-                        }
-                    }
-                }
-
-                return "No info found"
-            }
-
-        }
-        #result for just 'pmix help'
-        set helpstr ""
-        append helpstr "commands:\n"
-
-        foreach {source cmdlist} $command_info {
-            append helpstr \n     "  $source"
-            foreach cmd $cmdlist {
-                append helpstr \n "  - $cmd"
-            }
-        }
-        return $helpstr
-    }
-    #proc dostuff {args} {
-    #    extension@@opts/@?@-extension,args@@args= [_split_args $args] 
-    #    puts stdout "base doingstuff-with-args:'$args'-in-namespace:'[namespace current]'"
-    #}
-    namespace eval lib {
-        variable sha3_implementation "" ;#set by cksum_algorithms (which is called by cksum_path) It looks for fossil or sqlite3. Todo - add proper Tcl implementation.
-        namespace export *
-
-        #-----------------------------------------------------
-        #literate-programming style naming for some path tests
-        #Note the naming of the operator portion of a_op_b is consistent in that it is the higher side of the filesystem tree first.
-        #hence aboveorat vs atorbelow
-        #These names also sort in the logical order of higher to lower in the filesystem (when considering the root as 'higher' in the filesystem)
-        proc path_a_above_b {path_a path_b} {
-            #stripPath prefix path
-            return [expr {[fileutil::stripPath $path_a $path_b] ni [list . $path_b]}]
-        }
-        proc path_a_aboveorat_b {path_a path_b} {
-            return [expr {[fileutil::stripPath $path_a $path_b] ne $path_b}]
-        }
-        proc path_a_at_b {path_a path_b} {
-            return [expr {[fileutil::stripPath $path_a $path_b] eq "." }]
-        }
-        proc path_a_atorbelow_b {path_a path_b} {
-            return [expr {[fileutil::stripPath $path_b $path_a] ne $path_a}]
-        }
-        proc path_a_below_b {path_a path_b} {
-            return [expr {[fileutil::stripPath $path_b $path_a] ni [list . $path_a]}]
-        }
-        proc path_a_inlinewith_b {path_a path_b} {
-            return [expr {[path_a_aboveorat_b $path_a $path_b] || [path_a_below_b $path_a $path_b]}]
-        }
-        #-----------------------------------------------------
-
-
-
-        #find src/something folders which are not certain known folders with other purposes, (such as: bootsupport .vfs folders or vendor folders etc) and contain .tm file(s)
-        proc find_source_module_paths {{path {}}} {
-            if {![string length [set candidate [punk::repo::find_candidate $path]]]} {
-                error "find_source_module_paths cannot determine a suitable project root at or above path '$path' - path supplied should be within a project"
-            }
-            #we can return module paths even if the project isn't yet under revision control 
-            set src_subs [glob -nocomplain -dir [file join $candidate src] -type d -tail *]
-            set antipatterns [list *.vfs vendor* lib _build doc embedded runtime bootsupport]
-            set tm_folders [list]
-            foreach sub $src_subs {
-                set is_ok 1
-                foreach anti $antipatterns {
-                    if {[string match $anti $sub]} {
-                        set is_ok 0 
-                        break 
-                    }
-                }
-                if {!$is_ok} {
-                    continue
-                }
-                set testfolder [file join $candidate src $sub]
-                set tmfiles [glob -nocomplain -dir $testfolder -type f -tail *.tm]
-                if {[llength $tmfiles]} {
-                    lappend tm_folders $testfolder
-                } 
-            }
-            return $tm_folders
-        }
-
-        proc mix_templates_dir {} {
-            puts stderr "mix_templates_dir WARNING: deprecated - use get_template_basefolders instead"
-            set provide_statement [package ifneeded punk::mix [package require punk::mix]]
-            set tmdir [file dirname [lindex $provide_statement end]]
-            set tpldir $tmdir/mix/templates
-            if {![file exists $tpldir]} {
-                error "punk::mix::lib::mix_templates_dir unable to locate mix templates folder at '$tpldir'"
-            }
-            return $tpldir
-        }
-
-        #get_template_basefolders
-        #   scriptpath - file or folder
-        #   It represents the base point from which to search for mixtemplates folders either directly related to the scriptpath (../) or in the containing project if any
-        #   The cwd will also be searched for project root - but with lower precedence in the resultset (later in list)
-        proc get_template_basefolders {{scriptpath ""}} {
-            #1 lowest precedence - templates from packages (ordered by order in which packages registered with punk::cap)
-            set folderdict [dict create]
-
-            package require punk::cap
-            if {[punk::cap::capability_has_handler punk.templates]} {
-                set template_folder_dict [punk::cap::call_handler punk.templates folders]
-                dict for {dir folderinfo} $template_folder_dict {
-                    dict set folderdict $dir $folderinfo
-                }
-            }
-
-            #2 middle precedence - mixtemplates folder relative to cwd
-            set searchbase [pwd] 
-            set fld [file join $searchbase mixtemplates]
-            if {[file isdirectory $fld]} {
-                if {![dict exists $folderdict $fld]} {
-                    dict set folderdict $fld [list source $searchbase sourcetype cwd]
-                }
-            }
-            set pathinfo    [punk::repo::find_repos $searchbase]
-            set pwd_projectroot [dict get $pathinfo closest]
-            if {$pwd_projectroot ne ""} {
-                set fld [file join $pwd_projectroot src/mixtemplates]
-                if {![dict exists $folderdict $fld]} {
-                    dict set folderdict $fld [list source $pwd_projectroot sourcetype project]
-                }
-            }
-
-            #3 highest precedence - mixtemplates relative to scriptpath argument
-            if {$scriptpath ne ""} {
-                if {[file type $scriptpath] eq "file"} {
-                    set searchbase [file dirname $scriptpath]
-                } else {
-                    set searchbase $scriptpath
-                }
-                if {[file isdirectory [file join $searchbase mixtemplates]]} {
-                    dict set folderdict [file join $searchbase mixtemplates] [list source $searchbase sourcetype pathsearch]
-                }
-                set pathinfo    [punk::repo::find_repos $searchbase]
-                set scriptpath_projectroot [dict get $pathinfo closest]
-                if {$scriptpath_projectroot ne ""} {
-                    set fld [file join $scriptpath_projectroot src/mixtemplates]
-                    if {[file isdirectory $fld]} {
-                        dict set folderdict $fld [list source $scriptpath_projectroot sourcetype project]
-                    }
-                }
-            }
-            #don't sort - order in which encountered defines the precedence - with later overriding earlier
-            return $folderdict
-        }
-
-        proc module_subpath {modulename} {
-            set modulename [string trim $modulename :]
-            set nsq [namespace qualifiers $modulename]
-            return [string map [list :: /] $nsq]
-        }
-
-        proc get_build_workdir {path} {
-            set repo_info [punk::repo::find_repos $path]
-            set base [lindex [dict get $repo_info project] 0]
-            if {![string length $base]} {
-                error "get_build_workdir unable to determine project base for path '$path'"
-            }
-            if {![file exists $base/src] || ![file writable $base/src]} {
-                error "get_build_workdir unable to access $base/src"
-            }
-            file mkdir $base/src/_build
-            return $base/src/_build
-        }
-
-
-   
-        #todo - move cksum stuff to punkcheck - more logical home
-        proc cksum_path_content {path args} {
-            dict set args -cksum_content 1
-            dict set args -cksum_meta 0
-            tailcall cksum_path $path {*}$args
-        }
-
-        #not just used by cksum_path. used by caller (e.g fill_relativecksums_from_base_and_relativepathdict via cksum_filter_opts) to determine what opt names passed through
-        proc cksum_default_opts {} {
-            return [dict create -cksum_content 1 -cksum_meta auto -cksum_acls 0 -cksum_usetar auto -cksum_algorithm sha1]
-        }
-
-        #crc::cksum is extremely slow in tcllib as at 2023 e.g 20x slower (no c implementation?)
-        #sha1 is performant - and this is not being used in a cryptographic or adversarial context - so performance and practical unlikelihood of accidental collisions should be the main consideration.
-        #adler32 is fastest for some larger files of a few MB but slower on small files (possibly due to Tcl-based file load?)
-        #sha1 as at 2023 seems a good default 
-        proc cksum_algorithms {} {
-            variable sha3_implementation
-            #sha2 is an alias for sha256
-            #2023 - no sha3 available in tcllib - we can exec fossil for now - which will be very slow
-            set algs [list md5 sha1 sha2 sha256 cksum adler32]
-            set sha3_algs [list sha3 sha3-224 sha3-256 sha3-384 sha3-512]
-            if {[auto_execok sqlite3] ne ""} {
-                lappend algs {*}$sha3_algs 
-                set sha3_implementation sqlite3_sha3
-            } else {
-                if {[auto_execok fossil] ne ""} {
-                    lappend algs {*}$sha3_algs 
-                    set sha3_implementation fossil_sha3
-                }
-            }
-            return $algs
-        }
-
-        proc sqlite3_sha3 {bits filename} {
-            return [exec sqlite3 :memory: "select lower(hex(sha3(readfile('$filename'),$bits)))"]
-        }
-        proc fossil_sha3 {bits filename} {
-            return [lindex [exec fossil sha3sum -$bits $filename] 0]
-        }
-
-        #adler32 via file-slurp
-        proc cksum_adler32_file {filename} {
-            package require zlib; #should be builtin anyway
-            set data [punk::mix::util::fcat -translation binary $filename]
-            #set data [fileutil::cat -translation binary $filename] ;#no significant performance diff on windows - and doesn't handle win-illegal names
-            zlib adler32 $data
-        }
-
-
-        #required to be able to accept relative paths
-        #for full cksum - using tar could reduce number of hashes to be made..
-        #but as it stores metadata such as permission - we don't know if/how the archive will vary based on platform/filesystem
-        #-noperms only available on extraction - so that doesn't help
-        #Needs to operate on non-existant paths and return empty string in cksum field
-        proc cksum_path {path args} {
-            variable sha3_implementation
-            if {$path eq {}} { set path [pwd] }
-            if {[file pathtype $path] eq "relative"} {
-                set path [file normalize $path]
-            }
-            set base [file dirname $path]
-            set startdir [pwd]
-            
-            set defaults [cksum_default_opts]
-            set known_opts [dict keys $defaults]
-            foreach {k v} $args {
-                if {$k ni $known_opts} {
-                    error "cksum_path unknown option '$k' known_options: $known_opts"
-                }
-            }
-
-            set opts [dict merge $defaults $args]
-            set opts_actual $opts ;#default  - auto updated to 0 or 1 later
-
-            #if {![file exists $path]} {
-            #    return [list cksum "" opts $opts]
-            #}
-        
-            if {[catch {file type $path} ftype]} {
-                return [list  cksum "<PATHNOTFOUND>" opts $opts]
-            }
-            if {$ftype ni [list file directory]} {
-                #review - links?
-                error "cksum_path error file type '$ftype' not supported"
-            }
-
-
-            set opt_cksum_algorithm [dict get $opts -cksum_algorithm]
-            if {$opt_cksum_algorithm ni [cksum_algorithms]} {
-                return [list error unsupported_cksum_algorithm cksum "<ERR>" opts $opts]
-            }
-            set opt_cksum_acls [dict get $opts -cksum_acls]
-            if {$opt_cksum_acls} {
-                puts stderr "cksum_path is not yet able to cksum ACLs"
-                return
-            }
-
-            set opt_cksum_meta [dict get $opts -cksum_meta]
-            set opt_use_tar [dict get $opts -cksum_usetar]
-            if {$ftype eq "file"} {
-                if {$opt_use_tar eq "auto"} {
-                    if {$opt_cksum_meta eq "1"} {
-                        set opt_use_tar 1
-                    } else {
-                        #prefer no tar if meta not required - faster/simpler
-                        #meta == auto or 0
-                        set opt_cksum_meta 0
-                        set opt_use_tar 0
-                    }
-                } elseif {$opt_use_tar eq "0"} {
-                    if {$opt_cksum_meta eq "1"} {
-                        puts stderr "cksum_path doesn't yet support a non-tar cksum with metadata for a file"
-                        return [list error unsupported_meta_without_tar cksum "<ERR>" opts $opts]
-                    } else {
-                        #meta == auto or 0
-                        set opt_cksum_meta 0
-                    }
-                } else {
-                    #tar == 1
-                    if {$opt_cksum_meta eq "0"} {
-                        puts stderr "cksum_path doesn't yet support a tar cksum without metadata for a file"
-                        return [list error unsupported_tar_without_meta cksum "<ERR>" opts $opts]
-                    } else {
-                        #meta == auto or 1
-                        set opt_cksum_meta 1
-                    }
-                }
-            } elseif {$ftype eq "directory"} {
-                if {$opt_use_tar eq "auto"} {
-                    if {$opt_cksum_meta in [list "auto" "1"]} {
-                        set opt_use_tar 1
-                        set opt_cksum_meta 1
-                    } else {
-                        puts stderr "cksum_path doesn't yet support a content-only cksum of a folder structure. Currently only files supported without metadata. For folders use cksum_path -cksum_meta 1 or auto"
-                        return [list error unsupported_directory_cksum_without_meta cksum "<ERR>" opts $opts]
-                    }
-                } elseif {$opt_use_tar eq "0"} {
-                        puts stderr "cksum_path doesn't yet support a cksum of a folder structure without tar. Currently only files supported without metadata. For folders use cksum_path -cksum_meta 1 or auto with -cksum_usetar 1 or auto"
-                        return [list error unsupported_directory_cksum_without_tar cksum "<ERR>" opts $opts]
-                } else {
-                    #tar 1
-                    if {$opt_cksum_meta eq "0"} {
-                        puts stderr "cksum_path doesn't yet support a tar checksum of a folder structure without metadat. Currently only files supported without metadata. For folders use cksum_path -cksum_meta 1 or auto with -cksum_usetar 1 or auto"
-                        return [list error unsupported_without_meta cksum "<ERR>" opts $opts]
-                    } else {
-                        #meta == auto or 1
-                        set opt_cksum_meta 1
-                    }
-                }
-            }
-
-            dict set opts_actual -cksum_meta $opt_cksum_meta
-            dict set opts_actual -cksum_usetar $opt_use_tar
-
-
-            if {$opt_use_tar} {
-                package require tar ;#from tcllib
-            }
-
-            if {$path eq $base} {
-                #attempting to cksum at root/volume level of a filesystem.. extra work
-                #This needs fixing for general use.. not necessarily just for project repos 
-                puts stderr "cksum_path doesn't yet support cksum of entire volume. (todo)"
-                return [list error unsupported_path opts $opts]
-            }
-
-            if {$opt_cksum_algorithm eq "sha1"} {
-                package require sha1
-                set cksum_command [list sha1::sha1 -hex -file]
-            } elseif {$opt_cksum_algorithm in [list "sha2" "sha256"]} {
-                package require sha256
-                set cksum_command [list sha2::sha256 -hex -file]
-            } elseif {$opt_cksum_algorithm eq "md5"} {
-                package require md5
-                set cksum_command [list md5::md5 -hex -file]
-            } elseif {$opt_cksum_algorithm eq "cksum"} {
-                package require cksum ;#tcllib
-                set cksum_command [list crc::cksum -format 0x%X -file]
-            } elseif {$opt_cksum_algorithm eq "adler32"} {
-                set cksum_command [list cksum_adler32_file]
-            } elseif {$opt_cksum_algorithm in [list "sha3" "sha3-256"]} {
-                #todo - replace with something that doesn't call another process
-                #set cksum_command [list apply {{file} {lindex [exec fossil sha3sum -256 $file] 0}}]
-                set cksum_command [list $sha3_implementation 256]
-            } elseif {$opt_cksum_algorithm in [list "sha3-224" "sha3-384" "sha3-512"]} {
-                set bits [lindex [split $opt_cksum_algorithm -] 1]
-                #set cksum_command [list apply {{bits file} {lindex [exec fossil sha3sum -$bits $file] 0}} $bits]
-                set cksum_command [list $sha3_implementation $bits]
-            }
-
-            set cksum ""
-            if {$opt_use_tar != 0} {
-                set target [file tail $path]
-                set tmplocation [punk::mix::util::tmpdir]
-                set archivename $tmplocation/[punk::mix::util::tmpfile].tar
-
-                cd $base ;#cd is process-wide.. keep cd in effect for as small a scope as possible. (review for thread issues)
-            
-                #temp emission to stdout.. todo - repl telemetry channel 
-                puts stdout "cksum_path: creating temporary tar archive for $path"
-                puts stdout "  at: $archivename .."
-                tar::create $archivename $target
-                if {$ftype eq "file"} {
-                    set sizeinfo "(size [file size $target])"
-                } else {
-                    set sizeinfo "(file type $ftype - size unknown)"
-                }
-                puts stdout "cksum_path: calculating cksum for $target $sizeinfo..."
-                set cksum [{*}$cksum_command $archivename]
-                #puts stdout "cksum_path: cleaning up.. "
-                file delete -force $archivename
-                cd $startdir
-
-            } else {
-                #todo
-                if {$ftype eq "file"} {
-                    if {$opt_cksum_meta} {
-                        return [list error unsupported_opts_combo cksum "<ERR>" opts $opts]
-                    } else {
-                        set cksum [{*}$cksum_command $path]
-                    }
-                } else {
-                    error "cksum_path unsupported $opts for path type [file type $path]"       
-                }
-            }
-            set result [dict create]
-            dict set result cksum $cksum
-            dict set result opts $opts_actual
-            return $result
-        }
-
-        #dict_path_cksum keyed on path - with value as a dict that must contain cksum key - but can contain other keys
-        #e.g -cksum_usetar  which is one of the keys understood by the punk::mix::base::lib::cksum_path function - or unrelated keys which will also be passed through
-        #cksum only calculated for keys in dict where cksum is empty - ie return same dict but with empty cksums filled out.
-        #base can be empty string in which case paths must be absolute
-        proc fill_relativecksums_from_base_and_relativepathdict {base {dict_path_cksum {}}} {
-            if {$base eq ""} {
-                set error_paths [list]
-                dict for {path pathinfo} $dict_path_cksum {
-                    if {[file pathtype $path] ne "absolute"} {
-                        lappend error_paths $path
-                    }
-                }
-                if {[llength $error_paths]} {
-                    puts stderr "get_relativecksums_from_base_and_relativepathdict has empty base - and non-absolute paths in the supplied checksum dict - aborting"
-                    puts stderr "error_paths: $error_paths"
-                    error "fill_relativecksums_from_base_and_relativepathdict error: non-absolute paths when base empty. $error_paths"
-                }
-            } else {
-                if {[file pathtype $base] ne "absolute"} {
-                    error "fill_relativecksums_from_base_and_relativepathdict error: base supplied but was not absolute path.  $base"
-                }
-                #conversely now we have a base - so we require all paths are relative.
-                #We will ignore/disallow volume-relative - as these shouldn't be used here either
-                set error_paths [list]
-                dict for {path pathinfo} $dict_path_cksum {
-                    if {[file pathtype $path] ne "relative"} {
-                        lappend error_paths $path
-                    }
-                }
-                if {[llength $error_paths]} {
-                    puts stderr "fill_relativecksums_from_base_and_relativepathdict has a supplied absolute base path, but some of the paths in the supplied dict are not relative - aborting"
-                    error "fill_relativecksums_from_base_and_relativepathdict error: non-relative paths when base supplied. $error_paths"
-                }
-            }
-
-
-            dict for {path pathinfo} $dict_path_cksum {
-                if {![dict exists $pathinfo cksum]} {
-                    dict set pathinfo cksum ""
-                } else {
-                    if {[dict get $pathinfo cksum] ne "" && ![cksum_is_tag [dict get $pathinfo cksum]]} {
-                        continue ;#already filled with non-tag value
-                    }
-                }
-                if {$base ne ""} {
-                   set fullpath [file join $base $path] 
-                } else {
-                    set fullpath $path
-                }
-
-                set ckopts [cksum_filter_opts {*}$pathinfo]
-
-                if {![file exists $fullpath]} {
-                    dict set dict_path_cksum $path cksum "<PATHNOTFOUND>"
-                } else {
-                    set ckinfo [cksum_path $fullpath {*}$ckopts]
-                    dict set dict_path_cksum $path cksum [dict get $ckinfo cksum]
-                    dict set dict_path_cksum $path cksum_all_opts [dict get $ckinfo opts]
-                    if {[dict exists $ckinfo error]} {
-                        dict set dict_path_cksum $path cksum_error [dict get $ckinfo error]
-                    }
-                }
-            }
-
-            return $dict_path_cksum
-        }
-        #whether cksum is <XXX>  e.g <ERR> <PATHNOTFOUND>
-        proc cksum_is_tag {cksum} {
-            expr {[string index $cksum 0] eq "<" && [string index $cksum end] eq ">"}
-        }
-        proc cksum_filter_opts {args} {
-            set ck_opt_names [dict keys [cksum_default_opts]]
-            set ck_opts [dict create]
-            dict for {k v} $args {
-                if {$k in $ck_opt_names} {
-                    dict set ck_opts $k $v
-                }
-            }
-            return $ck_opts
-        }
-
-        #convenience so caller doesn't have to pre-calculate the relative path from the base
-        #Note semantic difference from fill_relativecksums_from_base_and_relativepathdict  (hence get_ vs fill_)
-        #Here we will raise an error if cksum exists and is not empty or a tag - whereas the multiple path version will ignore valid-looking prefilled cksum values
-        #base is the presumed location to store the checksum file. The caller should retain (normalize if relative)
-        proc get_relativecksum_from_base {base specifiedpath args} {
-            if {$base ne ""} { 
-                #targetpath ideally should be within same project tree as base if base supplied - but not necessarily below it
-                #we don't necessarily want to restrict this to use in punk projects though - so we'll allow anything with a common prefix
-                if {[file pathtype $specifiedpath] eq "relative"} {
-                    if {[file pathtype $base] eq "relative"} {
-                        set normbase [file normalize $base]
-                        set normtarg [file normalize [file join $normbase $specifiedpath]]
-                        set targetpath $normtarg
-                        set storedpath [punk::path::relative $normbase $normtarg]
-                    } else {
-                        set targetpath [file join $base $specifiedpath]
-                        set storedpath $specifiedpath
-                    }
-                } else {
-                    #specifed absolute
-                    if {[file pathtype $base] eq "relative"} {
-                        #relative to cwd or to specifiedpath? For consistency it should arguably be cwd but a case could be made that when one path is relative it is in reference to the other
-                        #there is a strong possibility that allowing this combination will cause confusion - better to disallow
-                        error "get_relativecksum_from_base error: disallowed pathtype combination. Base must be empty or absolute when specified path is absolute"
-                    }
-                    #both absolute - compute relative path if they share a common prefix
-                    set commonprefix [punk::mix::util::path_common_prefix $base $specifiedpath]
-                    if {$commonprefix eq ""} {
-                        #absolute base with no shared prefix doesn't make sense - we could ignore it - but better to error-out and require the caller specify an empty base
-                        error "get_relativecksum_from_base error: base '$base' and specifiedpath '$specifiedpath' don't share a common root. Use empty-string for base if independent absolute path is required"
-                    }
-                    set targetpath $specifiedpath 
-                    set storedpath [punk::path::relative $base $specifiedpath]
-                    
-                }
-            } else {
-                if {[file type $specifiedpath] eq "relative"} {
-                    #if specifiedpath is relative - and we don't have a base, we now need to convert relative to cwd to an absolute path for storage
-                    set targetpath [file normalize $specifiedpath]
-                    set storedpath $targetpath
-                } else {
-                    set targetpath $specifiedpath
-                    set storedpath $targetpath
-                }
-            }
-
-            #
-            #NOTE: specifiedpath can be a relative path (to cwd) when base is empty
-            #OR - a relative path when base itself is relative  e.g base: somewhere  targetpath somewhere/etc 
-            #possibly also:  base: somewhere targetpath: ../elsewhere/etc
-            #
-            #todo - write tests
-
-
-            if {([llength $args] % 2) != 0} {
-                error "get_relativecksum_from_base error. args supplied must be in the form of key-value pairs. received '$args' "
-            }
-            if {[dict exists $args cksum]} {
-                if {[dict get $args cksum] ne "" && ![cksum_is_tag [dict get $args cksum]]} {
-                    error "get_relativecksum_from_base called with existing cksum value (and is not a tag or empty-value to be replaced) cksum: [dict get $args cksum]  Set cksum to be empty, any tag such as <REPLACE> or remove the key and try again."
-                }
-            }
-
-
-            set ckopts [cksum_filter_opts {*}$args]
-            set ckinfo [cksum_path $targetpath {*}$ckopts]
-            
-            set keyvals $args
-            dict set keyvals cksum [dict get $ckinfo cksum]
-            dict set keyvals cksum_all_opts [dict get $ckinfo opts]
-            if {[dict exists $ckinfo error]} {
-                dict set keyvals cksum_error [dict get $ckinfo error]
-            }
-
-            #set relpath [punk::repo::path_strip_alreadynormalized_prefixdepth $fullpath $base] ;#empty base ok noop
-            #storedpath is relative if possible 
-            return [dict create $storedpath $keyvals]
-        }
-
-        #calculate the runtime checksum and vfs checksums
-        proc get_all_vfs_build_cksums {path} {
-            set buildfolder [get_build_workdir $path]
-            set cksum_base_folder [file dirname $buildfolder] ;#this is the <project>/src folder - a reasonable base for our vfs cksums
-            set dict_cksums [dict create]
-
-            set buildrelpath [punk::repo::path_strip_alreadynormalized_prefixdepth $buildfolder $cksum_base_folder]
-            set vfs_tail_list [glob -nocomplain -dir $cksum_base_folder -type d -tails *.vfs]
-
-            foreach vfstail $vfs_tail_list {
-                set vname [file rootname $vfstail]
-                dict set dict_cksums $vfstail [list cksum ""]
-                dict set dict_cksums [file join $buildrelpath $vname.exe] [list cksum ""]
-            }
-
-            set fullpath_buildruntime $buildfolder/buildruntime.exe
-
-            set ckinfo_buildruntime [cksum_path $fullpath_buildruntime]
-            set ck [dict get $ckinfo_buildruntime cksum]
-
-
-            set relpath [file join $buildrelpath "buildruntime.exe"]
-            dict set dict_cksums $relpath [list cksum $ck]
-
-            set dict_cksums [fill_relativecksums_from_base_and_relativepathdict $cksum_base_folder $dict_cksums]
-
-            return $dict_cksums
-        }
-
-        proc get_vfs_build_cksums_stored {vfsfolder} {
-            set vfscontainer [file dirname $vfsfolder]
-            set buildfolder $vfscontainer/_build
-            set vfs [file tail $vfsfolder]
-            set vname [file rootname $vfs]
-            set dict_vfs [list $vname.vfs "" $vname.exe "" buildruntime.exe ""]
-            set ckfile $buildfolder/$vname.cksums
-            if {[file exists $ckfile]} {
-                set data [punk::mix::util::fcat -translation binary $ckfile]
-                foreach ln [split $data \n] {
-                    if {[string trim $ln] eq ""} {continue}
-                    lassign $ln path cksum
-                    dict set dict_vfs $path $cksum
-                }
-            }
-            return $dict_vfs
-        }
-        proc get_all_build_cksums_stored {path} {
-            set buildfolder [get_build_workdir $path]
-            
-            set vfscontainer [file dirname $buildfolder]
-            set vfslist [glob -nocomplain -dir $vfscontainer -type d -tail *.vfs]
-            set dict_cksums [dict create]
-            foreach vfs $vfslist {
-                set vname [file rootname $vfs]
-                set dict_vfs [get_vfs_build_cksums_stored $vfscontainer/$vfs]
-
-                dict set dict_cksums $vname $dict_vfs
-            }
-            return $dict_cksums
-        }
-
-        proc store_vfs_build_cksums {vfsfolder} {
-            if {![file isdirectory $vfsfolder]} {
-                error "Unable to find supplied vfsfolder: $vfsfolder"
-            }
-            set vfscontainer [file dirname $vfsfolder]
-            set buildfolder $vfscontainer/_build
-            set dict_vfs [get_vfs_build_cksums $vfsfolder] 
-            set data ""
-            dict for {path cksum} $dict_vfs {
-                append data "$path $cksum" \n
-            }
-            set fd [open $buildfolder/$vname.cksums w]
-            chan configure $fd -translation binary
-            puts $fd $data
-            close $fd
-            return $dict_vfs
-        }
-
-
-
-    }
-}
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/cli-0.3.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/cli-0.3.tm
deleted file mode 100644
index a845285c..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/cli-0.3.tm
+++ /dev/null
@@ -1,925 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::cli 0.3
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require punk::repo
-package require punkcheck ;#checksum and/or timestamp records 
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-
-namespace eval punk::mix::cli {
-    namespace eval temp_import {
-    }
-    namespace ensemble create
-
-    package require punk::overlay
-    catch {
-        punk::overlay::import_commandset module . ::punk::mix::commandset::module
-    }
-    punk::overlay::import_commandset debug . ::punk::mix::commandset::debug
-    punk::overlay::import_commandset repo  . ::punk::mix::commandset::repo
-    punk::overlay::import_commandset lib   . ::punk::mix::commandset::loadedlib
-
-    catch {
-        package require punk::mix::commandset::project
-        punk::overlay::import_commandset project    .       ::punk::mix::commandset::project
-        punk::overlay::import_commandset projects   .       ::punk::mix::commandset::project::collection 
-    }
-    if {[catch {
-        package require punk::mix::commandset::layout
-        punk::overlay::import_commandset project.layout       . ::punk::mix::commandset::layout
-        punk::overlay::import_commandset project.layouts      . ::punk::mix::commandset::layout::collection
-    } errM]} {
-        puts stderr "error loading punk::mix::commandset::layout"
-        puts stderr $errM
-    }
-    if {[catch {
-        package require punk::mix::commandset::buildsuite
-        punk::overlay::import_commandset buildsuite     .   ::punk::mix::commandset::buildsuite
-        punk::overlay::import_commandset buildsuites    .   ::punk::mix::commandset::buildsuite::collection
-    } errM]} {
-        puts stderr "error loading punk::mix::commandset::buildsuite"
-        puts stderr $errM
-    }
-    punk::overlay::import_commandset scriptwrap  . ::punk::mix::commandset::scriptwrap
-    if {[catch {
-        package require punk::mix::commandset::doc
-        punk::overlay::import_commandset doc . ::punk::mix::commandset::doc
-        punk::overlay::import_commandset ""  ""   ::punk::mix::commandset::doc::collection
-    } errM]} {
-        puts stderr "error loading punk::mix::commandset::doc"
-        puts stderr $errM
-    }
-
-
-    proc help {args} {
-        #set basehelp [punk::mix::base::help -extension [namespace current] {*}$args]
-        set basehelp [punk::mix::base help {*}$args]
-        #puts stdout "punk::mix help"
-        return $basehelp
-    }
-
-    proc stat {{workingdir ""} args} {
-        dict set args -v 0 
-        punk::mix::cli::lib::get_status $workingdir {*}$args 
-    }
-    proc status {{workingdir ""} args} {
-        dict set args -v 1 
-        punk::mix::cli::lib::get_status $workingdir {*}$args 
-    }
-
-
-
-
-
-
-
-}
-
-
-namespace eval punk::mix::cli {
-
-
-    #interp alias {} ::punk::mix::cli::project.new {} ::punk::mix::cli::new
-
-
-
-
-
-
-
-    proc make {args} {
-        set startdir [pwd]
-        set project_base "" ;#empty for unknown
-        if {[punk::repo::is_git $startdir]} {
-            set project_base [punk::repo::find_git]
-            set sourcefolder $project_base/src
-        } elseif {[punk::repo::is_fossil $startdir]} {
-            set project_base [punk::repo::find_fossil]
-            set sourcefolder $project_base/src
-        } else {
-            if {[punk::repo::is_candidate $startdir]} {
-                set project_base [punk::repo::find_candidate]
-                set sourcefolder $project_base/src
-                puts stderr "WARNING - project not under git or fossil control"
-                puts stderr "Using base folder $project_base" 
-            } else {
-                set sourcefolder $startdir
-            }
-        }
-
-        #review - why can't we be anywhere in the project? 
-        if {([file tail $sourcefolder] ne "src") || (![file exists $sourcefolder/make.tcl])} {
-            puts stderr "pmix make must be run from src folder containing make.tcl - unable to proceed (cwd: [pwd])"
-            if {[string length $project_base]} {
-                if {[file exists $project_base/src] && [string tolower [pwd]] ne [string tolower $project_base/src]} {
-                    puts stderr "Try cd to $project_base/src"
-                }
-            } else {
-                if {[file exists $startdir/Makefile]} {
-                    puts stdout "A Makefile exists at $startdir/Makefile."
-                    if {"windows" eq $::tcl_platform(platform)} {
-                        puts stdout "Try running: msys2 -ucrt64 -here -c \"make build\" or bash -c \"make build\""
-                    } else {
-                        puts stdout "Try runing: make build"
-                    }
-                }
-            }
-            return false
-        }
-
-        if {![string length $project_base]} {
-            puts stderr "WARNING no git or fossil repository detected."
-            puts stderr "Using base folder $startdir" 
-            set project_base $startdir
-        }
-
-        set lc_this_exe [string tolower [info nameofexecutable]]
-        set lc_proj_bin [string tolower $project_base/bin]
-        set lc_build_bin [string tolower $project_base/src/_build]
-
-        if {"project" in $args} {
-            set is_own_exe 0
-            if {[string match "${lc_proj_bin}*" $lc_this_exe] || [string match "${lc_build_bin}" $lc_this_exe]} {
-                set is_own_exe 1
-                puts stderr "WARNING - running make using executable that may be created by the project being built"
-                set answer [util::askuser "Do you want to proceed using this executable? (build will probably stop when it is unable to  update the executable) Y|N"]
-                if {[string tolower $answer] ne "y"} {
-                    puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                    return
-                }
-            }
-        }
-        cd $sourcefolder
-        #use run so that stdout visible as it goes
-        if {![catch {run --timeout=55000 -debug [info nameofexecutable] $sourcefolder/make.tcl {*}$args} exitinfo]} {
-            #todo - notify if exit because of timeout!
-            puts stderr "exitinfo: $exitinfo"
-            set exitcode [dict get $exitinfo exitcode]
-        } else {
-            puts stderr "Error unable to determine exitcode. err: $exitinfo"
-            cd $startdir
-            return false
-        }
-
-        cd $startdir
-        if {$exitcode != 0} {
-            puts stderr "FAILED with exitcode $exitcode"
-            return false
-        } else {
-            puts stdout "OK make finished "
-            return true
-        }
-    } 
-
-    proc Kettle {args} {
-        tailcall lib::kettle_call lib {*}$args
-    }
-    proc KettleShell {args} {
-        tailcall lib::kettle_call shell {*}$args
-    }
-
-
-
-    namespace eval lib {
-        namespace path ::punk::mix::util
-
-
-        proc module_types {} {
-            #first in list is default for unspecified -type when creating new module
-            return [list plain tarjar zipkit]
-        }
-
-        proc validate_modulename {modulename args} {
-            set defaults [list\
-                -name_description modulename\
-                ]
-            if {[llength $args] %2 != 0} {error "validate_modulename args must be name-value pairs: received '$args'"}
-            set known_opts [dict keys $defaults]
-            foreach k [dict keys $args] {
-                if {$k ni $known_opts} {
-                    error "validate_modulename error: unknown option $k. known options: $known_opts"
-                }
-            }
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_name_description            [dict get $opts -name_description]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-            validate_name_not_empty_or_spaced $modulename -name_description $opt_name_description
-            set testname [string map [list :: ""] $modulename]
-            if {[string first : $testname] >=0} {
-                error "$opt_name_description '$modulename' can only contain paired colons"
-            }
-            set badchars [list - "$" "?" "*"]
-            foreach bc $badchars {
-                if {[string first $bc $modulename] >= 0} {
-                    error "$opt_name_description '$modulename' can not contain character '$bc'"
-                }
-            }
-            return $modulename
-        }
-
-        proc validate_projectname {projectname args} {
-            set defaults [list\
-                -name_description projectname\
-                ]
-            if {[llength $args] %2 != 0} {error "validate_modulename args must be name-value pairs: received '$args'"}
-            set known_opts [dict keys $defaults]
-            foreach k [dict keys $args] {
-                if {$k ni $known_opts} {
-                    error "validate_modulename error: unknown option $k. known options: $known_opts"
-                }
-            }
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_name_description            [dict get $opts -name_description]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            validate_name_not_empty_or_spaced $projectname -name_description $opt_name_description
-            set reserved_words [list etc lib bin modules src doc vendorlib vendormodules embedded runtime _aside _build]
-            if {$projectname in $reserved_words } {
-                error "$opt_name_description '$projectname' cannot be one of reserved_words: $reserved_words"
-            }
-            if {[string first "::" $projectname] >= 0} {
-                error "$opt_name_description '$projectname' cannot contain namespace separator '::'"
-            }
-            return $projectname 
-        }
-        proc validate_name_not_empty_or_spaced {name args} {
-            set defaults [list\
-                -name_description projectname\
-                ]
-            if {[llength $args] %2 != 0} {error "validate_modulename args must be name-value pairs: received '$args'"}
-            set known_opts [dict keys $defaults]
-            foreach k [dict keys $args] {
-                if {$k ni $known_opts} {
-                    error "validate_modulename error: unknown option $k. known options: $known_opts"
-                }
-            }
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_name_description            [dict get $opts -name_description]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            if {![string length $name]} {
-                error "$opt_name_description cannot be empty"
-            }
-            if {[string length [string map [list " " "" \n "" \r "" \t ""] $name]] != [string length $name]} {
-                error "$opt_name_description cannot contain whitespace"
-            }
-            return $name
-        }
-
-        #split modulename (as present in a filename or namespaced name) into name/version ignoring leading namespace path
-        #ignore trailing .tm .TM if present
-        #if version doesn't pass validation - treat it as part of the modulename and return empty version string without error
-        #Up to caller to validate.
-        proc split_modulename_version {modulename} {
-            set lastpart [namespace tail $modulename]
-            set lastpart [file tail $lastpart] ;# should be ok to use file tail now that we've ensured no namespace components
-            if {[string equal -nocase [file extension $modulename] ".tm"]} {
-                 set fileparts [split [file rootname $lastpart] -]
-            } else {
-                 set fileparts [split $lastpart -]
-            }
-            if {[punk::mix::util::is_valid_tm_version [lindex $fileparts end]]} {
-                set versionsegment [lindex $fileparts end]
-                set namesegment [join [lrange $fileparts 0 end-1] -];#re-stitch
-            } else {
-                #
-                set namesegment [join $fileparts -]
-                set versionsegment ""
-            }
-            return [list $namesegment $versionsegment]
-        }
-
-        proc get_status {{workingdir ""} args} {
-            set result ""
-            if {$workingdir ne ""} {
-                if {[file pathtype $workingdir] ne "absolute"} {
-                set workingdir [file normalize $workingdir] 
-                }
-                set active_dir $workingdir
-            } else {
-                set active_dir [pwd]
-            }
-            set defaults [dict create\
-                -v 1\
-            ]
-            set opts [dict merge $defaults $args] 
-            # -- --- --- --- --- --- --- --- --- 
-            set opt_v       [dict get $opts -v]
-            # -- --- --- --- --- --- --- --- --- 
-
-
-            set repopaths [punk::repo::find_repos [pwd]]
-            set repos [dict get $repopaths repos]
-            if {![llength $repos]} {
-                append result [dict get $repopaths warnings]
-            } else {
-                append result [dict get $repopaths warnings]
-                lassign [lindex $repos 0] repopath repotypes
-                if {"fossil" in $repotypes} {
-                    #review - multiple process launches to fossil a bit slow on windows.. 
-                    #could we query global db in one go instead?
-                    #
-                    set fossil_prog [auto_execok fossil]
-                    append result "FOSSIL project based at $repopath with revision: [punk::repo::fossil_revision $repopath]" \n
-                    set fosinfo [exec {*}$fossil_prog info]
-                    append result [join [punk::repo::grep {repository:*}        $fosinfo] \n] \n
-
-                    set fosrem [exec {*}$fossil_prog remote ls]
-                    if {[string length $fosrem]} {
-                        append result "Remotes:\n"
-                        append result "    " $fosrem \n
-                    }
-
-
-                    append result [join [punk::repo::grep {tags:*}              $fosinfo] \n] \n
-
-                    set dbinfo [exec {*}$fossil_prog dbstat]
-                    append result [join [punk::repo::grep {project-name:*}      $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {tickets:*}           $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {project-age:*}       $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {latest-change:*}     $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {files:*}             $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {check-ins:*}         $dbinfo] \n] \n
-                    if {"project" in $repotypes} {
-                        #punk project
-                        if {![catch {package require textblock; package require patternpunk}]} {
-                           set result [textblock::join [textblock::join [>punk . logo] "  "] $result]
-                           append result \n
-                        } 
-                    }  
-
-                    set timeline [exec fossil timeline -n 5 -t ci]
-                    set timeline [string map [list \r\n \n] $timeline]
-                    append result $timeline 
-                    if {$opt_v} {
-                        set repostate [punk::repo::workingdir_state $repopath -repopaths $repopaths -repotypes fossil]
-                        append result \n [punk::repo::workingdir_state_summary $repostate]
-                    }
-
-                }
-                #repotypes *could* be both git and fossil - so report both if so
-                if {"git" in $repotypes} {
-                    append result "GIT project based at $repopath with revision: [punk::repo::git_revision $repopath]" \n
-                    if {[string length [set git_prog [auto_execok git]]]} {
-                        set git_remotes [exec {*}$git_prog remote -v]
-                        append result $git_remotes
-                        if {$opt_v} {
-                            set repostate [punk::repo::workingdir_state $repopath -repopaths $repopaths -repotypes git]
-                            append result \n [punk::repo::workingdir_state_summary $repostate]
-                        }
-                    }
-                }
-
-            }
-
-            return $result
-        }
-
-
-        proc build_modules_from_source_to_base {srcdir basedir args} {
-            set antidir [list "#*" "_aside" ".git" ".fossil*"] ;#exact or glob patterns for folders we don't want to search in.
-            set defaults [list\
-                -installer punk::mix::cli::build_modules_from_source_to_base\
-                -call-depth-internal 0\
-                -max_depth 1000\
-                -subdirlist {}\
-                -punkcheck_eventobj "\uFFFF"\
-                -glob *.tm\
-                ]
-            set opts [dict merge $defaults $args]
-
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set installername                       [dict get $opts -installer]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set CALLDEPTH                               [dict get $opts -call-depth-internal]
-            set max_depth                               [dict get $opts -max_depth]
-            set subdirlist                              [dict get $opts -subdirlist]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set fileglob                                [dict get $opts -glob]
-            if {![string match "*.tm" $fileglob]} {
-                error "build_modules_from_source_to_base -glob '$fileglob' doesn't seem to target tcl modules."
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_punkcheck_eventobj                   [dict get $opts -punkcheck_eventobj]
-
-            set magicversion [punk::mix::util::magic_tm_version] ;#deliberately large so given load-preference when testing
-            set module_list [list]
-
-            if {[file tail [file dirname $srcdir]] ne "src"} {
-                puts stderr "ERROR build_modules_from_source_to_base can only be called with a srcdir that is a subfolder of your 'src' directory"
-                puts stderr "The .tm modules are namespaced based on their directory depth - so we need to start at the root"
-                puts stderr "To build a subtree of your modules - use an appropriate src/modules folder and pass in the -subdirlist."
-                puts stderr "e.g if your modules are based at /x/src/modules2 and you wish to build only the .tm files at /x/src/modules2/skunkworks/lib"
-                puts stderr "Use: >build_modules_from_source_to_base /x/src/modules2 /x/modules2 -subdirlist {skunkworks lib}"
-                exit 2
-            }
-            set srcdirname [file tail $srcdir] 
-
-            set build [file dirname $srcdir]/_build/$srcdirname ;#relative to *original* srcdir - not current_source_dir
-            if {[llength $subdirlist] == 0} {
-                set target_module_dir $basedir
-                set current_source_dir $srcdir
-            } else {
-                set target_module_dir $basedir/[file join {*}$subdirlist]
-                set current_source_dir $srcdir/[file join {*}$subdirlist]
-            }
-            if {![file exists $target_module_dir]} {
-                error "build_modules_from_source_to_base from current source dir: '$current_source_dir'.  Basedir:'$current_module_dir' doesn't exist or is empty"
-            }
-            if {![file exists $current_source_dir]} {
-                error "build_modules_from_source_to_base from current source dir:'$current_source_dir' doesn't exist or is empty"
-            }
-
-            #----------------------------------------
-            set punkcheck_file [file join $basedir/.punkcheck]
-            if {$CALLDEPTH == 0} {
-
-                set config [dict create\
-                    -glob $fileglob\
-                    -max_depth 0\
-                ]
-                #lassign [punkcheck::start_installer_event $punkcheck_file $installername $srcdir $basedir $config] _eventid punkcheck_eventid _recordset record_list
-                # -- ---
-                set installer [punkcheck::installtrack new $installername $punkcheck_file]
-                $installer set_source_target $srcdir $basedir
-                set event [$installer start_event $config]
-                # -- ---
-
-            } else {
-                set event $opt_punkcheck_eventobj
-            }
-            #----------------------------------------
-
-
-
-            set src_modules [glob -nocomplain -dir $current_source_dir -type f -tail $fileglob]
-
-            set did_skip 0 ;#flag for stdout/stderr formatting only
-            foreach m $src_modules {
-                set is_interesting 0
-                if {[string match "foobar" $current_source_dir]} {
-                    set  is_interesting 1
-                }
-                if {$is_interesting} {
-                    puts "build_modules_from_source_to_base >>> module $current_source_dir/$m"
-                }
-                set fileparts [split [file rootname $m] -]
-                set tmfile_versionsegment [lindex $fileparts end]
-                if {$tmfile_versionsegment eq $magicversion} {
-                    #rebuild the .tm from the #tarjar 
-                    set basename [join [lrange $fileparts 0 end-1] -]
-                    set versionfile $current_source_dir/$basename-buildversion.txt
-                    set versionfiledata ""
-                    if {![file exists $versionfile]} {
-                        puts stderr "\nWARNING: Missing buildversion text file: $versionfile"
-                        puts stderr "Using version 0.1 - create $versionfile containing the desired version number as the top line to avoid this warning\n"
-                        set module_build_version "0.1"
-                    } else {
-                        set fd [open $versionfile r]
-                        set versionfiledata [read $fd]; close $fd
-                        set ln0 [lindex [split $versionfiledata \n] 0]
-                        set ln0 [string trim $ln0]; set ln0 [string trim $ln0 \r]
-                        if {![util::is_valid_tm_version $ln0]} {
-                            puts stderr "ERROR: build version '$ln0' specified in $versionfile is not suitable. Please ensure a proper version number is at first line of file"
-                            exit 3
-                        }
-                        set module_build_version $ln0
-                    }
-
-
-                    if {[file exists $current_source_dir/#tarjar-$basename-$magicversion]} {
-                        #TODO
-                        file mkdir $buildfolder
-
-                        if {[file exists $current_source_dir/#tarjar-$basename-$magicversion/DESCRIPTION.txt]} {
-                        
-                        } else {
-                        
-                        }
-                        #REVIEW - should be in same structure/depth as $target_module_dir  in _build?
-                        set tmfile $basedir/_build/$basename-$module_build_version.tm
-                        file mkdir $basedir/_build
-                        file delete -force $basedir/_build/#tarjar-$basename-$module_build_version
-                        file delete -force $tmfile
-                        
-                        
-                        file copy -force $current_source_dir/#tarjar-$basename-$magicversion $basedir/_build/#tarjar-$basename-$module_build_version
-                        #
-                        #bsdtar doesn't seem to work.. or I haven't worked out the right options?
-                        #exec tar -cvf $basedir/_build/$basename-$module_build_version.tm $basedir/_build/#tarjar-$basename-$module_build_version
-                        package require tar
-                        tar::create $tmfile $basedir/_build/#tarjar-$basename-$module_build_version  
-                        if {![file exists $tmfile]} {
-                            puts stdout "ERROR: Failed to build tarjar file $tmfile"
-                            exit 4
-                        }
-                        #copy the file?
-                        #set target $target_module_dir/$basename-$module_build_version.tm                
-                        #file copy -force $tmfile $target
-                        
-                        lappend module_list $tmfile
-                    } else {
-                        #assume that either the .tm is not a tarjar - or the tarjar dir is capped (trailing #) and the .tm has been manually tarred.
-                        if {[file exists $current_source_dir/#tarjar-$basename-${magicversion}#]} {
-                            puts stderr "\nWarning: found 'capped' folder #tarjar-$basename-${magicversion}# - No attempt being made to update version in description.txt"
-                        }
-
-                        #------------------------------
-                        #
-                        #set target_relpath [punkcheck::lib::path_relative $basedir $target_module_dir/$basename-$module_build_version.tm]
-                        #set file_record [punkcheck::installfile_begin $basedir $target_relpath $installername -eventid $punkcheck_eventid]
-                        $event targetset_init INSTALL $target_module_dir/$basename-$module_build_version.tm 
-                        $event targetset_addsource $versionfile
-                        $event targetset_addsource $current_source_dir/$m
-
-                        #set changed_list [list]
-                        ## -- --- --- --- --- ---
-                        #set source_relpath [punkcheck::lib::path_relative $basedir $versionfile]
-                        #set file_record [punkcheck::installfile_add_source_and_fetch_metadata $basedir $source_relpath $file_record]
-                        ## -- --- --- --- --- ---
-                        #set source_relpath [punkcheck::lib::path_relative $basedir $current_source_dir/$m]
-                        #set file_record [punkcheck::installfile_add_source_and_fetch_metadata $basedir $source_relpath $file_record]
-                        ## -- --- --- --- --- ---
-                        #set changed_unchanged [punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $file_record body] end]]
-                        #set changed_list [dict get $changed_unchanged changed]
-
-
-                        if {\
-                                [llength [dict get [$event targetset_source_changes] changed]]\
-                            || [llength [$event get_targets_exist]] < [llength [$event get_targets]]\
-                            } {
-
-                            #set file_record [punkcheck::installfile_started_install $basedir $file_record]
-                            $event targetset_started
-                            # -- --- --- --- --- ---
-                            set target $target_module_dir/$basename-$module_build_version.tm
-                            if {$did_skip} {set did_skip 0; puts -nonewline stdout \n}
-                            puts stdout "copying module $current_source_dir/$m to $target as version: $module_build_version ([file tail $target])"
-                            set fd [open $current_source_dir/$m r]; fconfigure $fd -translation binary; set data [read $fd]; close $fd
-                            set data [string map [list $magicversion $module_build_version] $data]
-                            set fdout [open $target w]
-                            fconfigure $fdout -translation binary
-                            puts -nonewline $fdout $data
-                            close $fdout
-                            #file copy -force $srcdir/$m $target
-                            lappend module_list $target
-                            # -- --- --- --- --- ---
-                            #set file_record [punkcheck::installfile_finished_install $basedir $file_record]
-                            $event targetset_end OK
-                        } else {
-                            if {$is_interesting} {
-                                puts stdout "skipping module $current_source_dir/$m - no change in sources detected"
-                            }
-                            puts -nonewline stderr "."
-                            set did_skip 1
-                            #set file_record [punkcheck::installfile_skipped_install $basedir $file_record]
-                            $event targetset_end SKIPPED
-                        }
-
-                        #------------------------------
-
-                    }
-                     
-                    continue
-                }
-                
-                
-                if {![util::is_valid_tm_version $tmfile_versionsegment]} {
-                    #last segment doesn't look even slightly versiony - fail.
-                    puts stderr "ERROR: Unable to confirm file $current_source_dir/$m is a reasonably versioned .tm module - ABORTING."
-                    exit 1
-                }
-
-                ##------------------------------
-                ##
-                #set target_relpath [punkcheck::lib::path_relative $basedir $target_module_dir/$m]
-                #set file_record [punkcheck::installfile_begin $basedir $target_relpath $installername -eventid $punkcheck_eventid]
-                #set changed_list [list]
-                ## -- --- --- --- --- ---
-                #set source_relpath [punkcheck::lib::path_relative $basedir $current_source_dir/$m]
-                #set file_record [punkcheck::installfile_add_source_and_fetch_metadata $basedir $source_relpath $file_record]
-                ## -- --- --- --- --- ---
-                #set changed_unchanged [punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $file_record body] end]]
-                #set changed_list [dict get $changed_unchanged changed]
-
-                #----------
-                $event targetset_init INSTALL $target_module_dir/$m 
-                $event targetset_addsource $current_source_dir/$m
-                if {\
-                        [llength [dict get [$event targetset_source_changes] changed]]\
-                    || [llength [$event get_targets_exist]] < [llength [$event get_targets]]\
-                    } {
-
-                    #set file_record [punkcheck::installfile_started_install $basedir $file_record]
-                    $event targetset_started
-                    # -- --- --- --- --- ---
-                    if {$did_skip} {set did_skip 0; puts -nonewline stdout \n}
-                    lappend module_list $current_source_dir/$m
-                    file copy -force $current_source_dir/$m $target_module_dir
-                    puts stderr "Copied already versioned module $current_source_dir/$m to $target_module_dir"
-                    # -- --- --- --- --- ---
-                    #set file_record [punkcheck::installfile_finished_install $basedir $file_record]
-                    $event targetset_end OK -note "already versioned module"
-                } else {
-                    puts -nonewline stderr "."
-                    set did_skip 1
-                    if {$is_interesting} {
-                        puts stderr "$current_source_dir/$m [$event targetset_source_changes]"
-                    }
-                    #set file_record [punkcheck::installfile_skipped_install $basedir $file_record]
-                    $event targetset_end SKIPPED
-                }
-
-            }
-            if {$CALLDEPTH >= $max_depth} {
-                set subdirs [list]
-            } else {
-                set subdirs [glob -nocomplain -dir $current_source_dir -type d -tail *]
-            }
-            #puts stderr "subdirs: $subdirs"
-            foreach d $subdirs {
-                set skipdir 0
-                foreach dg $antidir {
-                    if {[string match $dg $d]} {
-                        set skipdir 1
-                        continue
-                    }
-                }
-                if {$skipdir} {
-                    continue
-                }
-                if {![file exists $target_module_dir/$d]} {
-                    file mkdir $target_module_dir/$d
-                }
-                lappend module_list {*}[build_modules_from_source_to_base $srcdir $basedir\
-                    -call-depth-internal [expr {$CALLDEPTH +1}]\
-                    -subdirlist [list {*}$subdirlist $d]\
-                    -punkcheck_eventobj $event\
-                    -glob $fileglob\
-                ]
-            }
-            if {$did_skip} {
-                puts -nonewline stdout \n
-            }
-            if {$CALLDEPTH == 0} {
-                $event destroy
-                $installer destroy 
-            }
-            return $module_list
-        }
-
-        variable kettle_reset_bodies [dict create]
-        variable kettle_reset_args [dict create]
-        #We are abusing kettle to run in-process.
-        # when we change to another project we need recipes to be reloaded.
-        # Kettle rewrites some of it's own procs - stopping reloading of recipes when we change folders
-        #kettle_init stores the original proc bodies & args
-        proc kettle_init {} {
-            variable kettle_reset_bodies ;#dict
-            variable kettle_reset_args
-            set reset_procs [list\
-                ::kettle::benchmarks\
-                ::kettle::doc\
-                ::kettle::figures\
-                ::kettle::meta::scan\
-                ::kettle::testsuite\
-            ]
-            foreach p $reset_procs {
-                set b [info body $p]
-                if {[string match "*Overwrite self*" $b]} {
-                    dict set kettle_reset_bodies $p $b
-                    set argnames [info args $p]
-                    set arglist [list]
-                    foreach a $argnames {
-                        if {[info default $p $a dval]} {
-                            lappend arglist [list $a $dval]
-                        } else {
-                            lappend arglist $a
-                        }
-                    }
-                    dict set kettle_reset_args $p $arglist
-                }
-            } 
-
-        }
-        #call kettle_reinit to ensure recipes point to current project
-        proc kettle_reinit {} {
-            variable kettle_reset_bodies
-            variable kettle_reset_args
-            foreach p [dict keys $kettle_reset_bodies] {
-                set b [dict get $kettle_reset_bodies $p]
-                set argl [dict get $kettle_reset_args $p]
-                uplevel 1 [list ::proc $p $argl $b]
-            }
-            #todo - determine standard recipes by examining standard.tcl instead of hard coding?
-            set standard_recipes [list\
-                null\
-                forever\
-                list-recipes\
-                help-recipes\
-                help-dump\
-                help-recipes\
-                help\
-                list\
-                list-options\
-                help-options\
-                show-configuration\
-                show-state\
-                show\
-                meta-status\
-                gui\
-            ]
-            #set ::kettle::recipe::recipe [dict create]
-            foreach r [dict keys $::kettle::recipe::recipe] {
-                if {$r ni $standard_recipes} {
-                    dict unset ::kettle::recipe::recipe $r
-                }
-            }
-        }
-        proc kettle_call {calltype args} {
-            variable kettle_reset_bodies
-            if {$calltype ni [list lib shell]} {
-                error "pmix kettle_call 1st argument must be one of: 'lib' for direct use of kettle module or 'shell' to call as separate process"
-            }
-            if {$calltype eq "shell"} {
-                set kettleappfile [file dirname [info nameofexecutable]]/kettle
-                set kettlebatfile [file dirname [info nameofexecutable]]/kettle.bat
-
-                if {(![file exists $kettleappfile]) && (![file exists $kettlebatfile])} {
-                    error "pmix kettle_call unable to find installed kettle application file '$kettleappfile' (or '$kettlebatfile' if on windows)"
-                }
-                if {[file exists $kettleappfile]} {
-                    set kettlescript $kettleappfile
-                }
-                if {$::tcl_platform(platform) eq "windows"} {
-                    if {[file exists $kettlebatfile]} {
-                        set kettlescript $kettlebatfile
-                    }
-                }
-            }
-            set startdir [pwd]
-            if {![file exists $startdir/build.tcl]} {
-                error "pmix kettle must be run from a folder containing build.tcl (cwd: [pwd])"
-            }
-            if {[package provide kettle] eq ""} {
-                puts stdout "Loading kettle package - may be delay on first load ..."
-                package require kettle
-                kettle_init ;#store original procs for those kettle procs that rewrite themselves
-            } else {
-                if {[dict size $kettle_reset_bodies] == 0} {
-                    #presumably package require kettle was called without calling our kettle_init hack.
-                    kettle_init
-                } else {
-                    #undo proc rewrites
-                    kettle_reinit
-                }
-            }
-            set first [lindex $args 0] 
-            if {[string match @* $first]} {
-                error "pmix kettle doesn't support special operations - try calling tclsh kettle directly"
-            }
-            if {$first eq "-f"} {
-                set args [lassign $args __ path]
-            } else {
-                set path $startdir/build.tcl 
-            }
-            set opts [list]
-
-            if {[lindex $args 0] eq "-trace"} {
-                set args [lrange $args 1 end]
-                lappend opts --verbose on
-            }
-            set goals [list]
-
-            if {$calltype eq "lib"} {
-                file mkdir ~/.kettle
-                set dotfile ~/.kettle/config
-                if {[file exists $dotfile] &&
-                    [file isfile $dotfile] &&
-                    [file readable $dotfile]} {
-                    ::kettle io trace {Loading dotfile $dotfile ...}
-                    set args [list {*}[::kettle path cat $dotfile] {*}$args]
-                }
-            }
-
-            #hardcoded kettle option names (::kettle option names) - retrieved using kettle::option names 
-            #This is done so we don't have to load kettle lib for shell call (both loading as module and running shell are annoyingly SLOW)
-            #REVIEW - needs to be updated to keep in sync with kettle. 
-            set knownopts [list\
-                --exec-prefix --bin-dir --lib-dir --prefix --man-dir --html-dir --markdown-dir --include-dir \
-                --ignore-glob --dry --verbose --machine --color --state --config --with-shell --log \
-                --log-append --log-mode --with-dia --constraints --file --limitconstraints --tmatch --notfile --single --valgrind --tskip --repeats \
-                --iters --collate --match --rmatch --with-doc-destination --with-git --target --test-include \
-                ]
-
-            while {[llength $args]} {
-                set o [lindex $args 0]
-                switch -glob -- $o {
-                    --* {
-                        #instead of using: kettle option known
-                        if {$o ni $knownopts} {
-                            error "Unable to process unknown option $o." {} [list KETTLE (pmix)]
-                        }
-                        lappend opts $o [lindex $args 1]
-                        #::kettle::option set $o [lindex $args 1]
-                        set args [lrange $args 2 end]
-                    }
-                    default {
-                        lappend goals $o
-                        set args [lrange $args 1 end]
-                    }
-                }
-            }
-
-            if {![llength $goals]} {
-                lappend goals help
-            }
-            if {"--prefix" ni [dict keys $opts]} {
-                dict set opts --prefix [file dirname $startdir]
-            }
-            if {$calltype eq "lib"} {
-                ::kettle status clear
-                ::kettle::option::set @kettle $startdir
-                foreach {o v} $opts {
-                    ::kettle option set $o $v
-                }
-                ::kettle option set @srcscript $path
-                ::kettle option set @srcdir [file dirname $path]
-                ::kettle option set @goals $goals
-                #load standard recipes as listed in build.tcl
-                ::source $path
-                puts stderr "recipes: [::kettle recipe names]"
-                ::kettle recipe run {*}[::kettle option get @goals]
-
-                set state [::kettle option get --state]
-                if {$state ne {}} {
-                    puts stderr "saving kettle state: $state"
-                    ::kettle status save $state
-                }
-
-            } else {
-                #shell
-                puts stdout "Running external kettle process with args: $opts $goals"
-                run -n tclsh $kettlescript -f $path {*}$opts {*}$goals
-            }
-
-        }
-        proc kettle_punk_recipes {} {
-            set txtdst ...
-        }
-
-    }
-}
-
-
-namespace eval punk::mix::cli {
-    proc _cli {args} {
-        #don't use tailcall - base uses info level to determine caller
-        ::punk::mix::base::_cli {*}$args
-    }
-    variable default_command help
-    package require punk::mix::base
-    package require punk::overlay
-    punk::overlay::custom_from_base [namespace current] ::punk::mix::base 
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::cli [namespace eval punk::mix::cli {
-    variable version
-    set version 0.3 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/buildsuite-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/buildsuite-0.1.0.tm
deleted file mode 100644
index 883e02d2..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/buildsuite-0.1.0.tm
+++ /dev/null
@@ -1,152 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::buildsuite 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::buildsuite {
-    namespace export *
-    proc projects {suite} {
-        set pathinfo [punk::repo::find_repos [pwd]]
-        set projectdir [dict get $pathinfo closest]
-        set suites_dir [file join $projectdir src buildsuites]
-        if {![file isdirectory [file join $suites_dir $suite]]} {
-            puts stderr "suite: $suite not found in buildsuites folder: $suites_dir"
-            return
-        }
-        set suite_dir [file join $suites_dir $suite]
-        set projects [glob -dir $suite_dir -type d -tails *]
-
-        #use internal du which although breadth-first is generally faster
-        puts stdout "Examining source folders in $suite_dir." ;#A hint that something is happening in case sources are large
-        set du_info [punk::du::du -d 1 -b $suite_dir]
-        set du_sizes [dict create]
-        set suite_total_size "-" 
-        foreach du_record $du_info {
-            if {[llength $du_record] != 2} {
-                #sanity precaution - punk::du::du should always output list of 2 element lists - at least with flags we're using
-                continue
-            }
-            set sz [lindex $du_record 0]
-            set path_parts [file split [lindex $du_record 1]] ;#should handle spaced-paths ok.
-            set s [lindex $path_parts end-1]
-            set p [lindex $path_parts end]
-            
-            #This handles case where a project folder is same name as suite  e.g src/buildsuites/tcl/tcl
-            #so we can't just use tail as dict key. We could assume last record is always total - but 
-            if {![string match -nocase $s $suite]} {
-                if {$s eq "buildsuites" && [string match -nocase $p $suite]} {
-                    set suite_total_size $sz ;#this includes config files in suite base - so we don't really want to use this to report the total source size
-                } else {
-                    #something else - shouldn't happen
-                    puts stderr "Unexpected output from du in suite_dir: $suite_dir"
-                    puts stderr "$du_record"
-                    #try to continue anyway
-                }
-            } else {
-                dict set du_sizes $p $sz
-            }
-        }
-
-        #build another dict for sizes where we ensure exactly one entry for each project exists and exclude total (don't blindly trust du output e.g in case weird filename/permission issue)
-        set psizes [list]
-        foreach p $projects {
-            if {[dict exists $du_sizes $p]} {
-                dict set psizes $p [dict get $du_sizes $p]
-            } else {
-                dict set psizes $p -
-            }
-        }
-        set total_source_size "-"
-        if {[catch {
-            set total_source_size [tcl::mathop::+ {*}[dict values $psizes]]
-        } errM]} {
-            puts stderr "Failed to calculate total source size. Errmsg: $errM"
-        }
-        package require overtype
-
-        set title1 "Projects"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $projects] {punk::strlen $v}]]
-        set col1 [string repeat " " $widest1] 
-
-        set size_values [dict values $psizes]
-        # Title is probably widest - but go through the process anyway!
-        set title2 "Source Bytes"
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $size_values] {punk::strlen $v}]]
-        set col2 [string repeat " " $widest2]
-
-
-        set output ""
-        append output "[overtype::left $col1 $title1] [overtype::right $col2 $title2]" \n
-        foreach p [lsort $projects] {
-            #todo - provide some basic info for each - last build time? last time-to-build?
-            append output "[overtype::left $col1 $p] [overtype::right $col2 [dict get $psizes $p]]" \n
-        }
-        append output "Total Source size: $total_source_size bytes" \n
-        return $output
-    }
-
-
-    namespace eval collection {
-        namespace export *
-        proc _default {{glob {}}} {
-            if {![string length $glob]} {
-                set glob *
-            }
-            #todo - review - we want the furthest not the closest if we are potentially inside a buildsuite project
-            set pathinfo [punk::repo::find_repos [pwd]]
-            set projectdir [dict get $pathinfo closest]
-            set suites_dir [file join $projectdir src buildsuites]
-            if {![file exists $suites_dir]} {
-                puts stderr "No buildsuites folder found at $suites_dir"
-                return
-            }
-            set suites [lsort [glob -dir $suites_dir -type d -tails *]]
-            if {$glob ne "*"} {
-                set suites [lsearch -all -inline $suites $glob]
-            }
-            return $suites
-        }
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::buildsuite [namespace eval punk::mix::commandset::buildsuite {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/debug-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/debug-0.1.0.tm
deleted file mode 100644
index 8ed735c1..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/debug-0.1.0.tm
+++ /dev/null
@@ -1,92 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::debug 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::debug {
-    namespace export get paths
-    namespace path ::punk::mix::cli
-
-    #Except for 'get' - all debug commands should emit to stdout 
-    proc paths {} {
-        set out ""
-        puts stdout "find_repos output:" 
-        set pathinfo [punk::repo::find_repos [pwd]]
-        pdict $pathinfo
-
-        set projectdir [dict get $pathinfo closest]
-        set modulefolders [lib::find_source_module_paths $projectdir]
-        puts stdout "modulefolders: $modulefolders"
-
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-        puts stdout "get_template_basefolders output:"
-        pdict $template_base_dict
-        return 
-    }
-
-    #call other debug command - but capture stdout as return value
-    proc get {args} {
-        set nm [lindex $args 0]
-        if {$nm eq ""} {
-            set nscmds [info commands [namespace current]::*]
-            set cmds [lmap v $nscmds {namespace tail $v}]
-            error "debug.get missing debug command argument. Try one of: $cmds"
-            return
-        }
-        set nextargs [lrange $args 1 end]
-        set out ""
-        if {[info commands [namespace current]::$nm] ne ""} {
-            append out [runout -n -tcl  [namespace current]::$nm {*}$nextargs] \n
-        } else {
-            set nscmds [info commands [namespace current]::*]
-            set cmds [lmap v $nscmds {namespace tail $v}]
-            error "debug.get invalid debug command '$nm' Try one of: $cmds"
-        }
-        return $out
-    }
-    namespace eval lib {
-
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::debug [namespace eval punk::mix::commandset::debug {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm
deleted file mode 100644
index 36a654b7..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm
+++ /dev/null
@@ -1,286 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::doc 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-package require punk::path ;# for treefilenames, relative
-package require punk::repo
-package require punk::docgen ;#inline doctools - generate doctools .man files at src/docgen prior to using kettle to producing .html .md etc
-package require punk::mix::cli  ;#punk::mix::cli::lib used for kettle_call
-#package require punk::mix::util ;#for path_relative
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::doc {
-    namespace export *
-
-    proc _default {} {
-        puts "documentation subsystem"
-        puts "commands: doc.build"
-        puts "        build documentation from src/doc to src/embedded using the kettle build tool"
-    }
-
-    proc build {} {
-        puts "build docs"
-        set projectdir [punk::repo::find_project]
-        if {$projectdir eq ""} {
-            puts stderr "No current project dir - unable to build docs"
-            return
-        }
-        #user may delete the comment containing "--- punk::docgen::overwrites" and then manually edit, and we won't overwrite
-        #we still generate output in src/docgen so user can diff and manually update if thats what they prefer
-        set oldfiles [punk::path::treefilenames $projectdir/src/doc _module_*.man]
-        foreach maybedoomed $oldfiles {
-            set fd [open $maybedoomed r]
-            set data [read $fd]
-            close $fd
-            if {[string match "*--- punk::docgen overwrites *" $data]} {
-                file delete -force $maybedoomed
-            }
-        }
-        set generated [lib::do_docgen modules]
-        if {[dict get $generated count] > 0} {
-            #review
-            set doclist [dict get $generated docs]
-            set source_base [dict get $generated base]
-            set target_base $projectdir/src/doc
-            foreach dinfo $doclist {
-                lassign $dinfo module fpath
-                set relpath [punk::path::relative $source_base $fpath]
-                set relfolder [file dirname $relpath]
-                if {$relfolder eq "."} {
-                    set relfolder ""
-                }
-                file mkdir [file join $target_base $relfolder]
-                set target [file join $target_base $relfolder _module_[file tail $fpath]]
-                puts stderr "target --> $target"
-                if {![file exists $target]} {
-                    file copy $fpath $target
-                }
-            }
-        }
-
-        if {[file exists $projectdir/src/doc]} {
-            set original_wd [pwd]
-            cd $projectdir/src
-            #----------
-            set installer [punkcheck::installtrack new project.new $projectdir/src/.punkcheck]
-            $installer set_source_target $projectdir/src/doc $projectdir/src/embedded
-            set event [$installer start_event {-install_step kettledoc}]
-            #use same virtual id "kettle_build_doc" as project.new - review best way to keep identifiers like this in sync. 
-            $event targetset_init VIRTUAL kettle_build_doc ;#VIRTUAL - since there is no specific target file - and we don't know all the files that will be generated
-            $event targetset_addsource $projectdir/src/doc  ;#whole doc tree is considered the source 
-            #----------
-            if {\
-                    [llength [dict get [$event targetset_source_changes] changed]]\
-                } {
-                $event targetset_started
-                # -- --- --- --- --- ---
-                puts stdout "BUILDING DOCS at $projectdir/src/embedded from src/doc"
-                if {[catch {
-
-                    punk::mix::cli::lib::kettle_call lib doc
-                    #Kettle doc
-
-                } errM]} {
-                    $event targetset_end FAILED -note "kettle_build_doc failed: $errM"
-                } else {
-                    $event targetset_end OK
-                }
-                # -- --- --- --- --- ---
-            } else {
-                puts stderr "No change detected in src/doc"
-                $event targetset_end SKIPPED
-            }
-            $event end
-            $event destroy
-            $installer destroy
-            cd $original_wd
-        } else {
-            puts stderr "No doc folder found at $projectdir/src/doc"
-        }
-    }
-    proc status {} {
-        set projectdir [punk::repo::find_project]
-        if {$projectdir eq ""} {
-            puts stderr "No current project dir - unable to check doc status"
-            return
-        }
-        if {![file exists $projectdir/src/doc]} {
-            set result "No documentation source found. Expected .man files in doctools format at $projectdir/src/doc"
-            return $result
-        }
-        set original_wd [pwd]
-        cd $projectdir/src
-        puts stdout "Testing status of doctools source location $projectdir/src/doc ..."
-        flush stdout
-        #----------
-        set installer [punkcheck::installtrack new project.new $projectdir/src/.punkcheck]
-        $installer set_source_target $projectdir/src/doc $projectdir/src/embedded
-        set event [$installer start_event {-install_step kettledoc}]
-        #use same virtual id "kettle_build_doc" as project.new - review best way to keep identifiers like this in sync. 
-        $event targetset_init QUERY kettle_build_doc ;#usually VIRTUAL - since there is no specific target file - and we don't know all the files that will be generated - but here we use QUERY to ensure no writes to .punkcheck
-        set last_completion [$event targetset_last_complete]
-
-        if {[llength $last_completion]} {
-            #adding a source causes it to be checksummed
-            $event targetset_addsource $projectdir/src/doc  ;#whole doc tree is considered the source 
-            #----------
-            set changeinfo [$event targetset_source_changes]
-            if {\
-                    [llength [dict get $changeinfo changed]]\
-                } {
-                    puts stdout "changed"
-                    puts stdout $changeinfo
-            } else {
-                puts stdout "No changes detected in $projectdir/src/doc tree"
-            }
-        } else {
-            #no previous completion-record for this target - must assume changed - no need to trigger checksumming
-            puts stdout "No existing record of doc build in .punkcheck. Assume it needs to be rebuilt."
-        }
-
-
-        $event destroy
-        $installer destroy
-
-        cd $original_wd
-    }
-    proc validate {} {
-        #todo - run and validate punk::docgen output
-        set projectdir [punk::repo::find_project]
-        if {$projectdir eq ""} {
-            puts stderr "No current project dir - unable to check doc status"
-            return
-        }
-        if {![file exists $projectdir/src/doc]} {
-            set result "No documentation source found. Expected .man files in doctools format at $projectdir/src/doc"
-            return $result
-        }
-        set original_wd [pwd]
-        set docroot $projectdir/src/doc
-        cd $docroot
-
-        dtplite validate  $docroot
-
-        #punk::mix::cli::lib::kettle_call lib validate-doc
-
-        cd $original_wd
-    }
-
-    namespace eval collection {
-        variable pkg
-        set pkg punk::mix::commandset::doc
-
-        namespace export *
-        namespace path [namespace parent]
-
-    }
-
-    namespace eval lib {
-        variable pkg
-        set pkg punk::mix::commandset::doc
-        proc  do_docgen {{project_subpath modules}} {
-            #Extract doctools comments from source code
-            set projectdir [punk::repo::find_project]
-            set output_base [file join $projectdir src docgen]
-            set codesource_path [file join $projectdir $project_subpath]
-            if {![file isdirectory $codesource_path]} {
-                puts stderr "WARNING punk::mix::commandset::doc unable to find codesource_path $codesource_path during do_docgen - skipping inline doctools generation"
-                return
-            }
-            if {[file isdirectory $output_base]} {
-                if {[catch {
-                    file delete -force $output_base
-                }]}  {
-                    error "do_docgen failed to delete existing output base folder: $output_base"
-                }
-            }
-            file mkdir $output_base
-
-            set matched_paths [punk::path::treefilenames $codesource_path *.tm -antiglob_paths {**/mix/templates/** **/mixtemplates/**}]
-            set count 0
-            set newdocs [list] 
-            set docgen_header_comments ""
-            append docgen_header_comments {[comment {--- punk::docgen generated from inline doctools comments ---}]} \n
-            append docgen_header_comments {[comment {--- punk::docgen DO NOT EDIT DOCS HERE UNLESS YOU REMOVE THESE COMMENT LINES ---}]} \n
-            append docgen_header_comments {[comment {--- punk::docgen overwrites this file ---}]} \n
-            foreach fullpath $matched_paths {
-                set doctools [punk::docgen::get_doctools_comments $fullpath] 
-                if {$doctools ne ""} {
-                    set fname [file tail $fullpath]
-                    set mod_tail [file rootname $fname] 
-                    set relpath [punk::path::relative $codesource_path [file dirname $fullpath]]
-                    if {$relpath eq "."} {
-                        set relpath ""
-                    }
-                    set tailsegs [file split $relpath]
-                    set module_fullname [join $tailsegs ::]::$mod_tail
-                    set target_docname $fname.man
-                    set this_outdir [file join $output_base $relpath]
-
-                    if {[string length $fname] > 99} {
-                        #output needs to be tarballed to do checksum change tests in a reasonably straightforward and not-too-terribly slow way.
-                        #hack - review. Determine exact limit - test if tcllib tar fixed or if it's a limit of the particular tar format
-                        #work around tcllib tar filename length limit ( somewhere around 100?) This seems to be a limit on the length of a particular segment in the path.. not whole path length?
-                        #this case only came up because docgen used to path munge to long filenames - but left because we know there is a limit and renaming fixes it - even if it's ugly - but still allows doc generation.
-                        #review - if we're checking fname - should also test length of whole path and determine limits for tar
-                        package require md5
-                        set target_docname [md5::md5 -hex $fullpath]_overlongfilename.man
-                        puts stderr "WARNING - overlong file name - renaming $fullpath"
-                        puts stderr "          to                            [file dirname $fullpath]/$target_docname"
-                    }
-
-                    file mkdir $this_outdir
-                    puts stdout "saving [string length $doctools] bytes of doctools output from file $relpath/$fname"
-                    set outfile [file join $this_outdir $target_docname]
-                    set fd [open $outfile w]
-                    fconfigure $fd -translation binary
-                    puts -nonewline $fd $docgen_header_comments$doctools
-                    close $fd
-                    incr count
-                    lappend newdocs [list $module_fullname $outfile]
-                }
-            }
-            return [list count $count docs $newdocs base $output_base]
-        }
-
-    }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::doc [namespace eval punk::mix::commandset::doc {
-    variable pkg punk::mix::commandset::doc
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm
deleted file mode 100644
index 0a9ff2d4..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm
+++ /dev/null
@@ -1,188 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::layout 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-#sort of a circular dependency when commandset loaded by punk::mix::cli - that's ok, but this could theoretically be loaded by another cli and with another base
-package require punk::mix
-package require punk::mix::base
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::layout {
-    namespace export *
-
-    #per layout functions
-    proc files {layout} {
-        set allfiles [lib::layout_all_files $layout]
-        return [join $allfiles \n]
-    }
-    proc templatefiles {layout} {
-        set templatefiles [lib::layout_scan_for_template_files $layout]
-        return [join $templatefiles \n]
-    }
-    proc templatefiles.relative {layout} {
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-
-        set bases_containing_layout [list]
-        dict for {tbase folderinfo} $template_base_dict {
-           if {[file exists $tbase/layouts/$layout]} {
-                lappend bases_containing_layout $tbase
-           } 
-        }
-        if {![llength $bases_containing_layout]} {
-            puts stderr "Unable to locate folder for layout '$layout'"
-            puts stderr "searched [dict size $template_base_dict] template folders"
-            return
-        }
-        set tpldir [lindex $bases_containing_layout end]
-
-        set layout_base $tpldir/layouts
-        set layout_dir [file join $layout_base $layout]
-
-        set stripprefix [file normalize $layout_dir]
-        set templatefiles [lib::layout_scan_for_template_files $layout]
-        set tails [list]
-        foreach templatefullpath $templatefiles {
-            lappend tails [punk::repo::path_strip_alreadynormalized_prefixdepth $templatefullpath $stripprefix]
-        }
-        return [join $tails \n]
-    }
-
-    #layout collection functions - to be imported with punk::overlay::import_commandset separately
-    namespace eval collection {
-        namespace export *
-        proc _default {{glob {}}} {
-            if {![string length $glob]} {
-                set glob *
-            }
-            set layouts [list]
-            #set tplfolderdict [punk::cap::call_handler punk.templates folders]
-            set tplfolderdict [punk::mix::base::lib::get_template_basefolders]
-            dict for {tdir folderinfo} $tplfolderdict {
-                set layout_base $tdir/layouts
-                #collect all layouts and use lsearch glob rather than the filesystem glob (avoid issues with dotted folder names)
-                set all_layouts [lsort [glob -nocomplain -dir $layout_base -type d -tail *]]
-                foreach match [lsearch -all -inline $all_layouts $glob] {
-                   lappend layouts [list $match $folderinfo] 
-                }
-            }
-            return [join [lsort -index 0 $layouts] \n]
-        }
-
-    }
-    namespace eval lib {
-        proc layout_all_files {layout} {
-            set tplbasedict [punk::mix::base::lib::get_template_basefolders]
-            set layouts_found [list]
-            dict for {tplbase folderinfo} $tplbasedict {
-                if {[file isdirectory $tplbase/layouts/$layout]} {
-                    lappend layouts_found $tplbase/layouts/$layout
-                }
-            } 
-            if {![llength $layouts_found]} {
-                puts stderr "layout '$layout' not found."
-                puts stderr "searched [dict size $tplbasedict] template folders"
-                dict for {tplbase pkg} $tplbasedict {
-                    puts stderr " - $tplbase $pkg"
-                }
-                return
-            }
-            set layoutfolder [lindex $layouts_found end]
-
-            if {![file isdirectory $layoutfolder]} {
-                puts stderr "layout '$layout' not found in /layouts within one of template_folders. (get_template_folder returned: $tplbasedict)"
-            }
-            set file_list [list] 
-            util::foreach-file $layoutfolder path {
-                lappend file_list $path
-            }
-
-            return $file_list
-        }
-
-        # 
-        #todo - allow specifying which package the layout is from:  e.g "punk::mix::templates project" ??
-        proc layout_scan_for_template_files {layout {tags {}}} {
-            #equivalent for projects? punk::mix::commandset::module::lib::templates_dict  -scriptpath "" 
-            set tplbasedict [punk::mix::base::lib::get_template_basefolders]
-            set layouts_found [list]
-            dict for {tpldir pkg} $tplbasedict {
-                if {[file isdirectory $tpldir/layouts/$layout]} {
-                    lappend layouts_found $tpldir/layouts/$layout
-                }
-            } 
-            if {![llength $layouts_found]} {
-                puts stderr "layout '$layout' not found."
-                puts stderr "searched [dict size $tplbasedict] template folders"
-                dict for {tpldir pkg} $tplbasedict {
-                    puts stderr " - $tpldir $pkg"
-                }
-                return
-            }
-            set layoutfolder [lindex $layouts_found end]
-
-            #use last matching layout found.  review silent if multiple?
-            if {![llength $tags]} {
-                #todo - get standard tags from somewhere
-                set tagnames [list project]
-                foreach tn $tagnames {
-                    lappend tags [string cat % $tn %]
-                }
-            }
-            set file_list [list] 
-            util::foreach-file $layoutfolder path {
-                set fd [open $path r]
-                fconfigure $fd -translation binary
-                set data [read $fd]
-                close $fd
-                foreach tag $tags {
-                    if {[string match "*$tag*" $data]} {
-                        lappend file_list $path
-                    }
-                }
-            }
-
-            return $file_list
-        }
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::layout [namespace eval punk::mix::commandset::layout {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm
deleted file mode 100644
index 3bbe8b47..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm
+++ /dev/null
@@ -1,529 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::loadedlib 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require punk::ns
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::loadedlib {
-    namespace export *
-    #search automatically wrapped in * * - can contain inner * ? globs
-    proc search {searchstring} {
-        catch {package require frobznodule666} ;#ensure pkg system has loaded/searched for everything
-        if {[catch {package require natsort}]} {
-            set has_natsort 0
-        } else {
-            set has_natsort 1
-        }
-        if {[regexp {[?*]} $searchstring]} {
-            #caller has specified specific glob pattern - use it
-            #todo - respect supplied case only if uppers present? require another flag?
-            set matches [lsearch -all -inline -nocase [package names] $searchstring]
-        } else {
-            #make it easy to search for anything
-            set matches [lsearch -all -inline -nocase [package names] "*$searchstring*"]
-        }
-
-        set matchinfo [list]
-        foreach m $matches {
-            set versions [package versions $m]
-            if {$has_natsort} {
-                set versions [natsort::sort $versions]
-            } else {
-                set versions [lsort $versions]
-            }
-            lappend matchinfo [list $m $versions]
-        }
-        return [join [lsort $matchinfo] \n]
-    }
-    proc loaded.search {searchstring} {
-        set search_result [search $searchstring]
-        set all_libs [split $search_result \n]
-        set col1items [list]
-        set col2items [list]
-        set col3items [list]
-        foreach libinfo $all_libs {
-            if {[string trim $libinfo] eq ""} {
-                continue
-            }
-            set versions [lassign $libinfo libname]
-            if {[set ver [package provide $libname]] ne ""} {
-                lappend col1items $libname
-                lappend col2items $versions
-                lappend col3items $ver
-            }
-        }
-
-        package require overtype
-        set title1 "Library"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {string length $v}]]
-        set col1 [string repeat " " $widest1]
-        set title2 "Versions Avail."
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {string length $v}]]
-        set col2 [string repeat " " $widest2]
-        set title3 "Loaded Version"
-        set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {string length $v}]]
-        set col3 [string repeat " " $widest3]
-
-
-        set tablewidth [expr {$widest1 + 1 + $widest2 + 1 + $widest3}]
-
-        set table ""
-        append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col1 $title1] [overtype::left $col2 $title2] [overtype::left $col3 $title3]" \n
-        append table [string repeat - $tablewidth] \n
-        foreach c1 $col1items c2 $col2items c3 $col3items {
-            append table "[overtype::left $col1 $c1] [overtype::left $col2 $c2] [overtype::left $col3 $c3]" \n
-        }
-
-        return $table
-
-
-        set loaded_libs [list]
-        foreach libinfo $all_libs {
-            if {[string trim $libinfo] eq ""} {
-                continue
-            }
-            set versions [lassign $libinfo libname]
-            if {[set ver [package provide $libname]] ne ""} {
-                lappend loaded_libs "$libname $versions (loaded $ver)"
-            }
-        }
-        return [join $loaded_libs \n]
-    }
-
-    proc info {libname} {
-        if {[catch {package require natsort}]} {
-            set has_natsort 0
-        } else {
-            set has_natsort 1
-        }
-        catch {package require frobznodule666} ;#ensure pkg system has loaded/searched for everything
-        set pkgsknown [package names]
-        if {[set posn [lsearch $pkgsknown $libname]] >= 0} {
-            puts stdout "Found package [lindex $pkgsknown $posn]"
-        } else {
-            puts stderr "Package not found as available library/module - check tcl::tm::list and \$auto_path"
-        }
-        set versions [package versions [lindex $libname 0]]
-        if {$has_natsort} {
-            set versions [natsort::sort $versions]
-        } else {
-            set versions [lsort $versions]
-        }
-        if {![llength $versions]} {
-            puts stderr "No version numbers found for library/module $libname"
-            return false
-        }
-        puts stdout "Versions of $libname found: $versions"
-        set alphaposn [lsearch $versions "999999.*"]
-        if {$alphaposn >= 0} {
-            set alpha [lindex $versions $alphaposn]
-            #remove and tack onto beginning..
-            set versions [lreplace $versions $alphaposn $alphaposn] 
-            set versions [list $alpha {*}$versions]
-        }
-        foreach ver $versions {
-            set loadinfo [package ifneeded $libname $ver]
-            puts stdout "$libname $ver"
-            puts stdout "--- 'package ifneeded' script ---"
-            puts stdout $loadinfo
-            puts stdout "---"
-        }
-        return
-    }
-
-    proc copyasmodule {library modulefoldername args} {
-        set defaults [list -askme 1]
-        set opts [dict merge $defaults $args]
-        set opt_askme [dict get $opts -askme]
-
-        if {[catch {package require natsort}]} {
-            set has_natsort 0
-        } else {
-            set has_natsort 1
-        }
-
-        catch {package require frobznodule666} ;#ensure pkg system has loaded/searched for everything
-
-        if {[file pathtype $modulefoldername] eq "absolute"} {
-            if {![file exists $modulefoldername]} {
-                error "Path '$modulefoldername' not found. Enter a fully qualified path, or just the tail such as 'modules' if you are within the project to use <projectdir>/src/modules"
-            }
-            #use the target folder as the source of projectdir info
-            set pathinfo [punk::repo::find_repos $modulefoldername]
-            set projectdir [dict get $pathinfo closest]
-            set modulefolder_path $modulefoldername
-        } else {
-            #use the current working directory as the source of projectdir info
-            set pathinfo [punk::repo::find_repos [pwd]]
-            set projectdir [dict get $pathinfo closest]
-            if {$projectdir ne ""} {
-                set modulefolders [punk::mix::cli::lib::find_source_module_paths $projectdir]
-                foreach k [list modules vendormodules] {
-                    set knownfolder [file join $projectdir src $k]
-                    if {$knownfolder ni $modulefolders} {
-                        lappend modulefolders $knownfolder
-                    }
-                }
-                set mtails [list]
-                foreach path $modulefolders {
-                    lappend mtails [file tail $path]
-                }
-
-                #special case bootsupport/modules so it can be referred to as just bootsupport or bootsupport/modules
-                lappend modulefolders [file join $projectdir src bootsupport/modules]
-
-                if {$modulefoldername ni $mtails && $modulefoldername ni "bootsupport bootsupport/modules"} {
-                    set msg "Suplied modulefoldername '$modulefoldername' doesn't appear to be a known module folder within the project at $projectdir\n"
-                    append msg "Known module folders: [lsort $mtails]\n"
-                    append msg "Use a name from the above list, or a fully qualified path\n"
-                    error $msg
-                }
-
-                if {$modulefoldername eq "bootsupport"} {
-                    set modulefoldername "bootsupport/modules"
-                }
-                set modulefolder_path [file join $projectdir src $modulefoldername]
-            } else {
-                set msg     "No current project found at or above current directory\n"
-                append msg  "Supplied modulefoldername '$modulefoldername' is a name or relative path - cannot use when outside a project." \n
-                append msg  "Supply an absolute path for the target modulefolder, or try again from within a project directory" \n
-                error $msg
-            }
-        }
-        puts stdout "-----------------------------"
-        if {$projectdir ne ""} {
-            puts stdout "Using projectdir: $projectdir for lib.copyasmodule"
-        } else {
-            puts stdout "No current project."
-        }
-        puts stdout "-----------------------------"
-        if {![file exists $modulefolder_path]} {
-            error "Selected module folder path '$modulefolder_path' doesn't exist. Required subdirectories for namespaced modules will be created automatically - but base selected folder must exist first"
-        }
-
-       
-        set libfound [lsearch -all -inline [package names] $library]
-        if {[llength $libfound] != 1 || ![string length $libfound]} {
-            error "Library must match exactly one entry in the list of package names visible to the current interpretor: found '$libfound'"
-        }
-
-        set versions [package versions [lindex $libfound 0]]
-        if {$has_natsort} {
-            set versions [natsort::sort $versions]
-        } else {
-            set versions [lsort $versions]
-        }
-        if {![llength $versions]} {
-            error "No version numbers found for library/module $libfound - sorry, you will need to copy it across manually"
-        }
-        puts stdout "Versions of $libfound found: $versions"
-        set alphaposn [lsearch $versions "999999.*"]
-        if {$alphaposn >= 0} {
-            set alpha [lindex $versions $alphaposn]
-            #remove and tack onto beginning..
-            set versions [lreplace $versions $alphaposn $alphaposn] 
-            set versions [list $alpha {*}$versions]
-        }
-
-        set ver [lindex $versions end] ;# todo - make selectable! don't assume tail is latest?.. package vcompare?
-        if {[llength $versions] > 1} {
-            puts stdout  "Version selected: $ver"
-        }
-
-        set loadinfo [package ifneeded $libfound $ver]
-        set loadinfo [string map [list \r\n \n] $loadinfo]
-        set loadinfo_lines [split $loadinfo \n]
-        if {[catch {llength $loadinfo}]} {
-            set loadinfo_is_listshaped 0
-        } else {
-            set loadinfo_is_listshaped 1
-        }
-        
-        #check for redirection to differently cased version of self - this is only detected if this is the only command in the package ifneeded result
-        #- must have matching version. REVIEW this requirement. Is there a legitimate reason to divert to a differently cased other-version?
-        set is_package_require_self_recased 0
-        set is_package_require_diversion 0
-        set lib_diversion_name ""
-        if {[llength $loadinfo_lines] == 1} {
-            #e.g Thread 3.0b1 diverts to thread 3.0b1
-            set line1 [lindex $loadinfo_lines 0]
-            #check if multiparted with semicolon
-            #We need to distinguish "package require <lib> <ver>; more stuff"  from "package require <lib> ver> ;"  possibly with trailing comment?
-            set parts [list]
-            if {[regexp {;} $line1]} {
-                foreach p [split $line1 {;}] {
-                    set p [string trim $p]
-                    if {[string length $p]} {
-                        #only append parts with some content that doesn't look like a comment
-                        if {![string match "#*" $p]} {
-                            lappend parts $p
-                        }
-                    }
-                }
-
-            }
-            if {[llength $parts] == 1} {
-                #seems like a lone package require statement.
-                #check if package require, package\trequire etc
-                if {[string match "package*require" [lrange $line1 0 1]]} {
-                    set is_package_require_diversion 1
-                    if {[lindex $line1 2] eq "-exact"} {
-                        #package require -exact <pkg> <ver>
-                        set lib_diversion_name [lindex $line1 3]
-                        #check not an exact match - but is a -nocase match - i.e differs in case only
-                        if {($lib_diversion_name ne $libfound) && [string match -nocase $lib_diversion_name $libfound]} {
-                            if {[lindex $line1 4] eq $ver} {
-                                set is_package_require_self_recased 1
-                            } 
-                        }
-                    } else {
-                        #may be package require <pkg> <ver>
-                        #or package require <pkg> <ver> ?<ver>?...
-                        set lib_diversion_name [lindex $line1 2]
-                        #check not an exact match - but is a -nocase match - i.e differs in case only
-                        if {($lib_diversion_name ne $libfound) && [string match -nocase $lib_diversion_name $libfound]} {
-                            set requiredversions [lrange $line1 3 end]
-                            if {$ver in $requiredversions} {
-                                set is_package_require_self_recased 1
-                            }
-                        }
-                    }
-                } 
-            }
-        }
-
-        if {$is_package_require_self_recased && [string length $lib_diversion_name]} {
-            #we only follow one level of package require redirection - seems unlikely/imprudent to follow arbitrarily in a while loop(?)    
-            set libfound $lib_diversion_name
-            set loadinfo [package ifneeded $libfound $ver]
-            set loadinfo [string map [list \r\n \n] $loadinfo]
-            set loadinfo_lines [split $loadinfo \n]
-            if {[catch {llength $loadinfo}]} {
-                set loadinfo_is_listshaped 0
-            } else {
-                set loadinfo_is_listshaped 1
-            }
-
-
-        } else {
-            if {$is_package_require_diversion} {
-                #single 
-                #for now - we'll abort and tell the user to run again with specified pkg/version
-                #We could automate - but it seems likely to be surprising.
-                puts stderr "Loadinfo for $libfound seems to be diverting to another pkg/version: $loadinfo_lines"
-                puts stderr "Review and consider trying with the pkg/version described in the result above."
-                return
-            }
-        }
-
-
-        if {$loadinfo_is_listshaped && ([llength $loadinfo] == 2 && [lindex $loadinfo 0] eq "source")} {
-            set source_file [lindex $loadinfo 1]
-        } elseif {[string match "*source*" $loadinfo]} {
-            set parts [list]
-            foreach ln $loadinfo_lines {
-                if {![string length $ln]} {continue}
-                lappend parts {*}[split $ln ";"]
-            }
-            set sources_found [list]
-            set loads_found [list]
-            set dependencies [list]
-            set incomplete_lines [list]
-            foreach p $parts {
-                set p [string trim $p]
-                if {![string length $p]} {
-                    continue ;#empty line or trailing colon
-                }
-                if {[string match "*tclPkgSetup*" $p]} {
-                    puts stderr "Unable to process load script for library $libfound"
-                    puts stderr "The library appears to use the deprecated tcl library support utility 'tclPkgSetup'"
-                    return false
-                }
-                if {![::info complete $p]} {
-                    #
-                    #probably a perfectly valid script - but slightly more complicated than we can handle
-                    #better to defer to manual processing
-                    lappend incomplete_lines $p
-                    continue
-                }
-                if {[lindex $p 0] eq "source"} {
-                    #may have args.. e.g -encoding utf-8
-                    lappend sources_found [lindex $p end]
-                }
-                if {[lindex $p 0] eq "load"} {
-                    lappend loads_found [lrange $p 1 end]
-                }
-                if {[lrange $p 0 1] eq "package require"} {
-                    lappend dependencies [lrange $p 2 end]
-                }
-            }
-            if {[llength $incomplete_lines]} {
-                puts stderr "unable to interpret load script for library $libfound"
-                puts stderr "Load info: $loadinfo"
-                return false
-            }
-            if {[llength $loads_found]} {
-                puts stderr "package $libfound appears to have binary components"
-                foreach l $loads_found {
-                    puts stderr " binary - $l"
-                }
-                foreach s $sources_found {
-                    puts stderr " script - $s"
-                } 
-                puts stderr "Unable to automatically copy binary libraries to your module folder."
-                return false 
-            }
-
-            if {[llength $sources_found] != 1} {
-                puts stderr "sorry - unable to interpret source library location"
-                puts stderr "Only 1 source supported for now"
-                puts stderr "Load info: $loadinfo"
-                return false
-            }
-            if {[llength $dependencies]} {
-                #todo - check/ignore if dependency is Tcl ?
-                puts stderr "WARNING the package appears to depend on at least one other. Review and copy dependencies if required."
-                foreach d $dependencies {
-                    puts stderr " - $d"
-                }
-            } 
-
-            set source_file [lindex $sources_found 0]
-        } else {
-            puts stderr "sorry - unable to interpret source library location"
-            puts stderr "Load info: $loadinfo"
-            return false
-        }
-
-        # -- ---------------------------------------
-        #Analyse source file
-        if {![file exists $source_file]} {
-            error "Unable to verify source file existence at: $source_file"
-        }
-        set source_data [fcat -translation binary $source_file] 
-        if {![string match "*package provide*" $source_data]} {
-            puts stderr "Sorry - unable to verify source file contains 'package provide' statement of some sort  - copy manually"
-            return false
-        } else {
-            if {![string match "*$libfound*" $source_data]} {
-                # as an exception - look for the specific 'package provide $pkg $version' as occurs in the auto-name auto-version modules
-                #e.g anyname-0.1.tm example
-                if {![string match "*package provide \$pkg \$version*" $source_data]} {
-                    puts stderr "Sorry - unable to verify source file contains 'package provide' and '$libfound' - copy manually"
-                    return false
-                }
-            }
-        }
-
-
-        if {[string match "*lappend ::auto_path*" $source_data] || [string match "*lappend auto_path*" $source_data] || [string match "*set ::auto_path*" $source_data]} {
-            puts stderr "Sorry - '$libfound' source file '$source_file' appears to rely on ::auto_path and can't be automatically copied as a .tm module"
-            puts stderr "Copy the library across to a lib folder instead"
-            return false
-        }
-        # -- ---------------------------------------
-
-        set moduleprefix [punk::ns::nsprefix $libfound]
-        if {[string length $moduleprefix]} {
-            set moduleprefix_parts [punk::ns::nsparts $moduleprefix]
-            set relative_path [file join {*}$moduleprefix_parts]
-        } else {
-            set relative_path ""
-        }
-        set pkgtail [punk::ns::nstail $libfound] 
-        set target_path [file join $modulefolder_path $relative_path ${pkgtail}-${ver}.tm]
-
-        if {$opt_askme} {
-            puts stdout "WARNING - you should check that there aren't extra required files for the library/modules"
-            puts stdout ""
-            puts stdout "This is not intended for binary modules - use at own risk and check results"
-            puts stdout ""
-            puts stdout "Base module path: $modulefolder_path"
-            puts stdout "Target path     :  $target_path"
-            puts stdout "results of 'package ifneeded $libfound'"
-            puts stdout "---"
-            puts stdout "$loadinfo"
-            puts stdout "---"
-            puts stdout "Proceed to create ${pkgtail}-${ver}.tm module? Y|N" 
-            set stdin_state [fconfigure stdin]
-            fconfigure stdin -blocking 1 
-            set answer [string tolower [gets stdin]]
-            fconfigure stdin -blocking [dict get $stdin_state -blocking]
-            if {$answer ne "y"} {
-                puts stderr "mix libcopy.asmodule aborting due to user response '$answer' (required Y|y to proceed)  use -askme 0 to avoid prompts."
-                return
-            }
-        }
-
-        if {![file exists $modulefolder_path]} {
-            puts stdout "Creating module base folder at $modulefolder_path"
-            file mkdir $modulefolder_path
-        }
-        if {![file exists [file dirname $target_path]]} {
-            puts stdout "Creating relative folder at [file dirname $target_path]"
-            file mkdir [file dirname $target_path]
-        }
-
-        if {[file exists $target_path]} {
-            puts stdout "WARNING - module already exists at $target_path"
-            if {$opt_askme} {
-                puts stdout "Copy anyway? Y|N" 
-                set stdin_state [fconfigure stdin]
-                fconfigure stdin -blocking 1 
-                set answer [string tolower [gets stdin]]
-                fconfigure stdin -blocking [dict get $stdin_state -blocking]
-                if {$answer ne "y"} {
-                    puts stderr "mix libcopy.asmodule aborting due to user response '$answer' (required Y|y to proceed)  use -askme 0 to avoid prompts."
-                    return
-                }
-            }
-        }
-
-        file copy -force $source_file $target_path
-        
-        return $target_path
-    }
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::loadedlib [namespace eval punk::mix::commandset::loadedlib {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm
deleted file mode 100644
index 19fbadb3..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm
+++ /dev/null
@@ -1,419 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::module 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::module {
-    namespace export *
-
-    proc paths {} {
-        set roots [punk::repo::find_repos ""]
-        set project [lindex [dict get $roots project] 0]
-        if {$project ne ""} {
-            set is_project 1
-            set searchbase $project
-        } else {
-            set is_project 0
-            set searchbase [pwd]
-        }
-
-        if {[catch {
-            set source_module_folderlist [punk::mix::cli::lib::find_source_module_paths $searchbase]
-        } errMsg]} {
-            set source_module_folderlist [list]
-        }
-
-        set tm_folders [tcl::tm::list]
-        package require overtype
-
-        set result ""
-        if {$is_project} {
-            append result "Project module source paths:" \n
-            foreach f $source_module_folderlist {
-                append result "$f" \n    
-            }
-        }
-        append result \n
-        append result "tcl::tm::list" \n
-        foreach f $tm_folders {
-            if {$is_project} {
-                if {[punk::mix::cli::lib::path_a_aboveorat_b $project $f]} {
-                    set pinfo "(within project)"
-                } else {
-                    set pinfo ""
-                }
-            } else {
-                set pinfo ""
-            }
-            set warning ""
-            if {![file isdirectory $f]} {
-                set warning "(PATH NOT FOUND)"
-            }
-            append result "$f $pinfo $warning" \n
-        }
-
-
-        return $result
-    }
-    #require current dir when calling to be the projectdir, or 
-    proc templates {args} {
-        set tdict [templates_dict {*}$args]
-
-        package require overtype       
-        set paths [dict values $tdict]
-        set names [dict keys $tdict]
-
-        set title1 "Path"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $paths] {punk::strlen $v}]]
-        set col1 [string repeat " " $widest1] 
-
-        set title2 "Template Name"
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $names] {punk::strlen $v}]]
-        set col2 [string repeat " " $widest2]
-
-        set tablewidth [expr {$widest1 + 1 + $widest2}]
-        set table ""
-        append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col1 $title1] [overtype::left $col2 $title2]" \n
-        append table [string repeat - $tablewidth] \n
-
-        foreach p $paths n $names {
-           append table "[overtype::left $col1 $p] [overtype::left $col2 $n]" \n 
-        }
-
-        return $table
-    }
-    #return all module templates with repeated ones suffixed with .2 .3 etc
-    proc templates_dict {args} {
-        tailcall lib::templates_dict {*}$args
-    }
-    proc new {module args} {
-        set year [clock format [clock seconds] -format %Y]
-        set defaults [list\
-            -project \uFFFF\
-            -version \uFFFF\
-            -license <unspecified>\
-            -template module-0.0.1.tm\
-            -type \uFFFF\
-            -force 0\
-            ]
-        set opts [dict merge $defaults $args]
-
-        #todo - review compatibility between -template and -type
-        #-type is the wrapping technology e.g 'plain' for none or tarjar/zipkit etc (consider also snappy/snappy-tcl)
-        #-template may be a folder - but only if the selected -type suports it
-
-
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        # option -version
-        # we need this value before looking at the named argument
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_version_supplied                    [dict get $opts -version]
-        if {$opt_version_supplied eq "\uFFFF"} {
-            set opt_version "0.1.0"
-        } else {
-            set opt_version $opt_version_supplied
-            if {![util::is_valid_tm_version $opt_version]} {
-                error "pmix module.new error - supplied -version $opt_version doesn't appear to be a valid Tcl module version"
-            }
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        #named argument
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set mversion_supplied "" ;#version supplied directly in module argument
-        if {[string first - $module]> 0} {
-            #if it has a dash then version is required to be valid
-            lassign [punk::mix::cli::lib::split_modulename_version $module] modulename mversion
-            if {![util::is_valid_tm_version $mversion]} {
-                error "pmix module.new error - unable to determine modulename-version from supplied value '$module'"
-            }
-            set mversion_supplied $mversion ;#record as may need to compare to version from templatefile name
-            set vcompare_is_mversion_bigger [package vcompare $mversion $opt_version]
-            if {$vcompare_is_mversion_bigger > 0} {
-                set opt_version $mversion; #module parameter has higher value than -version
-                set vmsg "from module argument: $module"
-            } else {
-                set vmsg "from -version option: $opt_version_supplied"
-            }
-            if {$opt_version_supplied ne "\uFFFF"} {
-                if {$vcompare_is_mversion_bigger != 0} {
-                    #is bigger or smaller
-                    puts stderr "module.new WARNING: version supplied in module argument as well as -version option. Using the higher version number $vmsg"
-                }
-            }
-        } else {
-            set modulename $module
-        }
-        punk::mix::cli::lib::validate_modulename $modulename -name_description "mix module.new name"
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        #options
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_project                             [dict get $opts -project]
-        set testdir [pwd]
-        if {![string length [set projectdir [punk::repo::find_project $testdir]]]} {
-            if {![string length [set projectdir [punk::repo::find_candidate $testdir]]]} {
-                set msg [punkc::repo::is_candidate_root_requirements_msg]
-                error "module.new unable to create module in projectdir:$projectdir - directory doesn't appear to meet basic standards $msg"
-            }
-        }
-        if {$opt_project == "\uFFFF"} {
-            set projectname [file tail $projectdir]
-        } else {
-            set projectname $opt_project 
-            if {$projectname ne [file tail $projectdir]} {
-                error "module.new -project '$opt_project' doesn't match detected projectname '$projectname' at path: $projectdir"
-            }
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_license                             [dict get $opts -license]
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_template                            [dict get $opts -template]
-
-        set templates_dict [templates_dict] ;#possibly suffixed with .2 .3 etc
-        #todo - allow versionless name - pick latest which isn't suffixed with .2 etc
-        if {![dict exists $templates_dict $opt_template]} {
-            error "module.new unable to find template '$opt_template'. Known templates: [dict keys $templates_dict]"
-        }
-        set templatefile [dict get $templates_dict $opt_template]
-        set tpldir [file dirname $templatefile] ;#use same folder for modulename_buildversion.txt, modulename_description.txt if they exist
-
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_type                                [dict get $opts -type]
-        if {$opt_type eq "\uFFFF"} {
-            set opt_type [lindex [punk::mix::cli::lib::module_types] 0] ;#default to plain
-        }
-        if {$opt_type ni [punk::mix::cli::lib::module_types]} {
-            error "module.new - error - unknown -type '$opt_type' known-types: [punk::mix::cli::lib::module_types]"
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-
-
-
-
-        set subpath [punk::mix::cli::lib::module_subpath $modulename] ;#commonly empty string for simple modulename e.g "mymodule"  but x::mymodule has subpath 'x' and x::y::mymodule has subpath 'x/y'
-        if {![string length $subpath]} {
-            set modulefolder $projectdir/src/modules
-        } else {
-            set modulefolder $projectdir/src/modules/$subpath
-        }
-        file mkdir $modulefolder
-
-        set moduletail [namespace tail $modulename]
-        set magicversion [punk::mix::util::magic_tm_version] ;#deliberately large so given load-preference when testing
-
-
-
-
-        set template_tail [file tail $templatefile] ;#convert template_xxx-version.tm.x  to {xxx version}
-        set template_tail [string range $template_tail [string length template_] end]
-        set ext [string tolower [file extension $template_tail]]
-        if {$ext eq ".tm"} {
-            set template_modulename_part [file rootname $template_tail]
-        } elseif {[string is integer -strict [string range $ext 1 end]]} {
-            #something like modulename-0.0.1.tm.2
-            #strip of last 2 dotted parts
-            set shortened [file rootname $template_tail]
-            if {![string equal -nocase [file extension $shortened] ".tm"]} {
-                error "module.new error: Unable to interpret filename components of template file '$templatefile' (expected .tm as second-last or last component)"
-            }
-            set template_modulename_part [file rootname $shortened]
-        } else {
-            error "module.new error: Unable to interpret filename components of template file '$templatefile'"
-        }
-        lassign [punk::mix::cli::lib::split_modulename_version $template_modulename_part] t_mname t_version
-        #t_version may be empty string if template is unversioned e.g template_whatever.tm
-
-        set fd [open $templatefile r]; set template_filedata [read $fd]; close $fd
-        if {[string match "*$magicversion*" $template_filedata]} {
-            set use_magic 1
-            set build_version $opt_version
-            set infile_version $magicversion
-        } else {
-            set use_magic 0
-            if {$opt_version_supplied ne "\uFFFF"} {
-                set build_version $opt_version
-            } else {
-                if {[util::is_valid_tm_version $t_version]} {
-                    if {$mversion_supplied eq ""} {
-                        set build_version $t_version
-                    } else {
-                        #we have a version from the named argument 'module'
-                        if {[package vcompare $mversion_supplied $t_version] > 0} {
-                            set build_version $mversion_supplied
-                        } else {
-                            set build_version $t_version
-                        }
-                    }
-                } else {
-                    #probably an unversioned module template
-                    #use opt_version default from above
-                    set build_version $opt_version
-                }
-            }
-            set infile_version $build_version
-        }
-
-        set template_filedata [string map [list %project% $projectname %pkg% $modulename %year% $year %license% $opt_license %version% $infile_version] $template_filedata]
-
-        set modulefile $modulefolder/${moduletail}-$infile_version.tm
-        if {[file exists $modulefile]} {
-            set errmsg "module.new error: module file $modulefile already exists - aborting"
-            if {[string match "*$magicversion*" $modulefile]} {
-                append errmsg \n "If you are attempting to create a module file with a specific version in the source-file name - you will need to use a template that doesn't contain the string '$magicversion' e.g the provided template moduleexactversion-0.0.1.tm"
-            }
-            error $errmsg
-        }
-
-
-        if {[file exists $tpldir/modulename_buildversion.txt]} {
-            set fd [open $tpldir/modulename_buildversion.txt r]; set buildversion_filedata [read $fd]; close $fd
-        } else {
-            #mix_templates_dir warns of deprecation - review
-            set lib_tpldir [file join [punk::mix::cli::lib::mix_templates_dir] modules];#fallback for modulename_buildversion.txt, modulename_description.txt
-            set fd [open $lib_tpldir/modulename_buildversion.txt r]; set buildversion_filedata [read $fd]; close $fd
-        }
-        set buildversionfile [file join $modulefolder ${moduletail}-buildversion.txt]
-        set existing_build_version ""
-        if {[file exists $buildversionfile]} {
-            set buildversiondata [punk::mix::util::fcat $buildversionfile]
-            set lines [split $buildversiondata \n]
-            set existing_build_version [string trim [lindex $lines 0]]
-            if {[package vcompare $existing_build_version $build_version] >= 0} {
-                #existing version in -buildversion.txt file is lower than the module version we are creating
-                error "module.new error: there is an existing buildversion file $buildversionfile with version $existing_build_version equal to or higher than $build_version - unable to continue"
-            }
-        }
-
-        set existing_versions [glob -nocomplain -dir $modulefolder -tails ${moduletail}-*.tm]
-        #it shouldn't be possible to overmatch with the glob - because '-' is not valid in a Tcl module name
-        if {[llength $existing_versions]} {
-            set name_version_pairs [list]
-            lappend name_version_pairs [list $moduletail $infile_version]
-            foreach existing $existing_versions {
-                lappend name_version_pairs [punk::mix::cli::lib::split_modulename_version $existing] ;# .tm is stripped and ignored
-            }
-            set name_version_pairs [lsort -command {package vcompare} -index 1 $name_version_pairs] ;#while plain lsort will often work with versions - it can get order wrong with some - so use package vcompare
-            if {[lindex $name_version_pairs end] ne [list $moduletail $infile_version]} {
-                set thisposn [lsearch -index 1 $name_version_pairs $infile_version]
-                set name_version_pairs [lreplace $name_version_pairs $thisposn $thisposn]
-                set other_versions [lsearch -all -inline -index 1 -subindices $name_version_pairs *]
-                set errmsg      "module.new error: There are existing modules in the target folder with higher versions than $infile_version."
-                append errmsg  \n "Other versions found: $other_versions"
-                if {$magicversion in $other_versions} {
-                    append errmsg \n "Existing build version for special source file name: '$magicversion'  is: '$existing_build_version'"
-                    append errmsg \n "If '$magicversion' file doesn't represent the latest source it should be removed or the filename and contents adjusted to be a specific version"
-                }
-                error $errmsg
-            } else {
-                puts stderr "module.new WARNING: There are existing modules in the target folder with lower versions than $infile_version - manual review recommended"
-                puts stderr "Other versions found: [lsearch -all -inline -index 1 -subindices [lrange $name_version_pairs 0 end-1] *]"
-            }
-        }
-
-
-        set fd [open $modulefile w]
-        fconfigure $fd -translation binary
-        puts -nonewline $fd $template_filedata
-        close $fd
-
-
-        set buildversion_filedata [string map [list %Major.Minor.Level% $build_version] $buildversion_filedata]
-        set fd [open $buildversionfile w]
-        fconfigure $fd -translation binary
-        puts -nonewline $fd $buildversion_filedata
-        close $fd
-
-        return [list file $modulefile version $build_version]
-    }
-
-    namespace eval lib {
-        proc templates_dict {args} {
-            set defaults [list -scriptpath ""]
-            set opts [dict merge $defaults $args]
-            set opt_scriptpath [dict get $opts -scriptpath]
-
-            set module_template_bases [list]
-            set tbasedict [punk::mix::base::lib::get_template_basefolders $opt_scriptpath]
-            dict for {tbase folderinfo} $tbasedict {
-                lappend module_template_bases [file join $tbase modules]
-            }
-
-
-
-            set template_files [list]
-            foreach basefld $module_template_bases {
-                set matched_files [glob -nocomplain -dir $basefld -type f template_*]
-                foreach tf $matched_files {
-                    if {[string match ignore* $tf]} {
-                        continue
-                    }
-                    set ext [file extension $tf]
-                    if {$ext in [list ".tm"]} {
-                        lappend template_files $tf
-                    }
-                }
-            }
-
-            set tdict [dict create]
-            set seen_dict [dict create]
-            foreach fullpath $template_files {
-                set ftail [file tail $fullpath]
-                set tname [string range $ftail [string length template_] end]
-                if {![dict exists $seen_dict $tname]} {
-                    dict set seen_dict $tname 1 
-                    dict set tdict $tname $fullpath ; #first seen of filename gets no number
-                } else {
-                    set n [dict get $seen_dict $tname]
-                    incr n
-                    dict incr seen_dict $tname
-                    dict set tdict ${tname}.$n $fullpath
-                }
-            }
-            return $tdict
-        }
-    }
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::module [namespace eval punk::mix::commandset::module {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm
deleted file mode 100644
index d8da3a47..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm
+++ /dev/null
@@ -1,983 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::project 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin punkshell_module_punk::mix::commandset::project 0 0.1.0]
-#[copyright "2023"]
-#[titledesc {pmix commandset - project}]  [comment {-- Name section and table of contents description --}]
-#[moddesc {pmix CLI commandset - project}]             [comment {-- Description at end of page heading --}] 
-#[require punk::mix::commandset::project]
-#[description]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section Overview]
-#[para] overview of punk::mix::commandset::project
-#[para]Import into an ensemble namespace similarly to the way it is done with punk::mix::cli e.g 
-#[example {
-#    namespace eval myproject::cli {
-#        namespace export *
-#        namespace ensemble create
-#        package require punk::overlay
-#    
-#        package require punk::mix::commandset::project
-#        punk::overlay::import_commandset project    .       ::punk::mix::commandset::project
-#        punk::overlay::import_commandset projects   .       ::punk::mix::commandset::project::collection 
-#    }
-#}]
-#[para] Where the . in the above example is the prefix/command separator
-#[para]The prefix ('project' in the above example) can be any string desired to disambiguate commands imported from other commandsets.
-#[para]The above results in the availability of the ensemble command: ::myproject::cli project.new, which is implemented in ::punk::mix::commandset::project::new  
-#[para]Similarly, procs under ::punk::mix::commandset::project::collection will be available as subcommands of the ensemble as <ensemblecommand> projects.<procname>
-#[para]
-#[subsection Concepts]
-#[para] see punk::overlay 
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[subsection dependencies]
-#[para] packages used by punk::mix::commandset::project 
-#[list_begin itemized]
-
-package require Tcl 8.6
-#*** !doctools
-#[item] [package {Tcl 8.6}]
-#[item] [package punk::ns]
-#[item] [package sqlite3] (binary)
-#[item] [package overtype]
-#[item] [package textutil] (tcllib)
-
-
-# #package require frobz
-# #*** !doctools
-# #[item] [package {frobz}]
-
-#*** !doctools
-#[list_end]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section API]
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::project {
-    namespace export *
-    #*** !doctools
-    #[subsection {Namespace punk::mix::commandset::project}]
-    #[para] core commandset functions for punk::mix::commandset::project 
-    #[list_begin definitions]
-
-    proc _default {} {
-        package require punk::ns
-        set dispatched_to [lindex [info level 2] 0] ;#e.g ::punk::mix::cli::project
-        set dispatch_tail [punk::ns::nstail $dispatched_to]
-        set dispatch_ensemble [punk::ns::nsprefix $dispatched_to] ;#e.g ::punk::mix::cli
-        set sibling_commands [namespace eval $dispatch_ensemble {namespace export}]
-        #todo - get separator?
-        set sep "."
-        set result [list]
-        foreach sib $sibling_commands {
-            if {[string match ${dispatch_tail}${sep}* $sib]} {
-                lappend result $sib
-            }
-        }
-        return [lsort $result]
-    }
-
-
-
-
-    proc new {newprojectpath_or_name args} {
-        #*** !doctools
-        # [call [fun new] [arg newprojectpath_or_name] [opt args]]
-        #new project structure - may be dedicated to one module, or contain many. 
-        #create minimal folder structure only by specifying in args:  -modules {}
-        if {[file pathtype $newprojectpath_or_name] eq "absolute"} {
-            set projectfullpath [file normalize $newprojectpath_or_name]
-            set projectname [file tail $projectfullpath]
-            set projectparentdir [file dirname $newprojectpath_or_name]
-        } else {
-            set projectfullpath [file join [pwd] $newprojectpath_or_name]
-            set projectname [file tail $projectfullpath]
-            set projectparentdir [file dirname $projectfullpath]
-        }
-        if {[file type $projectparentdir] ne "directory"} {
-            error "punk::mix::cli::new error: unable to determine containing folder for '$newprojectpath_or_name'"
-        }
-
-        punk::mix::cli::lib::validate_projectname $projectname -name_description "punk mix project.new"
-
-
-        set defaults [list\
-            -type plain\
-            -empty 0\
-            -force 0\
-            -update 0\
-            -confirm 1\
-            -modules \uFFFF\
-            -layout project
-        ] ;#todo
-        set known_opts [dict keys $defaults]
-        foreach {k v} $args {
-            if {$k ni $known_opts} {
-                error "project.new error: option '$k' not known. Known options: $known_opts"
-            }
-        }
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_type                                [dict get $opts -type]
-        if {$opt_type ni [punk::mix::cli::lib::module_types]} {
-            error "pmix new error - unknown type '$opt_type' known types: [punk::mix::cli::lib::module_types]"
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_force                               [dict get $opts -force]
-        set opt_confirm                             [string tolower [dict get $opts -confirm]]
-        # -- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_modules                             [dict get $opts -modules]
-        if {[llength $opt_modules] == 1 && [lindex $opt_modules 0] eq "\uFFFF"} {
-            #if not specified - add a single module matching project name
-            set opt_modules [list $projectname]
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_layout                              [dict get $opts -layout]
-        set opt_update                              [dict get $opts -update]
-        # -- --- --- --- --- --- --- --- --- --- --- --- ---
-
-
-        set fossil_prog [auto_execok fossil]
-        if {![string length $fossil_prog]} {
-            puts stderr "The fossil program was not found. A fossil executable is required to use most pmix features."
-            if {[string length [set scoop_prog [auto_execok scoop]]]} {
-                #restrict to windows?
-                set answer [util::askuser "scoop detected. Would you like pmix to install fossil now using scoop? Y|N"]
-                if {[string tolower $answer] ne "y"} {
-                    puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                    return
-                }
-                #we don't assume 'unknown' is configured to run shell commands
-                if {[string length [package provide shellrun]]} {
-                    set exitinfo [run {*}$scoop_prog install fossil] 
-                    #scoop tends to return successful exitcode (0) even when packages not found etc. - so exitinfo not much use.
-                    puts stdout "scoop install fossil ran with result: $exitinfo"
-                } else {
-                    puts stdout "Please wait while scoop runs - there may be a slight delay and then scoop output will be shown. (use punk shellrun package for )"
-                    set result [exec {*}$scoop_prog install fossil] 
-                    puts stdout $result
-                }
-                catch {::auto_reset}   ;#can be missing (unsure under what circumstances - but I've seen it raise error 'invalid command name "auto_reset"')
-                if {![string length [auto_execok fossil]]} {
-                    puts stderr "Fossil still not detected. If it was successfully installed, try restarting your punk/tcl shell."
-                    return
-                }
-                #todo - ask user if they want to configure fosssil first..
-                set answer [util::askuser "Fossil command now appears to be available. You may wish to answer N to exit and customize it - but default config may be ok. Type the word 'continue' to proceed with default configuration."]
-                if {[string tolower $answer] ne "continue"} {
-                    return
-                }
-
-            } else {
-                puts stdout "See: https://fossil-scm.org/home/uv/download.html"
-                if {"windows" eq $::tcl_platform(platform)} {
-                    puts stdout "Consider using a package manager such as scoop: https://scoop.sh"
-                    puts stdout "(Then: scoop install fossil)"
-                }
-                return
-            }
-        }
-        set startdir [pwd]
-        if {[set in_project [punk::repo::find_project $startdir]] ne ""} {
-            # use this project as source of templates
-            puts stdout "-------------------------------------------"
-            puts stdout "Currently in a project directory '$in_project'"
-            puts stdout "This project will be searched for templates"
-            puts stdout "-------------------------------------------"
-        }
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-        set template_bases_containing_layout [list]
-        dict for {tbase folderinfo} $template_base_dict {
-           if {[file exists $tbase/layouts/$opt_layout]} {
-                lappend template_bases_containing_layout $tbase
-           } 
-        }
-        if {![llength $template_bases_containing_layout]} {
-            puts stderr "layout '$opt_layout' was not found in template dirs"
-            puts stderr "searched [dict size $template_base_dict] template folders"
-            dict for  {tbase folderinfo} $template_base_dict {
-                puts stderr " - $tbase $folderinfo"
-            }
-            return
-        }
-        #review: silently use last entry which had the layout (?)
-        set templatebase [lindex $template_bases_containing_layout end]
-
-
-
-        #todo - detect whether inside cwd-project or inside a different project
-        set projectdir $projectparentdir/$projectname
-        if {[set target_in_project [punk::repo::find_project $projectparentdir]] ne ""} {
-            puts stderr "Target location for new project is already within a project: $target_in_project"
-            error "Nested projects not yet supported aborting"
-        }
-
-
-
-        if {[punk::repo::is_git $projectparentdir]} {
-            puts stderr "mix new WARNING: target project location is within a git repo based at [punk::repo::find_git $projectparentdir]"
-            puts stderr "The new project will create a fossil repository (which you are free to ignore - but but will be used to confirm project base)"
-            puts stderr "If you intend to use both git and fossil in the same project space - you should research and understand the details and any possible interactions/issues"
-            set answer [util::askuser "Do you want to proceed to create a project based at: $projectdir? Y|N"]
-            if {[string tolower $answer] ne "y"} {
-                puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                return
-            }
-        }
-        set is_nested_fossil 0 ;#default assumption
-        if {[punk::repo::is_fossil $projectparentdir]} {
-            puts stderr "mix new WARNING: target project location is within an open fossil repo based at [punk::repo::find_fossil $projectparentdir] NESTED fossil repository"
-            if {$opt_confirm ni [list 0 no false]} {
-                puts stderr "If you proceed - the new project's fossil repo will be created using the --nested flag"
-                set answer [util::askuser "Do you want to proceed to create a NESTED project based at: $projectdir? Y|N"]
-                if {[string tolower $answer] ne "y"} {
-                    puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                    return
-                }
-                set is_nested_fossil 1
-            }
-        }
-
-        
-        set project_dir_exists [file exists $projectdir]
-        if {$project_dir_exists && !($opt_force || $opt_update)} {
-            puts stderr "Unable to create new project at $projectdir - file/folder already exists use -update 1 to fill in missing items from template use -force 1 to overwrite from template"
-            return
-        } elseif {$project_dir_exists && $opt_force} {
-            puts stderr "mix new WARNING: -force 1 was supplied. Will copy layout $templatebase/layouts/$opt_layout using -force option to overwrite from template"
-            if {$opt_confirm ni [list 0 no false]} {
-                set answer [util::askuser "Do you want to proceed to possibly overwrite existing files in $projectdir? Y|N"]
-                if {[string tolower $answer] ne "y"} {
-                    puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                    return
-                }
-            }
-        } elseif {$project_dir_exists && $opt_update} {
-            puts stderr "mix new WARNING: -update 1 was supplied. Will copy layout $templatebase/layouts/$opt_layout using -update option to add missing items"
-        }
-
-        set fossil_repo_file "" 
-        set is_fossil_root 0
-        if {$project_dir_exists && [punk::repo::is_fossil_root $projectdir]} {
-            set is_fossil_root 1
-            set fossil_repo_file [punk::repo::fossil_get_repository_file $projectdir]
-            if {$fossil_repo_file ne ""} {
-                set repodb_folder [file dirname $fossil_repo_file]
-            }
-        }
-
-        if {$fossil_repo_file eq ""} {
-            set repodb_folder [punk::repo::fossil_get_repository_folder_for_project $projectname -parentfolder $startdir]
-            if {![string length $repodb_folder]} {
-                puts stderr "No usable repository database folder selected for $projectname.fossil file"
-                return
-            }
-        }
-        if {[file exists $repodb_folder/$projectname.fossil]} {
-            puts stdout "NOTICE: $repodb_folder/$projectname.fossil already exists"
-            if {!($opt_force || $opt_update)} {
-                puts stderr "-force 1 or -update 1 not specified - aborting"
-                return
-            }
-        }
-
-        if {$fossil_repo_file eq ""} {
-            puts stdout "Initialising fossil repo: $repodb_folder/$projectname.fossil"
-            set fossilinit [runx -n {*}$fossil_prog init $repodb_folder/$projectname.fossil -project-name $projectname]
-            if {[dict get $fossilinit exitcode] != 0} {
-                puts stderr "fossil init failed:"
-                puts stderr [dict get $fossilinit stderr]
-                return
-            } else {
-                puts stdout "fossil init result:"
-                puts stdout [dict get $fossilinit stdout]
-            }
-        }
-
-        file mkdir $projectdir
-
-        set layout_dir $templatebase/layouts/$opt_layout
-        puts stdout ">>> about to call punkcheck::install $layout_dir $projectdir" 
-        set resultdict [dict create]
-        set antipaths [list\
-            src/doc/*\
-            src/doc/include/*\
-        ]
-
-        #default antiglob_dir_core will stop .fossil* from being updated - which is generally desirable as these are likely to be customized
-        if {$opt_force} {
-            puts stdout "copying layout files - with force applied - overwrite all-targets" 
-            set resultdict [punkcheck::install $layout_dir $projectdir -installer project.new  -overwrite ALL-TARGETS -antiglob_paths $antipaths]
-            #file copy -force $layout_dir $projectdir
-        } else {
-            puts stdout "copying layout files - (if source file changed)" 
-            set resultdict [punkcheck::install $layout_dir $projectdir -installer project.new -overwrite installedsourcechanged-targets -antiglob_paths $antipaths]
-        }
-        puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-        puts stdout "copying layout src/doc files (if target missing)"
-        set resultdict [punkcheck::install $layout_dir/src/doc $projectdir/src/doc -punkcheck_folder $projectdir -installer project.new  -overwrite SYNCED-TARGETS]
-        puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-        #target folders .fossil-custom and .fossil-settings may not exist. use -createdir 1 to ensure existence. 
-        #In this case we need to override the default dir antiglob - as .fossil-xxx folders need to be installed from template if missing, or if target is uncustomized.
-        ## default_antiglob_dir_core  [list "#*" "_aside" ".git" ".fossil*"]
-        set override_antiglob_dir_core [list #* _aside .git] 
-        puts stdout "copying layout src/.fossil-custom files (if target missing or uncustomised)"
-        set resultdict [punkcheck::install $layout_dir/.fossil-custom $projectdir/.fossil-custom -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
-        puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-        puts stdout "copying layout src/.fossil-settings files (if target missing or uncustomised)"
-        set resultdict [punkcheck::install $layout_dir/.fossil-settings $projectdir/.fossil-settings -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
-        puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-
-
-
-        #lappend substfiles $projectdir/README.md
-        #lappend substfiles $projectdir/src/README.md
-        #lappend substfiles $projectdir/src/doc/main.man
-        #expect this in all templates? - todo make these substitutions independent of specific paths and filenames?
-        #scan all files in template 
-        #
-        #TODO - pmix command to substitute templates? 
-        set templatefiles [punk::mix::commandset::layout::lib::layout_scan_for_template_files $opt_layout]
-        set stripprefix [file normalize $layout_dir]
-
-        foreach templatefullpath $templatefiles {
-            set templatetail [punk::repo::path_strip_alreadynormalized_prefixdepth $templatefullpath $stripprefix]
-
-            set fpath [file join $projectdir $templatetail]
-            if {[file exists $fpath]} {
-                set fd [open $fpath r]; fconfigure $fd -translation binary; set data [read $fd]; close $fd
-                set data2 [string map [list [lib::template_tag project] $projectname] $data]
-                if {$data2 ne $data} {
-                    puts stdout "updated template file: $fpath"
-                    set fdout [open $fpath w]; fconfigure $fdout -translation binary; puts -nonewline $fdout $data2; close $fdout 
-                }
-            } else {
-                puts stderr "warning: Missing template file $fpath"
-            }
-        }
-        #todo - tag substitutions in src/doc tree
-
-
-        ::cd $projectdir
-
-        if {[file exists $projectdir/src/modules]} {
-            foreach m $opt_modules {
-                if {![file exists $projectdir/src/modules/$m-[punk::mix::util::magic_tm_version].tm]} {
-                    punk::mix::commandset::module::new $m -project $projectname -type $opt_type 
-                } else {
-                    if {$opt_force} {
-                        punk::mix::commandset::module::new $m -project $projectname -type $opt_type -force 1
-                    }
-                }
-            }
-        } else {
-            puts stderr "project.new WARNING template hasn't created src/modules - skipping creation of new module(s) for project"
-        }
-
-        #generate www/man/md output in 'embedded' folder which should be checked into repo for online documentation
-        if {[file exists $projectdir/src]} {
-            ::cd $projectdir/src
-            #----------
-            set installer [punkcheck::installtrack new project.new $projectdir/src/.punkcheck]
-            $installer set_source_target $projectdir/src/doc $projectdir/src/embedded
-            set event [$installer start_event {-install_step kettledoc}]
-            $event targetset_init VIRTUAL kettle_build_doc ;#VIRTUAL - since there is no specific target file - and we don't know all the files that will be generated
-            $event targetset_addsource $projectdir/src/doc  ;#whole doc tree is considered the source 
-            #----------
-            if {\
-                    [llength [dict get [$event targetset_source_changes] changed]]\
-                } {
-                $event targetset_started
-                # -- --- --- --- --- ---
-                puts stdout "BUILDING DOCS at src/embedded from src/doc"
-                if {[catch {
-
-                    punk::mix::cli::lib::kettle_call lib doc
-                    #Kettle doc
-
-                } errM]} {
-                    $event targetset_end FAILED -note "kettle_build_doc failed: $errM"
-                } else {
-                    $event targetset_end OK
-                }
-                # -- --- --- --- --- ---
-            } else {
-                puts stderr "No change detected in src/doc"
-                $event targetset_end SKIPPED
-            }
-            $event end
-            $event destroy
-            $installer destroy
-        }
-
-        ::cd $projectdir
-
-        if {![punk::repo::is_fossil_root $projectdir]} {
-            set first_fossil 1
-            #-k  = keep.  (only modify the manifest file(s))  
-            if {$is_nested_fossil} {
-                set fossilopen [runx -n {*}$fossil_prog open --nested $repodb_folder/$projectname.fossil -k --workdir $projectdir]
-            } else {
-                set fossilopen [runx -n {*}$fossil_prog open $repodb_folder/$projectname.fossil -k --workdir $projectdir]
-            }
-            if {[file exists $projectdir/_FOSSIL_] && ![file exists $projectdir/.fslckout]} {
-                file rename $projectdir/_FOSSIL_ $projectdir/.fslckout
-            }
-            if {[dict get $fossilopen exitcode] != 0} {
-                puts stderr "fossil open in project workdir '$projectdir' FAILED:"
-                puts stderr [dict get $fossilopen stderr]
-                return
-            } else {
-                puts stdout "fossil open in project workdir '$projectdir' OK:"
-                puts stdout [dict get $fossilopen stdout]
-            }
-        } else {
-            set first_fossil 0
-        }
-        set fossiladd [runx -n {*}$fossil_prog add --dotfiles $projectdir]
-        if {[dict get $fossiladd exitcode] != 0} {
-            puts stderr "fossil add workfiles in workdir '$projectdir' FAILED:"
-            puts stderr [dict get $fossiladd stderr]
-            return
-        } else {
-            puts stdout "fossil add workfiles in workdir '$projectdir' OK:"
-            puts stdout [dict get $fossiladd stdout]
-        }
-        if {$first_fossil} {
-            #fossil commit may prompt user for input.. runx runout etc will pause with no prompts
-            util::do_in_path $projectdir {
-                set fossilcommit [run -n {*}$fossil_prog commit -m "initial project commit"]
-            }
-            if {[dict get $fossilcommit exitcode] != 0} {
-                puts stderr "fossil commit in workdir '$projectdir' FAILED"
-                return
-            } else {
-                puts stdout "fossil commit in workdir '$projectdir' OK"
-            }
-        }
-
-        puts stdout "-done- project:$projectname projectdir: $projectdir"
-    }
-
-    #*** !doctools
-    #[list_end] [comment {--- end definitions namespace punk::mix::commandset::project ---}]
-
-    namespace eval collection {
-        #*** !doctools
-        #[subsection {Namespace punk::mix::commandset::project::collection}]
-        #[para] commandset functions for operating with multiple projects.
-        #[para] It would usually be imported with the prefix "projects" and separator "." to result in commands such as: <ensemblecommand> projects.detail
-        #[list_begin definitions]
-        namespace export *
-        namespace path [namespace parent]
-
-        #e.g imported as 'projects'
-        proc _default {{glob {}} args} {
-            #*** !doctools
-            #[call [fun _default] [arg glob] [opt {option value...}]]
-            #[para]List projects under fossil management, showing fossil db location and number of checkouts
-            #[para]The glob argument is optional unless option/value pairs are also supplied, in which case * should be explicitly supplied
-            #[para]glob restricts output based on the name of the fossil db file e.g s* for all projects beginning with s
-            #[para]The _default function is made available in the ensemble by the name of the prefix used when importing the commandset.
-            #[para]e.g  
-            #[para]    punk::overlay::import_commandset projects   .       ::punk::mix::commandset::project::collection 
-            #[para]Will result in the command being available as <ensemblecommand> projects
-            package require overtype
-            set db_projects [lib::get_projects $glob] 
-            set col1items [lsearch -all -inline -index 0 -subindices $db_projects *]
-            set col2items [lsearch -all -inline -index 1 -subindices $db_projects *]
-            set checkouts [lsearch -all -inline -index 2 -subindices $db_projects *]
-            set col3items [lmap v $checkouts {llength $v}]
-
-            set title1 "Fossil Repo DB"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {punk::strlen $v}]]
-            set col1 [string repeat " " $widest1]
-            set title2 "File Name"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
-            set col2 [string repeat " " $widest2]
-            set title3 "Checkouts"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {punk::strlen $v}]]
-            set col3 [string repeat " " $widest3]
-            set tablewidth [expr {$widest1 + 1 + $widest2 + 1 + $widest3}]
-            
-            
-            append msg "[overtype::left $col1 $title1] [overtype::left $col2 $title2] [overtype::left $col3 $title3]" \n
-            append msg [string repeat "=" $tablewidth] \n
-            foreach p $col1items n $col2items c $col3items {
-                append msg "[overtype::left $col1 $p] [overtype::left $col2 $n] [overtype::right $col3 $c]" \n
-            } 
-            return $msg
-            #return [list_as_lines [lib::get_projects $glob]] 
-        }
-        proc detail {{glob {}} args} {
-            package require overtype
-            package require textutil
-            set defaults [dict create\
-                -description 0\
-            ]
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- ---
-            set opt_description     [dict get $opts -description]
-            # -- --- --- --- --- --- ---
-             
-
-            set db_projects [lib::get_projects $glob] 
-            set col1_dbfiles [lsearch -all -inline -index 0 -subindices $db_projects *]
-            set col2items [lsearch -all -inline -index 1 -subindices $db_projects *]
-            set checkouts [lsearch -all -inline -index 2 -subindices $db_projects *]
-            set col3items [lmap v $checkouts {llength $v}]
-            
-            set col4_pnames [list]
-            set col5_pcodes [list]
-            set col6_dupids [list]
-            set col7_pdescs [list]
-            set codes [dict create]
-            foreach dbfile $col1_dbfiles {
-                set project_name ""
-                set project_code ""
-                set project_desc ""
-                sqlite3 dbp $dbfile
-                dbp eval {select name,value from config where name like 'project-%';}  r {
-                    if {$r(name) eq "project-name"} {
-                       set project_name $r(value) 
-                    } elseif {$r(name) eq "project-code"} {
-                        set project_code $r(value)
-                    } elseif {$r(name) eq "project-description"} {
-                        set project_desc $r(value)
-                    }
-                }
-                dbp close
-                lappend col4_pnames $project_name
-                lappend col5_pcodes $project_code
-                dict lappend codes $project_code $dbfile
-                lappend col7_pdescs $project_desc
-            }
-            
-            set setid 1
-            set codeset [dict create]
-            dict for {code dbs} $codes {
-                if {[llength $dbs]>1} {
-                    dict set codeset $code setid $setid
-                    dict set codeset $code count [llength $dbs]
-                    dict set codeset $code seen 0
-                    incr setid
-                } 
-            }
-            set dupid 1
-            foreach pc $col5_pcodes {
-                if {[dict exists $codeset $pc]} {
-                   set seen [dict get $codeset $pc seen] 
-                   set this_seen [expr {$seen + 1}]
-                   dict set codeset $pc seen $this_seen
-                   lappend col6_dupids "[dict get $codeset $pc setid].${this_seen}/[dict get $codeset $pc count]" 
-                } else {
-                   lappend col6_dupids "" 
-                }
-            }
-
-            set title1 "Fossil Repo DB"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1_dbfiles] {punk::strlen $v}]]
-            set col1 [string repeat " " $widest1]
-            set title2 "File Name"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
-            set col2 [string repeat " " $widest2]
-            set title3 "Checkouts"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {punk::strlen $v}]]
-            set col3 [string repeat " " $widest3]
-            set title4 "Project Name"
-            set widest4 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col4_pnames] {punk::strlen $v}]]
-            set col4 [string repeat " " $widest4]
-            set title5 "Project Code"
-            set widest5 [tcl::mathfunc::max {*}[lmap v [concat [list $title5] $col5_pcodes] {punk::strlen $v}]]
-            set col5 [string repeat " " $widest5]
-            set title6 "Dup"
-            set widest6 [tcl::mathfunc::max {*}[lmap v [concat [list $title6] $col6_dupids] {punk::strlen $v}]]
-            set col6 [string repeat " " $widest6]
-            set title7 "Description"
-            #set widest7 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col7_pdescs] {punk::strlen $v}]]
-            set widest7 35
-            set col7 [string repeat " " $widest7]
-            
-            
-            set tablewidth [expr {$widest1 + 1 + $widest2 + 1 + $widest3 +1 + $widest4 + 1 + $widest5 + 1 + $widest6}]
-            
-            append msg "[overtype::left $col1 $title1] [overtype::left $col2 $title2] [overtype::left $col3 $title3]\
-                        [overtype::left $col4 $title4] [overtype::left $col5 $title5] [overtype::left $col6 $title6]"
-            if {!$opt_description} {
-                append msg \n
-            } else {
-                append msg            "[overtype::left $col7 $title7]" \n
-                set tablewidth [expr {$tablewidth + 1 + $widest7}]
-            }
-
-            append msg [string repeat "=" $tablewidth] \n
-            foreach p $col1_dbfiles n $col2items c $col3items pn $col4_pnames pc $col5_pcodes dup $col6_dupids desc $col7_pdescs {
-                set desclines [split [textutil::adjust $desc -length $widest7] \n] 
-                set desc1 [lindex $desclines 0]
-                append msg "[overtype::left $col1 $p] [overtype::left $col2 $n] [overtype::right $col3 $c]\
-                [overtype::left $col4 $pn] [overtype::left $col5 $pc] [overtype::left $col6 $dup]"
-                if {!$opt_description} {
-                    append msg \n
-                } else {
-                    append msg  " [overtype::left $col7 $desc1]" \n
-                    foreach dline [lrange $desclines 1 end] {
-                    append msg "$col1 $col2 $col3 $col4 $col5 $col6 [overtype::left $col7 $dline]" \n 
-                    }
-                }
-            } 
-            return $msg            
-            #return [list_as_lines [lib::get_projects $glob]] 
-        }
-        proc cd {{glob {}} args} {
-            dict set args -cd 1
-            work $glob {*}$args 
-        }
-        proc work {{glob {}} args} {
-            package require sqlite3
-            set db_projects [lib::get_projects $glob] 
-            if {[llength $db_projects] == 0} {
-                puts stderr "::punk::mix::commandset::project::work No Repo DB name matches found for '$glob'"
-                return ""
-            }
-            #list of lists of the form:
-            #{fosdb fname workdirlist}
-            set defaults [dict create\
-                -cd 0\
-                -detail "\uFFFF"\
-            ] 
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- 
-            set opt_cd      [dict get $opts -cd]
-            # -- --- --- --- --- --- --- 
-            set opt_detail  [dict get $opts -detail]
-            set opt_detail_explicit_zero 1 ;#default assumption only
-            if {$opt_detail eq "\uFFFF"} {
-                set opt_detail_explicit_zero 0
-                set opt_detail 0; #default
-            }
-            # -- --- --- --- --- --- ---             
-            set workdir_dict [dict create]
-            set all_workdirs [list]
-            foreach pinfo $db_projects {
-                lassign $pinfo fosdb name workdirs 
-                foreach wdir $workdirs {
-                    dict set workdir_dict $wdir $pinfo
-                    lappend all_workdirs $wdir
-                }
-            }
-            set col_rowids  [list]
-            set workdirs [lsort -index 0 $all_workdirs]
-            set col_dupids [list]
-            set col_fnames [list]
-            set col_pnames [list]
-            set col_pcodes [list]
-            set col_dupids [list]
-
-            set fosdb_count [dict create]            
-            set fosdb_dupset [dict create]
-            set fosdb_cache [dict create]
-            set dupset 0
-            set rowid 1
-            foreach wd $workdirs {
-                set wdinfo [dict get $workdir_dict $wd]
-                lassign $wdinfo fosdb nm siblingworkdirs 
-                dict incr fosdb_count $fosdb 
-                set dbcount [dict get $fosdb_count $fosdb]
-                if {[llength $siblingworkdirs] > 1}  {
-                    if {![dict exists $fosdb_dupset $fosdb]} {
-                        #first time this multi-checkout fosdb seen
-                        dict set fosdb_dupset $fosdb [incr dupset]
-                    }
-                    set dupid "[dict get $fosdb_dupset $fosdb].$dbcount/[llength $siblingworkdirs]"
-                } else {
-                    set dupid "" 
-                }
-                if {$dbcount == 1} {
-                    set pname ""
-                    set pcode ""
-                    if {[file exists $fosdb]} {
-                        if {[catch {
-                            sqlite3 fdb $fosdb
-                            set pname [lindex [fdb eval {select value from config where name = 'project-name'}] 0]
-                            set pcode [lindex [fdb eval {select value from config where name = 'project-code'}] 0]
-                            fdb close
-                            dict set fosdb_cache $fosdb [list name $pname code $pcode]
-                        }  errM]} {
-                            puts stderr "!!! problem with fossil db: $fosdb when examining workdir $wd"
-                            puts stderr "!!! error: $errM"
-                        }
-                    } else {
-                        puts stderr "!!! missing fossil db $fosdb" 
-                    }
-                } else {
-                    set info [dict get $fosdb_cache $fosdb]
-                    lassign $info _name pname _code pcode
-                }
-                lappend col_rowids $rowid
-                lappend col_fnames $nm
-                lappend col_dupids $dupid
-                lappend col_pnames $pname
-                lappend col_pcodes [string range $pcode 0 9]
-                incr rowid
-            }
-
-            set col_states [list]
-            set state_title ""
-            #if only one set of fossil checkouts in the resultset and opt_detail is 0 and not explicit - retrieve workingdir state for each co 
-            if {([llength [dict keys $fosdb_cache]] == 1)} {
-                if {!$opt_detail_explicit_zero} {
-                    set opt_detail 1
-                }
-                puts stderr "Result is from a single repo db [dict keys $fosdb_cache]"
-            }
-            if {$opt_detail} {
-                puts stderr "Gathering file state for [llength $workdirs] checkout folder(s). Use -detail 0 to omit file state"
-                set c_rev [list]
-                set c_rev_iso [list]
-                set c_unchanged [list]
-                set c_changed [list]
-                set c_new [list]
-                set c_missing [list]
-                set c_extra [list]
-                foreach wd $workdirs {
-                    set wd_state [punk::repo::workingdir_state $wd]
-                    set state_dict [punk::repo::workingdir_state_summary_dict $wd_state]
-                    lappend c_rev       [string range [dict get $state_dict revision] 0 9]
-                    lappend c_rev_iso   [dict get $state_dict revision_iso8601]
-                    lappend c_unchanged [dict get $state_dict unchanged] 
-                    lappend c_changed   [dict get $state_dict changed]
-                    lappend c_new       [dict get $state_dict new]
-                    lappend c_missing   [dict get $state_dict missing]
-                    lappend c_extra     [dict get $state_dict extra]
-                    puts -nonewline stderr "."
-                } 
-                puts -nonewline stderr \n
-                set t0 "Revision"
-                set w0 [tcl::mathfunc::max {*}[lmap v [concat [list $t0] $c_rev] {string length $v}]]
-                set c0 [string repeat " " $w0]
-                set t0b "Revision iso8601"
-                set w0b [tcl::mathfunc::max {*}[lmap v [concat [list $t0] $c_rev_iso] {string length $v}]]
-                set c0b [string repeat " " $w0b]
-                set t1 "Unch"
-                set w1 [tcl::mathfunc::max {*}[lmap v [concat [list $t1] $c_unchanged] {string length $v}]]
-                set c1 [string repeat " " $w1]
-                set t2 "Chgd"
-                set w2 [tcl::mathfunc::max {*}[lmap v [concat [list $t2] $c_changed] {string length $v}]]
-                set c2 [string repeat " " $w2]
-                set t3 "New"
-                set w3 [tcl::mathfunc::max {*}[lmap v [concat [list $t3] $c_new] {string length $v}]]
-                set c3 [string repeat " " $w3]
-                set t4 "Miss"
-                set w4 [tcl::mathfunc::max {*}[lmap v [concat [list $t4] $c_missing] {string length $v}]]
-                set c4 [string repeat " " $w4]
-                set t5 "Extr"
-                set w5 [tcl::mathfunc::max {*}[lmap v [concat [list $t5] $c_extra] {string length $v}]]
-                set c5 [string repeat " " $w5]
-                
-                set state_title "[overtype::left $c0 $t0] [overtype::left $c0b $t0b] [overtype::right $c1 $t1] [overtype::right $c2 $t2] [overtype::right $c3 $t3] [overtype::right $c4 $t4] [overtype::right $c5 $t5]"
-                foreach r $c_rev iso $c_rev_iso u $c_unchanged c $c_changed n $c_new m $c_missing e $c_extra {
-                    lappend col_states "[overtype::left $c0 $r] [overtype::left $c0b $iso] [overtype::right $c1 $u] [overtype::right $c2 $c] [overtype::right $c3 $n] [overtype::right $c4 $m] [overtype::right $c5 $e]"
-                }
-            }
-            
-            set msg ""
-            if {$opt_cd} {
-                set title0 "CD"
-            } else {
-                set title0 ""
-            }
-            set widest0 [tcl::mathfunc::max {*}[lmap v [concat [list $title0] $col_rowids] {punk::strlen $v}]]
-            set col0 [string repeat " " $widest0]
-            set title1 "Checkout dir"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $workdirs] {punk::strlen $v}]]
-            set col1 [string repeat " " $widest1]
-            set title2 "Repo DB name"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col_fnames] {string length $v}]]
-            set col2 [string repeat " " $widest2]
-            set title3 "CO dup"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col_dupids] {string length $v}]]
-            set col3 [string repeat " " $widest3]
-            set title4 "Project Name"
-            set widest4 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col_pnames] {string length $v}]]
-            set col4 [string repeat " " $widest4]
-            set title5 "Project Code"
-            set widest5 [tcl::mathfunc::max {*}[lmap v [concat [list $title5] $col_pcodes] {string length $v}]]
-            set col5 [string repeat " " $widest5]
-
-            set tablewidth [expr {$widest0 + 1 + $widest1 + 1 + $widest2 + 1 + $widest3 +1 + $widest4 + 1 + $widest5}]
-            append msg "[overtype::right $col0 $title0] [overtype::left $col1 $title1] [overtype::left $col2 $title2] [overtype::left $col3 $title3] [overtype::left $col4 $title4] [overtype::left $col5 $title5]"
-
-            if {[llength $col_states]} {
-                set title6 $state_title 
-                set widest6 [tcl::mathfunc::max {*}[lmap v [concat [list $title6] $col_states] {string length $v}]]
-                set col6 [string repeat " " $widest6]
-                incr tablewidth [expr {$widest6 + 1}]
-                append msg " [overtype::left $col6 $title6]" \n
-            } else {
-                append msg \n
-            }
-            append msg [string repeat "=" $tablewidth] \n
-
-            if {[llength $col_states]} {
-                foreach row $col_rowids wd $workdirs db $col_fnames dup $col_dupids pname $col_pnames pcode $col_pcodes s $col_states {
-                    append msg "[overtype::right $col0 $row] [overtype::left $col1 $wd] [overtype::left $col2 $db] [overtype::right $col3 $dup] [overtype::left $col4 $pname] [overtype::left $col5 $pcode] [overtype::left $col6 $s]" \n
-                } 
-            } else {
-                foreach row $col_rowids wd $workdirs db $col_fnames dup $col_dupids pname $col_pnames pcode $col_pcodes {
-                    append msg "[overtype::right $col0 $row] [overtype::left $col1 $wd] [overtype::left $col2 $db] [overtype::right $col3 $dup] [overtype::left $col4 $pname] [overtype::left $col5 $pcode]" \n
-                } 
-            }
-            set numrows [llength $col_rowids]
-            if {$opt_cd && $numrows >= 1} {
-                puts stdout $msg
-                if {$numrows == 1} {
-                    set workingdir [lindex $workdirs 0]
-                    puts stdout "1 result. Changing dir to $workingdir"
-                    if {[file exists $workingdir]} {
-                        ::cd $workingdir
-                        return $workingdir
-                    } else {
-                        puts stderr "path $workingdir doesn't appear to exist" 
-                        return [pwd]
-                    }
-                } else {
-                    set answer [util::askuser "Change directory to working folder - select a number from 1 to [llength $col_rowids] or any other key to cancel."]
-                    if {[string trim $answer] in $col_rowids} {
-                        set index [expr {$answer - 1}]
-                        set workingdir [lindex $workdirs $index]
-                        ::cd $workingdir
-                        puts stdout [pmix stat]
-                        return $workingdir
-                    }
-                }
-            }
-            return $msg
-        }
-        #*** !doctools
-        #[list_end] [comment {-- end collection namespace definitions --}]
-    }
-    
-    namespace eval lib {
-        proc template_tag {tagname} {
-            #todo - support different tagwrappers - it shouldn't be so likely to collide with common code idioms etc.
-            #we need to detect presence of tags intended for punk::mix system
-            #consider using punk::cap to enable multiple template-substitution providers with their own set of tagnames and/or tag wrappers, where substitution providers are all run 
-            return [string cat % $tagname %]
-        }
-        #get project info only by opening the central confg-db
-        #(will not have proper project-name etc)
-        proc get_projects {{globlist {}} args} {
-            if {![llength $globlist]} {
-                set globlist [list *]
-            }
-            set fossil_prog [auto_execok fossil]
-
-            set fossilinfo [exec {*}$fossil_prog info] ;#will give us the necessary config-db info whether in a project folder or not
-            set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
-            if {[llength $matching_lines] != 1} {
-                puts stderr "Unable to find config-db info from fossil. Check your fossil installation."
-                puts stderr "Fossil output was:"
-                puts stderr "-------------" 
-                puts stderr "$fossilinfo"
-                puts stderr "-------------"
-                puts stderr "config-db info:"
-                puts stderr "$matching_lines"
-                return
-            }
-            set ln [lindex $matching_lines 0]
-            set configdb [string trim [string range $ln [string length "config-db: "] end]]
-            if {![file exists $configdb]} {
-                error "config-db not found at path $configdb"
-            }
-            package require sqlite3
-            ::sqlite3 fosconf $configdb
-            #set testresult [fosconf eval {select name,value from global_config;}]
-            #puts stderr $testresult
-            set project_repos [fosconf eval {select name from global_config where name like 'repo:%';}]
-            set paths_and_names [list]
-            foreach pr $project_repos {
-                set path [string trim [string range $pr 5 end]]
-                set nm [file rootname [file tail $path]]
-                set ckouts [fosconf eval {select name from global_config where value = $path;}]
-                set checkout_paths [list]
-                #strip "ckout:"
-                foreach ck $ckouts {
-                   lappend checkout_paths [string trim [string range $ck 6 end]]
-                }
-                lappend paths_and_names [list $path $nm $checkout_paths] 
-            }
-            set filtered_list [list]
-            foreach glob $globlist {
-                set matches [lsearch -all -inline -index 1 $paths_and_names $glob]
-                foreach m $matches {
-                    if {$m ni $filtered_list} {
-                        lappend filtered_list $m
-                    } 
-                }
-            }
-            set projects [lsort -index 1 $filtered_list]
-            return $projects
-        }
-    
-    }
-    
-    
-
-
-
-}
-
-
-#*** !doctools
-#[manpage_end]
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::project [namespace eval punk::mix::commandset::project {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm
deleted file mode 100644
index abfb0e55..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm
+++ /dev/null
@@ -1,92 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::repo 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::repo {
-    namespace export *
-    proc tickets {{project ""}} {
-        set result ""
-        if {[string length $project]} {
-            puts stderr "project status unimplemented"
-            return
-        }
-        set active_dir [pwd]
-        append result "Retrieving top 10 tickets only (for more, use fossil timeline -n <int> -t t)" \n
-        append result [exec fossil timeline -n 10 -t t]
-
-        return $result
-    }
-
-    proc fossilize { args} {
-        #check if project already managed by fossil.. initialise and check in if not.
-        puts stderr "unimplemented"
-    }
-
-    proc unfossilize {projectname args} {
-        #remove/archive .fossil 
-        puts stderr "unimplemented"
-    }
-    proc state {} {
-        set result ""
-        set repopaths [punk::repo::find_repos [pwd]]
-        set repos [dict get $repopaths repos]
-        if {![llength $repos]} {
-            append result [dict get $repopaths warnings]
-        } else {
-            append result [dict get $repopaths warnings]
-            lassign [lindex $repos 0] repopath repotypes
-            if {"fossil" in $repotypes} {
-                append result \n "Fossil repo based at $repopath"
-                set repostate [punk::repo::workingdir_state $repopath -repopaths $repopaths -repotypes fossil]
-                append result \n [punk::repo::workingdir_state_summary $repostate]
-            }
-            if {"git" in $repotypes} {
-                append result \n "Git repo based at $repopath"
-                set repostate [punk::repo::workingdir_state $repopath -repopaths $repopaths -repotypes git]
-                append result \n [punk::repo::workingdir_state_summary $repostate]
-            }
-        }
-        return $result
-    }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::repo [namespace eval punk::mix::commandset::repo {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm
deleted file mode 100644
index e40bc899..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm
+++ /dev/null
@@ -1,681 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::scriptwrap 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-package require punk::mix
-package require punk::mix::base
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::scriptwrap {
-    namespace export *
-
-
-    #scriptpath allows templates command to use same custom template set as when multishell pointed to a filepath
-    #it may or may not be within a project
-    #by using the same folder or path, the same project root will be discovered. REVIEW.
-    proc templates_dict {args} {
-        set defaults [list -scriptpath ""]
-        set opts [dict merge $defaults $args]
-        set opt_scriptpath [dict get $opts -scriptpath]
-
-        set wrapper_folders [lib::get_wrapper_folders $opt_scriptpath]
-
-        set wrapper_templates [list]
-        foreach fld $wrapper_folders {
-            set templates [glob -nocomplain -dir $fld -type f *]
-            foreach tf $templates {
-                if {[string match ignore* $tf]} {
-                    continue
-                }
-                set ext [file extension $tf]
-                if {$ext in [list "" ".bat" ".cmd" ".sh"]} {
-                    lappend wrapper_templates $tf
-                }
-            }
-        }
-
-        set tdict [dict create]
-        set seen_dict [dict create]
-        foreach fullpath $wrapper_templates {
-            set ftail [file tail $fullpath]
-            if {![dict exists $seen_dict $ftail]} {
-                dict set seen_dict $ftail 1 
-                dict set tdict $ftail $fullpath ; #first seen of filename gets no number
-            } else {
-                set n [dict get $seen_dict $ftail]
-                incr n
-                dict incr seen_dict $ftail
-                dict set tdict ${ftail}.$n $fullpath
-            }
-        }
-        return $tdict
-    }
-    proc templates {args} {
-        package require overtype
-        set tdict [templates_dict {*}$args]
-
-       
-        set paths [dict values $tdict]
-        set names [dict keys $tdict]
-
-        set title1 "Path"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $paths] {punk::strlen $v}]]
-        set col1 [string repeat " " $widest1] 
-
-        set title2 "Template Name"
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $names] {punk::strlen $v}]]
-        set col2 [string repeat " " $widest2]
-
-        set tablewidth [expr {$widest1 + 1 + $widest2}]
-        set table ""
-        append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col1 $title1] [overtype::left $col2 $title2]" \n
-        append table [string repeat - $tablewidth] \n
-
-        foreach p $paths n $names {
-           append table "[overtype::left $col1 $p] [overtype::left $col2 $n]" \n 
-        }
-
-
-        return $table
-    }
-    #specific filepath to just wrap one script at the tcl-payload or xxx-payload-pre-tcl site
-    #scriptset name to substiture multiple scriptset.xxx files at the default locations - or as specified in scriptset.wrapconf
-    proc multishell {filepath_or_scriptset args} {
-        set defaults [dict create\
-             -askme 1\
-             -outputfolder "\uFFFF"\
-             -template "\uFFFF"\
-        ]
-        set known_opts [dict keys $defaults]
-        dict for {k v} $args {
-            if {$k ni $known_opts} {
-
-                error "punk::mix::commandset::scriptwrap error. Unrecognized option '$k'. Known-options: $known_opts"
-            }
-        }
-        set usage ""
-        append usage "Use directly with the script file to wrap, or supply the name of a scriptset" \n
-        append usage "The scriptset name will be used to search for yourname.sh|tcl|ps1 or names as you specify in  yourname.wrapconfig if it exists" \n
-        append usage "If no template is specified in a .wrapconfig and no -template argument is supplied, it will default to punk-multishell.cmd" \n
-        if {![string length $filepath_or_scriptset]} {
-            puts stderr "No filepath_or_scriptset specified"
-            puts stderr $usage
-            return false
-        }
-        set opts            [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_askme       [dict get $opts -askme]
-        set opt_template    [dict get $opts -template]
-        set opt_outputfolder [dict get $opts -outputfolder]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-
-
-        set ext [file extension $filepath_or_scriptset]
-        set startdir [pwd]
-
-
-
-        #first check if relative or absolute path matches a file
-        if {[file pathtype $filepath_or_scriptset] eq "absolute"} {
-            set specified_path $filepath_or_scriptset 
-        } else {
-            set specified_path [file join $startdir $filepath_or_scriptset]
-        }
-        set ext [string trim [file extension $filepath_or_scriptset] .]
-        set allowed_extensions [list wrapconfig tcl ps1 sh bash]
-        #set allowed_extensions [list tcl]
-        set found_script 0  
-        if {[file exists $specified_path]} {
-            set found_script 1
-        } else {
-            foreach e $allowed_extensions {
-                if {[file exists $filepath_or_scriptset.$e]} {
-                    set found_script 1
-                    break
-                }
-            }
-        }
-
-        #TODO! - use get_wrapper_folders - multishell should use same available templates as the 'templates' function
-        set scriptset [file rootname [file tail $specified_path]] 
-        if {$found_script} {
-            if {[file type $specified_path] eq "file"} {
-                set specified_root [file dirname $specified_path]
-                set pathinfo    [punk::repo::find_repos [file dirname $specified_path]]
-                set projectroot [dict get $pathinfo closest]
-                if {[string length $projectroot]} {
-                    #use the specified files folder - but use the main scriptapps/wrappers folder if specified one has no wrappers subfolder
-                    set scriptroot [file dirname $specified_path] 
-                    if {[file exists $scriptroot/wrappers]} {
-                        set customwrapper_folder $scriptroot/wrappers
-                    } else {
-                        set customwrapper_folder $projectroot/src/scriptapps/wrappers
-                    }
-                } else {
-                    #outside of any project
-                    set scriptroot [file dirname $specified_path] 
-                    if {[file exists $scriptroot/wrappers]} {
-                        set customwrapper_folder $scriptroot/wrappers
-                    } else {
-                        #no customwrapper folder available
-                        set customwrapper_folder ""
-                    }
-                }
-            } else {
-                puts stderr "wrap_in_multishell doesn't currently support a directory as the path."
-                puts stderr $usage
-                return false
-            }
-        } else {
-            set pathinfo [punk::repo::find_repos $startdir]
-            set projectroot [dict get $pathinfo closest]
-            if {[string length $projectroot]} {
-                if {[llength [file split $filepath_or_scriptset]] > 1} {
-                    puts stderr "filepath_or_scriptset looks like a path - but doesn't seem to point to a file"
-                    puts stderr "Ensure you are within a project and use just the name of the scriptset, or pass in the full correct path or relative path to current directory"
-                    puts stderr $usage
-                    return false
-                } else {
-                    #we've already ruled out empty string - so must have a single element representing scriptset - possibly with file extension
-                    set scriptroot $projectroot/src/scriptapps
-                    set customwrapper_folder $projectroot/src/scriptapps/wrappers
-                    #check something matches the scriptset.. 
-                    set something_found ""
-                    if {[file exists $scriptroot/$scriptset]} {
-                        set found_script 1
-                        set something_found $scriptroot/$scriptset  ;#extensionless file - that's ok too
-                    } else {
-                        foreach e $allowed_extensions {
-                            if {[file exists $scriptroot/$scriptset.$e]} {
-                                set found_script 1
-                                set something_found $scriptroot/$scriptset.$e
-                                break
-                            }
-                        }
-                    }
-                    if {!$found_script} {
-                        puts stderr "Searched within $scriptroot"
-                        puts stderr "Unable to find a file matching $scriptset or one of the extensions: $allowed_extensions"
-                        puts stderr $usage
-                        return false
-                    } else {
-                        if {[file type $something_found] ne "file"} {
-                            puts stderr "Found '$something_found'"
-                            puts stderr "wrap_in_multishell doesn't currently support a directory as the path."
-                            puts stderr $usage
-                            return false
-                        }
-                    }
-                }
-
-            } else {
-                puts stderr "filepath_or_scriptset parameter doesn't seem to refer to a file, and you are not within a directory where projectroot and src/scriptapps/wrappers can be determined"
-                puts stderr $usage
-                return false
-            }
-        }
-        #assert - customwrapper_folder var exists - but might be empty
-
-        
-        if {[string length $ext]} {
-            #If there was an explicitly supplied extension - then that file should exist
-            if {![file exists $scriptroot/$scriptset.$ext]} {
-                puts stderr "Explicit extension .$ext was supplied - but matching file not found."
-                puts stderr $usage
-                return false
-            } else {
-                if {$ext eq "wrapconfig"} {
-                    set process_extensions ALLFOUNDORCONFIGURED
-                } else {
-                    set process_extensions $ext
-                }
-            }
-        } else {
-            #no explicit extension - process all for scriptset
-            set process_extensions ALLFOUNDORCONFIGURED
-        }
-        #process_extensions - either a single one - or all found or as per .wrapconfig
-
-        if {$opt_template eq "\uFFFF"} {
-            set templatename punk-multishell.cmd
-        } else {
-            set templatename $opt_template
-        }
-
-
-
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-        set tpldirs [list]
-        dict for {tdir tsourceinfo} $template_base_dict {
-           if {[file exists $tdir/utility/scriptappwrappers/$templatename]} {
-                lappend tpldirs $tdir
-           } 
-        }
-
-        if {[string length $customwrapper_folder] && [file exists [file join $customwrapper_folder $templatename] ]} {
-            set wrapper_template [file join $customwrapper_folder $templatename]
-        } else {
-            if {![llength $tpldirs]} {
-                set msg "No template named '$templatename' found in src/scriptapps/wrappers or in template dirs from packages"
-                append msg \n "Searched [dict size $template_base_dict] template dirs"
-                error $msg
-            }
-
-            #last pkg with templates cap which was loaded has highest precedence
-            set wrapper_template ""
-            foreach tdir [lreverse $tpldirs] {
-                set ftest [file join $tdir utility scriptappwrappers $templatename]
-                if {[file exists $ftest]} {
-                    set wrapper_template $ftest
-                    break
-                }
-            }
-        }
-
-        if {$wrapper_template eq "" || ![file exists $wrapper_template]} {
-            error "wrap_in_multishell: unable to find multishell template $templatename in template folders [concat $tpldirs $customwrapper_folder]"
-        }
-
-
-        if {$opt_outputfolder eq "\uFFFF"} {
-            #outputfolder not explicitly specified by caller
-            if {[string length $projectroot]} {
-                set output_folder [file join $projectroot/bin]
-            } else {
-                set output_folder $startdir
-            }
-        } else {
-            if {[file pathtype $opt_outputfolder] eq "relative"} {
-               if {[string length $projectroot]} {
-                    set output_folder [file join $projectroot $opt_outputfolder]
-               } else {
-                    set output_folder [file join $startdir $opt_outputfolder]
-               }
-            } else {
-                set output_folder $opt_outputfolder
-            }
-        }
-        if {![file isdirectory $output_folder]} {
-            error "wrap_in_multishell: output folder '$output_folder' not found. Please ensure target directory exists"
-        }
-
-
-        #todo
-        #output_file extension may also depend on the template being used.. and/or the .wrapconfig
-        if {$::tcl_platform(platform) eq "windows"} {
-            set output_extension cmd
-        } else {
-            set output_extension sh
-        }
-        set output_file [file join $output_folder $scriptset.$output_extension]
-        if {[file exists $output_file]} {
-            error "wrap_in_multishell: target file $output_file already exists.. aborting"
-        }
-        
-
-        set fdt [open $wrapper_template r]
-        fconfigure $fdt -translation binary
-        set template_data [read $fdt]
-        close $fdt
-        puts stdout "Read [string length $template_data] bytes of template data.."
-        set template_lines [split $template_data \n]
-        puts stdout "Displaying first 3 lines of template between dashed lines..."
-        puts stdout "-----------------------------------------------"
-        foreach ln [lrange $template_lines 0 3] {
-            puts stdout $ln
-        }
-        puts stdout "-----------------------------------------------\n"
-        #foreach  ln $template_lines {
-        #}
-
-        set list_input_files [list]
-        if {$process_extensions eq "ALLFOUNDORCONFIGURED"} {
-            #todo - look for .wrapconfig  or all extensions for the scriptset
-            puts stderr "Sorry - only single input file supported. Supply a file extension or use a .wrapconfig with a single input file for now - implementation incomplete"
-            return false
-        } else {
-            lappend list_input_files $scriptroot/$scriptset.$ext
-        }
-
-        #todo - split template at each <ext-payload> etc marker and build a dict of parts
-
-
-        #hack - process one input
-        set filepath [lindex $list_input_files 0]
-
-        set fdscript [open $filepath r]
-        fconfigure $fdscript -translation binary
-        set script_data [read $fdscript]
-        close $fdscript
-        puts stdout "Read [string length $script_data] bytes of template data.."
-        set script_lines [split $script_data \n]
-        puts stdout "Displaying first 3 lines of your script between dashed lines..."
-        puts stdout "-----------------------------------------------"
-        foreach ln [lrange $script_lines 0 3] {
-            puts stdout $ln
-        }
-        puts stdout "-----------------------------------------------\n"
-        puts stdout "Target for above data is '$output_file'"
-        if {$opt_askme} {
-            set answer [util::askuser "Does this look correct? Y|N"]
-            if {[string tolower $answer] ne "y"} {
-                puts stderr "mix new aborting due to user response '$answer' (required Y or y to proceed)  use -askme 0 to avoid prompts."
-                return
-            }
-        }
-
-        set start_idx 0
-        set end_idx 0
-        set line_idx 0
-        set existing_payload [list]
-        foreach ln $template_lines {
-
-            if {[string match  "#<tcl-payload>*" $ln]} {
-                set start_idx $line_idx
-            } elseif {[string match "#</tcl-payload>*" $ln]} {
-                set end_idx $line_idx
-                break
-            } elseif {$start_idx > 0} {
-                 if {$end_idx > 0} {
-                     lappend existing_payload [string trim $ln]
-                 }   
-            } else {
-
-            }
-            incr line_idx
-        }
-        if {($start_idx == 0) || ($end_idx == 0)} {
-            error "wrap_in_multishell was unable to find payload area in template marked with #<tcl-payload>  and #</tcl-payload> on separate lines"
-        }
-        set existing_string [join $existing_payload \n]
-        if {[string length [string trim $existing_string]]} {
-            puts stdout "EXISTING PAYLOAD!!"
-            puts stdout "-----------------------------------------------\n"
-            puts stdout $existing_string
-            puts stdout "-----------------------------------------------\n"
-            error "wrap_in_multishell found existing payload.. aborting."
-            #todo - allow overwrite only in files outside of punkshell distribution?
-            if 0 {
-                puts stderr "Found existing payload.. overwrite?" 
-                if {$opt_askme} {
-                    set answer [util::askuser "Are you sure you want to replace the tcl payload shown above? Y|N"]
-                    if {[string tolower $answer] ne "y"} {
-                        puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -askme 0 to avoid prompts."
-                        return
-                    }
-                }
-            }
-        }
-
-        set tpl_head_lines [lrange $template_lines 0 $start_idx] ;#include tag line
-        set tpl_tail_lines [lrange $template_lines $end_idx end]
-        set newscript [join $tpl_head_lines \n]\n[join $script_lines \n]\n[join $tpl_tail_lines \n]
-        puts stdout "New script is [string length $newscript] bytes"
-        puts stdout $newscript
-        set fdtarget [open $output_file w]
-        fconfigure $fdtarget -translation binary
-        puts -nonewline $fdtarget $newscript
-        close $fdtarget
-        puts stdout "Wrote script file at $output_file"
-
-        #even though chmod might exist on windows - we will leave permissions alone
-        if {$::tcl_platform(platform) ne "windows"} {
-            catch {exec chmod +x $output_file}
-        }
-        puts stdout "-done-"
-        return $output_file
-    }
-
-    namespace eval lib {
-
-        #get_wrapper_folders
-        #   scriptpath - file or folder
-        #   It represents the base point from which to search for /wrapper folders either directly above the scriptpath or in the containing project if any
-        #   The cwd will also be searched for /wrapper folder and project - but with lower precedence in the resultset (later in list)
-        proc get_wrapper_folders {{scriptpath ""}} {
-            set wrapper_folders [list]
-            if {$scriptpath ne ""} {
-                if {[file type $scriptpath] eq "file"} {
-                    set searchbase [file dirname $scriptpath]
-                } else {
-                    set searchbase $scriptpath
-                }
-                if {[file isdirectory [file join $searchbase wrappers]]} {
-                    lappend wrapper_folders [file join $searchbase wrappers]
-                }
-                set pathinfo    [punk::repo::find_repos $searchbase]
-                set scriptpath_projectroot [dict get $pathinfo closest]
-                if {$scriptpath_projectroot ne ""} {
-                    set fld [file join $scriptpath_projectroot src/scriptapps/wrappers]
-                    if {[file isdirectory $fld]} {
-                        if {$fld ni $wrapper_folders} {
-                            lappend wrapper_folders $fld
-                        }
-                    }
-                }
-            }
-            set searchbase [pwd] 
-            set fld [file join $searchbase wrappers]
-            if {[file isdirectory $fld]} {
-                if {$fld ni $wrapper_folders} {
-                    lappend wrapper_folders $fld
-                }
-            }
-            set pathinfo    [punk::repo::find_repos $searchbase]
-            set pwd_projectroot [dict get $pathinfo closest]
-            if {$pwd_projectroot ne ""} {
-                set fld [file join $pwd_projectroot src/scriptapps/wrappers]
-                if {[file isdirectory $fld]} {
-                    if {$fld ni $wrapper_folders} {
-                        lappend wrapper_folders $fld
-                    }
-                }
-            }
-
-            set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-            set tpldirs [list]
-            dict for {tdir tsourceinfo} $template_base_dict {
-                if {[file exists $tdir/utility/scriptappwrappers]} {
-                        lappend tpldirs $tdir
-                } 
-            }
-            foreach tpldir $tpldirs {
-                set fld [file join $tpldir utility scriptappwrappers]
-                if {[file isdirectory $fld]} {
-                    if {$fld ni $wrapper_folders} {
-                        lappend wrapper_folders $fld
-                    }
-                }
-            }
-            return $wrapper_folders
-        }
-        proc _scriptapp_tag_from_line {line} {
-            set result [list istag 0 raw ""] ;#default assumption. All 
-            #----
-            set startc [string first "#" $line] ;#tags must be commented
-            #todo - review. next line is valid - note # doesn't have to be the only one before <tagname>  
-            # @REM # etc < blah # <tagname> etc 
-            #---
-            #fix - we should use a regexp on at least <tagname> </tagname> <tagname/> and only catch tagname without whitespace
-            regexp {(\s*).*} $line _ln indent  ;#will match on empty line, whitespace only line - or anything really.
-            set indent [string map [list \t "    "] $indent] ;#opinionated I guess - but need to normalize to something. The spec is that spaces should be used anyway.
-            dict set result indent [string length $indent]
-            set starttag [string first "<" $line]
-            set pretag [string range $line $startc $starttag-1] 
-            if {[string match "*>*" $pretag]} {
-                return [list istag 0 raw $line reason pretag_contents]
-            }
-            set closetag [string first ">" $line] 
-            set inelement [string range $line $starttag+1 $closetag-1]
-            if {[string match "*<*" $inelement]} {
-                return [list istag 0 raw $line reason tag_malformed_angles]
-            }
-            set elementchars [split $inelement ""]
-            set numslashes [llength [lsearch -all $elementchars "/"]]
-            if {$numslashes == 0} {
-                dict set result type "open"
-            } elseif {$numslashes == 1} {
-                if {[lindex $elementchars 0] eq "/"} {
-                    dict set result type "close"
-                } elseif {[lindex $elementchars end] eq "/"} {
-                    dict set result type "openclose"
-                } else {
-                    return [list istag 0 raw $line reason tag_malformed_slashes]
-                }
-            } else {
-               return [list istag 0 raw $line reason tag_malformed_extraslashes]
-            }
-            if {[dict get $result type] eq "open"} {
-                dict set result name $inelement
-            } elseif {[dict get $result type] eq "close"} {
-                dict set result name [string range $inelement 1 end]
-            } else {
-                dict set result name [string range $inelement 0 end-1]
-            }
-            dict set result istag 1
-            dict set result raw $line
-            return $result
-        }
-
-        #get all \n#<something>\n ...\n#</something>  data - where number of intervening newlines is at least one (and whitespace and/or other data can precede #)
-        #we don't verify 'something' against known tags - as custom templates can have own tags
-        #An openclose tag #<xxx/>  is used to substitute a specific line in its entirety - but the tag *must* remain in the line
-        #
-        #e.g for the line:
-        #   @set "nextshell=pwsh" & :: #<batch-nextshell-line/>
-        #The .wrapconfig might contain
-        #   tag <batch-nextshell-line> line {@set "nextshell=tclsh" & :: @<batch-nextshell-line/>}
-        #
-        proc scriptapp_wrapper_get_tags {wrapperdata} {
-            set wrapperdata [string map [list \r\n \n] $wrapperdata]
-            set lines [split $wrapperdata \n]
-            #set tags_in_data [dict create];#active tags - list of lines accumulating. supports nested tags
-            set status 0
-            set tags [dict create]
-            set errors [list]
-            set errortags [dict create] ;#mark names invalid on first error so that more than 2 tags can't obscure config problem
-            set linenum 1 ;#editors and other utils use 1-based indexing when referencing files - we should too to avoid confusion, despite it being less natural for lindex operations on the result.
-            foreach ln $lines {
-                set lntrim [string trim $ln]
-                if {![string length $lntrim]} {
-                    incr linenum
-                    continue
-                }
-                if {[string match "*#*<*>*" $lntrim]} {
-                    set taginfo [_scriptapp_tag_from_line $ln] ;#use untrimmed line - to get indent
-                    if {[dict get $taginfo istag]} {
-                       set nm [dict get $taginfo name]
-                       if {[dict exists $errortags $nm]} {
-                           #tag is already in error condition - 
-                       } else {
-                            set tp [dict get $taginfo type] ;# type singular - related to just one line
-                            #set raw [dict get $taginfo raw] #equivalent to $ln
-                            if {[dict exists $tags $nm]} {
-                                    #already seen tag name
-                                    #tags dict has types key *plural* - need to track whether we have type open and type close (or openclose for self-closing tags)
-                                    if {[dict get $tags $nm types] ne "open"} { 
-                                        lappend errors "line: $linenum tag $nm encountered type $tp after existing type [dict get $tags $nm types]"
-                                        dict incr errortags $nm
-                                    } else {
-                                        #we already have open - expect only close
-                                        if {$tp ne "close"} {
-                                            lappend errors "line: $linenum tag $nm encountered type $tp after existing type [dict get $tags $nm types]"
-                                            dict incr errortags $nm 
-                                        } else {
-                                            #close after open
-                                            dict set tags $nm types [list open close]
-                                            dict set tags $nm end $linenum
-                                            set taglines [dict get $tags $nm taglines]
-                                            if {[llength $taglines] != 1} {
-                                                error "Unexpected result when closing tag $nm. Existing taglines length not 1."
-                                            }
-                                            dict set tags $nm taglines [concat $taglines $ln]
-                                        }
-                                    }
-                            } else {
-                                    #first seen of tag name
-                                    if {$tp eq "close"} {
-                                            lappend errors "line: $linenum tag $nm encountered type $p close first"
-                                            dict incr errortags $nm
-                                    } else {
-                                        dict set tags $nm types $tp 
-                                        dict set tags $nm indent [dict get $taginfo indent]
-                                        if {$tp eq "open"} {
-                                            dict set tags $nm start $linenum
-                                            dict set tags $nm taglines [list $ln] ;#first entry - another will be added on encountering matching closing tag
-                                        } elseif {$tp eq "openclose"} {
-                                            dict set tags $nm start $linenum
-                                            dict set tags $nm end $linenum
-                                            dict set tags $nm taglines [list $ln] ;#single entry is final result for self-closing tag
-                                        }
-                                    }
-                            }
-                        }
-                    } else {
-                        #looks like it should be a tag.. but failed to even parse for some reason.. just add to errorlist
-                        lappend errors "line: $linenum tag parse failure reason: [dict get $taginfo reason] raw line: [dict get $taginfo raw]"
-                    }
-                }
-                #whether the line is tag or not append to any tags_in_data
-                #foreach t [dict keys $tags_in_data] {
-                #    dict lappend tags_in_data $t $ln ;#accumulate raw lines - written to the tag entry in tags only on encountering a closing tag, then removed from tags_in_data
-                #}
-                incr linenum
-            }
-            #assert [expr {$linenum -1 == [llength $lines]}]
-            if {[llength $errors]} {
-                set status 0
-            } else {
-                set status 1
-            }
-            if {$linenum == 0} {
-                
-            }
-            return [dict create ok $status linecount [llength $lines] data $tags errors $errors]
-        }
-
-
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::scriptwrap [namespace eval punk::mix::commandset::scriptwrap {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/templates-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/templates-0.1.0.tm
deleted file mode 100644
index 46065bda..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/templates-0.1.0.tm
+++ /dev/null
@@ -1,84 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::templates 0.1.0
-# Meta platform     tcl
-# Meta license      BSD
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require punk::cap
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::templates {
-    variable pkg punk::mix::templates
-    variable cap_provider
-
-    #punk::cap::register_package punk::mix::templates [list\
-    #   {punk.templates {relpath ../templates}}\
-    #]
-
-    namespace eval capsystem {
-        if {[info commands capprovider.registration] eq ""} {
-            punk::cap::class::interface_capprovider.registration create capprovider.registration
-            oo::objdefine capprovider.registration {
-                method get_declarations {} {
-                    set decls [list]
-                    lappend decls [list punk.templates {relpath ../templates}]
-                    lappend decls [list punk.templates {relpath ../templates2}]
-                    lappend decls [list punk.test {something blah}]
-                    return $decls
-                }
-            }
-        }
-    }
-
-    if {[info commands provider] eq ""} {
-        punk::cap::class::interface_capprovider.provider create provider punk::mix::templates
-        oo::objdefine provider {
-            method register {{capabilityname_glob *}} {
-                #puts  registering punk::mix::templates $capabilityname
-                next
-            }
-            method capabilities {} {
-                next
-            }
-        }
-    }
-
-    # -- ---
-    #provider api
-    # -- ---
-    #none - declarations only
-}
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::templates [namespace eval punk::mix::templates {
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/util-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/util-0.1.0.tm
deleted file mode 100644
index 5622bc02..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/mix/util-0.1.0.tm
+++ /dev/null
@@ -1,350 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::util 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-namespace eval punk::mix::util {
-    variable has_winpath 0
-}
-
-if {"windows" eq $::tcl_platform(platform)} {
-   if {![catch {package require punk::winpath}]} {
-       set punk::mix::util::has_winpath 1
-   }
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::util {
-    variable tmpfile_counter 0 ;#additional tmpfile collision avoidance
-
-    namespace export *
-
-
-    proc fcat {args} {
-        variable has_winpath
-
-        if {$::tcl_platform(platform) ne "windows"} {
-            return [fileutil::cat {*}$args]
-        }
-
-        set knownopts [list -eofchar -translation -encoding --]
-        set last_opt 0
-        for {set i 0} {$i < [llength $args]} {incr i} {
-            set ival [lindex $args $i]
-            #puts stdout "i:$i a: $ival known: [expr {$ival in $knownopts}]"
-            if {$ival eq "--"} {
-                set last_opt $i
-                break
-            } else {
-                if {$ival in $knownopts} {
-                    #puts ">known at $i : [lindex $args $i]"
-                    if {($i % 2) != 0} {
-                        error "unexpected option at index $i. known options: $knownopts must come in -opt val pairs."
-                    }
-                    incr i
-                    set last_opt $i
-                } else {
-                set last_opt [expr {$i - 1}] 
-                break
-                }
-            }
-        }
-        set first_non_opt [expr {$last_opt + 1}]
-
-        #puts stderr "first_non_opt: $first_non_opt"
-        set opts [lrange $args -1 $first_non_opt-1]
-        set paths [lrange $args $first_non_opt end]
-        if {![llength $paths]} {
-            error "Unable to find file in the supplied arguments: $args. Ensure options are all -opt val pairs and that file name(s) follow"
-        }
-        #puts stderr "opts: $opts  paths: $paths"
-        set finalpaths [list]
-        foreach p $paths {
-            if {$has_winpath && [punk::winpath::illegalname_test $p]} {
-                lappend finalpaths [punk::winpath::illegalname_fix $p]
-            } else {
-                lappend finalpaths $p
-            }
-        }
-        fileutil::cat {*}$opts {*}$finalpaths
-    }
-
-    #----------------------------------------
-    namespace eval internal {
-        proc path_common_prefix_pop {varname} {
-            upvar 1 $varname var
-            set var [lassign $var head]
-            return $head
-        }
-    }
-    proc path_common_prefix {args} {
-        set dirs $args
-        set parts [file split [internal::path_common_prefix_pop dirs]]
-        while {[llength $dirs]} {
-            set r {}
-            foreach cmp $parts elt [file split [internal::path_common_prefix_pop dirs]] {
-                if {$cmp ne $elt} break
-                lappend r $cmp
-            }
-            set parts $r
-        }
-        if {[llength $parts]} {
-            return [file join {*}$parts]
-        } else {
-            return ""
-        }
-    }
-
-    #retains case from first argument only - caseless comparison
-    proc path_common_prefix_nocase {args} {
-        set dirs $args
-        set parts [file split [internal::path_common_prefix_pop dirs]]
-        while {[llength $dirs]} {
-            set r {}
-            foreach cmp $parts elt [file split [internal::path_common_prefix_pop dirs]] {
-                if {![string equal -nocase $cmp $elt]} break
-                lappend r $cmp
-            }
-            set parts $r
-        }
-        if {[llength $parts]} {
-            return [file join {*}$parts]
-        } else {
-            return ""
-        }
-    }
-    #----------------------------------------
-
-    #namespace import ::punk::ns::nsimport_noclobber 
-
-    proc namespace_import_pattern_to_namespace_noclobber {pattern ns} {
-        set source_ns [namespace qualifiers $pattern]
-        if {![namespace exists $source_ns]} {
-            error "namespace_import_pattern_to_namespace_noclobber error namespace $source_ns not found"
-        }
-        if {![string match ::* $ns]} {
-            set nscaller [uplevel 1 {namespace current}]
-            set ns [punk::nsjoin $nscaller $ns]
-        }
-        set a_export_patterns [namespace eval $source_ns {namespace export}] 
-        set a_commands [info commands $pattern]
-        set a_tails [lmap v $a_commands {namespace tail $v}]
-        set a_exported_tails [list]
-        foreach pattern $a_export_patterns {
-            set matches [lsearch -all -inline $a_tails $pattern]
-            foreach m $matches {
-                if {$m ni $a_exported_tails} {
-                    lappend a_exported_tails $m
-                }
-            }
-        }
-        set imported_commands [list]
-        foreach e $a_exported_tails {
-            set imported [namespace eval $ns [string map [list <func> $e <a> $source_ns] {
-                set cmd ""
-                if {![catch {namespace import <a>::<func>}]} {
-                    set cmd <func>
-                }
-                set cmd
-            }]]
-            if {[string length $imported]} {
-                lappend imported_commands $imported
-            }
-        }
-        return $imported_commands
-    }
-
-    proc askuser {question} {
-        puts stdout $question
-        flush stdout
-        set stdin_state [fconfigure stdin]
-        fconfigure stdin -blocking 1
-        set answer [gets stdin]
-        fconfigure stdin -blocking [dict get $stdin_state -blocking]
-        return $answer
-    }
-
-    proc do_in_path {path script} {
-        #from ::kettle::path::in
-        set here [pwd]
-        try {
-            cd $path
-            uplevel 1 $script
-        } finally {
-            cd $here
-        }
-    }
-
-    proc foreach-file {path script_pathvariable script} {
-        upvar 1 $script_pathvariable thepath
-
-        set known {}
-        lappend waiting $path
-        while {[llength $waiting]} {
-        set pending $waiting
-        set waiting {}
-        set at 0
-        while {$at < [llength $pending]} {
-            set current [lindex $pending $at]
-            incr at
-
-            # Do not follow into parent.
-            if {[string match *.. $current]} continue
-
-            # Ignore what we have visited already.
-            set c [file dirname [file normalize $current/___]]
-            if {[dict exists $known $c]} continue
-            dict set known $c .
-
-            if {[file tail $c] eq ".git"} {
-                continue
-            }
-
-            # Expand directories.
-            if {[file isdirectory $c]} {
-                lappend waiting {*}[lsort -unique [glob -directory $c * .*]]
-                continue
-            }
-
-            # Handle files as per the user's will.
-            set thepath $current
-            switch -exact -- [catch { uplevel 1 $script } result] {
-            0 - 4 {
-                # ok, continue - nothing
-            }
-            2 {
-                # return, abort, rethrow
-                return -code return
-            }
-            3 {
-                # break, abort
-                return
-            }
-            1 - default {
-                # error, any thing else - rethrow
-                return -code error $result
-            }
-            }
-        }
-        }
-        return
-    }
-
-    proc is_valid_tm_version {versionpart} {
-        #Needs to be suitable for use with Tcl's 'package vcompare'
-        if {![catch [list package vcompare $versionpart $versionpart]]} {
-            return 1
-        } else {
-            return 0
-        }
-    }
-    #Note that semver only has a small overlap with tcl tm versions.
-    #todo - work out what overlap and whether it's even useful
-    #see also TIP #439: Semantic Versioning (tcl 9??)
-    proc semver {versionstring} {
-        set re {^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$}
-    }
-    #todo - semver conversion/validation for other systems?
-    proc magic_tm_version {} {
-        set magicbase 999999  ;#deliberately large so given load-preference when testing!
-        #we split the literal to avoid the literal appearing here - reduce risk of accidentally converting to a release version
-        return ${magicbase}.0a1.0
-    }
-
-
-
-    proc tmpfile {{prefix tmp_}} {
-        #note risk of collision if pregenerating a list of tmpfile names
-        #we will maintain an icrementing id so the caller doesn't have to bear that in mind
-        variable tmpfile_counter
-        global tcl_platform
-        return .punkutil_$prefix[pid]_[clock microseconds]_[incr tmpfile_counter]_[info hostname]_$tcl_platform(user)
-    }
-
-    proc tmpdir {} {
-        # Taken from tcllib fileutil.
-        global tcl_platform env
-
-        set attempdirs [list]
-        set problems   {}
-
-        foreach tmp {TEMP TMP TMPDIR} {
-            if { [info exists env($tmp)] } {
-                lappend attempdirs $env($tmp)
-            } else {
-                lappend problems "No environment variable $tmp"
-            }
-        }
-
-        switch $tcl_platform(platform) {
-        windows {
-            lappend attempdirs "C:\\TEMP" "C:\\TMP" "\\TEMP" "\\TMP"
-        }
-        macintosh {
-            lappend attempdirs $env(TRASH_FOLDER)  ;# a better place?
-        }
-        default {
-            lappend attempdirs \
-            [file join / tmp] \
-            [file join / var tmp] \
-            [file join / usr tmp]
-        }
-        }
-
-        lappend attempdirs [pwd]
-
-        foreach tmp $attempdirs {
-            if { [file isdirectory $tmp] &&
-                [file writable $tmp] } {
-                return [file normalize $tmp]
-            } elseif { ![file isdirectory $tmp] } {
-                lappend problems "Not a directory: $tmp"
-            } else {
-                lappend problems "Not writable: $tmp"
-            }
-        }
-
-        # Fail if nothing worked.
-        return -code error "Unable to determine a proper directory for temporary files\n[join $problems \n]"
-    }
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::util [namespace eval punk::mix::util {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/ns-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/ns-0.1.0.tm
deleted file mode 100644
index 156d51d1..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/ns-0.1.0.tm
+++ /dev/null
@@ -1,1698 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::ns 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-namespace eval ::punk_dynamic::ns {
-
-}
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::ns {
-    variable ns_current "::"
-    variable ns_re_cache [dict create] ;#cache regular expressions used in globmatchns
-    namespace export nsjoin nsprefix nstail nsparts nseval nsimport_noclobber corp
-
-    #leading colon makes it hard (impossible?) to call directly if not within the namespace 
-    proc ns/ {v {ns_or_glob ""} args}  {
-        variable ns_current ;#change active ns of repl by setting ns_current
-
-        set ns_caller [uplevel 1 {::namespace current}]
-        #puts stderr "ns_cur:$ns_current ns_call:$ns_caller"
-
-
-        set types [list all]
-        set nspathcommands 0
-        if {$v eq "/"} {
-            set types [list children]
-        }
-        if {$v eq "///"} {
-            set nspathcommands 1
-        }
-
-        #todo - cooperate with repl?
-        set out ""
-        if {$ns_or_glob eq ""} {
-            set is_absolute 1
-            set ns_queried  $ns_current
-            set out [nslist [nsjoin $ns_current *] -types $types -nspathcommands $nspathcommands]
-        } else {
-            set is_absolute [string match ::* $ns_or_glob]
-            set has_globchars [regexp {[*?]} $ns_or_glob]
-            if {$is_absolute} {
-                if {!$has_globchars} {
-                    if {![namespace exists $ns_or_glob]} {
-                        error "cannot change to namespace $ns_or_glob"
-                    }
-                    set ns_current $ns_or_glob
-                    set ns_queried $ns_current
-                    tailcall ns/ $v "" 
-                } else {
-                    set ns_queried $ns_or_glob
-                    set out [nslist $ns_or_glob -types $types -nspathcommands $nspathcommands]
-                }
-            } else {
-                if {!$has_globchars} {
-                    set nsnext [nsjoin $ns_current $ns_or_glob]
-                    if {![namespace exists $nsnext]} {
-                        error "cannot change to namespace $ns_or_glob"
-                    }
-                    set ns_current $nsnext
-                    set ns_queried $nsnext
-                    set out [nslist [nsjoin $nsnext *] -types $types -nspathcommands $nspathcommands]
-                } else {
-                    set ns_queried [nsjoin $ns_current $ns_or_glob]
-                    set out [nslist [nsjoin $ns_current $ns_or_glob] -types $types -nspathcommands $nspathcommands]
-                }
-            }
-        }
-        set ns_display "\n$ns_queried"
-        if {$ns_current eq $ns_queried} {
-            if {$ns_current in [info commands $ns_current] } {
-                if {![catch [list namespace ensemble configure $ns_current] ensemble_info]} {
-                    if {[llength $ensemble_info] > 0} {
-                        #this namespace happens to match ensemble command. 
-                        #todo - keep cache of encountered ensembles from commands.. and examine namespace in the configure info.
-                        set ns_display  "\n[a+ yellow bold]$ns_current  (ensemble)[a+]"
-                    }
-                }
-            }
-        }
-        append out $ns_display
-        return $out
-
-
-    }
-
-
-    #create possibly nested namespace structure - but only if not already existant
-    proc n/new {args} {
-        variable ns_current
-        if {![llength $args]} {
-            error "usage: :/new <ns> \[<ns> ...\]"
-        }
-        set a1 [lindex $args 0]
-        set is_absolute [string match ::* $a1]
-        if {$is_absolute} {
-            set nspath [nsjoinall {*}$args]
-        } else {
-            if {[string match :* $a1]} {
-                puts stderr "n/new WARNING namespace with leading colon '$a1' is likely to have unexpected results"
-            }
-            set nspath [nsjoinall $ns_current {*}$args]
-        }
-
-        set ns_exists [nseval [nsprefix $nspath] [list ::namespace exists [nstail $nspath] ]]
-
-        if {$ns_exists} {
-            error "Namespace $nspath already exists"
-        }
-        #namespace eval [nsprefix $nspath] [list namespace eval [nstail $nspath] {}]
-        nseval [nsprefix $nspath] [list ::namespace eval [nstail $nspath] {}]
-        n/ $nspath
-    }
-
-
-    #nn/ ::/ nsup/ - back up one namespace level
-    proc nsup/ {v args} {
-        variable ns_current
-        if {$ns_current eq "::"} {
-            puts stderr "Already at global namespace '::'"
-        } else {
-            set out ""
-            set nsq [nsprefix $ns_current]
-            if {$v eq "/"} {
-                set out [get_nslist -match [nsjoin $nsq *] -types [list children]]
-            } else {
-                set out [get_nslist -match [nsjoin $nsq *] -types [list all]]
-            }
-            #set out [nslist [nsjoin $nsq *]] 
-            set ns_current $nsq
-            append out "\n$ns_current"
-            return $out
-        }
-    }
-
-    #todo - walk up each ns - testing for possibly weirdly named namespaces
-    #review - do we even need it.
-    proc nsexists {nspath} {
-        error "unimplemented"
-    }
-
-    #recursive nseval - for introspection of weird namespace trees
-    #approx 10x slower than normal namespace eval - but still only a few microseconds.. fine for repl introspection
-    proc nseval_script {location} {
-        set parts [nsparts $location]
-        if {[lindex $parts 0] eq ""} {
-            lset parts 0 ::
-        }
-        if {[lindex $parts end] eq ""} {
-            set parts [lrange $parts 0 end-1]
-        }
-
-        set body ""
-        set i 0
-        set tails [lrepeat [llength $parts] ""]
-        foreach ns $parts {
-            set cmdlist [list ::namespace eval $ns]
-            set t ""
-            if {$i > 0} {
-                append body " <lb>"
-            }
-            append body $cmdlist
-            if {$i == ([llength $parts] -1)} {
-                append body " <script>"
-            }
-            if {$i > 0} {
-                set t {<rb>}
-            }
-            lset tails $i $t
-            incr i
-        }
-        append body [join [lreverse $tails] " "]
-        #puts stdout "tails: $tails"
-        #puts stdout "i: $i"
-        set body [string map [list <lb> "\{" <rb> "\}"] $body]
-
-        set scr {[::list ::eval [::uplevel <i>  {::set script}]]}
-
-        set up [expr {$i - 1}]
-        set scr [string map [list <i> $up] $scr]
-
-        set body [string map [list <script> $scr] $body]
-        return $body
-    }
-    proc nseval {fqns script} {
-        if {![string match ::* $fqns]} {
-            error "nseval only accepts a fully qualified namespace"
-        }
-        set loc [string map [list :: "_sep_"] $fqns]
-        #set cmd ::punk::pipecmds::nseval_$loc
-        set cmd ::punk_dynamic::ns::eval-$loc
-        if {$cmd ni [info commands $cmd]} {
-            append body \n [nseval_script $fqns]
-            proc $cmd {script} $body
-            debug.punk.pipe.compile {proc $cmd} 6
-        }
-        tailcall $cmd $script
-    }
-    proc nschildren {fqns} {
-        if {![string match ::* $fqns]} {
-            error "nschildren only accespts a fully qualified namespace"
-        }
-        set parent [nsprefix $fqns]
-        set tail [nstail $fqns]
-        #puts ">>> parent $parent tail $tail"
-        #set nslist [nseval $parent [list ::namespace children $tail]]
-        set nslist [namespace eval $parent [list ::namespace children $tail]]
-        return [lsort $nslist]
-    }
-
-    proc nsjoin {prefix name} {
-        if {[string match ::* $name]} {
-            if {"$prefix" ne ""} {
-                error "nsjoin: won't join non-empty prefix to absolute namespace path '$name'"
-            }
-            return $name
-        }
-        if {"$prefix" eq "::"} {
-            return ::$name
-        }
-        #if {"$name" eq ""} {
-        #    return $prefix
-        #}
-        #nsjoin ::x::y ""  should return ::x::y::   - this is the correct fully qualified form used to call a command that is the empty string
-        return ${prefix}::$name
-    }
-    proc nsjoinall {prefix args} {
-        #if {![llength $args]} {
-        #    error "usage: nsjoinall prefix relativens \[relativens ...\]"
-        #}
-        set segments [list $prefix]
-        foreach sub $args {
-            if {[string match ::* $sub]} {
-                if {[string length [concat {*}$segments]]} {
-                    error "nsjoin: won't join non-empty namespace prefix to absolute namespace path '$sub'"
-                }
-            }
-            lappend segments $sub
-        }
-        set nonempty_segments [list]
-        foreach s $segments {
-            if {[string length $s]} {
-                lappend nonempty_segments $s
-            }
-        }
-        if {$prefix eq "::"} {
-            return ::[join [lrange $nonempty_segments 1 end] ::]
-        }
-        return [join $nonempty_segments ::]
-    }
-    proc nsprefix {{nspath ""}} {
-        #normalize the common case of ::::
-        set nspath [string map [list :::: ::] $nspath]
-        set rawprefix [string range $nspath 0 end-[string length [nstail $nspath]]]
-        if {$rawprefix eq "::"} {
-            return $rawprefix
-        } else {
-            if {[string match *:: $rawprefix]} {
-                return  [string range $rawprefix 0 end-2]
-            } else {
-                return $rawprefix
-            }
-            #return [string trimright $rawprefix :]
-        }
-    }
-
-    #namespace tail which handles :::cmd  ::x:::y  ::x:::/y  etc
-    #todo - raise error for unexpected sequences such as ::::  or more than 2 colons together.
-    proc nstail {nspath args} {
-        #normalize the common case of ::::
-        set nspath [string map [list :::: ::] $nspath]
-        set mapped [string map [list :: \u0FFF] $nspath] 
-        set parts [split $mapped \u0FFF]
-
-        set defaults [list -strict 0]
-        set opts [dict merge $defaults $args]
-        set strict [dict get $opts -strict]
-
-        if {$strict} {
-            foreach p $parts {
-                if {[string match :* $p]} {
-                    error "nstail unpaired colon ':' in $nspath"
-                }
-            }
-        }
-
-        #e.g  ::x::y:::z  should return ":z"
-        return [lindex $parts end]
-    }
-
-    #return a list of namespace segments - always with leading empty string for fully qualified namespace (ie for ::x)
-    #'supports' to some extent unreasonable namespaces /commands such as x:  ::x:  ::x:::y
-    #Can be used to either support use of such namespaces/commands - or as part of validation to disallow them 
-    #as opposed to silent behaviour of Tcl namespace commands which don't handle them consistently (for tcl 8.x anyway  Review tcl 9)
-    #Note that for  ::x::   the trailing :: cannot represent a trailing namespace part being an empty string 
-    #This is because Tcl's 'namespace eval "" ""' reports 'only global namespace can have empty name'
-    #NOTE tcl allows creating ambiguous namespaces.  e.g ::punk:::etc:::blah 
-    # is this :: punk :etc :blah  or :: punk :etc: blah 
-    #clearly leading/trailing colons in namespaces and commands are just a bad idea. 
-    #nsparts will prefer leading colon (ie greedy on ::)
-    #This is important to support leading colon commands such as :/
-    # ie ::punk:::jjj:::etc -> :: punk :jjj :etc
-    proc nsparts {nspath} {
-        set nspath [string map [list :::: ::] $nspath]
-        set mapped [string map [list  :: \u0FFF] $nspath] 
-        set parts [split $mapped \u0FFF]
-        if {[lindex $parts end] eq ""} {
-
-        }
-        return $parts
-    }
-
-    #tcl 8.x has creative writing var weirdness.. tcl 9 is likely to differ
-    proc nsvars {{nsglob "*"}} {
-        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $nsglob]]
-        #set commandns [uplevel 1 [list namespace current]]
-
-        set searchns [nsprefix $ns_absolute] ;#the ns within which we want to searchns
-        set searchall [nsjoin $searchns *] ;#will correctly form ::*  or ::childns::*
-
-        set rawresult [info vars $searchall] ;#will not find vars in ::x:::y   etc.  - seems to be impossible in tcl 8.x
-        set matched_fullpath [list]
-        foreach r $rawresult {
-            lappend matched_fullpath [nstail $r]
-        }
-
-        set location [nsprefix $ns_absolute]
-        set tailmatch [nstail $ns_absolute]
-        set raw_matched_in_ns [nseval $location [list ::info vars $tailmatch]]
-        #NOTE: tcl <9 will read vars from global namespace - so we are only checking the intersection here
-        #(this is due to info vars ::etc:::blah failing to handle additional colon)
-        set matched_in_ns [list]
-        set result [list]
-        foreach r $raw_matched_in_ns {
-            set m [nstail $r]
-            lappend matched_in_ns $m
-            if {$m in $matched_fullpath} {
-                lappend result $m
-            }
-        }
-
-
-        return [list_as_lines [lsort $result]]
-        #.= lsort $result |> list_as_lines
-    }
-
-    proc nsglob_as_re {glob} {
-        #any segment that is not just * must match exactly one segment in the path
-        set pats [list]
-        foreach seg [nsparts $glob] {
-            if {$seg eq ""} {
-                set seg ""
-            }
-            if {$seg eq "*"} {
-                lappend pats {[^:]*}
-            } elseif {$seg eq "**"} {
-                lappend pats {.*}
-            } else {
-                set seg [string map [list  . {[.]}] $seg]
-                if {[regexp {[*?]} $seg]} {
-                    set pat [string map [list ** {.*} * {[^:]*} ? {[^:]}] $seg]
-                    lappend pats "$pat"
-                } else {
-                    lappend pats "$seg"
-                }
-            }
-        }
-        return  "^[join $pats ::]\$"
-    }
-    proc globmatchns {glob path} {
-        #the total set of namespaces is *generally* reasonably bounded so we could just cache all globs, perhaps with some pretty high limit for sanity.. (a few thousand?) review - memory cost?
-        # Tcl (reportedly https://wiki.tcl-lang.org/page/regexp) only caches 'up to 30'dynamically - but should cache more if more stored.
-        variable ns_re_cache
-        if {![dict exists $ns_re_cache $glob]} {
-            if {[dict size $ns_re_cache] > 4200} {
-                #shimmer dict to list and back doesn't seem to affect internal rep of regexp items therein.
-                set ns_re_cache [lrange $ns_re_cache 400 end] ;#chop 200 items off beginning of dict
-            }
-            dict set ns_re_cache $glob [nsglob_as_re $glob]
-        }
-        return [regexp [dict get $ns_re_cache $glob] $path]
-    }
-
-    proc nstree {{location ""}} {
-        if {![string match ::* $location]} {
-            set nscaller [uplevel 1 {::namespace current}]
-             set location [nsjoin $nscaller $location] 
-        }
-        list_as_lines [nstree_list $location]
-    }
-
-
-    #important: add tests for tricky cases - e.g punk::m**::util  vs punk::m*::util vs punk::m*::**::util  - these should all be able to return different results depending on namespace structure.
-    #e.g punk::m**::util will return punk::mix::util  but punk::m*::**::util will not because punk::mix::util is too short to match. Both will return deeper matches such as: punk::mix::commandset::repo::util
-    proc nstree_list {location args} {
-        package require struct::list
-        #puts "> nstree_list $location $args"
-        set defaults [dict create\
-            -call-depth-internal 0\
-            -subnslist {}\
-            -allbelow 1\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- ---- --- --- --- ---
-        set CALLDEPTH   [dict get $opts -call-depth-internal]
-        set subnslist   [dict get $opts -subnslist]
-        set allbelow    [dict get $opts -allbelow] ;#whether to return matches longer than the matched glob-path
-        # -- ---- --- --- --- ---
-    
-        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $location]]
-        set has_globchars [regexp {[*?]} $ns_absolute] ;#don't use regexes on plain namespaces with no glob chars
-        if {!$has_globchars && !$allbelow && ![llength $subnslist]} {
-            #short circuit trivial case 
-            return [list $location]
-        }
-        
-
-        set base ""    
-        set tailparts [list]
-        if {$CALLDEPTH == 0} { 
-            set parts [nsparts $ns_absolute]
-            lset parts 0 ::
-            set idx 0
-            if {$has_globchars} {
-                foreach seg $parts {
-                    if {![regexp {[*?]} $seg]} {
-                        set base [nsjoin $base $seg]
-                    } else {
-                        set tailparts [lrange $parts $idx end]
-                        break
-                    }
-                    incr idx
-                }
-            } else {
-                set base $ns_absolute
-            }
-        } else {
-           set base $location 
-           set tailparts $subnslist
-        }
-        if {![namespace exists $base]} {
-           return [list]
-        } 
-        #set parent [nsprefix $ns_absolute]
-        #set tail [nstail $ns_absolute]
-
-        #set allchildren [lsort [nseval $base [list ::namespace children]]]
-        set allchildren [lsort [namespace eval $base [list ::namespace children]]]
-
-        #puts "->base:$base tailparts:$tailparts allchildren: $allchildren"
-        #puts "->base:$base tailparts:$tailparts childcount: [llength $allchildren]"
-
-        #** only significant when it is the trailing part of a segment eg ::**::xxx  ::a**::xxx  
-        if {[llength $tailparts]} {
-            set nextglob [lindex $tailparts 0]
-            if {$nextglob eq "**"} {
-                set nslist [nstree_list $base -subnslist {} -allbelow 1] 
-            } elseif {[regexp {[*]{2}$} $nextglob]} {
-                set nslist [list]
-                lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
-                foreach ch $nsmatches {
-                    lappend nslist $ch
-                    #lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow 1] 
-                    lappend nslist {*}[nstree_list $ch -subnslist [list "**" {*}[lrange $tailparts 1 end]] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow 0] 
-                }                
-            } else {
-                #lsearch with -glob ok even if nextglob has no globchars (no discernable speed diff, and earlier parts may have globchars anyway)
-                set nslist [list]
-                lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
-                if {[llength $tailparts] >1 || $allbelow} {
-                    foreach ch $nsmatches {
-                        lappend nslist $ch
-                        lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow $allbelow] 
-                    }
-                } else {
-                    #if only one tailpart remaining and not $allbelow - then we already have what we need
-                    set nslist $nsmatches
-                }
-            }
-        } else {
-            #puts "nstree_list: no tailparts base:$base"
-            if {$allbelow} {
-                set nsmatches $allchildren
-                set nslist [list]
-                foreach ch $nsmatches {
-                    lappend nslist $ch
-                    lappend nslist {*}[nstree_list $ch -subnslist {} -call-depth-internal 0 -allbelow 1] 
-                }
-            } else {
-                set nslist $allchildren
-            }
-           #set nsmatches $allchildren
-           #set nslist [nstree_list $base -subnslist {} -allbelow 0] 
-        }
-        set nslist [lsort -unique $nslist]
-
-
-        if 0 {
-            set nextglob [lindex $tailparts 0]
-            if {$nextglob ne "**"} {
-                set nslist [list]
-                if {[llength $tailparts]} {
-                    set nsmatches [list]
-                    #lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]::*]
-                    lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
-                } else {
-                    set nsmatches $allchildren
-                }
-                #return
-
-                foreach ch $nsmatches {
-                    lappend nslist $ch
-                    lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow $allbelow] 
-                }
-            } else {
-            set nslist [nstree_list $base -subnslist {} -allbelow 1] 
-            }
-        }
-
-        #foreach ns $nslist {
-        #    puts "== $ns"
-        #}
-        set nslist_filtered [list]
-        if {$CALLDEPTH == 0} {
-            #puts "--base: $base"
-            #puts "-- globmatchns [nsjoin ${ns_absolute} **]"
-            #puts "-- globmatchns ${ns_absolute}"
-            if {$base ni $nslist} {
-                #puts stderr "> adding $base to $nslist"
-                set nslist [list $base {*}$nslist]
-            } 
-            if {$has_globchars} {
-                if {$allbelow} {
-                    foreach ns $nslist {
-                        if {[globmatchns ${ns_absolute} $ns] || [globmatchns [nsjoin ${ns_absolute} **] $ns]} {
-                            lappend nslist_filtered $ns
-                        }
-                    } 
-                } else {
-                    set nslist_filtered [struct::list::Lfilter $nslist [list globmatchns ${ns_absolute}]]
-                }
-            } else {
-                if {$allbelow} {
-                    foreach ns $nslist {
-                        if {[string equal ${ns_absolute} $ns] || [globmatchns [nsjoin ${ns_absolute} **] $ns]} {
-                            lappend nslist_filtered $ns
-                        }
-                    } 
-                } else {
-                    #set nslist_filtered [struct::list::Lfilter $nslist [list string match ${ns_absolute}]]
-                    set nslist_filtered [list $ns_absolute]
-                }
-            }
-            return $nslist_filtered
-        }
-        return $nslist
-    }
-
-
-    #REVIEW - ansi codes can be *very*  confusing to the user when trying to handle lists etc..
-    proc get_nslist {args} {
-   
-        set known_types [list children commands exported imported aliases procs ensembles ooclasses ooobjects]
-        set defaults [dict create\
-            -match ""\
-            -types $known_types\
-            -nsdict ""\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- 
-        set fq_glob             [dict get $opts -match]
-        set requested_types     [dict get $opts -types]
-        set opt_nsdict          [dict get $opts -nsdict]
-
-        set types $requested_types
-        if {"all" in $requested_types} {
-            foreach t $known_types {
-                if {$t ni $types} {
-                    lappend types $t
-                }
-            }
-        }
-        if {"oo" in $requested_types} {
-            if {"ooclasses" ni $types} {
-                lappend types "ooclasses"
-            }
-            if {"ooobjects" ni $types} {
-                lappend types "ooobjects"
-            }
-        }
-        foreach t $types {
-            if {$t in [list "oo" "all"]} {
-                continue
-            }
-            if {$t ni $known_types} {
-                error "Unrecognised namespace member type: $t known types: $known_types"
-            }
-        }
-
-        set glob_is_absolute [expr {[string match ::* $fq_glob]}]
-        if {!$glob_is_absolute} {
-            error "get_nslist requires fully-qualified namespace glob e.g ::*"
-        }
-        #2 columns for namespaces 4 for commands/procs/aliases - todo make less duplicated - generalize to specified number of columns for each?
-        #NOTE aliases may not be commands in current namespace - but we want to show them (marked red and with R)
-        #
-
-        set children [list]
-        set commands [list]
-        set exported [list]
-        set imported [list]
-        set aliases  [list]
-        set procs    [list]
-        set ensembles [list]
-        set ooclasses [list]
-        set ooobjects [list]
-
-        if {$opt_nsdict eq ""} {
-            set nsmatches [get_ns_dicts $fq_glob -allbelow 0] 
-            set itemcount 0
-            set matches_with_results [list]
-            foreach nsinfo $nsmatches {
-                set itemcount [dict get $nsinfo itemcount] 
-                if {$itemcount > 0} {
-                    lappend matches_with_results $nsinfo
-                } 
-            }
-            if {[llength $matches_with_results] == 1} {
-               set contents [lindex $matches_with_results 0]
-            } elseif {[llength $matches_with_results] > 1} {
-               puts stderr "get_nslist WARNING: more than one ([llength $matches_with_results]) namespace had results for the pattern '$fq_glob'. Displaying only first. Consider calling get_ns_dicts and passing results to get_nslist one at a time using -nsdict option" 
-               set contents [lindex $matches_with_results 0]
-            } else {
-                return "- no results -"
-            }
-        } else {
-            set contents $opt_nsdict
-            if {[dict get $opt_nsdict itemcount] == 0} {
-                return "- no results -"
-            }
-        }
-        set ns       [dict get $contents location] 
-
-        package require overtype
-        if {"children" in $types} {
-            set children [dict get $contents children]
-        }
-        if {"commands" in $types} {
-            set commands [dict get $contents commands]
-            if {"exported" in $types} {
-                set exported [dict get $contents exported]
-            }
-            if {"imported" in $types} {
-                set imported [dict get $contents imported]
-            }
-            if {"aliases" in $types} {
-                set aliases  [dict get $contents aliases]
-            }
-            if {"procs" in $types} {
-                set procs    [dict get $contents procs]
-            }
-            if {"ensembles" in $types} {
-                set ensembles [dict get $contents ensembles]
-            }
-            if {"ooclasses" in $types} {
-                set ooclasses [dict get $contents ooclasses]
-            }
-            if {"ooobjects" in $types} {
-               set ooobjects [dict get $contents ooobjects]
-            }
-        }
-
-        set numchildren [llength $children]
-        if {$numchildren} {
-           set mid [expr {int(ceil($numchildren/2.0))}]
-           set children1 [lrange $children 0 $mid-1]
-           set children2 [lrange $children $mid end]
-        } else {
-            set children1 [list]
-            set children2 [list]
-        }
-
-        #elements are commands and possibly renamed aliases which may or may not have been renamed into the current namespace
-        #a command could be an empty string or something else weird. 
-        #Primarily just to handle empty string command - we will wrap each command as a 2-part element here
-        #(our foreach loop needs to ignore missing commands - but not empty string)
-        set elements [lmap v $commands {list c $v}]
-
-        set seencmds [list]
-        set masked [list] ;# 
-        foreach a $aliases {
-            if {[list c $a] in $elements} {
-                #possibly an ordinary alias - or a renamed alias that is masked by a proc/ensemble/oo 
-                #we can detect masking by proc/ensemble/oo - but not by a binary extension loaded after the rename:  REVIEW
-                if {$a in [concat $procs $ensembles $ooclasses $ooobjects]} {
-                    #we have an alias that is also a known other command-type
-                    lappend elements [list c $a] ;#add in twice so we can display both.
-                    lappend  masked $a
-                }
-            } else {
-                #a renamed-alias
-                lappend elements [list c $a]
-            }
-        }
-        set elements [lsort -index 1 $elements]
-        
-        
-        set numelements [llength $elements]
-        if {$numelements} {
-            set split1 [expr {int(ceil($numelements/4.0))}]
-            set elements1 [lrange $elements 0 $split1-1]
-            set remaining3 [lrange $elements $split1 end]
-
-            set numremaining3 [llength $remaining3] 
-            set split2 [expr {int(ceil($numremaining3/3.0))}]
-            set elements2 [lrange $remaining3 0 $split2-1]
-            set remaining2 [lrange $remaining3 $split2 end]
-
-            set numremaining2 [llength $remaining2]
-            set mid [expr {int(ceil($numremaining2/2.0))}]
-            set elements3 [lrange $remaining2 0 $mid-1]
-            set elements4 [lrange $remaining2 $mid end]
-
-        } else {
-            set elements1 [list]
-            set elements2 [list]
-            set elements3 [list]
-            set elements4 [list]
-        }
-
-
-
-        set chwidest1 [pipedata [list {*}$children1 ""] {lmap v $data {string length $v}}  {tcl::mathfunc::max {*}$data}]
-        set chwidest2 [pipedata [list {*}$children2 ""] {lmap v $data {string length $v}}  {tcl::mathfunc::max {*}$data}]
-
-        #wrap the cmd in [list] (just for the width calc) to get a proper length for what will actually be displayed
-        set cmdwidest1 [pipedata [list {*}$elements1 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-        set cmdwidest2 [pipedata [list {*}$elements2 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-        set cmdwidest3 [pipedata [list {*}$elements3 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-        set cmdwidest4 [pipedata [list {*}$elements4 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-
-        set displaylist [list]
-        set col1 [string repeat " " [expr {$chwidest1 + 8}]]
-        set col2 [string repeat " " [expr {$chwidest2 + 8}]]
-        set col3 [string repeat " " [expr {$cmdwidest1 + 8}]]
-        set col4 [string repeat " " [expr {$cmdwidest2 + 8}]]
-        set col5 [string repeat " " [expr {$cmdwidest3 + 8}]]
-        set a [a+ purple bold]
-        set e [a+ yellow bold]
-        set o [a+ cyan bold]
-        set p [a+ white bold]
-        foreach ch1 $children1 ch2 $children2 cmd1 $elements1 cmd2 $elements2 cmd3 $elements3 cmd4 $elements4 {
-            set a1 [a+ cyan]
-            set c1 [a+ white]
-            set c2 [a+ white]
-            set c3 [a+ white]
-            set c4 [a+ white]
-
-            for {set i 1} {$i <= 4} {incr i} {
-                if {[llength [set cmd$i]]} {
-                    set c [a+ white]
-                    set prefix "     "
-                    set element [set cmd$i]
-                    set cmd [lindex $element 1]
-                    set cmd_display [list $cmd] ;#wrap in list so empty command is visible (and distinguishable from for example a double-curly command)
-                    if {$cmd ni $commands && $cmd in $aliases } {
-                        #ordinary un-masked commandless-alias
-                        set c [a+ red bold]
-                        set prefix "${a}als  "
-                        set prefix [overtype::right $prefix "-R"]
-                    } else {
-                        if {$cmd in $exported} {
-                            set c [a+ green bold]
-                        }
-                        if {$cmd in $aliases && $cmd in $seencmds} {
-                            #masked commandless-alias
-                            #assert member of masked - but we use seencmds instead to detect.
-                            set c [a+ yellow bold]
-                            set prefix "${a}als  "
-                            set prefix [overtype::right $prefix "-R"]
-                        } elseif {$cmd in $procs} {
-                            set prefix "${p}prc  "
-                        } elseif {$cmd in $ensembles} {
-                            set prefix "${e}ens  "
-                        } elseif {$cmd in $ooclasses} {
-                            set prefix "${o}ooc  "
-                        } elseif {$cmd in $ooobjects} {
-                            set prefix "${o}ooo  "
-                        } elseif {$cmd in $aliases} {
-                            set prefix "${a}als  "
-                        } else {
-                        }
-                        if {$cmd in $imported} {
-                            set prefix [overtype::right $prefix "-[a+ yellow bold]I[a+]"]
-                        }
-                    }
-                    set cmd$i "${prefix} $c$cmd_display"
-                    set c$i $c 
-                    lappend seencmds $cmd
-                }
-            }
-
-            lappend displaylist $a1[overtype::left $col1 $ch1][a+]$a1[overtype::left $col2 $ch2][a+]$c1[overtype::left $col3 $cmd1][a+]$c2[overtype::left $col4 $cmd2][a+]$c3[overtype::left $col5 $cmd3][a+]$c4$cmd4[a+]
-        }
-    
-        return [list_as_lines $displaylist]
-    }
-    proc nspath_here_absolute {{nspath "\uFFFF"}} {
-        set path_is_absolute [expr {[string match ::* $nspath]}]
-        if {$path_is_absolute} {
-            return $nspath
-        }
-        set ns_caller [uplevel 1 {::namespace current}] ;#must qualify. Needs to be called from arbitrary namespaces where 'namespace' command may exist (e.g tdom::schema)
-        if {$nspath eq "\uFFFF"} {
-            return $ns_caller
-        }
-        #nsjoin will join nscaller with empty nspath to form nscaller::  - which is correct way to represent command named with empty string
-        return [nsjoin $ns_caller $nspath]
-    }
-
-    proc nspath_to_absolute {nspath base} {
-        set path_is_absolute [expr {[string match ::* $nspath]}]
-        if {$path_is_absolute} {
-            return $nspath
-        }
-        if {![string length $nspath]} {
-            return $base
-        }
-        return [nsjoin $base $nspath]
-    }
-
-    proc nslist {{glob "*"} args} {
-        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $glob]]
-        if {[dict exists $args -match]} {
-           #review -  presumably this is due to get_nslist taking -match? 
-           error "nslist requires positional argument 'glob' instead of -match option" 
-        }
-        set defaults [dict create\
-            -match $ns_absolute\
-            -nspathcommands 0\
-        ]
-
-        package require textblock
-        set opts [dict merge $defaults $args]
-        # -- --- ---
-        set opt_nspathcommands          [dict get $opts -nspathcommands]
-        # -- --- ---
-
-
-        set ns_matches [get_ns_dicts $ns_absolute -nspathcommands $opt_nspathcommands] 
-        set with_results [list]
-        foreach nsdict $ns_matches {
-            if {[dict get $nsdict itemcount]>0} {
-                lappend with_results $nsdict
-            }
-        }
-
-        #special case when glob is for * - we should also consider existence of item(s) namespacepath as a 'result' 
-
-        set count_with_results [llength $with_results]
-        set output ""
-        foreach nsdict $with_results {
-            dict set opts -nsdict $nsdict
-            set block [get_nslist {*}$opts]
-            if {[string first \n $block] < 0} {
-                #single line
-                set width [textblock::width [list $block]]
-            } else {
-                set width [textblock::width $block]
-            }
-            #if multiple results or if there is only 1 result - but we are path-globbing - then we need to show location 
-            if {$count_with_results > 1 || [regexp {[*?]} [nsprefix $ns_absolute]]} {
-                append output \n [dict get $nsdict location]
-            }
-            if {[string length $block]} {
-                append output \n $block
-            }
-            if {[dict size [dict get $nsdict namespacepath]]} {
-                set path_text ""
-                if {!$opt_nspathcommands} {
-                    append path_text \n "  also resolving cmds in namespace paths: [dict keys [dict get $nsdict namespacepath]]"
-                } else {
-                    append path_text \n "  also resolving cmds in namespace paths:"
-                    set nspathdict [dict get $nsdict namespacepath]
-                    dict for {k v} $nspathdict {
-                        set cmds [dict get $v commands]
-                        append path_text \n "    path: $k"
-                        append path_text \n "    cmds: $cmds"
-                    }
-                }
-                append output $path_text
-                set path_text_width [textblock::width $path_text]
-                append output \n [string repeat - [expr {max($width,$path_text_width)}]] 
-            } elseif {$count_with_results > 1 && $width > 0 } {
-                append output \n [string repeat - $width] 
-            }
-        }
-        return $output
-    }
-    #cli command - impure - relies on caller/ns_current
-    proc nslist_dict {{glob "*"} args} {
-        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $glob]]
-        return [get_ns_dicts $ns_absolute {*}$args]
-    }
-
-    #non-contextual - but impure due to state-retrieval from the passed-in namespace part of the fq_glob
-    #returns a list of dicts even if only one ns matched
-    #glob chars at last segment match contents/children of namespaces
-    #glob chars in the path will result in multiple namespaces being matched
-    #e.g  ::tcl::*::d* will match commands beginning with d and child namespaces beginning with d in any namespaces 1 below ::tcl
-    proc get_ns_dicts {fq_glob args} {
-        #JMN
-        #puts stderr "get_ns_dicts $fq_glob"
-        set glob_is_absolute [expr {[string match ::* $fq_glob]}]
-        if {!$glob_is_absolute} {
-            error "get_ns_dicts requires fully-qualified namespace glob e.g ::*"
-        }
-        set has_globchars [regexp {[*?]} $fq_glob]
-
-        set defaults [dict create\
-            -allbelow 0\
-            -nspathcommands 1\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-        set allbelow            [dict get $opts -allbelow]
-        set nspathcommands      [dict get $opts -nspathcommands]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-
-        #set location [nsprefix $fq_glob]
-        set commands [list]
-
-        set nsglob [nsprefix $fq_glob]
-        set glob [nstail $fq_glob]
-        set matched_namespaces [nstree_list $nsglob -allbelow $allbelow]
-
-        set report_namespaces [list] 
-        #special case trailing ** in last segment
-        if {[regexp {[*]{2}$} $glob]} {
-            lappend report_namespaces {*}$matched_namespaces 
-            foreach ns $matched_namespaces {
-                lappend report_namespaces {*}[nstree_list [nsjoin $ns $glob]]
-            }
-        } else {
-           set report_namespaces $matched_namespaces 
-        }
-
-        set nsdict_list [list]
-        foreach ch $report_namespaces {
-            #puts "get_ns_dicts>>> $ch  glob:'$glob'"
-            if {$allbelow == 0 && !$has_globchars} {
-                set allchildren [list]
-            } else {
-                set allchildren [nschildren $ch] ; #sorted, only returns 1 level deeper
-            }
-            
-            #nscommands returns exactly one line per entry + a trailing newline. If there is an empty line other than at the end - that is because there is a command named as the empty string.
-            # By default 'linelist'  trims 1st and last empty line. Turn off all block trimming with -block {}
-            #set  commands [.= nscommands -raw [nsjoin $ch $glob] |> linelist -block {}]
-            set commands [linelist -block {} [nscommands -raw [nsjoin $ch $glob]]]
-
-            #by convention - returning just \n represents a single result of the empty string whereas no results  
-            #after passing through linelist this becomes {} {} which appears as a list of two empty strings.
-            #this is because there isn't a way to represent unambiguously all 3 cases of: empty-list, list of single empty string, list of two empty strings just using \n separated lines 
-            #unless we always return a newline at the tail if there is a result
-            #For this reason nscommands returns a trailing newline - so the last entry should always be empty string - and is a bogus entry
-            #We double-check it here to avoid regressions/mistakes - as nscommands is also a user-level command so there exists the temptation to make it not return the extra newline. 
-            if {[lindex $commands end] eq ""} {
-                set commands [lrange $commands 0 end-1]
-            } else {
-                puts stderr "get_ns_dicts WARNING nscommands didn't return a trailing newline - unexpected"
-            }
-            
-            
-#JMN
-            set location $ch 
-            set exportpatterns [namespace eval $location {::namespace export}]
-            set nspathlist     [namespace eval $location {::namespace path}]
-            set nspathdict [dict create]
-            if {$nspathcommands} {
-                foreach pathns $nspathlist {
-                    set pathcommands [lmap v [info commands ${pathns}::*] {namespace tail $v}]
-                    set matched [lsearch -all -inline $pathcommands $glob]
-                    dict set nspathdict $pathns [dict create commands $matched]
-                }
-            } else {
-                foreach pathns $nspathlist {
-                    dict set nspathdict $pathns [dict create] ;#use consistent structure when nspathcommands false
-                }
-            }
-            #set exportpatterns [nseval $location {::namespace export}]
-            set allexported [list]
-            set matched [list]
-            foreach p $exportpatterns {
-                if {[regexp {[*?]} $p]} {
-                    #lappend matched {*}[nseval $location [list ::info commands [nsjoin ${location} $p]]]
-                    lappend matched {*}[namespace eval $location [list ::info commands [nsjoin ${location} $p]]]
-                    foreach m $matched {
-                        lappend allexported [nstail $m]
-                    }
-                } else {
-                    lappend allexported $p
-                }
-            }
-            set allexported [lsort -unique $allexported]
-            #NOTE: info procs within namespace eval is different to 'info commands' within namespace eval (info procs doesn't look outside of namespace)
-            set allprocs [namespace eval $location {::info procs}] 
-            #set allprocs    [nseval $location {::info procs}]
-            set childtails [lmap v $allchildren {nstail $v}]
-            set allaliases [list]
-            set allensembles [list]
-            set allooobjects [list]
-            set allooclasses [list]
-            set allimported [list]
-            set allundetermined [list]
-            set interp_aliases [interp aliases ""]
-            #use aliases glob - because aliases can be present with or without leading ::
-            #NOTE: alias may not have matching command in the relevant namespce (renamed alias) so we can't just start with commands and check if it's an alias if we want to show all aliases
-            set raw_aliases [namespace eval $location [list ::aliases $glob]] ;#'aliases $glob' must be passed as list, not separate args to namespace eval. 
-            #set raw_aliases [nseval $location [list ::aliases $glob]] ;#'aliases $glob' must be passed as list, not separate args to namespace eval. 
-            set aliases [list]
-            foreach a $raw_aliases {
-                if {[string match *:: $a]} {
-                    #exception for alias such as ::p::2::  so that it doesn't show up as empty string
-                    #lappend aliases ::
-                    #JMN - 2023 - better to display an empty string somehow
-                    lappend aliases "" 
-                } else {
-                    lappend aliases [nstail $a]
-                }
-            }
-
-            foreach cmd $commands {
-                #if {"${location}::$cmd" in $interp_aliases || [string trimleft "${location}::$cmd" ":"] in $interp_aliases} {
-                #    #NOTE: doesn't cater for renamed aliases - Tcl 8.x doesn't seem to have any introspection capabilities to match command to a renamed alias
-                #    #which_alias hack from wiki relies on trace and executing the command - which we don't want to do.
-                #    lappend allaliases $cmd
-                #}
-
-                if {![catch {namespace ensemble configure ${location}::$cmd} ensemble_info]} {
-                    lappend allensembles $cmd 
-                } elseif {[info object isa object ${location}::$cmd]} {
-                    lappend allooobjects $cmd
-                    if {[info object isa class ${location}::$cmd]} {
-                        lappend allooclasses $cmd
-                    }
-                }
-
-                if {[catch {
-                    if {$cmd eq ""} {
-                        #empty command was previously marked as "::" - too confusing - nslist updated to properly display empty string.
-                        set nsorigin [namespace origin ${location}::]
-                    } elseif {[string match :* $cmd]} {
-                        set nsorigin [nseval $location "::namespace origin $cmd"] 
-                    } else {
-                        set nsorigin [namespace origin [nsjoin $location $cmd]]
-                    }
-                } errM]} {
-                    puts stderr "get_ns_dicts failed to determine origin of command '$cmd' adding to 'undetermined'"
-                    puts stderr "error message: $errM"
-                    lappend allundetermined $cmd
-                } else {
-                    if {[nsprefix $nsorigin] ne $location} {
-                        lappend allimported $cmd
-                    }
-                }
-            }
-            if {$glob ne "*"} {
-                set childtailmatches [lsearch -all -inline $childtails $glob]
-                #set fqchildren [lmap v $childtailmatches {lindex ${location}::$v}]  ;#lindex without indices is fast equivalent of 'val' or string cat
-
-                set exported [lsearch -all -inline $allexported $glob]
-                set procs [lsearch -all -inline $allprocs $glob]
-                #set aliases [lsearch -all -inline $allaliases $glob]
-                set ensembles [lsearch -all -inline $allensembles $glob]
-                set ooobjects [lsearch -all -inline $allooobjects $glob]
-                set ooclasses [lsearch -all -inline $allooclasses $glob]
-                set imported [lsearch -all -inline $allimported $glob]
-                set undetermined [lsearch -all -inline $allundetermined $glob]
-            } else {
-                set childtailmatches $childtails
-                #set fqchildren $allchildren
-                set exported $allexported
-                set procs $allprocs
-                #set aliases $allaliases
-                set ensembles $allensembles
-                set ooobjects $allooobjects
-                set ooclasses $allooclasses
-                set imported $allimported
-                set undetermined $allundetermined
-            }
-            
-            #itemcount will overcount if we are including commands as well as procs/exported etc - 
-            set itemcount 0
-            incr itemcount [llength $childtailmatches]
-            incr itemcount [llength $commands]
-            
-
-            #incr itemcount [llength $procs]
-            #incr itemcount [llength $exported]
-            #incr itemcount [llength $imported]
-            #incr itemcount [llength $aliases]
-            #incr itemcount [llength $ensembles]
-            #incr itemcount [llength $ooobjects]
-            #incr itemcount [llength $ooclasses]
-            #definitely don't count exportpatterns
-            incr itemcount [llength $undetermined]
-
-
-            set nsdict [dict create\
-                location $location\
-                children [lsort $childtailmatches]\
-                commands $commands\
-                procs $procs\
-                exported $exported\
-                imported $imported\
-                aliases $aliases\
-                ensembles $ensembles\
-                ooobjects $ooobjects\
-                ooclasses $ooclasses\
-                namespacexport $exportpatterns\
-                undetermined $undetermined\
-                namespacepath $nspathdict\
-                glob $glob\
-                itemcount $itemcount\
-            ]
-            lappend nsdict_list $nsdict
-        }
-        return $nsdict_list 
-    }
-    #Must be no ansi when only single arg used.
-    #review - ansi codes will be very confusing in some scenarios! 
-    #todo - only output color when requested (how?) or via repltelemetry ?
-    interp alias {} nscommands2 {} .= ,'ok'@0.= {
-            #Note: namespace argument to apply doesn't accept namespace segments with leading colon - so pipelines won't work fully in dodgily-named namespaces such as :::x
-            #inspect -label namespace_current [namespace current]
-            #inspect -label info_procs [info procs]
-
-            ::set commandns [::namespace current]
-            ::set commandlist [::list]
-            #color code multiple args? - not very practical if many ns args supplied, but then... common case will only be 1 or 2 anyway
-            #colors can be stripped by caller with ansistrip - but we'll make the default case easier by using no ansi codes if a single arg is passed 
-            ::set colors [::list none cyan yellow green]
-            ::set ci 0 ;#colourindex
-            ::set do_raw 0
-            ::if {[::set posn [::lsearch $searchlist -raw]] >= 0} {
-                ::set searchlist [::lreplace $searchlist $posn $posn]
-                ::set do_raw 1 
-            }
-            ::if {![::llength $searchlist]} {
-                ::lappend searchlist *
-            }
-            ::foreach search $searchlist {
-                ::if {$ci > [::llength $colors]-1} {
-                    ::set ci 0
-                }
-                #by using pipeswitch instead of pipeswitchc - we give the ability* for the switch script block to affect vars in the calling scope
-                # (*not a desirable feature from a functional point of view - but useful for debugging, and also potentially faster )
-                ::if {$ci == 0 || $do_raw} {
-                    ::set col ""
-                    ::set rst ""
-                } else {
-                    ::set col [a+ [::lindex $colors $ci] bold]
-                    ::set rst [a+]
-                }
-                ::incr ci ;#colourindex
-                #inspect -label search $search
-                
-                ::if {![::llength $search]} {
-                    ::set base $commandns
-                    ::set what "*"
-                } else {
-                    ::if {[::string match ::* $search]} {
-                        ::set base [::punk::ns::nsprefix $search]
-                        ::set what [::punk::ns::nstail $search]
-                    } else {
-                        ::set base $commandns
-                        ::set what $search
-                    }
-                }
-
-                ::set all_ns_commands [::info commands [::punk::ns::nsjoin $base $what]]
-                #important not to call namespace eval (or punk::ns::nseval) on non-existant base - or it will be created
-                ::if {![::namespace exists $base]} {
-                   ::continue 
-                }
-
-                if 0 {
-                    #NOTE - matched commands will return commands from global ns due to 'namespace eval' - also any commands from namespaces in the 'namespace path' list
-                    #We don't simply do info commands ${base}::$what  because it misses some oddly named things (JMN 2023 - like what?)
-                    #this was to support weird namespaces with leading/trailing colons - not an important usecase for the cost
-                    ::set matchedcommands [::pipeswitch {
-                        ::pipecase \
-                            caseresult.= ::list $base $what |,basens/0,g/1>  {namespace eval $basens [::list ::info commands $g]}
-                    }]
-                    #lappend commandlist {*}[@@ok/result= $matchedcommands]
-                    #need to pull result from matchedcommands dict
-                    #set cmd_tails [@@ok/result= $matchedcommands |> {::lmap v $data {punk::ns::nstail $v}}]
-                    ::set cmd_tails [::lmap v [::dict get $matchedcommands ok result] {::punk::ns::nstail $v}]
-                    ::set all_ns_tails [::lmap v $all_ns_commands {::punk::ns::nstail $v}]
-                    ::foreach c $cmd_tails {
-                        ::if {$c in $all_ns_tails} {
-                            ::if {$do_raw} {
-                                ::lappend commandlist [::list $c $c]
-                            } else {
-                                ::lappend commandlist [::list $c $col[::list $c]$rst]
-                            }
-                        }
-                    }
-                } else {
-
-                    ::set all_ns_tails [::lmap v $all_ns_commands {::punk::ns::nstail $v}]
-                    foreach c $all_ns_tails {
-                        ::if {$do_raw} {
-                            ::lappend commandlist [::list $c $c]
-                        } else {
-                            ::lappend commandlist [::list $c $col[::list $c]$rst]
-                        }
-                    }
-                }
-            }
-            ::list ok [::list result $commandlist]
-            #unless we always return trailing \n - it's impossible to represent a list containing only the empty string using \n (cannot disambiguate between empty list and/or list of 2 empty strings)
-            #we use the convention that a result of just \n represents a list of just the empty string - as we don't require duplicates anyway - so it shouldn't mean two empty strings.
-    }  |data@@ok/result> ::lsort -index 0  |> {::lmap v $data {::lindex $v 1}} |> {::if {![::llength $data]} {::return {}} else {::return [::join $data \n]\n}} <searchlist|  
-
-    proc nscommands {args} {
-            set commandns [uplevel 1 [list ::namespace current]]
-            set commandlist [::list]
-            #color code multiple args? - not very practical if many ns args supplied, but then... common case will only be 1 or 2 anyway
-            #colors can be stripped by caller with ansistrip - but we'll make the default case easier by using no ansi codes if a single arg is passed 
-            set colors [::list none cyan yellow green]
-            set ci 0 ;#colourindex
-            set do_raw 0
-            if {[::set posn [::lsearch $args -raw]] >= 0} {
-                ::set args [::lreplace $args $posn $posn]
-                ::set do_raw 1 
-            }
-            if {![llength $args]} {
-                lappend args *
-            }
-            ::foreach search $args {
-                ::if {$ci > [::llength $colors]-1} {
-                    ::set ci 0
-                }
-                ::if {$ci == 0 || $do_raw} {
-                    ::set col ""
-                    ::set rst ""
-                } else {
-                    ::set col [a+ [::lindex $colors $ci] bold]
-                    ::set rst [a+]
-                }
-                ::incr ci ;#colourindex
-                #inspect -label search $search
-                
-                ::if {![::llength $search]} {
-                    ::set base $commandns
-                    ::set what "*"
-                } else {
-                    ::if {[::string match ::* $search]} {
-                        ::set base [::punk::ns::nsprefix $search]
-                        ::set what [::punk::ns::nstail $search]
-                    } else {
-                        ::set base $commandns
-                        ::set what $search
-                    }
-                }
-
-                ::set all_ns_commands [::info commands [::punk::ns::nsjoin $base $what]]
-                #important not to call namespace eval (or punk::ns::nseval) on non-existant base - or it will be created
-                ::if {![::namespace exists $base]} {
-                   ::continue 
-                }
-                ::set all_ns_tails [::lmap v $all_ns_commands {::punk::ns::nstail $v}]
-                foreach c $all_ns_tails {
-                    ::if {$do_raw} {
-                        ::lappend commandlist [::list $c $c]
-                    } else {
-                        ::lappend commandlist [::list $c $col[::list $c]$rst]
-                    }
-                }
-            }
-            set commandlist [lsort -index 0 $commandlist]
-            set results [list]
-            foreach pair $commandlist  {
-                lappend results [lindex $pair 1]
-            }
-            #unless we always return trailing \n - it's impossible to represent a list containing only the empty string using \n (cannot disambiguate between empty list and/or list of 2 empty strings)
-            #we use the convention that a result of just \n represents a list of just the empty string - as we don't require duplicates anyway - so it shouldn't mean two empty strings.
-            if {![llength $results]} {
-                return {}
-            } else {
-                return [join $results \n]\n
-            }
-    }
-    interp alias {} nscommands {} punk::ns::nscommands
-
-
-
-    interp alias {} nscommands1 {} .= ,'ok'@0.= {
-            set commandns [namespace current]
-            #upvar caseresult caseresult
-            inspect -label namespace_current [namespace current]
-            inspect -label nsthis [nsthis]
-            inspect -label nsthis2 [nsthis2]
-            inspect -label commandns $commandns
-            inspect -label info_procs [info procs]
-            #by using pipeswitch instead of pipeswitchc - we give the ability* for the switch script block to affect vars in the calling scope
-            # (*not a desirable feature from a functional point of view - but useful for debugging, and also potentially faster )
-            pipeswitch {
-                #no glob chars present
-                if {![llength $ns]} {
-                    set ns $commandns
-                } else {
-                    if {![string match ::* $ns]} {
-                        if {$commandns eq "::"} {set commandns ""}
-                        set ns ${commandns}::$ns
-                    }
-                }
-                inspect '$ns'
-                pipecase \
-                    caseresult= $ns |input> \
-                    1.= {expr {[string length [string map [list * "" ? ""] $data]] == [string length $data]}} |>  {
-                        #uplevel 1 [list info commands ${input}::*]
-                        info commands ${input}::*
-                    }
-
-                #pipecase1 ns has one or more of glob chars * or ?
-                pipecase \
-                    caseresult= $ns |input>  {
-                        #uplevel 1 [list info commands ${input}]
-                        info commands ${input}
-                    }
-            }
-    } |data@@ok/result>  {lmap v $data {punk::ns::nstail $v}} |> lsort |> {join $data \n} <ns/0| 
-
-    #todo - package up as navns
-    proc corp {path} {
-        #thanks to Richard Suchenwirth for the original - wiki.tcl-lang.org/page/corp 
-        #Note: modified here to support aliases and relative/absolute name (with respect to namespace .ie ::name vs name)
-        if {[info exists ::auto_index($path)]} {
-            set body "# $::auto_index($path)\n"
-        } else {
-            set body ""
-        }
-
-        if {[string match ::* $path]} {
-            set targetns [nsprefix $path]
-            set name [nstail $path]
-        } else {
-            set thispath [uplevel 1 [list ::nsthis $path]]
-            set targetns [nsprefix $thispath]
-            set name [nstail $thispath]
-        }
-        #puts stderr "corp upns:$upns"
-
-        #set name [string trim $name :]        
-        #set origin [namespace origin ${upns}::$name]
-        set origin [nseval $targetns [list ::namespace origin $name]]
-
-        #An renamed alias may exist that is the same name as a proc that was created later.. so we must check for the proc before looking into aliases!
-        if {$origin ni [info procs $origin]} {
-
-            #It seems an interp alias of "::x""  behaves the same as "x" 
-            #But we can't create both at the same time - and they have to be queried by the exact name.
-            #So we query for alias with and without leading ::
-            set alias_qualified [interp alias {} [string trim $origin :]]
-            set alias_unqualified [interp alias {} $origin]
-            if {[string length $alias_qualified] && [string length $alias_unqualified]} {
-                #our assumptions are wrong.. change in tcl version?
-                puts stderr "corp: Found alias for unqualified name:'[string trim $origin :]' and qualified name: '$origin' - unexpected (assumed impossible as at Tcl 8.6)"
-                if {$alias_qualified ne $alias_unqalified} {
-
-                } else {
-                    set alias $alias_unqualified
-                }
-            } else {
-                set alias ${alias_qualified}${alias_unqualified} ;#concatenate - as at least one should be empty
-            }
-
-            if {[string length $alias]} {
-                #todo - consider following alias-chain to ultimate proc?
-                #it can always be manually done with:
-                #.= corp $name |/1> corp |/1> corp ..
-                #depending on number of aliases in the chain
-                return [list alias {*}$alias]
-            }
-        } 
-        if {[nsprefix $origin] ne [nsprefix [nsjoin ${targetns} $name]]} {
-            append body "# namespace origin $origin" \n
-        }
-
-        append body [info body $origin]
-        set argl {}
-        foreach a [info args $origin] {
-            if {[info default $origin $a def]} {
-                lappend a $def
-            }
-            lappend argl $a
-        }
-        list proc [nsjoin ${targetns} $name] $argl $body
-    }
-
-
-    #review ???
-    proc ns_relative_to_location {name} {
-        if {[string match ::* $name]} {
-            error "ns_relative_to_location accepts a relative namespace name only ie one without leading ::"
-        }
-
-    }
-    proc ns_absolute_to_location {name} {
-
-    }
-
-
-    namespace eval internal {
-
-
-        #maintenance: similar in punk::winrun
-        proc get_run_opts {options alias_dict arglist} {
-            if {[catch {
-                set callerinfo [info level -1]
-            } errM]} {
-                set caller ""
-            } else {
-                set caller [lindex $callerinfo 0]
-            }
-
-            #update alias dict mapping shortnames to longnames - longnames to self
-            foreach o $options {
-                dict set alias_dict $o $o
-            }
-            set known_runopts [dict keys $alias_dict]
-            set runopts [list]
-            set cmdargs [list]
-
-            set first_eopt_posn [lsearch $arglist --]
-            if {$first_eopt_posn >=0} {
-                set pre_eopts [lrange $arglist 0 $first_eopt_posn-1]
-                set is_eopt_for_runopts 1 ;#default assumption that it is for this function rather than part of user's commandline - cycle through previous args to disprove.
-                foreach pre $pre_eopts {
-                    if {$pre ni $known_runopts} {
-                        set is_eopt_for_runopts 0; #the first -- isn't for us.
-                    }
-                }
-            } else {
-                set is_eopt_for_runopts 0
-            }
-            #split on first -- if only known opts preceding (or nothing preceeding) - otherwise split on first arg that doesn't look like an option and bomb if unrecognised flags before it.
-            if {$is_eopt_for_runopts} {
-                set idx_first_cmdarg [expr $first_eopt_posn + 1]
-                set runopts [lrange $arglist 0 $idx_first_cmdarg-2] ;#exclude -- from runopts - it's just a separator.
-            } else {
-                set idx_first_cmdarg [lsearch -not $arglist "-*"]
-                set runopts [lrange $arglist 0 $idx_first_cmdarg-1]
-            }
-            set cmdargs [lrange $arglist $idx_first_cmdarg end]
-            foreach o $runopts {
-                if {$o ni $known_runopts} {
-                    error "$caller: Unknown runoption $o - known options $known_runopts"
-                }
-            }
-            set runopts [lmap o $runopts {dict get $alias_dict $o}]
-            #todo - get these out of here. Should be supplied by caller.
-            if {"-allowvars" in $runopts && "-disallowvars" in $runopts} {
-                puts stderr "Warning - conflicting options -allowvars & -disallowvars specified: $arglist"
-            }
-
-            #maintain order: runopts $runopts cmdargs $cmdargs as first 4 args (don't break 'lassign [get_runopts $args] _ runopts _ cmdargs')
-            #todo - add new keys after these indicating type of commandline etc.
-            return [list runopts $runopts cmdargs $cmdargs]
-        }
-
-        proc _pkguse_vars {varnames} {
-            while {"pkguse_vars_[incr n]" in $varnames} {}
-            return [concat $varnames pkguse_vars_$n]
-        }
-        proc tracehandler_nowrite {args} {
-            error "readonly in use block"
-        }
-
-    }
-
-
-    #load package and move to namespace of same name if run interactively with only pkg/namespace argument.
-    #if args is supplied - first word is script to run in the namespace remaining args are args passed to scriptblock
-    #if no newline or $args in the script - treat as one-liner and supply {*}$args automatically
-    proc pkguse {pkg_or_existing_ns args} {
-        lassign [internal::get_run_opts {-vars -nowarnings} {} $args] _r runopts _c cmdargs
-        set use_vars    [expr {"-vars" in $runopts}]
-        set no_warnings [expr {"-nowarnings" in $runopts}]
-
-
-        #todo support leading solo flags such as -capture to control whether we do a static capture of local vars in the ns
-        if {[string tolower $pkg_or_existing_ns] in [list :: global]} {
-            set ns ::
-            set ver "";# tcl version?
-        } else {
-            if {[string match ::* $pkg_or_existing_ns]} {
-                if {![namespace exists $pkg_or_existing_ns]} {
-                    set ver [package require [string range $pkg_or_existing_ns 2 end]]
-                } else {
-                    set ver ""
-                }
-                set ns $pkg_or_existing_ns
-            } else {
-                set ver [package require $pkg_or_existing_ns]
-                set ns ::$pkg_or_existing_ns
-            }
-        }
-        if {[namespace exists $ns]} {
-            if {[llength $cmdargs]} {
-                set binding {}
-                #if {[info level] == 1} {
-                #    #up 1 is global 
-                #    set get_vars [list info vars]
-                #} else {
-                #    set get_vars [list info locals]
-                #}
-                #set vars [uplevel 1 {*}$get_vars]
-
-                #set vars [namespace eval $ns {info vars}]
-
-                #review - upvar in apply within ns eval vs direct access of ${ns}::varname
-                set capture [namespace eval $ns {
-                    apply { varnames  {
-                        while {"prev_args_[incr n]" in $varnames} {}
-                        set capturevars [dict create]
-                        set capturearrs [dict create]
-                        foreach fullv $varnames {
-                            set  v [namespace tail $fullv]
-                            upvar 1 $v var
-                            if {[info exists var]} {
-                                if {$v eq "args"} {
-                                    dict set capturevars "prev_args$n" [list var $var]
-                                } else {
-                                    if {(![array exists var])} {
-                                        dict set capturevars $v $var
-                                    } else {
-                                        dict set capturearrs $v [array get var]
-                                    }
-                                }
-                            } else {
-                                #A variable can show in the results for 'info vars' (or nsvars) but still not exist. e.g a 'variable x' declaration in the namespace where the variable has never been set
-                            }
-                        }                        
-                        return [dict create vars $capturevars arrs $capturearrs]
-                    } } [info vars [namespace current]::*]  ;#we are relying on info vars ::::* returning same as info vars ::*  - a bit hacky (don't want to set any extra vars in the ns)
-                } ]
-
-
-                set arglist [lassign $cmdargs scriptblock]
-                if {[string first "\n" $scriptblock] <0 && [string first {$args} $scriptblock] <0} {
-                    #one liner without use of $args  
-                    append scriptblock { {*}$args}
-                    #tailcall apply [list args [string cat $scriptblock { {*}$args}] $ns] {*}$arglist
-                }
-                if {!$no_warnings & $use_vars} {
-                    set script ""
-                    foreach v [dict keys [dict get $capture vars]] {
-                        append script [string map [list <v> $v] {
-                            trace add variable <v> write ::punk::ns::internal::tracehandler_nowrite
-                            #unset?
-                        }]
-                    }
-                    append script \n $scriptblock
-                } else {
-                    set script $scriptblock
-                }
-                if {$use_vars} {
-                    tailcall apply [list [concat [dict keys [dict get $capture vars]] args] $script $ns] {*}[concat [dict values [dict get $capture vars]] $arglist]
-                } else {
-                    tailcall apply [list args $scriptblock $ns] {*}$arglist
-                }
-            } else {
-                set out [punk::ns::ns/ / $ns]
-                append out \n  $ver
-                return $out
-            }
-        } else {
-            error "Namespace $ns not found."
-        }
-        return $out
-    }
-    interp alias "" use "" punk::ns::pkguse
-
-    proc nsimport_noclobber {pattern {ns ""}} {
-        set source_ns [namespace qualifiers $pattern]
-        if {![namespace exists $source_ns]} {
-            error "nsimport_noclobber error namespace $source_ns not found"
-        }
-        if {$ns eq ""} {
-            set ns [uplevel 1 {namespace current}]
-        } elseif {![string match ::* $ns]} {
-            set nscaller [uplevel 1 {namespace current}]
-            set ns [punk::nsjoin $nscaller $ns]
-        }
-        set a_export_patterns [namespace eval $source_ns {namespace export}] 
-        set a_commands [info commands $pattern]
-        set a_tails [lmap v $a_commands {namespace tail $v}]
-        set a_exported_tails [list]
-        foreach pattern $a_export_patterns {
-            set matches [lsearch -all -inline $a_tails $pattern]
-            foreach m $matches {
-                if {$m ni $a_exported_tails} {
-                    lappend a_exported_tails $m
-                }
-            }
-        }
-        set imported_commands [list]
-        foreach e $a_exported_tails {
-            set imported [namespace eval $ns [string map [list <func> $e <a> $source_ns] {
-                set cmd ""
-                if {![catch {namespace import <a>::<func>}]} {
-                    set cmd <func>
-                }
-                set cmd
-            }]]
-            if {[string length $imported]} {
-                lappend imported_commands $imported
-            }
-        }
-        return $imported_commands
-    }
-
-    #todo - use ns::nsimport_noclobber instead
-
-    interp alias {} nsthis    {} punk::ns::nspath_here_absolute
-    interp alias {} nsorigin {} apply {ns {namespace origin [uplevel 1 ::punk::ns::nspath_here_absolute $ns]} ::}
-    interp alias {} nsvars {} punk::ns::nsvars
-    interp alias {} nsjoin {} punk::ns::nsjoin
-    interp alias {} nsprefix {} punk::ns::nsprefix
-    interp alias {} nstail {} punk::ns::nstail
-    interp alias {} nsparts {} punk::ns::nsparts
-    interp alias {} nstree  {} punk::ns::nstree
-    #namespace/command/proc query
-    interp alias {} nslist {} punk::ns::nslist
-    interp alias {} nslist_dict {} punk::ns::nslist_dict
-
-    #extra slash implies more verbosity (ie display commands instead of just nschildren)
-    interp alias {} n/ {} punk::ns::ns/ /
-    interp alias {} n// {} punk::ns::ns/ //
-    interp alias {} n/// {} punk::ns::ns/ ///
-    interp alias {} n/new {} punk::ns::n/new
-    interp alias {} nn/ {} punk::ns::nsup/ /
-    interp alias {} nn// {} punk::ns::nsup/ //
-    if 0 {
-    #we can't have ::/ without just plain / which is confusing.
-    interp alias {} :/ {} punk::ns::ns/ /
-    interp alias {} :// {} punk::ns::ns/ //
-    interp alias {} :/new {} punk::ns::n/new
-    interp alias {} ::/ {} punk::ns::nsup/ /
-    interp alias {} ::// {} punk::ns::nsup/ //
-    }
-
-
-    interp alias {} corp       {} punk::ns::corp
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::ns [namespace eval punk::ns {
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/overlay-0.1.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/overlay-0.1.tm
deleted file mode 100644
index eebf0e1e..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/overlay-0.1.tm
+++ /dev/null
@@ -1,159 +0,0 @@
-
-
-package require punk::mix::util
-
-namespace eval ::punk::overlay {
-    #based *loosely* on: wiki.tcl-lang.org/page/ensemble+extend
-    # extend an ensemble-like routine with the routines in some namespace
-    #
-    # e.g custom_from_base ::punk::mix::cli ::punk::mix::base
-    #
-    proc custom_from_base {routine base} {
-        if {![string match ::* $routine]} {
-            set resolved [uplevel 1 [list ::namespace which $routine]]
-            if {$resolved eq {}} {
-                error [list {no such routine} $routine]
-            }
-            set routine $resolved
-        }
-        set routinens [namespace qualifiers $routine]
-        if {$routinens eq {::}} {
-            set routinens {}
-        }
-        set routinetail [namespace tail $routine]
-
-        if {![string match ::* $base]} {
-            set base [uplevel 1 [
-                list [namespace which namespace] current]]::$base
-        }
-
-        if {![namespace exists $base]} {
-            error [list {no such namespace} $base]
-        }
-
-        set base [namespace eval $base [
-            list [namespace which namespace] current]]
-
-
-        #while 1 {
-        #    set renamed ${routinens}::${routinetail}_[info cmdcount]
-        #    if {[namespace which $renamed] eq {}} break
-        #}
-
-        namespace eval $routine [
-            list namespace ensemble configure  $routine -unknown [
-                list apply {{base ensemble subcommand args} {
-                    list ${base}::_redirected $ensemble $subcommand 
-                }} $base
-            ]
-        ]
-
-        punk::mix::util::namespace_import_pattern_to_namespace_noclobber ::punk::mix::util::* ${routine}::util
-        #namespace eval ${routine}::util {
-            #namespace import ::punk::mix::util::*
-        #}
-        punk::mix::util::namespace_import_pattern_to_namespace_noclobber ${base}::lib::* ${routine}::lib
-        #namespace eval ${routine}::lib [string map [list <base> $base] {
-        #    namespace import <base>::lib::*
-        #}]
-
-        namespace eval ${routine}::lib [string map [list <base> $base <routine> $routine] {
-            if {[namespace exists <base>::lib]} {
-                set current_paths [namespace path]
-                if {"<routine>" ni $current_paths} {
-                    lappend current_paths <routine>
-                }
-                namespace path $current_paths
-            }
-        }]
-
-        namespace eval $routine {
-            set exportlist [list]
-            foreach cmd [info commands [namespace current]::*] {
-                set c [namespace tail $cmd]
-                if {![string match _* $c]} {
-                    lappend exportlist $c
-                }
-            }
-            namespace export {*}$exportlist
-        }
-
-        return $routine
-    }
-    #load *exported* commands from cmdnamespace into caller's namespace - prefixing each command with $prefix
-    #Note: commandset may be imported by different CLIs with different bases *at the same time*
-    #so we don't make commands from the cli or its base available automatically (will generally require fully-qualified commands to use code from cli/base) 
-    #we do load punk::mix::util::*  into the util subnamespace even though the commandset might not be loaded in a cli using punk::mix::base  i.e punk::mix::util is a common dependency for CLIs.
-    #commandsets designed to be used with a specific cli/base may choose to do their own import e.g with util::namespace_import_pattern_to_namespace_noclobber and/or set namespace path if they 
-    #want the convenience of using lib:xxx with commands coming from those packages.
-    #This won't stop the commandset being used with other cli/bases unless the import is done by looking up the callers namespace.
-    #The basic principle is that the commandset is loaded into the caller(s) with a prefix 
-    #- but commandsets should explicitly package require if they have any backwards dependencies on cli/base (which they may or may not be loaded into)
-    proc import_commandset {prefix separator cmdnamespace} {
-        set bad_seps [list "::"]
-        if {$separator in $bad_seps} {
-            error "import_commandset invalid separator '$separator'"
-        }
-        #namespace may or may not be a package
-        # allow with or without leading ::
-        if {[string range $cmdnamespace 0 1] eq "::"} {
-            set cmdpackage [string range $cmdnamespace 2 end]
-        } else {
-            set cmdpackage $cmdnamespace
-            set cmdnamespace ::$cmdnamespace
-        }
-
-        if {![namespace exists $cmdnamespace]} {
-            #only do package require if the namespace not already present
-            catch {package require $cmdpackage} pkg_load_info 
-            #recheck
-            if {![namespace exists $cmdnamespace]} {
-                set prov [package provide $cmdpackage]
-                if {[string length $prov]} {
-                    set provinfo "(package $cmdpackage is present with version $prov)"
-                } else {
-                    set provinfo "(package $cmdpackage not present)"
-                }
-                error "punk::overlay::import_commandset supplied namespace '$cmdnamespace' doesn't exist. $provinfo  Pkg_load_result: $pkg_load_info  Usage: import_commandset prefix separator namespace"
-            }
-        }
-     
-        punk::mix::util::namespace_import_pattern_to_namespace_noclobber ::punk::mix::util::* ${cmdnamespace}::util
-
-        #let child namespace 'lib' resolve parent namespace and thus util::xxx
-        namespace eval ${cmdnamespace}::lib [string map [list <cmdns> $cmdnamespace] {
-            set nspaths [namespace path]
-            if {"<cmdns>" ni $nspaths} {
-                lappend nspaths <cmdns>
-            }
-            namespace path $nspaths
-        }]
-
-        set imported_commands [list]
-        set nscaller [uplevel 1 [list namespace current]]
-        if {[catch {
-            #review - noclobber?
-            namespace eval ${nscaller}::temp_import [list namespace import ${cmdnamespace}::*]
-            foreach cmd [info commands ${nscaller}::temp_import::*] {
-                set cmdtail [namespace tail $cmd]
-                if {$cmdtail eq "_default"} {
-                    set import_as ${nscaller}::${prefix}
-                } else {
-                    set import_as ${nscaller}::${prefix}${separator}${cmdtail}
-                }
-                rename $cmd  $import_as
-                lappend imported_commands $import_as
-            }
-        } errM]} {
-            puts stderr "Error loading commandset $prefix $separator $cmdnamespace"
-            puts stderr "err: $errM"
-        }
-        return $imported_commands
-    }
-}
-
-
-package provide punk::overlay [namespace eval punk::overlay {
-    variable version
-    set version 0.1 
-}]
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/path-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/path-0.1.0.tm
deleted file mode 100644
index f877417a..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/path-0.1.0.tm
+++ /dev/null
@@ -1,397 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::path 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin punkshell_module_punk::path 0 0.1.0]
-#[copyright "2023"]
-#[titledesc {Filesystem path utilities}]  [comment {-- Name section and table of contents description --}]
-#[moddesc {punk path filesystem utils}]             [comment {-- Description at end of page heading --}] 
-#[require punk::path]
-#[description]
-#[keywords module path filesystem]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section Overview]
-#[para] overview of punk::path
-#[para] Filesystem path utility functions
-#[subsection Concepts]
-#[para] -
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[subsection dependencies]
-#[para] packages used by punk::path
-#[list_begin itemized]
-
-package require Tcl 8.6
-#*** !doctools
-#[item] [package {Tcl 8.6}]
-
-# #package require frobz
-# #*** !doctools
-# #[item] [package {frobz}]
-
-#*** !doctools
-#[list_end]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section API]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# oo::class namespace
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::path::class {
-    #*** !doctools
-    #[subsection {Namespace punk::path::class}]
-    #[para] class definitions
-    if {[info commands [namespace current]::interface_sample1] eq ""} {
-        #*** !doctools
-        #[list_begin enumerated]
-
-        # oo::class create interface_sample1 {
-        #     #*** !doctools
-        #     #[enum] CLASS [class interface_sample1]
-        #     #[list_begin definitions]
-
-        #     method test {arg1} {
-        #         #*** !doctools
-        #         #[call class::interface_sample1    [method test] [arg arg1]]
-        #         #[para] test method
-        #         puts "test: $arg1"
-        #     }
-
-        #     #*** !doctools
-        #     #[list_end] [comment {-- end definitions interface_sample1}]
-        # }
-
-        #*** !doctools
-        #[list_end] [comment {--- end class enumeration ---}]
-    }
-}
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# Base namespace
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::path {
-    namespace export *
-    #variable xyz
-
-    #*** !doctools
-    #[subsection {Namespace punk::path}]
-    #[para] Core API functions for punk::path 
-    #[list_begin definitions]
-
-
-    proc pathglob_as_re {pathglob} {
-        #*** !doctools
-        #[call [fun pathglob_as_re] [arg pathglob]]
-        #[para] Returns a regular expression for matching a path to a glob pattern which can contain glob chars *|? in any segment of the path structure
-        #[para] ** matches any number of subdirectories. 
-        #[para] e.g /etc/**/*.txt will match any .txt files at any depth below /etc  (except directly within /etc itself)
-        #[para] e.g /etc/**.txt will match any .txt files at any depth below /etc
-        #[para] any segment that does not contain ** must match exactly one segment in the path
-        #[para] e.g the glob /etc/*/*.doc  - will match any .doc files that are exactly one tree level below /etc 
-        #[para] The pathglob doesn't have to contain glob characters, in which case the returned regex will match the pathglob exactly as specified.
-        #[para] Regular expression syntax is deliberateley not supported within the pathglob string so that supplied regex characters will be treated as literals 
-
-
-        #todo - consider whether a way to escape the glob chars ? * is practical - to allow literals ? *
-        # - would require counting immediately-preceding backslashes
-        set pats [list]
-        foreach seg [file split $pathglob] {
-            if {[string range $seg end end] eq "/"} {
-                set seg [string range $seg 0 end-1] ;# e.g c:/ -> c:   / -> ""  so that join at end doesn't double up
-            }
-            if {$seg eq "*"} {
-                lappend pats {[^/]*}
-            } elseif {$seg eq "**"} {
-                lappend pats {.*}
-            } else {
-                set seg [string map [list {^ {\^} $ {\$} [} {\[} ( {\(} \{ \\\{ \\ {\\}] $seg] ;#treat regex characters in the input as literals 
-                set seg [string map [list  . {[.]}] $seg]
-                if {[regexp {[*?]} $seg]} {
-                    set pat [string map [list ** {.*} * {[^/]*} ? {[^/]}] $seg]
-                    lappend pats "$pat"
-                } else {
-                    lappend pats "$seg"
-                }
-            }
-        }
-        return  "^[join $pats /]\$"
-    }
-    proc globmatchpath {pathglob path args} {
-        #*** !doctools
-        #[call [fun globmatchpath] [arg pathglob] [arg path] [opt {option value...}]]
-        #[para] Return true if the pathglob matches the path
-        #[para] see [fun pathglob_as_re] for pathglob description
-        #[para] Caller must ensure that file separator is forward slash. (e.g use file normalize on windows)
-        #[para]
-        #[para] Known options:
-        #[para]     -nocase 0|1  (default 0 - case sensitive)
-        #[para] If -nocase is not supplied - default to case sensitive *except for driveletter*
-        #[para] ie - the driveletter alone in paths such as c:/etc will still be case insensitive. (ie c:/ETC/* will match C:/ETC/blah but not C:/etc/blah)
-        #[para] Explicitly specifying -nocase 0 will require the entire case to match including the driveletter.
-
-        set defaults [dict create\
-            -nocase \uFFFF\
-        ]
-        set known_opts [dict keys $defaults]
-        set opts [dict merge $defaults $args]
-        dict for {k v} $args {
-            if {$k ni $known_opts} {
-                error "Unrecognised options $k - known options: $known_opts"
-            }
-        }
-        # -- --- --- --- --- --- 
-        set opt_nocase [dict get $opts -nocase]
-        set explicit_nocase 1 ;#default to disprove 
-        if {$opt_nocase eq "\uFFFF"} {
-            set opt_nocase 0
-            set explicit_nocase 0
-        } 
-        # -- --- --- --- --- --- 
-        if {$opt_nocase} {
-            return [regexp -nocase [pathglob_as_re $pathglob] $path]
-        } else {
-            set re [pathglob_as_re $pathglob]
-            if {$explicit_nocase} {
-                set ismatch [regexp $re $path] ;#explicit -nocase 0  - require exact match of path literals including driveletter
-            } else {
-                #caller is using default for -nocase - which indicates case sensitivity - but we have an exception for the driveletter.
-                set re_segments [file split $re] ;#Note that file split c:/etc gives {c:/ etc}  but file split ^c:/etc gives {^c: etc}
-                set first_seg [lindex $re_segments 0]
-                if {[regexp {^\^(.{1}):$} $first_seg _match driveletter]} {
-                    #first part of re is like "^c:" i.e a drive letter
-                    set chars [string tolower $driveletter][string toupper $driveletter]
-                    set re [join [concat "^\[$chars\]:" [lrange $re_segments 1 end]] /] ;#rebuild re with case insensitive driveletter only - use join - not file join. file join will misinterpret leading re segment.
-                }
-                #puts stderr "-->re: $re"
-                set ismatch [regexp $re $path]
-            }
-        }
-        return $ismatch
-    }
-
-    #todo - implement treefiles which acts like dirfiles but allows path globbing in the same way as punk::ns::ns/ 
-    #then review if treefiles can replace dirfiles or if both should exist (dirfiles can have literal glob chars in path segments - but that is a rare usecase)
-    proc treefilenames {basepath tailglob args} {
-        #*** !doctools
-        #[call [fun treefilenames] [arg basepath] [arg tailglob] [opt {option value...}]]
-        #basic (glob based) list of filenames matching tailglob - recursive
-        #no natsorting - so order is dependent on filesystem
-        set defaults [dict create\
-            -call-depth-internal 0\
-            -antiglob_paths {}\
-        ]
-        set opts [dict merge $defaults $args]
-        set opt_antiglob_paths [dict get $opts -antiglob_paths]
-        set CALLDEPTH [dict get $opts -call-depth-internal]
-
-        set files [list]
-        if {$CALLDEPTH == 0} {
-            if {![file isdirectory $basepath]} {
-                return [list] 
-            }
-        }
-
-        set skip 0
-        foreach anti $opt_antiglob_paths {
-            if {[globmatchpath $anti $basepath]} {
-                set skip 1
-                break
-            }
-        }
-        if {$skip} {
-            return [list]
-        }
-
-        #todo - account for vfs where matched path could appear to be a directory but is mounted so could be a desired match?
-        set dirfiles [glob -nocomplain -dir $basepath -type f $tailglob] 
-        lappend files  {*}$dirfiles
-        set dirdirs [glob -nocomplain -dir $basepath -type d *]
-        foreach dir $dirdirs {
-            set skip 0
-            foreach anti $opt_antiglob_paths {
-                if {[globmatchpath $anti $dir]} {
-                    set skip 1
-                    break 
-                }
-            }
-            if {$skip} {
-                continue
-            }
-            set nextargs [dict merge $args [list -call-depth-internal [incr CALLDEPTH]]]
-            lappend files {*}[treefilenames $dir $tailglob {*}$nextargs]
-        }
-        return $files
-    }
-
-    #maint warning - also in punkcheck
-    proc relative {reference location} {
-        #*** !doctools
-        #[call [fun relative] [arg reference] [arg location]]
-        #[para]    Taking two directory paths, a reference and a location, computes the path
-        #    of the location relative to the reference.
-        #[list_begin itemized]
-        #[item]
-        #[para] Arguments:
-        #       [list_begin arguments]
-        #       [arg_def string reference]       The path from which the relative path to location is determined. 
-        #       [arg_def string location]        The location path which may be above or below the reference path 
-        #       [list_end]
-        #[item]
-        #[para] Results:
-        #[para]    The relative path of the location to the reference path.
-        #[para]    Will return a single dot "." if the paths are the same
-        #[item]
-        #[para] Notes:
-        #[para]    Both paths must be the same type - ie both absolute or both relative
-        #[para]    Case sensitive.  ie  relative /etc /etC 
-        #      will return ../etC
-        #[para]    On windows, the drive-letter component (only) is not case sensitive
-        #[para]    ie relative c:/etc  C:/etc  returns .  
-        #[para]    but relative c:/etc C:/Etc returns ../Etc
-        #[para]    On windows, if the paths are absolute and specifiy different volumes, only the location will be returned.
-        #    ie  relative c:/etc d:/etc/blah
-        #    returns d:/etc/blah
-        #[list_end]
-
-        #see also kettle
-        # Modified copy of ::fileutil::relative (tcllib)
-        # Adapted to 8.5 ({*}).
-
-        #review - check volume info on windows.. UNC paths?
-        if {[file pathtype $reference] ne [file pathtype $location]} {
-            return -code error "Unable to compute relation for paths of different pathtypes: [file pathtype $reference] vs. [file pathtype $location], ($reference vs. $location)"
-        }
-
-        #avoid normalizing if possible (file normalize *very* expensive on windows)
-        set do_normalize 0
-        if {[file pathtype $reference] eq "relative"} {
-            #if reference is relative so is location 
-            if {[regexp {[.]{2}} [list $reference $location]]} {
-                set do_normalize 1
-            }
-            if {[regexp {[.]/} [list $reference $location]]} {
-                set do_normalize 1
-            }
-        } else {
-            set do_normalize 1
-        }
-        if {$do_normalize} {
-            set reference [file normalize $reference]
-            set location  [file normalize $location]
-        }
-
-        set save $location
-        set reference [file split $reference]
-        set location  [file split $location]
-
-        while {[lindex $location 0] eq [lindex $reference 0]} {
-            set location  [lrange $location  1 end]
-            set reference [lrange $reference 1 end]
-            if {![llength $location]} {break}
-        }
-
-        set location_len  [llength $location]
-        set reference_len [llength $reference]
-
-        if {($location_len == 0) && ($reference_len == 0)} {
-            # Cases:
-            # (a) reference == location
-
-            set location .
-        } else {
-            # Cases:
-            # (b) ref is: ref/sub = sub
-            #     loc is: ref     = {}
-
-            # (c) ref is: ref     = {}
-            #     loc is: ref/sub = sub
-
-            while {$reference_len > 0} {
-                set location [linsert $location 0 ..]
-                incr reference_len -1
-            }
-            set location [file join {*}$location]
-        }
-        return $location
-    }
-
-
-
-    #*** !doctools
-    #[list_end] [comment {--- end definitions namespace punk::path ---}]
-}
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# Secondary API namespace
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::path::lib {
-        namespace export *
-        namespace path [namespace parent]
-        #*** !doctools
-        #[subsection {Namespace punk::path::lib}]
-        #[para] Secondary functions that are part of the API 
-        #[list_begin definitions]
-
-
-
-
-
-        #*** !doctools
-        #[list_end] [comment {--- end definitions namespace punk::path::lib ---}]
-}
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[section Internal]
-namespace eval punk::path::system {
-        #*** !doctools
-        #[subsection {Namespace punk::path::system}]
-        #[para] Internal functions that are not part of the API 
-
-
-
-}
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::path [namespace eval punk::path {
-    variable pkg punk::path
-    variable version
-    set version 0.1.0 
-}]
-return
-
-#*** !doctools
-#[manpage_end]
-
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/repo-0.1.1.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/repo-0.1.1.tm
deleted file mode 100644
index d2aaf9fc..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/repo-0.1.1.tm
+++ /dev/null
@@ -1,1267 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#Copyright (c) 2023 Julian Noble
-#Copyright (c) 2012-2018 Andreas Kupries
-# - code from A.K's 'kettle' project used in this module
-#
-# @@ Meta Begin
-# Application punk::repo 0.1.1
-# Meta platform     tcl
-# Meta license      BSD
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#
-# path/repo functions
-#
-if {$::tcl_platform(platform) eq "windows"} {
-    package require punk::winpath
-} else {
-    catch {package require punk::winpath}
-}
-package require fileutil; #tcllib
-package require punk::path
-package require punk::mix::base ;#uses core functions from punk::mix::base::lib namespace e.g cksum_path 
-package require punk::mix::util ;#do_in_path
-
-
-# -- --- --- --- --- --- --- --- --- --- ---
-# For performance/efficiency reasons - use file functions on paths in preference to string operations
-# e.g use file join 
-# branch to avoid unnecessary calls to 'pwd' or 'file normalize' - which can be surprisingly expensive operations (as at tcl 8.7 2023)
-# pwd is only expensive if we treat it as a string instead of a list/path
-# e.g 
-# > time {set x [pwd]}
-# 5 microsoeconds..  no problem
-# > time {set x [pwd]}
-# 4 microsoeconds..  still no problem
-# > string length $x
-# 45
-# > time {set x [pwd]}
-# 1372 microseconds per iteration   ;#!!   values above 0.5ms common.. and that's a potential problem in loops that trawl filesystem
-# The same sorts of timings occur with file normalize
-# also.. even if we build up a path with file join from a base value that has already been normalized - the subsequent normalize will be expensive
-# -- --- --- --- --- --- --- --- --- --- ---
-
-namespace eval punk::repo {
-
-    #Todo - investigate proper way to install a client-side commit hook in the fossil project 
-    #Then we may still use this proxy to check the hook - but the required checks will occur when another shell used
-    proc fossil_proxy {args} {
-        set start_dir [pwd]
-        set fosroot [find_fossil $start_dir] 
-        set fossilcmd [lindex $args 0]
-
-        set no_warning_commands [list "help"  "dbstat" "grep" "diff" "xdiff" "cat" "version"]
-        if {$fossilcmd ni $no_warning_commands } {
-            set repostate [find_repos $start_dir] 
-        }
-
-        set no_prompt_commands [list "status" "info" {*}$no_warning_commands]
-
-
-        if {$fossilcmd ni $no_prompt_commands} {
-            set fossilrepos [dict get $repostate fossil]
-            if {[llength $fossilrepos] > 1} {
-                puts stdout [dict get $repostate warnings]
-                puts stdout "Operating on inner fossil repository: [lindex $fossilrepos 0]"
-                puts stdout "Use FOSSIL instead of fossil to avoid this prompt and warning"
-                set answer [askuser "Are you sure you want to perform the operation on this repo? Y/N"]
-                if {[string tolower $answer] ne "y"} {
-                    return
-                }
-            }
-        }
-        if {$fossilcmd eq "init"} {
-            #check if the path to .fossil is within an outer repo area.. offer to locate it somewhere else
-            set repos [dict get $repostate repos]
-            if {[llength $repos]} {
-                set chosenfossil [lindex $args end]
-                #if the user is naming it other than .fossil - assume they know what they're doing.
-                if {[string match *.fossil $chosenfossil]} {
-                    set norm_chosen [file normalize $chosenfossil]
-                    set fdir [file dirname $norm_chosen]
-                    set toprepo_info [lindex $repos end] ;#choose shortest path ie topmost
-                    set toprepo [lindex $toprepo_info 0]
-                    if {[punk::mix::base::lib::path_a_atorbelow_b $fdir $toprepo]} {
-                        set fproj [file rootname [file tail $norm_chosen]]
-                        puts stdout "Chosen .fossil location is within outer repository at $toprepo"
-                        set answer [askuser "Would you like the opportunity to choose a different location for the .fossil file from a menu? Y/N"]
-                        if {[string tolower $answer] eq "y"} {
-                            set repodir [fossil_get_repository_folder_for_project $fproj -extrachoice $fdir]
-                            if {[string length $repodir]} {
-                                puts stdout "LOCATION: $repodir/$fproj.fossil"
-                                set args [lrange $args 0 end-1]
-                                lappend args $repodir/$fproj.fossil
-                            } else {
-                                puts stderr "No directory found/selected - aborting"
-                                return
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if {$fossilcmd eq "commit"} {
-            if {[llength [file split $fosroot]]} {
-                if {[file exists [file join $fosroot src/buildsuites]]} {
-                    puts stderr "Todo - check buildsites/suite/projects for current branch/tag and update download_and_build_config"
-                }
-            }
-        } elseif {$fossilcmd in [list "info" "status"]} {
-            #emit warning whether or not multiple fossil repos
-            puts stdout [dict get $repostate warnings]
-        }
-        set fossil_prog [auto_execok fossil]
-        if {$fossil_prog ne ""} {
-            {*}$fossil_prog {*}$args
-        } else {
-            puts stderr "fossil command not found. Please install fossil"
-        }
-    }
-    interp alias "" fossil "" punk::repo::fossil_proxy
-
-    if {[auto_execok fossil] ne ""} { 
-        interp alias "" FOSSIL "" {*}[auto_execok fossil]
-    }
-
-    proc askuser {question} {
-        puts stdout $question
-        flush stdout
-        set stdin_state [fconfigure stdin]
-        try {
-            fconfigure stdin -blocking 1
-            set answer [gets stdin]
-        } finally {
-            fconfigure stdin -blocking [dict get $stdin_state -blocking]
-        }
-        return $answer
-    }
-    proc is_fossil {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[find_fossil $path] ne {}}]
-    }
-    proc is_git {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[find_git $path] ne {}}]
-    }
-    #tracked repo - but may not be a project
-    proc is_repo {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[isfossil] || [is_git]}]
-    }
-    proc is_candidate {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[find_candidate $path] ne {}}]
-    }
-    proc is_project {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[find_project $path] ne {}}]
-    }
-
-
-    proc find_fossil {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        scanup $path is_fossil_root
-    }
-    
-    proc find_git {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        scanup $path is_git_root
-    }
-    proc find_candidate {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        scanup $path is_candidate_root
-    }
-    proc find_repo {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        #find the closest (lowest in dirtree) repository
-        set f_root [find_fossil $path]
-        set g_root [find_git $path]
-        if {[string length $f_root]} {
-            if {[string length $g_root]} {
-                if {[punk::mix::base::lib::path_a_below_b $f_root $g_root]} {
-                    return $f_root
-                } else {
-                    return $g_root
-                }
-            } else {
-                return $f_root
-            }
-        } else {
-            if {[string length $g_root]} {
-                return $g_root
-            } else {
-                return ""
-            }
-        }
-    }
-    proc find_project {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        scanup $path is_project_root 
-    }
-
-    proc is_fossil_root {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        #from kettle::path::is.fossil
-        foreach control {
-            _FOSSIL_
-            .fslckout
-            .fos
-        } {
-            set control $path/$control
-            if {[file exists $control] && [file isfile $control]} {return 1}
-        }
-        return 0
-    }
-    
-    #review - is a .git folder sufficient?
-    #consider git rev-parse --git-dir ?
-    proc is_git_root {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        set control [file join $path .git]
-        expr {[file exists $control] && [file isdirectory $control]}
-    }
-    proc is_repo_root {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        expr {[is_fossil_root $path] || [is_git_root $path]}
-    }
-    #require a minimum of /src and /modules|lib|scriptapps|*.vfs - and that it's otherwise sensible
-    proc is_candidate_root {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        if {[file pathtype $path] eq "relative"} {
-            set normpath [punk::repo::norm $path]
-        } else {
-            set normpath $path
-        }
-        set unwise_paths [list "/" "/usr/local" "/usr/local/bin" "/usr/local/lib" "c:/windows"]
-        if {[string tolower $normpath] in $unwise_paths} {
-            return 0
-        }
-        if {[file pathtype [string trimright $normpath /]] eq "volumerelative"} {
-            #tcl 8.6/8.7 cd command doesn't preserve the windows "ProviderPath"  (per drive current working directory)
-            return 0
-        }
-
-        #review - adjust to allow symlinks to folders?
-        foreach required {
-            src
-        } {
-            set req $path/$required
-            if {(![file exists $req]) || ([file type $req] ne "directory") } {return 0}
-        }
-
-        set src_subs [glob -nocomplain -dir $path/src -types d -tail *]
-        if {"modules" in $src_subs || "lib" in $src_subs || "scriptapps" in $src_subs} {
-            return 1
-        }
-        foreach sub $src_subs {
-            if {[string match *.vfs $sub]} {
-                return 1
-            }
-        }
-
-        #todo - breadth first search with depth limit (say depth 3?) for *.tm or *.tcl as another positive qualifier for this dir to be a project-root
-        #we probably don't want to deep search a src folder in case the user is accidentally in some other type of project's tree
-        #such a src tree could be very large, so if we don't find tcl indicators near the root it's a good bet this isn't a candidate
-
-        return 0
-    }
-    #keep this message in sync with the programmed requirements of is_candidate_root
-    #message is not titled - it is intended to be output along with more contextual information from the calling site.
-    proc is_candidate_root_requirements_msg {} {
-        set msg ""
-        append msg "./src directory must exist." \n
-        append msg "At least one of ./src/lib ./src/modules ./src/scriptapps or a ./src/<something>.vfs folder should exist." \n
-        #append msg "Alternatively - the presence of any .tm or .tcl files within the top few levels of ./src will suffice." \n
-        return $msg
-    }
-
-    proc is_project_root {path} {
-        #review - find a reliable simple mechanism. Noting we have projects based on different templates. 
-        #Should there be a specific required 'project' file of some sort?
-
-        #test for file/folder items indicating fossil or git workdir base
-        if {(![punk::repo::is_fossil_root $path]) && (![punk::repo::is_git_root $path])} {
-            return 0
-        }
-        #exclude some known places we wouldn't want to put a project 
-        if {![is_candidate_root $path]} {
-            return 0
-        }
-        return 1
-    }
-
-    #review/tests
-    #todo - deleted items (e.g for git 1 .D ... )
-    #punkcheck uses this to check when copying a source-file to a repo-external location that the file can be tied to a revision.
-    #we are primarily concerned with the status of existent files (caller should check existence) and whether they belong to the revision that currently applies to the folder being examined.
-    #we are not concerned with git's staging facility - other than that it needs to be looked at to work out whether the file on disk is currently in a state matching the revision.
-    #
-    # -repotypes is an ordered list - if the closest repo is multi-typed the order will determine which is used.
-    # This deliberately doesn't allow bypassing a sub-repo to look for a higher-level repo in a repo-nest.
-    # The theory is that sub-repos shouldn't have their contents directly tracked directly by higher-level repos anyway
-    #REVIEW - if closest repo is both fossil and git - we only return info for one, with fossil being preferenced
-    #This may not make sense if we want to allow fossil tracking of projects where git is the primary repotype and fossil is just used to enable us to enumerate projects?
-    #does a dual git/fossil repo make sense if both are committing??
-    # see: https://fossil-scm.org/home/doc/trunk/www/inout.wiki for bidirectional sync info
-    proc workingdir_state {{abspath {}} args} {
-        set defaults [list\
-            -repotypes [list fossil git]\
-            -repopaths ""\
-        ]
-        #prefer fossil if first repo is dual git/fossil
-        if {$abspath in [dict keys $defaults]} {
-           set args [list $abspath {*}$args] 
-           set abspath ""
-        } 
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_repotypes [dict get $opts -repotypes]
-        set opt_repopaths [dict get $opts -repopaths]
-        if {"$opt_repopaths" ne ""} {
-            if {([llength $opt_repopaths] % 2 != 0) || ![dict exists $opt_repopaths closest]} {
-                error "workingdir_state error: -repopaths argument invalid. Expected a dict as retrieved using punk::repo::find_repos"
-            }
-            set repopaths $opt_repopaths
-        } else {
-            set repopaths [find_repos $abspath]
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-
-        if {$abspath eq ""} {set abspath [pwd]}
-        if {[file pathtype $abspath] ne "absolute"} {
-            error "workingdir_state error: absolute path required. Got '$abspath'"
-        }
-        if {![file isdirectory $abspath]} {
-            #shouldn't be passed a file.. but just use containing folder if we were
-            set abspath [file dirname $abspath]
-        }
-        set repodir [dict get $repopaths closest]
-        set ondisk_repotypes [dict get $repopaths closest_types]
-        set repotypes_to_query [list]
-        foreach r $opt_repotypes {
-            if {$r in $ondisk_repotypes} {
-                lappend repotypes_to_query $r              
-            }
-        }
-
-        if {$repodir eq ""} {
-            error "workingdir_state error: No repository found at or above path '$abspath'" 
-        }
-        set subpath [punk::path::relative $repodir $abspath]
-        if {$subpath eq "."} {
-            set subpath ""
-        }
-
-        set resultdict [dict create repodir $repodir subpath $subpath]
-        #set defaults in case no supported repotype found
-        set revision ""
-        set revision_iso8601 ""
-        set pathdict [dict create]
-
-        if {![llength $repotypes_to_query]} {
-            error "No tracking information available for project at $repodir with the chosen repotypes '$opt_repotypes'. Ensure project workingdir is a fossil (or git) checkout"
-        }
-        foreach rt $repotypes_to_query {
-            #We need entire list of files in the revision because there is no easy way to get the list of files configured to be ignored 
-            #(aside from attempting to calculate from .fossil-settings ignore-glob or .gitignore)
-            #This means we can't just use fossil extras or the list of git untracked files 
-            #i.e a file not showing as EDITED/MISSING/EXTRA can't be assumed to be in the revision as it may match an ignore-glob or .gitignore entry
-            #For this reason we will store 'unchanged' records for both git and fossil so that the combined dict should represent all files in the revision
-            if {$rt eq "fossil"} {
-                dict set resultdict repotype fossil
-                set fossil_cmd [auto_execok fossil]
-                if {$fossil_cmd eq ""} {
-                    error "workingdir_state error: fossil executable doesn't seem to be available"
-                }
-                if {[catch {punk::mix::util::do_in_path $repodir [list exec {*}$fossil_cmd status --all --differ --merge $abspath]} fossilstate]} {
-                    error "workingdir_state error: Unable to retrieve workingdir state using fossil. Errormsg: $fossilstate"
-                }
-                # line: checkout: fb971... Y-m-d H:M:S TZ
-                set checkout_info [lindex [grep {checkout:*} $fossilstate] 0] ;#grep returns a list - but it should always be a single match in this case
-                set revision [lindex $checkout_info 0 1]
-                #set checkrevision [fossil_revision $abspath]
-                lassign $checkout_info _key revision revision_ymd revision_hms revision_tz
-                if {$revision_tz eq "UTC"} {
-                    set revision_tz "+0000" ;#normalize UTC for consistency with git tz output - review - should do date-math if necessary on git and fossil to bring all to +0000 (is fossil always UTC? git )
-                }
-                set revision_iso8601 "${revision_ymd}T${revision_hms}${revision_tz}"
-
-
-                dict set resultdict ahead ""
-                dict set resultdict behind ""
-
-                foreach ln [split $fossilstate \n] {
-                    if {[string trim $ln] eq ""} {continue}
-                    set space1 [string first " " $ln]
-                    if {$space1 > 1} {
-                       set word1 [string range $ln 0 $space1-1] 
-                       if {[string index $word1 end] eq ":"} {
-                           #we've already examined any xxx: header lines we're interested in.
-                           continue
-                       }
-                    }
-                    if {[string match "EDITED *" $ln]} {
-                        set path [string trim [string range $ln [string length "EDITED "] end]] ;#should handle spaced paths
-                        dict set pathdict $path "changed"
-                    } elseif {[string match "ADDED *" $ln]} {
-                        set path [string trim [string range $ln [string length "ADDED "] end]]
-                        dict set pathdict $path "new"
-                    } elseif {[string match "DELETED *" $ln]} {
-                        set path [string trim [string range $ln [string length "DELETED "] end]]
-                        dict set pathdict $path "missing"
-                    } elseif {[string match "MISSING *" $ln]} {
-                        set path [string trim [string range $ln [string length "MISSING "] end]]
-                        dict set pathdict $path "missing"
-                    } elseif {[string match "EXTRA *" $ln]} {
-                        #fossil will explicitly list files in a new folder - as opposed to git which shows just the folder
-                        set path [string trim [string range $ln [string length "EXTRA "] end]]
-                        dict set pathdict $path "extra"
-                    } elseif {[string match "UNCHANGED *" $ln]} {
-                        set path [string trim [string range $ln [string length "UNCHANGED "] end]]
-                        dict set pathdict $path "unchanged"
-                    } else {
-                        #emit for now 
-                        puts stderr "unprocessed fossilstate line: $ln" 
-                    }
-                    #other entries??
-                }
-                break
-            } elseif {$rt eq "git"} {
-                dict set resultdict repotype git 
-                set git_cmd [auto_execok git]
-                # -uno =  suppress ? lines.
-                # -b = show ranch and tracking info
-                if {[catch {punk::mix::util::do_in_path $repodir [list exec {*}$git_cmd status --porcelain=2 -b -- $abspath]} gitstate]} {
-                    error "workingdir_state error: Unable to retrieve workingdir state using git. Errormsg: $gitstate"
-                }
-                # line: # branch.oid f2d2a...
-                set revision [lindex [grep {# branch.oid *} $gitstate] 0 2]
-                if {$revision eq "(initial)"} {
-                    puts stderr "workingdir_state: git revision is (initial) - no file state to gather"
-                    break
-                }
-
-                # -- --- --- --- --- 
-                #could use %ci for ISO8601 data - see git-show manpage, but this will be in timezone of developer's machine - we need it in UTC for comparison to fossil outputs and other devs
-                set had_TZ 0
-                if {[info exists ::env(TZ)]} {
-                    set TZ_prev $::env(TZ)
-                    set had_TZ 1
-                }
-                set ::env(TZ) "UTC0"
-                if {[catch {punk::mix::util::do_in_path $repodir [list exec {*}$git_cmd show -s --date=format-local:%Y:%m:%dT%H:%M:%S+0000 --format=format:%cd -- $abspath]} revision_iso8601]} {
-                    puts stderr "workingdir_state warning: Unable to retrieve workingdir state using git. Errormsg: $gitstate"
-                }
-                if {$had_TZ} {
-                    set ::env(TZ) $TZ_prev
-                } else {
-                    unset ::env(TZ)
-                }
-                # -- --- --- --- --- 
-
-                dict set resultdict ahead ""
-                dict set resultdict behind ""
-                set aheadbehind [lindex [grep {# branch.ab *} $gitstate] 0]
-                if {[llength $aheadbehind] > 0} {
-                    lassign [lrange $aheadbehind 2 3] a b
-                    if {$a > 0} {
-                        dict set resultdict ahead [expr {abs($a)}]
-                    }
-                    if {$b < 0} {
-                        dict set resultdict behind [expr {abs($b)}]
-                    }
-                }
-                #set checkrevision [git_revision $abspath]
-                if {[catch {punk::mix::util::do_in_path $repodir [list exec {*}$git_cmd ls-tree -r $revision $abspath]} gitfiles]} {
-                    error "workingdir_state error: Unable to retrieve files for revision '$revision' using git. Errormsg: $gitfiles"
-                }
-
-                #paths will be relative to $repodir/$subpath
-                foreach ln [split $gitfiles \n] {
-                    if {[string trim $ln] eq ""} {continue}
-                    #review - spaced paths?
-                    set path [lindex $ln end] 
-                    dict set pathdict $path "unchanged" ;#default only - to be overridden with info from gitstate
-                }
-
-                foreach ln [split $gitstate \n] {
-                    if {[string trim $ln] eq ""} {continue}
-                    if {[string match "#*" $ln]} {continue}
-                    if {[string match "1 *" $ln]} {
-                        # ordinary changed entries
-                        # format:  1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>
-                        #review - what does git do for spaced paths? 
-                        #for now we will risk treating as a list
-                        set path [lindex $ln end]
-                        set xy [lindex $ln 1]
-                        lassign [split $xy ""] staged unstaged
-                        if {[string match "*M*" $xy]} { 
-                            #e.g .M when unstaged M. when staged
-                            dict set pathdict $path "changed"
-                        } elseif {[string match "*D*" $xy]} {
-                            dict set pathdict $path "missing"
-                        } elseif {[string match "*A*" $xy]} {
-                            #e.g A. for new file that has been staged
-                            dict set pathdict $path "new"
-                        } else {
-                            dict set pathdict $path "UNKNOWN" ;#review - fix
-                        }
-                    } elseif {[string match "? *" $ln]} {
-                        #note that git will list a folder entry without going deeper to list contents
-                        set path [string trim [string range $ln [string length "? "] end]] ;#should handle spaced paths
-                        dict set pathdict $path "extra"
-                    } elseif {[string match "2 *" $ln]} {
-                        # renamed or copied entries
-                        # as we don't supply -z option - <sep> is tab char.
-                        # format: 2 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <X><score> <path><sep><origPath>
-                        #we should mark target of rename as 'new' - consistent with fossil - and stops caller from seeing no entry for an existent file and assuming it already belongs to the revision checkout
-                        lassign [split $ln \t] pretab posttab
-                        set path [lindex $pretab end]
-                        dict set pathdict $path "new" ;#review - if file was first deleted then renamed - is it more appropriately flagged as 'changed' - possibly doesn't matter for revision-membership detection new or changed should be ok
-
-                        set pathorig [string trim $posttab]
-                        dict set pathdict $pathorig "missing"
-                    } elseif {[string match "u *" $ln]} {
-                        #Unmerged entries
-                        # format: u <XY> <sub> <m1> <m2> <m3> <mW> <h1> <h2> <h3> <path>
-                        #
-                        #presume file on disk not as per revision - treat as changed (?review)
-                        set path [lindex $ln end]
-                        dict set pathdict $path "changed"
-                    } elseif {[string match "! *" $ln]} {
-                        #ignored files - not part of revision
-
-                    } else {
-                        #emit for now
-                        puts stderr "unprocessed gitstat line $ln"
-                    }
-                }
-                break
-            } else {
-                puts stderr "workingdir_state - repotype $rt not supported"
-            }
-        }
-        dict set resultdict revision $revision
-        dict set resultdict revision_iso8601 $revision_iso8601
-        dict set resultdict paths $pathdict
-        return $resultdict
-    }
-    proc workingdir_state_summary {repostate args} {
-        if {![dict exists $repostate repotype] || ![dict exists $repostate paths]} {
-            error "workingdir_state_summary error repostate doesn't appear to be a repostate dict. (use workingdir_state <path> to create)"
-        }
-        package require overtype
-        set defaults [dict create\
-            -fields {ahead behind unchanged changed new missing extra}\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- ---
-        set opt_fields [dict get $opts -fields]
-        # -- --- --- --- --- --- --- --- --- ---
-
-        set summary_dict [workingdir_state_summary_dict $repostate]
-        set repotype [dict get $summary_dict repotype]
-        set fieldnames [dict create\
-            repodir     repodir\
-            subpath     subpath\
-            revision    revision\
-            revision_iso8601    revision_iso8601\
-            ahead       ahead\
-            behind      behind\
-            repotype    repotype\
-            unchanged   unchanged\
-            changed     changed\
-            new         new\
-            missing     missing\
-            extra       extra\ 
-        ]
-        foreach f $opt_fields {
-            if {$f ni [dict keys $fieldnames]} {
-                error "workingdir_state_summary error: unknown field $f. known-values: [dict keys $fieldnames]"
-            }
-        }
-        if {$repotype eq "git"} {
-           dict set fieldnames extra "extra (files/folders)" 
-        }
-        set col1_fields [list]
-        set col2_values [list]
-        foreach f $opt_fields {
-            lappend col1_fields [dict get $fieldnames $f]
-            lappend col2_values [dict get $summary_dict $f]
-        }
-        set title1 ""
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1_fields] {string length $v}]]
-        set col1 [string repeat " " $widest1]
-        set title2 ""
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2_values] {string length $v}]]
-        set col2 [string repeat " " $widest2]
-
-        set result ""
-        foreach f $col1_fields v $col2_values {
-            append result "[overtype::left $col1 $f]: [overtype::right $col2 $v]" \n
-        }
-        set result [string trimright $result \n]
-        return $result
-    }
-    proc workingdir_state_summary_dict {repostate} {
-        if {![dict exists $repostate repotype] || ![dict exists $repostate paths]} {
-            error "workingdir_state_summary_dict error repostate doesn't appear to be a repostate dict. (use workingdir_state <path> to create)"
-        }
-        set filestates [dict values [dict get $repostate paths]]
-        set path_count_fields [list unchanged changed new missing extra]
-        set state_fields [list ahead behind repodir subpath repotype revision revision_iso8601]
-        set dresult [dict create]
-        foreach f $state_fields {
-           dict set dresult $f [dict get $repostate $f]
-        }
-        foreach f $path_count_fields {
-            dict set dresult $f [llength [lsearch -all $filestates $f]]
-        }
-        return $dresult
-    }
-    #determine nature of possibly-nested repositories (of various types) at and above this path
-    #Treat an untracked 'candidate' folder as a sort of repository
-    proc find_repos {path} {
-        set start_dir $path
-
-        #root is a 'project' if it it meets the candidate requrements and is under repo control
-        #therefore if project is in the closest_types list - candidate will always be there too - and at least one of git or fossil
-        #ie 'project' is a derived repo-type
-        set root_dict [list closest {} closest_types {} fossil {} git {} candidate {} project {} warnings {}]
-        set msg ""
-
-        #we're only searching in a straight path up the tree looking for a few specific marker files/folder
-        set fos_search_from $start_dir
-        set fossils_bottom_to_top [list]
-        while {[string length [set fosroot                  [punk::repo::find_fossil $fos_search_from]]]} {
-            lappend fossils_bottom_to_top $fosroot
-            set fos_search_from [file dirname $fosroot]
-        }
-        dict set root_dict fossil    $fossils_bottom_to_top
-
-        set git_search_from $start_dir
-        set gits_bottom_to_top [list]
-        while {[string length [set gitroot                  [punk::repo::find_git $git_search_from]]]} {
-            lappend gits_bottom_to_top $gitroot
-            set git_search_from [file dirname $gitroot]
-        }
-        dict set root_dict git       $gits_bottom_to_top
-
-        set cand_search_from $start_dir
-        set candidates_bottom_to_top [list]
-        while {[string length [set candroot                 [punk::repo::find_candidate $cand_search_from]]]} {
-            lappend candidates_bottom_to_top $candroot
-            set cand_search_from [file dirname $candroot]
-        }
-        dict set root_dict candidate $candidates_bottom_to_top
-
-
-        set projects_bottom_to_top [list]
-        set pathinfo [list] ;#list of {path plen} elements - for sorting on plen
-        set path_dict [dict create] ;#key on path - store repo-types as list
-        foreach repotype [list fossil git candidate] {
-            set repos [dict get $root_dict $repotype]
-            if {[llength $repos]} {
-                foreach p $repos {
-                    if {![dict exists $path_dict $p]} {
-                        dict set path_dict $p $repotype
-                    } else {
-                        if {$repotype eq "candidate"} {
-                            #path exists so this path is tracked and a candidate - therefore a punk 'project'
-                            dict lappend path_dict $p "candidate" "project"
-                            lappend projects_bottom_to_top $p
-                        } else {
-                            dict lappend path_dict $p $repotype
-                        }
-                    }
-                    set plen [llength [file split $p]]
-                }
-            }
-        }
-        dict set root_dict project $projects_bottom_to_top
-
-        dict for {path repotypes} $path_dict {
-            lappend pathinfo [list $repotypes $path [llength [file split $path]]]
-        }
-        #these root are all inline towards root of drive - so anything of same length should be same path - shorter path must be above another
-        #we will check equal depth paths are equal strings and raise an error just in case there are problems with the coding for the various path functions used here
-        #longest path is 'closest' to start_dir
-        set longest_first [lsort -decreasing -index 2 $pathinfo]
-        set repos [list]
-        foreach pinfo $longest_first {
-            lassign $pinfo types p len
-            lappend repos [list $p $types]
-        }
-        dict set root_dict repos $repos
-
-        set is_fossil_and_project 0; #fossil repo *and* candidate
-        foreach fos [dict get $root_dict fossil] {
-            if {$fos in [dict get $root_dict candidate]} {
-                set is_fossil_and_project 1
-                break
-            }
-        }
-        if {(!$is_fossil_and_project)} {
-            append msg "Not a punk fossil project" \n
-        }
-
-        if {![llength $longest_first]} {
-            #no repos or candidate
-            append msg "No fossil or git tracking found - No candidate project root found" \n
-        } else {
-            dict set root_dict closest [lindex $longest_first 0 1] ;#the *path* of the closest to start_dir
-            dict set root_dict closest_types [lindex $longest_first 0 0]
-        }
-        
-
-        set closest_fossil [lindex [dict get $root_dict fossil] 0]
-        set closest_fossil_len [llength [file split $closest_fossil]]
-        set closest_git [lindex [dict get $root_dict git] 0]
-        set closest_git_len [llength [file split $closest_git]]
-        set closest_candidate [lindex [dict get $root_dict candidate] 0]
-        set closest_candidate_len [llength [file split $closest_candidate]]
-
-        if {$closest_candidate_len > $closest_fossil_len && $closest_candidate_len > $closest_git_len} {
-                #only warn if this candidate is *within* a found repo root
-                append msg "**" \n
-                append msg "** found folder with /src at or above starting folder - that is below a fossil and/or git repo" \n
-                append msg "** starting folder : $start_dir" \n
-                append msg "** untracked       : $candroot" \n
-                if {$closest_fossil_len} {
-                    append msg "** fossil root     : $closest_fossil    ([punk::path::relative $start_dir $closest_fossil])" \n
-                }
-                if {$closest_git_len} {
-                    append msg "** git root        : $closest_git    ([punk::path::relative $start_dir $closest_git])" \n
-                }
-                append msg "**" \n
-        }
-
-
-        #don't warn if not git - unless also not fossil
-        if {(![llength [dict get $root_dict fossil]]) && (![llength [dict get $root_dict git]])} {
-            append msg "No repository located at or above starting folder $start_dir" \n
-            if {![llength [dict get $root_dict candidate]]} {
-                append msg "No candidate project root found. " \n
-                append msg "Searched upwards from '$start_dir' expecting a folder with the following requirements: " \n
-                append msg [punk::repo::is_candidate_root_requirements_msg] \n
-            } else {
-                append msg "Candidate project root found at : $closest_candidate" \n
-                append msg " - consider putting this folder under fossil control (and/or git)" \n
-            }
-        }
-
-        set nestinfo [list]
-        if {[llength $longest_first] > 1} {
-            foreach pinfo $longest_first {
-                lassign $pinfo types p len
-                lappend nestinfo [list $p [join $types -]]
-            }
-        }
-        if {[string length $nestinfo]} {
-            set rnestinfo [lreverse $nestinfo]
-            set col1items [lsearch -all -inline -index 0 -subindices $rnestinfo *]
-            set col2items [lsearch -all -inline -index 1 -subindices $rnestinfo *]
-
-            package require overtype
-            set title1 "Path"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {punk::strlen $v}]]
-            set col1 [string repeat " " $widest1]
-            set title2 "Repo-type(s)"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
-            set col2 [string repeat " " $widest2]
-            set tablewidth [expr {$widest1 + 1 + $widest2}]
-
-            append msg [string repeat "=" $tablewidth] \n
-            append msg "Found nested repository structure" \n
-            append msg "[overtype::left $col1 $title1] [overtype::left $col2 $title2]" \n
-
-            append msg "[string repeat - $widest1] [string repeat - $widest2]" \n
-
-            foreach p $col1items tp $col2items {
-                append msg "[overtype::left $col1 $p] [overtype::left $col2 $tp]" \n
-            }
-            append msg [string repeat "=" $tablewidth] \n
-        }
-
-        dict set root_dict warnings $msg
-
-        return $root_dict
-    }
-    proc fossil_get_repository_file {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        set fossilcmd [auto_execok fossil]
-        if {[llength $fossilcmd]} {
-            do_in_path $path {
-                set fossilinfo [::exec {*}$fossilcmd info]
-            }
-            set matching_lines [punk::repo::grep {repository:*} $fossilinfo]
-            if {![llength $matching_lines]} {
-                return ""
-            }
-            set trimmedline [string trim [lindex $matching_lines 0]]
-            set firstcolon [string first : $trimmedline]
-            set repofile_path [string trim [string range $trimmedline $firstcolon+1 end]]
-            if {![file exists $repofile_path]} {
-                puts stderr "Repository file pointed to by fossil configdb doesn't exist: $repofile_path"
-                return ""
-            }
-            return $repofile_path
-        } else {
-            puts stderr "fossil_get_repository_file: fossil command unavailable"
-            return "" 
-        }
-    }
-    proc fossil_get_repository_folder_for_project {projectname args} {
-
-        set defaults [list -parentfolder \uFFFF -extrachoice \uFFFF] 
-        set opts            [dict merge $defaults $args]
-
-        set opt_parentfolder [dict get $opts -parentfolder]
-        if {$opt_parentfolder eq "\uFFFF"} {
-            set opt_parentfolder [pwd]
-        }
-        set opt_extrachoice [dict get $opts -extrachoice]
-        set extrachoice ""
-        if {$opt_extrachoice ne "\uFFFF"} {
-            set extrachoice $opt_extrachoice
-        }
-
-        set startdir $opt_parentfolder
-
-        set fossil_prog [auto_execok fossil]
-        if {$fossil_prog eq ""} {
-            puts stderr "Fossil not found. Please install fossil"
-            return
-        }
-
-        set fossilinfo [exec {*}$fossil_prog info] ;#will give us the necessary config-db info whether in a project folder or not
-        set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
-        if {[llength $matching_lines] != 1} {
-            puts stderr "Unable to find config-db info from fossil. Check your fossil installation."
-            puts stderr "Fossil output was:"
-            puts stderr "-------------"
-            puts stderr "$fossilinfo"
-            puts stderr "-------------"
-            puts stderr "config-db info:"
-            puts stderr "$matching_lines"
-            return
-        }
-        set trimmedline [string trim [lindex $matching_lines 0]]
-        set firstcolon [string first : $trimmedline]
-        set config_db_path [string trim [string range $trimmedline $firstcolon+1 end]]
-        if {![file exists $config_db_path]} {
-            puts stderr "Unable to verify fossil global configuration info at path: $config_db_path"
-            return
-        }
-        set config_db_folder [file dirname $config_db_path]
-
-        #NOTE: we could use fossil all info to detect all locations of .fossil files - but there may be many that are specific to projects if the user wasn't in the habit of using a default location
-        #Whilst it might detect a central repo folder in a non-standard location - it might also be annoying.
-        #Todo - a separate environment variable for users to declare one or more locations where they would like to store project .fossil repositories?
-
-        set candidate_repo_folder_locations [list] 
-        #- choose a sensible default based on where fossil put the global config dir - or on the existence of a .fossils folder in a 'standard' location
-        #verify with user before creating a .fossils folder
-        #always check env(FOSSIL_HOME) first - but this is designed to locate the global .fossil (or _fossil) file - .fossils repository folder doesn't have to be at the same location
-        set usable_repo_folder_locations [list]
-        #If we find one, but it's not writable - add it to another list 
-        set readonly_repo_folder_locations [list]
-
-        #Examine a few possible locations for .fossils folder set 
-        #if containing folder is writable add to candidate list
-        set testpaths [list]
-
-        if {[info exists ::env(FOSSIL_HOME)]} {
-            set fossilhome_raw [string trim $::env(FOSSIL_HOME)]
-            if {![catch {package require Tcl 8.7-}]} {
-                set fossilhome [file normalize [file tildeexpand $fossilhome_raw]]
-            } else {
-                #8.6 
-                set fossilhome [file normalize $fossilhome_raw] 
-            }
-
-            lappend testpaths [file join $fossilhome .fossils]
-        }
-
-        if {[info exists ::env(HOME)]} {
-            set homedir $::env(HOME) ;#use capital for cross-platform
-            set tp [file join $homedir .fossils]
-            if {$tp ni $testpaths} {
-                lappend testpaths $tp
-            }
-        }
-        set tp  [file join $config_db_folder .fossils]
-        if {$tp ni $testpaths} {
-            lappend testpaths $tp
-        }
-        #test our current startdir too in case the user likes to keep their fossils closer to the projects
-        set tp [file join $startdir .fossils]
-        if {$tp ni $testpaths} {
-            lappend testpaths $tp
-        }
-        if {[string length $extrachoice]} {
-            set tp $extrachoice
-            if {$tp ni $testpaths} {
-                lappend testpaths $tp
-            }
-        }
-
-
-        foreach testrepodir $testpaths {
-            if {[file isdirectory $testrepodir]} {
-                if {[file writable $testrepodir]} {
-                    lappend usable_repo_folder_locations $testrepodir
-                } else {
-                    lappend readonly_repo_folder_locations $testrepodir
-                }
-            } else {
-                set repo_parent [file dirname $testrepodir]
-                if {[file writable $repo_parent]} {
-                    lappend candidate_repo_folder_locations $testrepodir
-                }
-            }
-        }
-      
-        set startdir_fossils [glob -nocomplain -dir $startdir -type f *.fossil]
-        if {[llength $startdir_fossils]} {
-            #user is already keeping .fossil files directly in curent dir - give them the option to easily keep doing this
-            #(we don't add it if no .fossil files there already - as it is probably a niche requirement - or a sign the user hasn't thought about a better/central location)
-            if {$startdir ni $usable_repo_folder_locations} {
-                lappend usable_repo_folder_locations $startdir 
-            }
-        }
-        set choice_folders [list]
-        set i 1
-        foreach fld $usable_repo_folder_locations {
-            set existing_fossils [glob -nocomplain -dir $fld -type f -tails *.fossil]
-            if {[set ecount [llength $existing_fossils]]} {
-                if {$ecount ==1} {set s ""} else {set s "s"}
-                set existingfossils "( $ecount existing .fossil$s )"
-            } else {
-                set existingfossils "( no existing .fossil files found )"
-            }
-            if {"$projectname.fossil" in $existing_fossils} {
-                set conflict "CONFLICT - $projectname.fossil already exists in this folder"
-            } else {
-                set conflict ""
-            }
-            lappend choice_folders [list index $i folder $fld folderexists 1 existingfossils $existingfossils conflict $conflict]
-            incr i
-        }
-
-        if {![llength $choice_folders]} {
-            #no existing writable .fossil folders (and no existing .fossil files in startdir)
-            #offer the (writable) candidate_repo_folder_locations
-            foreach fld $candidate_repo_folder_locations {
-                lappend choice_folders [list index $i folder $fld folderexists 0 existingfossils "" conflict ""] 
-                incr i
-            }
-        }
-
-        set menu_message ""
-        if {[llength $choice_folders]} {
-            append menu_message "Select the number of the folder to use to store the .fossil repository file" \n
-        } else {
-            append menu_message "--- NO suitable writable folders or locations found for .fossil file. Consider setting FOSSIL_HOME environment variable and check that folders are writable.--" \n
-        }
-
-        set conflicted_options [list]
-        foreach option $choice_folders {
-            set i [dict get $option index] ;# 1-based
-            set fld [dict get $option folder]
-            set existingfossils [dict get $option existingfossils]
-            set conflict [dict get $option conflict]
-            if {[string length $conflict]} {
-                lappend conflicted_options $i ;#1+
-            }
-            set folderexists [dict get $option folderexists]
-            if {$folderexists} {
-                set folderstatus "(existing folder)" 
-            } else {
-                set folderstatus "(CREATE folder for .fossil repository files)"
-            }
-            append menu_message "$i  $folderstatus $fld $existingfossils $conflict" \n
-        }
-
-
-        #append the readonly_repo_folder_locations so that user is aware of them as it may affect their choice 
-        if {[llength $readonly_repo_folder_locations]} {
-            append menu_message "--------------------------------------------------" \n
-            foreach readonly $readonly_repo_folder_locations {
-                append menu_message "<unavailable not writable> $readonly" \n
-            }
-            append menu_message "--------------------------------------------------" \n
-        }
-
-        #see if we can reasonably use the only available option and not bug the user
-        #Todo - option to always prompt?
-        #we will not auto-select if there is even one conflicted_option - as that seems like something you should know about
-        if {![llength $conflicted_options] && ([llength $choice_folders] == 1)} {
-            set repo_folder_choice [lindex $choice_folders 0]
-            set repository_folder [dict get $repo_folder_choice folder]
-        } else {
-            if {[llength $choice_folders]} {
-                puts stdout $menu_message
-                set max [llength $choice_folders] 
-                if {$max == 1} {
-                    set rangemsg "the number 1"
-                } else {
-                    set rangemsg "a number from 1 to $max" 
-                }
-                set answer [askuser "Enter $rangemsg to select location. (or N to abort)"]
-                if {![string is integer -strict $answer]} {
-                    puts stderr "Aborting"
-                    return
-                }
-
-                set index [expr {int($answer) -1}]
-                if {$index >= 0 && $index <= $max-1} {
-                    set repo_folder_choice [lindex $choice_folders $index]
-                    set repository_folder [dict get $repo_folder_choice folder]
-                    puts stdout "Selected fossil location $repository_folder" 
-                } else {
-                    puts stderr " No menu number matched - aborting."
-                    return
-                }
-            } else {
-                puts stdout $menu_message
-                set answer [askuser "Hit enter to exit"]
-                return
-            }
-        }
-        return $repository_folder
-    }
-
-    #------------------------------------
-    #limit to exec so full punk shell not required in scripts
-    proc git_revision {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        # ::kettle::path::revision.git
-        do_in_path $path {
-        try {
-            #git describe will error with 'No names found' if repo has no tags
-            #set v [::exec {*}[auto_execok git] describe]
-            set v [::exec {*}[auto_execok git] rev-parse HEAD] ;# consider 'git rev-parse --short HEAD'
-        } on error {e o} {
-            set v [lindex [split [dict get $o -errorinfo] \n] 0]
-        }
-        }
-        return [string trim $v]
-    }
-    proc git_remote {{path {{}}}} {
-        if {$path eq {}} { set path [pwd] }
-        do_in_path $path {
-        try {
-            #git describe will error with 'No names found' if repo has no tags
-            #set v [::exec {*}[auto_execok git] describe]
-            set v [::exec {*}[auto_execok git] -remote -v] ;# consider 'git rev-parse --short HEAD'
-        } on error {e o} {
-            set v [lindex [split [dict get $o -errorinfo] \n] 0]
-        }
-        }
-        return [string trim $v]
-    }
-
-    proc fossil_revision {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        # ::kettle::path::revision.fossil 
-        set fossilcmd [auto_execok fossil]
-        if {[llength $fossilcmd]} {
-            do_in_path $path {
-                set info [::exec {*}$fossilcmd info]
-            }
-            return [lindex [grep {checkout:*} $info] 0 1]
-        } else {
-            return Unknown
-        }
-    }
-
-    proc fossil_remote {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        # ::kettle::path::revision.fossil 
-        set fossilcmd [auto_execok fossil]
-        if {[llength $fossilcmd]} {
-            do_in_path $path {
-                set info [::exec {*}$fossilcmd remote ls]
-            }
-            return [string trim $info]
-        } else {
-            return Unknown
-        }
-    }
-    #------------------------------------
-    
-    #temporarily cd to workpath to run script - return to correct path even on failure
-    proc do_in_path {path script} {
-        #from ::kettle::path::in
-        set here [pwd]
-        try {
-            cd $path
-            uplevel 1 $script
-        } finally {
-            cd $here
-        }
-    }
-    proc scanup {path cmd} {
-        if {$path eq {}} { set path [pwd] }
-        #based on kettle::path::scanup
-        if {[file pathtype $path] eq "relative"} {
-            set path [file normalize $path]
-        }
-        while {1} {
-            # Found the proper directory, per the predicate.
-            if {[{*}$cmd $path]} { return $path }
-
-            # Not found, walk to parent
-            set new [file dirname $path]
-
-            # Stop when reaching the root.
-            if {$new eq $path} { return {} }
-            if {$new eq {}} { return {} }
-
-            # Ok, truly walk up.
-            set path $new
-        }
-        return {}
-    }
-    #get content part of content/zip delimited by special \x1a (ctrl-z) char as used in tarjr and kettle::path::c/z
-    proc c/z {content} {
-        return [lindex [split $content \x1A] 0]
-    }
-    proc grep {pattern data} {
-        set data [string map [list \r\n \n] $data]
-        return [lsearch -all -inline -glob [split $data \n] $pattern]
-    }
-
-    proc rgrep {pattern data} {
-        set data [string map [list \r\n \n] $data]
-        return [lsearch -all -inline -regexp [split $data \n] $pattern]
-    }
-
-
-    #todo - review
-    proc ensure-cleanup {path} {
-        #::atexit [lambda {path} {
-        #file delete -force $path
-        #} [norm $path]]
-
-        file delete -force $path
-    }
-
-
-    #whether path is at and/or below one of the vfs mount points
-    #The design should facilitate nested vfs mountpoints
-    proc path_vfs_info {filepath} {
-        error "unimplmented"
-    }
-
-    #file normalize is expensive so this is too
-    proc norm {path {platform env}} {
-        #kettle::path::norm
-        #see also wiki
-        #full path normalization
-
-        set platform [string tolower $platform]
-        if {$platform eq "env"} {
-            set platform $::tcl_platform(platform)
-        }
-
-        #No - don't do this sort of path translation here - leave as option for specific utils only such as ./ 
-        #Windows volume-relative syntax with specific volume specified is somewhat broken in Tcl - but leading slash volume-relative does work 
-        #We shouldn't break it totally just because accessing WSL/mingw paths is slightly more useful
-        #if {$platform eq "windows"} {
-            #return [file dirname [file normalize [punk::unixywindows::towinpath $path]/__]]
-        #}
-
-        return [file dirname [file normalize $path/__]]
-    }
-
-    #This taken from kettle::path::strip
-    #It doesn't compare the prefix contents presumably for speed when used in kettle::path::scan
-    #renamed to better indicate its behaviour
-    
-    proc path_strip_prefixdepth {path prefix} {
-        if {$prefix eq ""} {
-            return [norm $path]
-        }
-        return [file join \
-            {*}[lrange \
-                [file split [norm $path]] \
-                [llength [file split [norm $prefix]]] \
-                end]]
-    }
-
-    #Must accept empty prefix - which is effectively noop.
-    #MUCH faster version for absolute path prefix (pre-normalized)
-    proc path_strip_alreadynormalized_prefixdepth {path prefix} {
-        if {$prefix eq ""} {
-            return $path
-        }
-        return [file join \
-            {*}[lrange \
-                [file split $path] \
-                [llength [file split $prefix]] \
-                end]]
-    }
-    #fs agnostic - so file normalize must be done by caller
-    proc strip_if_prefix {prefix path args} {
-        set known_opts [list -nocase]
-        set opts [list]
-        foreach a $args {
-            lappend opts [tcl::prefix match -message "option" $known_opts $a]
-        }
-        if {"-nocase" in $opts} {
-            set lp [tcl::prefix longest [string tolower $path] [string tolower $prefix]]
-        } else {
-            set lp [tcl::prefix longest $path $prefix]
-        }
-        #return in original casing whether or not -nocase specified. -nocase only applies to the comparison
-        if {![llength $lp]} {
-            return $path
-        } else {
-            return  [string range $path [string length $prefix] end]
-        }
-    }
-
-
-    interp alias {} is_fossil   {} ::punk::repo::is_fossil
-    interp alias {} is_fossil_root   {} ::punk::repo::is_fossil_root
-    interp alias {} find_fossil   {} ::punk::repo::find_fossil
-    interp alias {} fossil_revision   {} ::punk::repo::fossil_revision
-    interp alias {} is_git      {} ::punk::repo::is_git
-    interp alias {} is_git_root      {} ::punk::repo::is_git_root
-    interp alias {} find_git   {} ::punk::repo::find_git
-    interp alias {} git_revision   {} ::punk::repo::git_revision
-
-
-    interp alias {} gs {} git status -sb
-    interp alias {} gr {} ::punk::repo::git_revision
-    interp alias {} gl {} git log --oneline --decorate ;#decorate so stdout consistent with what we see on console
-    interp alias {} glast {} git log -1 HEAD --stat
-    interp alias {} gconf {} git config --global -l
-
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::repo [namespace eval punk::repo {
-    variable version
-    set version 0.1.1 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/tdl-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/tdl-0.1.0.tm
deleted file mode 100644
index 7f034c18..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/tdl-0.1.0.tm
+++ /dev/null
@@ -1,104 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::tdl 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::tdl {
-    # https://wiki.tcl-lang.org/page/Config+file+using+slave+interp
-
-    variable sample_script {
-        server -name bsd1 -os FreeBSD
-        server -name p1 -os linux
-        server -name trillion -os windows
-
-        server -name vmhost1 -os FreeBSD {
-            guest -name bsd1 -vmmanager iocage
-            guest -name p1 -vmmanager bhyve
-        }
-
-    }
-
-
-    proc prettyparse {script} {
-        set i [interp create -safe]
-        try {
-    #       $i eval {unset {*}[info vars]}
-    #       foreach command [$i eval {info commands}] {$i hide $command}
-    #       $i invokehidden namespace delete {*}[$i invokehidden namespace children]
-            $i alias unknown apply {{i tag args} {
-                upvar 1 result result
-                set e [concat [list tag $tag]\
-                            [lrange $args 0 [expr {([llength $args] & ~1) - 1}]]]
-                if {[llength $args] % 2} {
-                    set saved $result
-                    set result {}
-                    $i eval [lindex $args end]
-                    lappend e body $result
-                    set result $saved
-                }
-                lappend result $e
-                list
-            }} $i
-            set result {}
-            $i eval $script
-            return $result
-        } finally {
-            interp delete $i
-        }
-    }
-    proc prettyprint {data {level 0}} {
-        set ind [string repeat "    " $level]
-        incr level
-        set result {}
-        foreach e $data {
-            set line $ind[concat [list [dict get $e tag]] [dict remove $e tag body]]
-            if {[dict exists $e body] && [llength [dict get $e body]]} {
-                append line " {\n[prettyprint [dict get $e body] $level]\n$ind}"
-            }
-            lappend result $line
-        }
-        join $result \n
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::tdl [namespace eval punk::tdl {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/winpath-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/winpath-0.1.0.tm
deleted file mode 100644
index a21e91ef..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punk/winpath-0.1.0.tm
+++ /dev/null
@@ -1,266 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::winpath 0.1.0
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::winpath {
-    namespace export winpath windir cdwin cdwindir illegalname_fix illegalname_test
-
-
-
-
-    #\\servername\share etc  or \\?\UNC\servername\share  etc.
-    proc is_unc_path {path} {
-        set strcopy_path [punk::objclone $path]
-        set strcopy_path [string map [list \\ /] $strcopy_path] ;#normalize to forward slashes for testing purposes (and forward slashes seem to be auto-translated by windows anyway)
-        if {[string first "//" $strcopy_path] == 0} {
-            #check for "Dos device path" syntax
-            if {[string range $strcopy_path 0 3] in [list "//?/" "//./"]} {
-                #Note that //./ doesn't appear to be supported in Tcl as at 2023-08 - but //?/ works  (except for //?/UNC/Server/share)
-                if {[string range $strcopy_path 4 6] eq "UNC"} {
-                    return 1
-                } else {
-                    #some other Dos device path. Could be a drive which is mapped to a UNC path - but the path itself isn't a unc path
-                    return 0
-                }
-            } else {
-                #leading double slash and not dos device path syntax
-                return 1
-            }
-        }
-        return 0
-    }
-
-    #ordinary \\Servername   or \\servername\share or \\servername\share\path  (or forward-slash equivalent) with no dos device syntax //?/ //./ etc.
-    proc is_unc_path_plain {path} {
-        if {[is_unc_path $path]} {
-            if {![is_dos_device_path $path]} {
-                return 1
-            } else {
-                return 0
-            }
-        } else {
-            return 0
-        }
-    }
-
-    #int-rep path preserved - but 'file attributes', and therefor this operation, is expensive (on windows at least)
-    proc pwdshortname {{path {}}} {
-        if {$path eq ""} {
-           set path [pwd]
-        } else {
-            if {[file pathtype $path] eq "relative"} {
-                set path [file normalize $path]
-            }
-        }
-        return [dict get [file attributes $path] -shortname]
-    }
-    #dos device path syntax allows windows api to acces extended-length paths and filenames with illegal path characters such as trailing dots or whitespace
-    #(can exist on server shares and on NTFS - but standard apps can't access without dos device syntax)
-    proc is_dos_device_path {path} {
-        set strcopy_path [punk::objclone $path]
-        set strcopy_path [string map [list \\ /] $strcopy_path] ;#normalize to forward slashes for testing purposes (and forward slashes seem to be auto-translated by windows anyway)
-        if {[string range $strcopy_path 0 3] in [list "//?/" "//./"]} {
-            return 1
-        } else {
-            return 0
-        }
-    }
-    proc strip_dos_device_prefix {path} {
-        #it's unlikely to be valid to strip only //?/ from a //?/UNC  path so check for it here and diver to strip that.
-        #(review.. or raise error because a //?/UNC path isn't *strictly* a UNC path? )
-        if {[is_unc_path $path]} {
-            return [strip_unc_path_prefix $path]
-        }
-        if {[is_dos_device_path $path]} {
-            return [string range $path 4 end]
-        } else {
-            return $path
-        }
-    }
-    proc strip_unc_path_prefix {path} {
-        if {[is_unc_path $path]} {
-            #//?/UNC/server/etc
-            set strcopy_path [punk::objclone $path]
-            set trimmedpath [string range $strcopy_path 7 end]
-            file pathtype $trimmedpath ;#shimmer it to path rep
-            return $trimmedpath
-        } elseif {is_unc_path_plain $path} {
-            #plain unc //server
-            set strcopy_path [punk::objclone $path]
-            set trimmedpath [string range $strcopy_path 2 end]
-            file pathtype $trimmedpath
-            return $trimmedpath
-        } else {
-            return $path
-        }
-    }
-    #we don't validate that path is actually illegal because we don't know the full range of such names.
-    #The caller can apply this to any path.
-    #don't test for platform here - needs to be callable from any platform for potential passing to windows (what usecase? 8.3 name is not always calculable independently)
-    #The utility of this is questionable. prepending a dos-device path won't make a filename with illegal characters readable by windows.
-    #It will need the 'shortname' at least for the illegal segment - if not the whole path
-    #Whilst the 8.3 name algorithm - including undocumented hash function has been reverse engineered 
-    #- it depends on the content of the directory - as collisions cause a different name (e.g incremented number) 
-    #- it also depends on the history of the folder
-    #- you can't take the current dir contents and a particular *existing* longname and determine the shortname algorithmically...
-    #- the shortname may have been generated during a different directory state.
-    #- It is then stored on disk (where?) - so access to reading the existing shortname is required.
-    #- An implementation of the 8.3 algorithm would only be potentially useful in determining the name that will result from adding a new file 
-    #  and would be subject to potential collisions if there are race-conditions in file creation
-    #- Using an 8.3 algorithm externally would be dangerous in that it could appear to work a lot of the time - but return a different file entirely sometimes.
-    #- Conclusion is that the 8.3 name must be retrieved rathern than calclated
-    proc illegalname_fix {path} {
-        #don't add extra dos device path syntax protection-prefix if already done
-        if {[is_unc_path $path]} {
-            error "illegalname_fix called on UNC path $path - unable to process"
-        }
-        if {[is_dos_device_path $path]} {
-            #we may have appended 
-            return $path
-        }
-
-
-
-        #\\servername\share theoretically maps to: \\?\UNC\servername\share  in protected form. https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
-        #NOTE: 2023-08 on windows 10 at least  \\?\UNC\Server\share  doesn't work - ie we can't use illegalname_fix on UNC paths such as \\Server\share 
-        #(but mapped drive to same path will work)
-        #Note that test-path cmdlet in powershell is also flaky with regards to \\?\UNC\Server paths.
-        #It seems prudent for now to disallow \\?\ protection for UNC paths such as \\server\etc
-        if {[is_unc_path $path]} {
-            set err ""
-            append err      "illegalname_fix doesn't currently support UNC paths (non dos device leading double slash or //?/UNC/...)"
-            append err \n   " - because //?/UNC/Servername/share is not supported in Tcl (and only minimally even in powershell) as at 2023. (on windows use mapped drive instead)"
-            error $err
-        }
-
-        set strcopy_path [punk::objclone $path]
-
-
-        #Note: path could still have leading double slash if it is a Dos device path: e.g. //?/c:/etc
-        if {[file pathtype $path] eq "absolute"} {
-            if {$path eq "~"} {
-                # non-normalized ~ is classified as absolute
-                # tilde special meaning is a bit of a nuisance..  but as it's the entire path in this case.. presumably it should be kept that way
-                # leave for caller to interpret it - but it's not an illegal name whether it's interpreted with special meaning or not
-                # unlikely this fix will be called on a plain tilde anyway
-                return $path
-            } else {
-                set fullpath $path
-            }
-        } else {
-            #set fullpath [file normalize $path] ;#very slow on windows
-            #set fullpath [pwd]/$path ;#will keep ./ in middle of path - not valid for dos-device paths
-            if {[string range $strcopy_path 0 1] eq "./"} {
-                set strcopy_path [string range $strcopy_path 2 end]
-            }
-            set fullpath [file join [pwd] $strcopy_path]
-        }
-        #For file I/O, the "\\?\" prefix to a path string tells the Windows APIs to disable all string parsing
-        # and to send the string that follows it straight to the file system.
-        set protect "\\\\?\\"  ;# value is: \\?\ prefix   
-        set protect2 "//?/" ;#file normalize may do this - it still works 
-        #don't use "//./" - not currently supported in Tcl - seems to work in powershell though.
-
-
-        #choose //?/  as normalized version - since likely 'file normalize' will do it anyway, and experimentall, the windows API accepts both  REVIEW
-        set result ${protect2}$fullpath
-        file pathtype $result ;#make it return a path rep
-        return $result
-    }
-
-    #don't test for platform here - needs to be callable from any platform for potential passing to windows
-    #we can create files with windows illegal names by using //?/ dos device path syntax - but we need to detect when that is required.
-    #
-    # path int-rep preserving
-    proc illegalname_test {path} {
-        #https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
-        #according to the above: Use any character in the current code page for a name, including Unicode characters and characters in the extended character set (128–255), except for the following:
-        set reserved [list  < > : \" / \\ | ? *]
-
-
-        #we need to exclude things like path/..   path/.
-        foreach seg [file split $path] {
-            if {$seg in [list . ..]} {
-                #review - what if there is a folder or file that actually has a name such as . or .. ? 
-                #unlikely in normal use - but could done deliberately for bad reasons?
-                #We are unable to check for it here anyway - as this command is intended for checking the path string - not the actual path on a filesystem.
-                #
-                #/./  /../  segments don't require protection - keep checking.
-                continue
-            }
-
-            #only check for actual space as other whitespace seems to work without being stripped
-            #trailing tab and trailing \n or \r seem to be creatable in windows with Tcl - map to some glyph
-            if {[string index $seg end] in [list " " "."]} {
-                #windows API doesn't handle trailing dots or spaces (silently strips) - even though such files can be created on NTFS systems (or seen via samba etc)
-                return 1
-            }
-        }
-        #glob chars '* ?' are probably illegal.. but although x*y.txt and x?y.txt don't display properly (* ? replaced with some other glyph)
-        #- they seem to be readable from cmd and tclsh as is.
-        # pipe symbol also has glyph substitution and behaves the same  e.g a|b.txt
-        #(at least with encoding system utf-8)
-
-        #todo - determine what else constitutes an illegal name according to windows APIs and requires protection with dos device syntax
-        return 0
-    }
-
-    proc test_ntfs_tunneling {f1 f2 args} {
-        file mkdir $f1
-        puts stderr  "waiting 15secs..."
-        after 5000 {puts -nonewline stderr .}
-        after 5000 {puts -nonewline stderr .}
-        after 5000 {puts -nonewline stderr .}
-        after 500 {puts stderr \n}
-        file mkdir $f2
-        puts stdout "$f1   [file stat $f1]"
-        puts stdout "$f2   [file stat $f2]"
-        file delete $f1
-        puts stdout "renaming $f2 to $f1"
-        file rename $f2 $f1
-        puts stdout "$f1   [file stat $f1]"
-
-    }
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::winpath [namespace eval punk::winpath {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punkcheck-0.1.0.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/punkcheck-0.1.0.tm
deleted file mode 100644
index 4582ac50..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/punkcheck-0.1.0.tm
+++ /dev/null
@@ -1,1962 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punkcheck 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-package require punk::tdl
-package require punk::path
-package require punk::repo
-package require punk::mix::util
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# Punkcheck uses the TDL format which is a list of lists in Tcl format
-# It is intended primarily for source build/distribution tracking within a punk project or single filesystem - with relative paths.
-#
-#see following article regarding the many problems with using mtime for build-decisions:  https://apenwarr.ca/log/20181113
-#
-namespace eval punkcheck {
-        namespace export\
-            uuid\
-            start_installer_event  installfile_*
-
-        variable default_antiglob_dir_core  [list "#*" "_aside" ".git" ".fossil*"]
-        variable default_antiglob_file_core ""
-        proc uuid {} {
-            set has_twapi 0
-            if {"windows" eq $::tcl_platform(platform)} {
-                if {![catch {package require twapi}]} {
-                    set has_twapi 1
-                }
-            }
-            if {!$has_twapi} {
-                if {[catch {package require uuid} errM]} {
-                    error "Unable to load a package for uuid on this platform. Try tcllib's uuid (any platform) - twapi for windows"
-                }
-                return [uuid::uuid generate]
-            } else {
-                return [twapi::new_uuid]
-            }
-        }
-
-        proc default_antiglob_dir_core {} {
-            variable default_antiglob_dir_core
-            return $default_antiglob_dir_core
-        }
-        proc default_antiglob_file_core {} {
-            variable default_antiglob_file_core
-            if {$default_antiglob_file_core eq ""} {
-                set default_antiglob_file_core [list "*.swp" "*[punk::mix::util::magic_tm_version]*" "*-buildversion.txt" ".punkcheck"]
-            }
-            return $default_antiglob_file_core
-        }
-
-
-        proc load_records_from_file {punkcheck_file} { 
-            set record_list [list]
-            if {[file exists $punkcheck_file]} {
-                set tdlscript [punk::mix::util::fcat $punkcheck_file]
-                set record_list [punk::tdl::prettyparse $tdlscript]
-            }
-            return $record_list
-        }
-        proc save_records_to_file {recordlist punkcheck_file} {
-            set newtdl [punk::tdl::prettyprint $recordlist]
-            set linecount [llength [split $newtdl \n]]
-            #puts stdout $newtdl
-            set fd [open $punkcheck_file w]
-            fconfigure $fd -translation binary
-            puts -nonewline $fd $newtdl
-            close $fd
-            return [list recordcount [llength $recordlist] linecount $linecount]
-        }
-
-
-        #todo - work out way to use same punkcheck file for multiple installers running concurrently. Thread?
-        #an installtrack objects represents an installation path from sourceroot to targetroot 
-        #The source and target folders should be as specific as possible but it is valid to specify for example c:/ -> c:/  (or / -> /)  if source and targets within the installation operation are spread around.
-        #
-        set objname [namespace current]::installtrack
-        if {$objname ni [info commands $objname]} {
-            package require oolib
-
-            #FILEINFO record - target fileset with body records: INSTALL-RECORD,INSTALL-INPROGRESS,INSTALL-SKIPPED,DELETE-RECORD,DELETE-INPROGRESS,MODIFY-INPROGRESS,MODIFY-RECORD
-            #each FILEINFO body being a list of SOURCE records
-            oo::class create targetset {
-                variable o_targets 
-                variable o_keep_installrecords
-                variable o_keep_skipped
-                variable o_keep_inprogress
-                variable o_records
-                constructor {args} {
-                    #set o_records [oolib::collection create [namespace current]::recordcollection]
-                    set o_records [list]
-
-                }
-
-                method as_record {} {
-
-                    set fields [list\
-                        -targets $o_targets\
-                        -keep_installrecords $o_keep_installrecords\
-                        -keep_skipped $o_keep_skipped\
-                        -keep_inprogress $o_keep_inprogress\
-                        body $o_records\
-                    ]
-
-                    set record [dict create tag FILEINFO {*}$fields]
-                }
-                
-                #retrieve last completed record for the fileset ie exclude SKIPPED,INSTALL-INPROGRESS,DELETE-INPROGRESS,MODIFY-INPROGRESS
-                method get_last_record {fileset_record} {
-                    set body [dict_getwithdefault $fileset_record body [list]]
-                    set previous_records [lrange $body 0 end-1]
-                    #get last previous that is tagged INSTALL-RECORD,MODIFY-RECORD,DELETE-RECORD
-                    set revlist [lreverse $previous_records]
-                    foreach rec $revlist {
-                        if {[dict get $rec tag] in [list "INSTALL-RECORD" "MODIFY-RECORD" "DELETE-RECORD" "VIRTUAL-RECORD"]} {
-                            return $rec
-                        }
-                    }
-                    return [list]
-                }
-            }
-
-            oo::class create installevent {
-                variable o_id
-                variable o_rel_sourceroot
-                variable o_rel_targetroot
-                variable o_ts_begin
-                variable o_ts_end
-                variable o_types
-                variable o_configdict
-                variable o_targets
-                variable o_operation
-                variable o_operation_start_ts
-                variable o_fileset_record
-                variable o_installer ;#parent object
-                constructor {installer rel_sourceroot rel_targetroot args} {
-                    set o_installer $installer
-                    set o_operation_start_ts ""
-                    set o_operation ""
-                    set defaults [dict create\
-                        -id ""\
-                        -tsbegin ""\
-                        -config [list]\
-                        -tsend ""\
-                        -types [list]\
-                    ]
-                    set opts [dict merge $defaults $args]
-                    if {[dict get $opts -id] eq ""} {
-                        set o_id [punkcheck::uuid]
-                    } else {
-                        set o_id [dict get $opts -id]
-                    }
-                    if {[dict get $opts -tsbegin] eq ""} {
-                        set o_ts_begin [clock microseconds]
-                    } else {
-                        set o_ts_begin [dict get $opts -tsbegin]
-                    }
-                    set o_ts_end    [dict get $opts -tsend]
-                    set o_types     [dict get $opts -types]
-                    set o_configdict [dict get $opts -config] 
-
-                    set o_rel_sourceroot $rel_sourceroot
-                    set o_rel_targetroot $rel_targetroot
-                }                
-                destructor {
-                    #puts "[self] destructor called"
-                }
-                method as_record {} {
-                    set begin_seconds [expr {$o_ts_begin / 1000000}]
-                    set tsiso_begin [clock format $begin_seconds -format "%Y-%m-%dT%H:%M:%S"]
-                    if {$o_ts_end ne ""} {
-                        set end_seconds [expr {$o_ts_end / 1000000}]
-                        set tsiso_end [clock format $end_seconds -format "%Y-%m-%dT%H:%M:%S"]
-                    } else {
-                        set tsiso_end ""
-                    }
-                    set fields [list\
-                        -tsiso_begin $tsiso_begin\
-                        -ts_begin    $o_ts_begin\
-                        -tsiso_end   $tsiso_end\
-                        -ts_end      $o_ts_end\
-                        -id          $o_id\
-                        -source      $o_rel_sourceroot\
-                        -targets     $o_rel_targetroot\
-                        -types       $o_types\
-                        -config      $o_configdict\
-                    ]
-
-                    set record [dict create tag EVENT {*}$fields]
-                }
-                method get_id {} {
-                    return $o_id
-                }
-                method get_operation {} {
-                    return $o_operation
-                }
-                method get_targets {} {
-                    return $o_targets
-                }
-                method get_targets_exist {} {
-                    set punkcheck_folder [file dirname [$o_installer get_checkfile]]
-                    set existing [list]
-                    foreach t $o_targets {
-                        if {[file exists [file join $punkcheck_folder $t]]} {
-                            lappend existing $t
-                        }
-                    }
-                    return $existing
-                }
-                method end {} {
-                    set o_ts_end [clock microseconds]
-                }
-                method targetset_dict {} {
-                    punk::records_as_target_dict [$o_installer get_recordlist]
-                }
-
-                #related - installfile_begin
-                #call init before we know if we are going to run the operation vs skip
-                method targetset_init {operation targetset} {
-                    set known_ops [list QUERY INSTALL MODIFY DELETE VIRTUAL]
-                    if {[string toupper $operation] ni $known_ops} {
-                        error "[self] add_target unknown operation '$operation'. Known operations $known_ops"
-                    }
-                    set o_operation [string toupper $operation]
-
-                    if {$o_operation_start_ts ne ""} {
-                        error "[self] targetset_tart $o_operation operation already in progress. Use targetset_finished or targetset_complete to finish."
-                    }
-                    set o_operation_start_ts [clock microseconds]
-                    set seconds [expr {$o_operation_start_ts / 1000000}]
-                    set tsiso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-                    set punkcheck_file [$o_installer get_checkfile]
-                    set punkcheck_folder [file dirname $punkcheck_file]
-
-                    set relativepath_targetset [list]
-                    if {$o_operation eq "VIRTUAL"} {
-                        foreach p $targetset {
-                            lappend relativepath_targetset $p
-                        }
-                    } else {
-                        foreach p $targetset {
-                            if {[file pathtype $p] eq "absolute"} {
-                                lappend relativepath_targetset [punkcheck::lib::path_relative $punkcheck_folder $p]
-                            } else {
-                                lappend relativepath_targetset $p
-                            }
-                        }
-                    }
-
-
-                    set fields [list\
-                        -tsiso $tsiso\
-                        -ts $o_operation_start_ts\
-                        -installer [$o_installer get_name]\
-                        -eventid $o_id\
-                        ]
-
-                    set o_targets [lsort -dictionary -increasing $relativepath_targetset] ;#exact sort order not critical - but must be consistent
-
-                    #set targetdict [my targetset_dict]
-
-                    set record_list [punkcheck::load_records_from_file $punkcheck_file]
-                    set extractioninfo [punkcheck::recordlist::extract_or_create_fileset_record $o_targets $record_list]
-                    set o_fileset_record [dict get $extractioninfo record]
-                    set record_list [dict get $extractioninfo recordset]
-                    set isnew       [dict get $extractioninfo isnew]
-                    set oldposition [dict get $extractioninfo oldposition]
-                    unset extractioninfo
-
-                    #INSTALL-INPROGRESS will become INSTALL-RECORD or INSTALL-FAILED or INSTALL-SKIPPED upon finalisation
-                    #-installer and -eventid keys are added here
-                    set new_inprogress_record [dict create tag [string toupper $operation]-INPROGRESS {*}$fields -tempcontext [my as_record] body {}]
-                    #set existing_body [dict_getwithdefault $o_fileset_record body [list]]
-                    #todo - look for existing "-INPROGRESS" records - mark as failed or incomplete?
-                    dict lappend o_fileset_record body $new_inprogress_record
-
-                    if {$isnew} {
-                        lappend record_list $o_fileset_record
-                    } else {
-                        set record_list [linsert $record_list[unset record_list] $oldposition $o_fileset_record]
-                    }
-                    if {$o_operation ne "QUERY"} {
-                        punkcheck::save_records_to_file $record_list $punkcheck_file
-                    }
-                    return $o_fileset_record
-
-                }
-                #operation has been started
-                #todo - upgrade .punkcheck format to hold more than just list of SOURCE entries in each record.
-                # - allow arbitrary targetset_startphase <name> targetset_endphase <name> calls to store timestamps and calculate elapsed time
-                method targetset_started {} {
-                    set punkcheck_folder [file dirname [$o_installer get_checkfile]]
-                    if {$o_operation eq "QUERY"} {
-                        set fileinfo_body [dict get $o_fileset_record body] ;#body of FILEINFO record
-                        set installing_record [lindex $fileinfo_body end]
-
-                        set ts_start [dict get $installing_record -ts]
-                        set ts_now [clock microseconds] 
-                        set metadata_us [expr {$ts_now - $ts_start}]
-
-                        dict set installing_record -metadata_us $metadata_us
-                        dict set installing_record -ts_start_transfer $ts_now
-
-                        lset fileinfo_body end $installing_record
-                        
-                        return [dict set o_fileset_record body $fileinfo_body]
-                    } else {
-                        #legacy call
-                        #saves to .punkcheck file
-                        return [set o_fileset_record [punkcheck::installfile_started_install $punkcheck_folder $o_fileset_record]]
-                    }
-                }
-                method targetset_end {status args} {
-                    set defaults [dict create\
-                        -note \uFFFF\
-                    ]
-                    set known_opts [dict keys $defaults]
-                    if {[llength $args] % 2 != 0} {
-                        error "targetset_end arguments after status must be in the form of -flag value pairs. known flags: $known_opts"
-                    }
-                    set opts [dict merge $defaults $args]
-                    if {[dict get $opts -note] eq "\uFFFF"} {
-                        dict unset opts -note
-                    }
-
-                    set status [string toupper $status]
-                    set statusdict [dict create OK RECORD SKIPPED SKIPPED FAILED FAILED] 
-                    if {$o_operation_start_ts eq ""} {
-                        error "[self] targetset_end $status - no current operation - call targetset_started first"
-                    }
-                    if {$status ni [dict keys $statusdict]} {
-                        error "[self] targetset_end unrecognized status:$status known values: [dict keys $statusdict]"
-                    }
-                    if {![punkcheck::lib::is_file_record_inprogress $o_fileset_record]} {
-                        error "targetset_end $status error: bad fileset_record - expected FILEINFO with last body element *-INPROGRESS"
-                    }
-                    set targetlist [dict get $o_fileset_record -targets]
-                    if {$targetlist ne $o_targets} {
-                        error "targetset_end $status error. targetlist mismatch between file : $targetlist vs $o_targets"
-                    }
-                    set operation_end_ts [clock microseconds]
-                    set elapsed_us [expr {$operation_end_ts - $o_operation_start_ts}] 
-                    set file_record_body [dict get $o_fileset_record body]
-                    set installing_record [lindex $file_record_body end]
-                    set punkcheck_file [$o_installer get_checkfile]
-                    set punkcheck_folder [file dirname $punkcheck_file]
-                    set record_list [punkcheck::load_records_from_file $punkcheck_file]
-                    if {[dict exists $installing_record -ts_start_transfer]} {
-                        set ts_start_transfer [dict get $installing_record -ts_start_transfer]
-                        set transfer_us [expr {$operation_end_ts - $ts_start_transfer}]
-                        dict set installing_record  -transfer_us $transfer_us
-                    }
-                    if {[dict exists $opts -note]} {
-                        dict set installing_record -note [dict get $opts -note]
-                    }
-
-                    dict set installing_record -elapsed_us $elapsed_us
-                    dict unset installing_record -tempcontext
-                    dict set installing_record tag "${o_operation}-[dict get $statusdict $status]" ;# e.g INSTALL-RECORD, INSTALL-SKIPPED
-                    if {$o_operation in [list INSTALL MODIFY] && [dict get $statusdict $status] eq "RECORD"} {
-                        #only calculate and store post operation target cksums on successful INSTALL or MODIFY, doesn't make sense for DELETE or VIRTUAL operations
-                        set new_targets_cksums [list] ;#ordered list of cksums matching targetset order
-                        set cksum_all_opts "" ;#same cksum opts for each target so we store it once
-                        set ts_begin_cksum [clock microseconds]
-                        foreach p $o_targets {
-                            set tgt_cksum_info [punk::mix::base::lib::cksum_path [file join $punkcheck_folder $p]]
-                            lappend new_targets_cksums [dict get $tgt_cksum_info cksum]
-                            if {$cksum_all_opts eq ""} {
-                                set cksum_all_opts [dict get $tgt_cksum_info opts]
-                            }
-                        }
-                        set cksum_us [expr {[clock microseconds] - $ts_begin_cksum}]
-                        dict set installing_record -targets_cksums $new_targets_cksums 
-                        dict set installing_record -cksum_all_opts $cksum_all_opts
-                        dict set installing_record -cksum_us $cksum_us
-                    }
-                    lset file_record_body end $installing_record
-                    dict set o_fileset_record body $file_record_body 
-                    set o_fileset_record [punkcheck::recordlist::file_record_prune $o_fileset_record]
-
-                    set oldrecordinfo [punkcheck::recordlist::get_file_record $targetlist $record_list]
-                    set old_posn [dict get $oldrecordinfo position]
-                    if {$old_posn == -1} {
-                        lappend record_list $o_fileset_record
-                    } else {
-                        lset record_list $old_posn $o_fileset_record
-                    }
-                    if {$o_operation ne "QUERY"} {
-                        punkcheck::save_records_to_file $record_list $punkcheck_file
-                    }
-                    set o_operation_start_ts ""
-                    set o_operation ""
-                    return $o_fileset_record
-                }
-                method targetset_addsource {source_path} {
-                    set punkcheck_file [$o_installer get_checkfile]
-                    set punkcheck_folder [file dirname $punkcheck_file]
-                    if {[file pathtype $source_path] eq "absolute"} {
-                        set rel_source_path [punkcheck::lib::path_relative $punkcheck_folder $source_path]
-                    } else {
-                        set rel_source_path $source_path
-                    }
-
-                    set o_fileset_record [punkcheck::installfile_add_source_and_fetch_metadata $punkcheck_folder $rel_source_path $o_fileset_record]
-
-                }
-                method targetset_last_complete {} {
-                    #retrieve last completed record for the fileset ie exclude SKIPPED,INSTALL-INPROGRESS,DELETE-INPROGRESS,MODIFY-INPROGRESS
-                    set body [punkcheck::dict_getwithdefault $o_fileset_record body [list]]
-                    set previous_records [lrange $body 0 end]
-                    #get last that is tagged INSTALL-RECORD,MODIFY-RECORD,DELETE-RECORD
-                    set revlist [lreverse $previous_records]
-                    foreach rec $revlist {
-                        if {[dict get $rec tag] in [list "INSTALL-RECORD" "MODIFY-RECORD" "DELETE-RECORD" "VIRTUAL-RECORD"]} {
-                            return $rec
-                        }
-                    }
-                    return [list]
-
-                }
-                method targetset_source_changes {} {
-                    punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $o_fileset_record body] end]
-                }
-
-            }
-
-
-            oo::class create installtrack {
-                variable o_name
-                variable o_tsiso
-                variable o_ts
-                variable o_keep_events
-                variable o_checkfile
-                variable o_sourceroot 
-                variable o_rel_sourceroot
-                variable o_targetroot
-                variable o_rel_targetroot
-                variable o_record_list
-                variable o_active_event 
-                variable o_events
-                constructor {installername punkcheck_file} {
-                    set o_active_event ""
-                    set o_name $installername
-
-                    set o_checkfile [file normalize $punkcheck_file]
-                    set o_sourceroot ""
-                    set o_targetroot ""
-                    set o_rel_sourceroot ""
-                    set o_rel_targetroot ""
-                    #todo - validate punkcheck file location further??
-                    set punkcheck_folder [file dirname $o_checkfile]
-                    if {![file isdirectory $punkcheck_folder]} {
-                        error "[self] constructor error. Folder for punkcheck_file not found - $o_checkfile"
-                    }
-
-                    my load_all_records
-                    set resultinfo [punkcheck::recordlist::get_installer_record $o_name $o_record_list]
-                    set existing_header_posn [dict get $resultinfo position]
-                    if {$existing_header_posn == -1} {
-                        set this_installer_record [punkcheck::recordlist::new_installer_record $o_name]
-                        set o_record_list [linsert $o_record_list 0 $this_installer_record]
-                    } else {
-                        set this_installer_record [dict get $resultinfo record]
-                    }
-                    set o_tsiso [dict get $this_installer_record -tsiso]
-                    set o_ts [dict get $this_installer_record -ts]
-                    set o_keep_events [dict get $this_installer_record -keep_events]
-
-                    set o_events [oolib::collection create [namespace current]::eventcollection]
-                    set eventlist [punkcheck::dict_getwithdefault $this_installer_record body [list]]
-                    foreach e $eventlist {
-                        set eobj [punkcheck::installevent create [namespace current]::event_[my events count] [self] [dict get $e -source] [dict get $e -targets] {*}$e]
-                        #$o_events add $e [dict get $e -id]
-                        $o_events add $eobj [dict get $e -id]
-                    }
-                    
-                }
-                destructor {
-                    #puts "[self] destructor called"
-                }
-                method test {} {
-                    return [self]
-                }
-                method get_name {} {
-                    return $o_name
-                }
-                method get_checkfile {} {
-                    return $o_checkfile
-                }
-
-                #call set_source_target before calling start_event/end_event
-                #each event can have different source->target pairs - but may often have same, so set on installtrack as defaults. Only persisted in event records. 
-                method set_source_target {sourceroot targetroot} {
-                    if {[file pathtype $sourceroot] ne "absolute"} {
-                        error "[self] set_source_target error: sourceroot must be absolute path. Received '$sourceroot'"
-                    }
-                    if {[file pathtype $targetroot] ne "absolute"} {
-                        error "[self] set_source_target error: targetroot must be absolute path. Received '$targetroot'"
-                    }
-                    set punkcheck_folder [file dirname $o_checkfile]
-                    set o_sourceroot $sourceroot
-                    set o_targetroot $targetroot
-                    set o_rel_sourceroot [punkcheck::lib::path_relative $punkcheck_folder $sourceroot]
-                    set o_rel_targetroot [punkcheck::lib::path_relative $punkcheck_folder $targetroot]
-                    return [list $o_rel_sourceroot $o_rel_targetroot]
-                }
-                #review/fix to allow multiple installtrack objects on same punkcheck file.
-                method load_all_records {} {
-                    set o_record_list [punkcheck::load_records_from_file $o_checkfile]
-                }
-
-                #does not include associated FILEINFO records - as a targetset (FILEINFO record) can be associated with events from multiple installers over time.
-                #e.g a logfile common to installers, or a separate installer that updates a previous output.
-                method as_record {} {
-                    set eventrecords [list]
-                    foreach eobj [my events items] {
-                        lappend eventrecords [$eobj as_record]
-                    }
-                    set fields [list\
-                        -tsiso       $o_tsiso\
-                        -ts          $o_ts\
-                        -name        $o_name\
-                        -keep_events $o_keep_events\
-                        body $eventrecords\
-                    ]
-                    set record [dict create tag INSTALLER {*}$fields]
-                }
-                #open file and save only own records
-                method save_all_records {} {
-                    my save_installer_record
-                    #todo - save FILEINFO targetset records
-                }
-                method save_installer_record {} {
-                    set file_records [punkcheck::load_records_from_file $o_checkfile]
-                    
-                    set this_installer_record [my as_record]
-
-                    set persistedinfo [punkcheck::recordlist::get_installer_record $o_name $file_records]
-                    set existing_header_posn [dict get $persistedinfo position]
-                    if {$existing_header_posn == -1} {
-                        set file_records [linsert $file_records 0 $this_installer_record]
-                    } else {
-                        lset file_records $existing_header_posn $this_installer_record
-                    }
-                    punkcheck::save_records_to_file $file_records $o_checkfile
-                }
-                method events {args} {
-                    tailcall $o_events {*}$args
-                }
-                method start_event {configdict} {
-                    if {$o_active_event ne ""} {
-                        error "[self] start_event error - event already started:   $o_active_event"
-                    }
-                    if {$o_rel_sourceroot eq "" || $o_rel_targetroot eq ""} {
-                        error "[self] No configured sourceroot or targetroot. Call [self] set_source_target <abspath_sourceroot> <abspath_targetroot> first"
-                    }
-
-                    if {[llength $configdict] %2 != 0} {
-                        error "[self] new_event configdict must have an even number of elements"
-                    }
-                    set resultinfo [punkcheck::recordlist::get_installer_record $o_name $o_record_list]
-                    set existing_header_posn [dict get $resultinfo position]
-                    if {$existing_header_posn == -1} {
-                        error "[self] start_event - installer record missing. installer: $o_name"
-                    } else {
-                        set this_installer_record [dict get $resultinfo record]
-                    }
-
-                    set eventobj [punkcheck::installevent create [namespace current]::event_[my events count] [self] $o_rel_sourceroot $o_rel_targetroot -config $configdict]
-                    set eventid [$eventobj get_id]
-                    set event_record [$eventobj as_record]
-
-                    set this_installer_record [punkcheck::recordlist::installer_record_add_event $this_installer_record $event_record]
-                    set this_installer_record [punkcheck::recordlist::installer_record_pruneevents $this_installer_record $o_record_list]
-
-                    #replace
-                    lset o_record_list $existing_header_posn $this_installer_record
-
-                    punkcheck::save_records_to_file $o_record_list $o_checkfile
-                    set o_active_event $eventobj
-                    my events add $eventobj $eventid
-                    return $eventobj
-                }
-                method installer_record_from_file {} {
-                    set resultinfo [punkcheck::recordlist::get_installer_record $o_name $o_record_list]
-                }
-                method get_recordlist {} {
-                    return $o_recordlist    
-                }
-                method end_event {} {
-                    if {$o_active_event eq ""} {
-                        error "[self] end_event error - no active event"
-                    }
-                    $o_active_event end 
-                }
-                method get_event {} {
-                    return $o_active_event
-                }
-            }
-        }
-        proc start_installer_event {punkcheck_file installername from_fullpath to_fullpath config} {
-            set eventid [punkcheck::uuid]
-            if {[file pathtype $from_fullpath] ne "absolute"} {
-                error "start_installer_event error: from_fullpath must be absolute path. Received '$from_fullpath'"
-            }
-            if {[file pathtype $to_fullpath] ne "absolute"} {
-                error "start_installer_event error: to_fullpath must be absolute path. Received '$to_fullpath'"
-            }
-            set punkcheck_folder [file dirname $punkcheck_file]
-            set rel_source [punkcheck::lib::path_relative $punkcheck_folder $from_fullpath]
-            set rel_target [punkcheck::lib::path_relative $punkcheck_folder $to_fullpath]
-
-
-            set record_list [punkcheck::load_records_from_file $punkcheck_file]
-            set resultinfo [punkcheck::recordlist::get_installer_record $installername $record_list]
-            set existing_header_posn [dict get $resultinfo position]
-            if {$existing_header_posn == -1} {
-                set this_installer_record [punkcheck::recordlist::new_installer_record $installername]
-            } else {
-                set this_installer_record [dict get $resultinfo record]
-            }
-
-            set event_record [punkcheck::recordlist::new_installer_event_record install\
-                -id $eventid\
-                -source $rel_source\
-                -targets $rel_target\
-                -config $config\
-            ]
-
-            set this_installer_record [punkcheck::recordlist::installer_record_add_event $this_installer_record $event_record]
-            set this_installer_record [punkcheck::recordlist::installer_record_pruneevents $this_installer_record $record_list]
-
-            if {$existing_header_posn == -1} {
-                #not found - prepend
-                set record_list [linsert $record_list 0 $this_installer_record]
-            } else {
-                #replace
-                lset record_list $existing_header_posn $this_installer_record
-            }
-
-            punkcheck::save_records_to_file $record_list $punkcheck_file
-            return [list eventid $eventid recordset $record_list]
-        }
-        #-----------------------------------------------
-        proc installfile_help {} {
-            set msg ""
-            append msg  "Call in order:" \n
-            append msg  "  start_installer_event (get dict with eventid and recordset keys)"
-            append msg  "  installfile_begin  (to return a new INSTALLING record) - must pass in a valid eventid"  \n
-            append msg  "  installfile_add_source_and_fetch_metadata (1+ times to update SOURCE record with checksum/timestamp info from source)" \n 
-            append msg  "     ( - possibly with same algorithm as previous installrecord)" \n
-            append msg  "     ( - todo - search/load metadata for this source from other FILEINFO records for same installer)" \n
-            append msg  "Finalize by calling:" \n
-            append msg  "  installfile_started_install" \n
-            append msg  "  (install the file e.g file copy)" \n
-            append msg  "  installfile_finished_install" \n
-            append msg  "  OR" \n
-            append msg  "  installfile_skipped_install" \n
-        }
-        proc installfile_begin {punkcheck_folder target_relpath installername args} {
-            if {[llength $args] %2 !=0} {
-                error "punkcheck installfile_begin args must be name-value pairs"
-            }
-            set target_relpath [lsort -dictionary -increasing $target_relpath] ;#exact sort order not critical - but must be consistent
-            set ts [clock microseconds]
-            set seconds [expr {$ts / 1000000}]
-            set tsiso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-            set defaults [list\
-                -tsiso $tsiso\
-                -ts $ts\
-                -installer $installername\
-                -eventid unspecified\
-                ]
-            set opts [dict merge $defaults $args]
-            set opt_eventid [dict get $opts -eventid]
-
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-            set record_list [load_records_from_file $punkcheck_file]
-           
-            set resultinfo [punkcheck::recordlist::get_installer_record $installername $record_list]
-            set installer_record_position [dict get $resultinfo position]
-            if {$installer_record_position == -1} {
-                error "installfile_begin error: Failed to retrieve installer record for installer name:'$installername' - ensure start_installer_event has been called with same installer, and -eventid is passed to installfile_begin"
-            }
-            set this_installer_record [dict get $resultinfo record]
-            set events [dict get $this_installer_record body]
-            set active_event [list]
-            foreach evt [lreverse $events] {
-                if {[dict get $evt -id] eq $opt_eventid} {
-                    set active_event $evt
-                    break
-                }
-            }
-            if {![llength $active_event]} {
-                error "installfile_begin error: eventid $opt_eventid not found for installer '$installername' - aborting"
-            }
-
-
-            set extractioninfo [punkcheck::recordlist::extract_or_create_fileset_record $target_relpath $record_list]
-            set file_record [dict get $extractioninfo record]
-            set record_list [dict get $extractioninfo recordset]
-            set isnew       [dict get $extractioninfo isnew]
-            set oldposition [dict get $extractioninfo oldposition]
-            unset extractioninfo
-
-            #INSTALL-INPROGRESS will become INSTALL-RECORD or INSTALL-FAILED or INSTALL-SKIPPED upon finalisation
-            #-installer and -eventid keys are added here
-            set new_installing_record [dict create tag INSTALL-INPROGRESS {*}$opts -tempcontext $active_event body {}]
-            #set existing_body [dict_getwithdefault $file_record body [list]]
-            #todo - look for existing "INSTALL-INPROGRESS" records - mark as failed?
-            dict lappend file_record body $new_installing_record
-
-            if {$isnew} {
-                lappend record_list $file_record
-            } else {
-                set record_list [linsert $record_list[unset record_list] $oldposition $file_record]
-            }
-
-            save_records_to_file $record_list $punkcheck_file
-            return $file_record
-        }
-
-        #todo - ensure that removing a dependency is noticed as a change
-        #e.g previous installrecord had 2 source records - but we now only depend on one.
-        #The files we depended on for the previous record haven't changed themselves - but the list of files has (reduced by one)
-        proc installfile_add_source_and_fetch_metadata {punkcheck_folder source_relpath file_record} {
-            if {![lib::is_file_record_inprogress $file_record]} {
-                error "installfile_add_source_and_fetch_metadata error: bad file_record - expected FILEINFO with last body element *-INPROGRESS ($file_record)"
-            }
-            set ts_start [clock microseconds]
-            set last_installrecord [lib::file_record_get_last_installrecord $file_record]
-            set prev_ftype ""
-            set prev_fsize ""
-            set prev_cksum ""
-            set prev_cksum_opts ""
-            if {[llength $last_installrecord]} {
-                set src [lib::install_record_get_matching_source_record $last_installrecord $source_relpath]
-                if {[llength $src]} {
-                    if {[dict_getwithdefault $src -path ""] eq $source_relpath} {
-                        set prev_ftype [dict_getwithdefault $src -type ""]
-                        set prev_fsize [dict_getwithdefault $src -size ""]
-                        set prev_cksum [dict_getwithdefault $src -cksum ""]
-                        set prev_cksum_opts [dict_getwithdefault $src -cksum_all_opts ""]
-                    }
-                }
-            }
-            #check that this relpath not already added as child of *-INPROGRESS 
-            set file_record_body [dict_getwithdefault $file_record body [list]] ;#new file_record may have no body
-            set installing_record [lindex $file_record_body end]
-            set already_present_record [lib::install_record_get_matching_source_record $installing_record $source_relpath]
-            if {[llength $already_present_record]} {
-                error "installfile_add_source_and_fetch_metadata error: source path $source_relpath already exists in the file_record - cannot add again"
-            }
-
-            if {$prev_cksum_opts ne ""} {
-                set cksum_opts $prev_cksum_opts
-            } else {
-                set cksum_opts ""
-            }
-
-            #todo - accept argument of cached source cksum info (for client calling multiple targets with same source in quick succession e.g when building .vfs kits with multiple runtimes)
-            #if same cksum_opts - then use cached data instead of checksumming here.
-
-            #allow nonexistant as a source 
-            set fpath [file join $punkcheck_folder $source_relpath]
-            if {![file exists $fpath]} {
-                set ftype "missing"
-                set fsize ""
-                #get_relativecksum_from_base will set cksum to <PATHNOTFOUND>
-                set source_cksum_info [punk::mix::base::lib::get_relativecksum_from_base $punkcheck_folder $source_relpath {*}$cksum_opts]
-            } else {
-                set ftype [file type $fpath]
-                if {$ftype eq "directory"} {
-                    set source_cksum_info [punk::mix::base::lib::get_relativecksum_from_base $punkcheck_folder $source_relpath {*}$cksum_opts]
-                    set fsize "NA"
-                } else {
-                    #todo - optionally use mtime instead of cksum (for files only)?
-                    #mtime is not reliable across platforms and filesystems though.. see article linked at toop.
-                    set source_cksum_info [punk::mix::base::lib::get_relativecksum_from_base $punkcheck_folder $source_relpath {*}$cksum_opts]
-                    set fsize [file size $fpath]
-                }
-            }
-
-
-            lassign $source_cksum_info pathkey ckinfo
-            if {$pathkey ne $source_relpath} {
-                error "installfile_add_source_and_fetch_metadata error: cksum returned wrong path info '$pathkey' expected '$source_relpath'"
-            }
-            set cksum [dict get $ckinfo cksum]
-            set cksum_all_opts [dict get $ckinfo cksum_all_opts]
-            if {$cksum ne $prev_cksum || $ftype ne $prev_ftype || $fsize ne $prev_fsize} {
-                set changed 1
-            } else {
-                set changed 0
-            }
-            set installing_record_sources [dict_getwithdefault $installing_record body [list]]
-            set ts_now [clock microseconds] ;#gathering metadata - especially checsums on folder can take some time - calc and store elapsed us for time taken to gather metadata
-            set metadata_us [expr {$ts_now - $ts_start}]
-            set this_source_record [dict create tag SOURCE -type $ftype -size $fsize -path $source_relpath -cksum $cksum -cksum_all_opts $cksum_all_opts -changed $changed -metadata_us $metadata_us]
-            lappend installing_record_sources $this_source_record
-            dict set installing_record body $installing_record_sources
-
-            lset file_record_body end $installing_record
-
-            dict set file_record body $file_record_body
-            return $file_record
-        }
-
-        #write back to punkcheck - don't accept recordset - invalid to update anything other than the installing_record at this time
-        proc installfile_started_install {punkcheck_folder file_record} {
-            if {![lib::is_file_record_inprogress $file_record]} {
-                error "installfile_started_install error: bad file_record - expected FILEINFO with last body element *-INPROGRESS"
-            }
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-            set record_list [load_records_from_file $punkcheck_file]
-
-            set file_record_body [dict get $file_record body]
-            set targetlist [dict get $file_record -targets]
-            set installing_record [lindex $file_record_body end]
-
-            set ts_start [dict get $installing_record -ts]
-            set ts_now [clock microseconds] 
-            set metadata_us [expr {$ts_now - $ts_start}]
-            
-            dict set installing_record -metadata_us $metadata_us
-            dict set installing_record -ts_start_transfer $ts_now
-
-            lset file_record_body end $installing_record
-            
-            dict set file_record body $file_record_body
-
-
-            set getresult [punkcheck::recordlist::get_file_record $targetlist $record_list]
-            set old_posn [dict get $getresult position]
-            if {$old_posn == -1} {
-                lappend record_list $file_record
-            } else {
-                lset record_list $old_posn $file_record
-            }
-
-            save_records_to_file $record_list $punkcheck_file
-            return $file_record
-        }
-        proc installfile_finished_install {punkcheck_folder file_record} {
-            if {![lib::is_file_record_inprogress $file_record]} {
-                error "installfile_finished_install error: bad file_record - expected FILEINFO with last body element *-INPROGRESS"
-            }
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-            set record_list [load_records_from_file $punkcheck_file]
-
-            set file_record_body [dict get $file_record body]
-            set targetlist [dict get $file_record -targets]
-            set installing_record [lindex $file_record_body end]
-
-            set ts_start [dict get $installing_record -ts]
-            set ts_start_transfer [dict get $installing_record -ts_start_transfer]
-            set ts_now [clock microseconds]
-            set elapsed_us [expr {$ts_now - $ts_start}]
-            set transfer_us [expr {$ts_now - $ts_start_transfer}]
-            dict set installing_record  -transfer_us $transfer_us
-            dict set installing_record -elapsed_us $elapsed_us
-            dict unset installing_record -tempcontext
-            dict set installing_record tag "INSTALL-RECORD"
-
-            lset file_record_body end $installing_record
-            dict set file_record body $file_record_body 
-
-            set file_record [punkcheck::recordlist::file_record_prune $file_record]
-
-            set oldrecordinfo [punkcheck::recordlist::get_file_record $targetlist $record_list]
-            set old_posn [dict get $oldrecordinfo position]
-            if {$old_posn == -1} {
-                lappend record_list $file_record
-            } else {
-                lset record_list $old_posn $file_record
-            }
-
-            save_records_to_file $record_list $punkcheck_file
-            return $file_record
-        }
-        proc installfile_skipped_install {punkcheck_folder file_record} {
-            if {![lib::is_file_record_inprogress $file_record]} {
-                set msg "installfile_skipped_install error: bad file_record - expected FILEINFO with last body element *-INPROGRESS"
-                append msg \n "received:"
-                append msg \n $file_record
-                error $msg
-            }
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-            set record_list [load_records_from_file $punkcheck_file]
-
-            set file_record_body [dict get $file_record body]
-            set targetlist [dict get $file_record -targets]
-            set installing_record [lindex $file_record_body end]
-
-            set ts_start [dict get $installing_record -ts]
-            set tsnow [clock microseconds]
-            set elapsed_us [expr {$tsnow - $ts_start}]
-            dict set installing_record -elapsed_us $elapsed_us
-            dict set installing_record tag "INSTALL-SKIPPED" 
-             
-            lset file_record_body end $installing_record
-            dict set file_record body $file_record_body
-
-            set file_record [punkcheck::recordlist::file_record_prune $file_record]
-
-            set getresult [punkcheck::recordlist::get_file_record $targetlist $record_list]
-            set old_posn [dict get $getresult position]
-            if {$old_posn == -1} {
-                lappend record_list $file_record
-            } else {
-                lset record_list $old_posn $file_record
-            }
-
-            save_records_to_file $record_list $punkcheck_file
-            return $file_record
-        }
-        #-----------------------------------------------
-        #then: file_record_add_installrecord
-
-        namespace eval lib {
-            set pkg punkcheck
-            namespace path ::punkcheck
-            proc is_file_record_inprogress {file_record} {
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    return 0
-                }
-                set installing_record [lindex [dict_getwithdefault $file_record body [list]] end]
-                if {[dict_getwithdefault $installing_record tag [list]] ni [list QUERY-INPROGRESS INSTALL-INPROGRESS MODIFY-INPROGRESS DELETE-INPROGRESS VIRTUAL-INPROGRESS]} {
-                    return 0
-                }
-                return 1
-            }
-            proc is_file_record_installing {file_record} {
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    return 0
-                }
-                set installing_record [lindex [dict_getwithdefault $file_record body [list]] end]
-                if {[dict_getwithdefault $installing_record tag [list]] ne "INSTALL-INPROGRESS"} {
-                    return 0
-                }
-                return 1
-            }
-            proc file_record_get_last_installrecord {file_record} {
-                set body [dict_getwithdefault $file_record body [list]]
-                set previous_install_records [lrange $body 0 end-1]
-                #get last previous that is tagged INSTALL-RECORD,MODIFY-RECORD,VIRTUAL-RECORD
-                #REVIEW DELETERECORD ???
-                set revlist [lreverse $previous_install_records]
-                foreach rec $revlist {
-                    if {[dict get $rec tag] in [list "INSTALL-RECORD" "MODIFY-RECORD" "VIRTUAL-RECORD"]} {
-                        return $rec
-                    }
-                }
-                return [list]
-            }
-
-            #should work on *-INPROGRESS or INSTALL(etc) record - don't restrict tag to INSTALL
-            proc install_record_get_matching_source_record {install_record source_relpath} {
-                set body [dict_getwithdefault $install_record body [list]] 
-                foreach src $body {
-                    if {[dict get $src tag] eq "SOURCE"} {
-                        if {[dict_getwithdefault $src -path ""] eq $source_relpath} {
-                            return $src
-                        }
-                    }
-                }
-                return [list]
-            }
-
-
-
-            #maint warning - also in punk::mix::util
-            proc path_relative {base dst} {
-                #see also kettle
-                # Modified copy of ::fileutil::relative (tcllib)
-                # Adapted to 8.5 ({*}).
-                #
-                #    Taking two _directory_ paths, a base and a destination, computes the path
-                #    of the destination relative to the base.
-                #
-                # Arguments:
-                #    base    The path to make the destination relative to.
-                #    dst     The destination path
-                #
-                # Results:
-                #    The path of the destination, relative to the base.
-
-                # Ensure that the link to directory 'dst' is properly done relative to
-                # the directory 'base'.
-
-                #review - check volume info on windows.. UNC paths?
-                if {[file pathtype $base] ne [file pathtype $dst]} {
-                    return -code error "Unable to compute relation for paths of different pathtypes: [file pathtype $base] vs. [file pathtype $dst], ($base vs. $dst)"
-                }
-
-                #avoid normalizing if possible - at least for relative paths which we are likely to loop on (file normalize *very* expensive on windows)
-                set do_normalize 0
-                if {[file pathtype $base] eq "relative"} {
-                    #if base is relative so is dst
-                    if {[regexp {[.]{2}} [list $base $dst]]} {
-                        set do_normalize 1
-                    }
-                    if {[regexp {[.]/} [list $base $dst]]} {
-                        set do_normalize 1
-                    }
-                } else {
-                    #case differences in volumes is common on windows 
-                    set do_normalize 1
-                }
-                if {$do_normalize} {
-                    set base [file normalize $base]
-                    set dst  [file normalize $dst]
-                }
-
-                set save $dst
-                set base [file split $base]
-                set dst  [file split $dst]
-
-                while {[lindex $dst 0] eq [lindex $base 0]} {
-                    set dst  [lrange $dst  1 end]
-                    set base [lrange $base 1 end]
-                    if {![llength $dst]} {break}
-                }
-
-                set dstlen  [llength $dst]
-                set baselen [llength $base]
-
-                if {($dstlen == 0) && ($baselen == 0)} {
-                    # Cases:
-                    # (a) base == dst
-
-                    set dst .
-                    } else {
-                    # Cases:
-                    # (b) base is: base/sub = sub
-                    #     dst  is: base     = {}
-
-                    # (c) base is: base     = {}
-                    #     dst  is: base/sub = sub
-
-                    while {$baselen > 0} {
-                        set dst [linsert $dst 0 ..]
-                        incr baselen -1
-                    }
-                    set dst [file join {*}$dst]
-                }
-
-                return $dst
-            }
-        }
-        #skip writing punkcheck during checksum/timestamp checks
-
-        proc install_tm_files {srcdir basedir args} {
-            set defaults [list\
-                -glob *.tm\
-                -antiglob_file [list "*[punk::mix::util::magic_tm_version]*"]\
-                -installer punkcheck::install_tm_files\
-                ]
-            set opts [dict merge $defaults $args]
-            punkcheck::install $srcdir $basedir {*}$opts
-        }
-        proc install_non_tm_files {srcdir basedir args} {
-            #set keys [dict keys $args]
-            #adjust the default antiglob_dir_core entries so that .fossil-custom, .fossil-settings are copied
-            set antiglob_dir_core [punkcheck::default_antiglob_dir_core]
-            set posn [lsearch $antiglob_dir_core ".fossil*"]
-            if {$posn >=0} {
-                set antiglob_dir_core [lreplace $antiglob_dir_core $posn $posn]
-            }
-            set defaults [list\
-                -glob *\
-                -antiglob_file [list "*.tm" "*-buildversion.txt" "*.exe"]\
-                -antiglob_dir_core $antiglob_dir_core\
-                -installer punkcheck::install_non_tm_files\
-                ]
-            set opts [dict merge $defaults $args]
-            punkcheck::install $srcdir $basedir {*}$opts
-        }
-
-        #for tcl8.6 - tcl8.7+ has dict getwithdefault (dict getdef)
-        proc dict_getwithdefault {dictValue args} {
-            if {[llength $args] < 2} {
-                error {wrong # args: should be "dict_getdef dictionary ?key ...? key default"}
-            }
-            set keys [lrange $args 0 end-1]
-            if {[dict exists $dictValue {*}$keys]} {
-                return [dict get $dictValue {*}$keys]
-            } else {
-                return [lindex $args end] 
-            }
-        }
-        ## unidirectional file transfer to possibly non empty folder
-        #default of -overwrite no-targets will only copy files that are missing at the target
-        #           -overwrite newer-targets will copy files with older source timestamp over newer target timestamp and those missing at the target (a form of 'restore' operation)
-        #           -overwrite older-targets will copy files with newer source timestamp over older target timestamp and those missing at the target
-        #           -overwrite all-targets will copy regardless of timestamp at target
-        #           -overwrite installedsourcechanged-targets will copy if the target doesn't exist or the source changed 
-        #           -overwrite synced-targets will copy if the target doesn't exist or the source changed and the target cksum is the same as the last INSTALL-RECORD targets_cksums entry
-        #           review - timestamps unreliable
-        #            - what about slightly mismatched system clocks and mounted filesystems? caller responsibility to verify first? 
-        #           if timestamp exactly equal -  should we check content-hash? This is presumably only likely to occur deliberately(maliciously?) 
-        #           e.g some process that digitally signs or otherwise modifies a file and preserves update timestmp?
-        #           if such a content-mismatch - what default behaviour and what options would make sense?
-        #           probably it's reasonable that only all-targets would overwrite such files.
-        #           consider -source_fudge_seconds  +-X  ?,  -source_override_timestamp ts  ???  etc which only adjust timestamp for calculation purposes? Define a specific need/usecase when reviewing.
-        #
-        # valid filetypes for src tgt
-        #  src dir      tgt dir
-        #  todo - review and consider enabling symlink src and dst
-        #  no need for src file  - as we use -glob with no glob characters to match one  source file file
-        #  no ability to target file with different name - keep it simpler and caller will have to use an intermediate folder/file if they need to rename something?
-        #
-        #  todo - determine what happens if mismatch between file type of a src vs target e.g target has dir matching filename at source
-        #  A pre-scan to determine no such conflict - before attempting to copy anything might provide the most integrity at slight cost in speed.
-        #  REVIEW  we should only expect dirs to be created as necessary to hold files? i.e target folder won't be created if no source file matches for that folder
-        #  -source_checksum  compare|store|comparestore|false|true  where true == comparestore
-        #  -punkcheck_folder target|source|project|<absolutepath>  target is default and is generally recommended
-        #  -punkcheck_records empty string | parsed TDL records ie {tag xxx k v}  structure
-        # install creates FILEINFO records with a single entry in the -targets field (it is legitimate to have a list of targets for an installation operation - the oo interface supports this)
-        proc install {srcdir tgtdir args} {
-            set defaults [list\
-                -call-depth-internal 0\
-                -max_depth 1000\
-                -subdirlist {}\
-                -createdir 0\
-                -glob *\
-                -antiglob_file_core "\uFFFF"\
-                -antiglob_file "" \
-                -antiglob_dir_core "\uFFFF"\
-                -antiglob_dir {}\
-                -antiglob_paths {}\
-                -overwrite no-targets\
-                -source_checksum comparestore\
-                -punkcheck_folder target\
-                -punkcheck_eventid "\uFFFF"\
-                -punkcheck_records ""\
-                -installer punkcheck::install\
-                ]
-
-            set opts [dict merge $defaults $args]
-            if {([llength $args] %2) != 0} {
-                error "punkcheck::install requires option-style arguments to be in pairs. Received args: $args"
-            }
-            foreach k [dict keys $args] {
-                if {$k ni [dict keys $defaults]} {
-                    error "punkcheck::install  unrecognised option '$k' known options: '[dict keys $defaults]'"
-                }
-            }
-
-            #The choice to recurse using the original values of srcdir & tgtdir, and passing the subpath down as a list in -subdirlist seems an odd one.
-            #(as opposed to a more 'standard' mechanism of adjusting srcdir & tgtdir as we move down the tree)
-            #It comes from build_modules_from_source_to_base where we need to keep track of position relative to our targetdir starting point to handle submodules e.g pkg::something::mypkg-0.1.tm
-            #It could have been handled with some other parameter such as -depth, but this -subdirlist mechanism, whilst perhaps not beautiful, is straightforward enough
-            #and may be less error prone than doing slightly more opaue path manipulations at each recursion level to determine where we started
-            #For consistency - we'll use the same mechanism in various recursive directory walking procedures such as this one.
-            set CALLDEPTH                               [dict get $opts -call-depth-internal] ;#added for extra debug/sanity checking - clearer test for initial function call ie CALLDPEPTH = 0
-            set max_depth                               [dict get $opts -max_depth]
-            set subdirlist                              [dict get $opts -subdirlist] ;# generally should be same length as CALLDEPTH - but user could prefill
-            set fileglob                                [dict get $opts -glob]
-            set createdir                               [dict get $opts -createdir] ;#defaults to zero to help avoid mistakes with initial target dir - required target subdirs are created regardless of this setting
-
-            if {$CALLDEPTH == 0} {
-                #expensive to normalize  but we need to do it at least once
-                set srcdir [file normalize $srcdir]
-                set tgtdir [file normalize $tgtdir]
-                if {$createdir} {
-                    file mkdir $tgtdir
-                }
-                #now the values we build from these will be properly cased
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_file_core                  [dict get $opts -antiglob_file_core]
-            if {$opt_antiglob_file_core eq "\uFFFF"} {
-                set opt_antiglob_file_core [default_antiglob_file_core]
-                dict set opts -antiglob_file_core $opt_antiglob_file_core
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_file                       [dict get $opts -antiglob_file]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_dir_core                   [dict get $opts -antiglob_dir_core]
-            if {$opt_antiglob_dir_core eq "\uFFFF"} {
-                set opt_antiglob_dir_core [default_antiglob_dir_core]
-                dict set opts -antiglob_dir_core $opt_antiglob_dir_core
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_dir                        [dict get $opts -antiglob_dir]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_paths                     [dict get $opts -antiglob_paths] ;#todo - combine with config file in source tree .punkcheckpublish (?)
-            set antiglob_paths_matched [list]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set known_whats [list no-targets newer-targets older-targets all-targets installedsourcechanged-targets synced-targets]
-            set overwrite_what                          [string tolower [dict get $opts -overwrite]]; #accept any case for value to allow emphasis by caller e.g -overwrite NEWER-TARGETS
-            if {$overwrite_what ni $known_whats} {
-                error "punkcheck::install received unrecognised value for -overwrite. Received value '$overwrite_what' vs known values '$known_whats'"
-            }
-            if {$overwrite_what in [list newer-targets older-targets]} {
-                error "punkcheck::install newer-target, older-targets not implemented - sorry"
-                #TODO - check crossplatform availability of ctime  (on windows it still seems to be creation time, but on bsd/linux it's last attribute mod time)
-                # external pkg?  use twapi and ctime only on other platforms?
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_source_checksum                     [dict get $opts -source_checksum]
-            if {[string is boolean $opt_source_checksum]} {
-                if {$opt_source_checksum} {
-                    set opt_source_checksum "comparestore"
-                } else {
-                    set opt_source_checksum 0
-                }
-                dict set opts -source_checksum $opt_source_checksum
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_punkcheck_folder                    [dict get $opts -punkcheck_folder]
-            if {$opt_punkcheck_folder eq "target"} {
-                set punkcheck_folder $tgtdir
-            } elseif {$opt_punkcheck_folder eq "source"} {
-                set punkcheck_folder $srcdir
-            } elseif {$opt_punkcheck_folder eq "project"} {
-                set sourceprojectinfo [punk::repo::find_repos $srcdir]
-                set targetprojectinfo [punk::repo::find_repos $tgtdir]
-                set srcproj [lindex [dict get $sourceprojectinfo project] 0]
-                set tgtproj [lindex [dict get $targetprojectinfo project] 0]
-                if {$srcproj eq $tgtproj} {
-                    set punkcheck_folder $tgtproj
-                } else {
-                    error "copy_files_from_source_to_target error: Unable to find common project dir for source and target folder - use absolutepath for -punkcheck_folder if source and target are not within same project"
-                }
-            } else {
-                set punkcheck_folder $opt_punkcheck_folder
-            }
-            if {$punkcheck_folder ne ""} {
-                if {[file pathtype $punkcheck_folder] ne "absolute"} {
-                    error "copy_files_from_source_to_target error: -punkcheck_folder '$punkcheck_folder' must be an absolute path, or one of: target|source|project"
-                }
-                if {![file isdirectory $punkcheck_folder]} {
-                    error "copy_files_from_source_to_target error: -punkcheck_folder '$punkcheck_folder' not found"
-                }
-            } else {
-                #review - leave empty? use pwd?
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set punkcheck_records                       [dict get $opts -punkcheck_records]
-            set punkcheck_records_init $punkcheck_records ;#change-detection
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_installer                           [dict get $opts -installer]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_punkcheck_eventid                             [dict get $opts -punkcheck_eventid]
-
-
-
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-
-            if {$CALLDEPTH == 0} {
-                set punkcheck_eventid "<invalid>"
-                if {$punkcheck_folder ne ""} {
-                    set config $opts
-                    dict unset config -call-depth-internal
-                    dict unset config -max_depth
-                    dict unset config -subdirlist
-                    dict for {k v} $config {
-                        if {$v eq "\uFFFF"} {
-                            dict unset config $k
-                        }
-                    }
-                    lassign [punkcheck::start_installer_event $punkcheck_file $opt_installer $srcdir $tgtdir $config] _eventid punkcheck_eventid _recordset punkcheck_records
-                }
-            } else {
-                set punkcheck_eventid $opt_punkcheck_eventid
-            }
-
-
-
-            if {$opt_source_checksum != 0} {
-                #we need to read the file even if only set to store (or we would overwrite entries)
-                set compare_cksums 1
-            } else {
-                set compare_cksums 0
-            }
-
-            if {[string match *store* $opt_source_checksum]} {
-                set store_source_cksums 1
-            } else {
-                set store_source_cksums 0
-            }
-            
-
-
-
-
-            if {[llength $subdirlist] == 0} {
-                set current_source_dir $srcdir
-                set current_target_dir $tgtdir
-            } else {
-                set current_source_dir $srcdir/[file join {*}$subdirlist]
-                set current_target_dir $tgtdir/[file join {*}$subdirlist]
-            }
-
-
-            set relative_target_dir [lib::path_relative $tgtdir $current_target_dir]
-            if {$relative_target_dir eq "."} {
-                set relative_target_dir ""
-            }
-            set relative_source_dir [lib::path_relative $srcdir $current_source_dir]
-            if {$relative_source_dir eq "."} {
-                set relative_source_dir ""
-            }
-            set target_relative_to_punkcheck_dir [lib::path_relative $punkcheck_folder $current_target_dir]
-            if {$target_relative_to_punkcheck_dir eq "."} {
-                set target_relative_to_punkcheck_dir ""
-            }
-            foreach unpub $opt_antiglob_paths {
-                #puts "testing folder - globmatchpath $unpub $relative_source_dir"
-                if {[punk::path::globmatchpath $unpub $relative_source_dir]} {
-                    lappend antiglob_paths_matched $current_source_dir
-                    return [list files_copied {} files_skipped {} sources_unchanged {} punkcheck_records $punkcheck_records antiglob_paths_matched $antiglob_paths_matched srcdir $srcdir tgtdir $tgtdir punkcheck_folder $punkcheck_folder]
-                }
-            }
-
-
-            if {![file exists $current_source_dir]} {
-                error "copy_files_from_source_to_target current source dir:'$current_source_dir' doesn't exist (srcdir:$srcdir tgtdir:$tgtdir args:'$args')"
-            }
-            if {![file exists $current_target_dir]} {
-                error "copy_files_from_source_to_target current target dir:'$current_target_dir' doesn't exist (srcdir:$srcdir tgtdir:$tgtdir args:'$args')"
-            }
-            if {([file type $current_source_dir] ni [list directory]) || ([file type $current_target_dir] ni [list directory])} {
-                error "copy_files_from_source_to_target requires source and target dirs to be of type 'directory' type current source: [file type $current_source_dir] type current target: [file type $current_target_dir]"
-            }
-
-            set files_copied [list]
-            set files_skipped [list]
-            set sources_unchanged [list]
-
-
-            set candidate_list [glob -nocomplain -dir $current_source_dir -type f -tail $fileglob]
-            set hidden_candidate_list [glob -nocomplain -dir $current_source_dir -types {hidden f} -tail $fileglob]
-            foreach h $hidden_candidate_list {
-                if {$h ni $candidate_list} {
-                    lappend candidate_list $h
-                }
-            }
-            set match_list [list]
-            foreach m $candidate_list {
-                set suppress 0
-                foreach anti [concat $opt_antiglob_file_core $opt_antiglob_file] {
-                    if {[string match $anti $m]} {
-                        #puts stderr "anti: $anti  vs m:$m"
-                        set suppress 1
-                        break
-                    }
-                }
-                if {$suppress == 0} {
-                    lappend match_list $m
-                } 
-            }
-
-            #sample .punkcheck file record (raw form) to make the code clearer
-            #punk::tdl converts to dict form e.g: tag FILEINFO -targets filename body sublist
-            #Valid installrecord types are INSTALL-RECORD SKIPPED INSTALL-INPROGRESS, MODIFY-RECORD MODIFY-INPROGRESS DELETE-RECORD DELETE-INPROGRESS 
-            #
-            #FILEINFO -targets jjjetc-0.1.0.tm -keep_installrecords 2 -keep_skipped 1 -keep_inprogress 2 {
-            #    INSTALL-RECORD -tsiso 2023-09-20T07:30:30 -ts 1695159030266610 -installer punk::mix::cli::build_modules_from_source_to_base -metadata_us 18426 -ts_start_transfer 1695159030285036 -transfer_us 10194 -elapsed_us 28620 {
-            #        SOURCE -type file -path ../src/modules/jjjetc-buildversion.txt -cksum c7c71839c36b3d21c8370fed106192fcd659eca9 -cksum_all_opts {-cksum_content 1 -cksum_meta 0 -cksum_acls 0 -cksum_usetar 0 -cksum_algorithm sha1} -changed 1 -metadata_us 3423
-            #        SOURCE -type file -path ../src/modules/jjjetc-999999.0a1.0.tm -cksum b646fc2ee88cbd068d2e946fe929b7aea96bd39d -cksum_all_opts {-cksum_content 1 -cksum_meta 0 -cksum_acls 0 -cksum_usetar 0 -cksum_algorithm sha1} -changed 1 -metadata_us 3413
-            #    }
-            #    INSTALL-SKIPPED -tsiso 2023-09-20T08:14:26 -ts 1695161666087880 -installer punk::mix::cli::build_modules_from_source_to_base -elapsed_us 18914 {
-            #        SOURCE -type file -path ../src/modules/jjjetc-buildversion.txt -cksum c7c71839c36b3d21c8370fed106192fcd659eca9 -cksum_all_opts {-cksum_content 1 -cksum_meta 0 -cksum_acls 0 -cksum_usetar 0 -cksum_algorithm sha1} -changed 0 -metadata_us 3435
-            #        SOURCE -type file -path ../src/modules/jjjetc-999999.0a1.0.tm -cksum b646fc2ee88cbd068d2e946fe929b7aea96bd39d -cksum_all_opts {-cksum_content 1 -cksum_meta 0 -cksum_acls 0 -cksum_usetar 0 -cksum_algorithm sha1} -changed 0 -metadata_us 3338
-            #    }
-            #}
-            
-            
-            #proc get_relativecksum_from_base_and_fullpath {base fullpath args}
-          
-
-            #puts stdout     "Current target dir: $current_target_dir"
-            foreach m $match_list {
-                set new_tgt_cksum_info [list]
-                set relative_target_path [file join $relative_target_dir $m]
-                set relative_source_path [file join $relative_source_dir $m]
-                set punkcheck_target_relpath [file join $target_relative_to_punkcheck_dir $m]
-                set is_antipath 0
-                foreach antipath $opt_antiglob_paths {
-                    #puts "testing file - globmatchpath $antipath  vs $relative_source_path" 
-                    if {[punk::path::globmatchpath $antipath $relative_source_path]} {
-                        lappend antiglob_paths_matched $current_source_dir
-                        set is_antipath 1
-                        break
-                    }
-                }
-                if {$is_antipath} {
-                    continue
-                }
-                #puts stdout "    checking file : $current_source_dir/$m"
-                set ts_start [clock microseconds]
-                set seconds [expr {$ts_start / 1000000}]
-                set ts_start_iso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-
-
-                #puts stdout "  rel_target: $punkcheck_target_relpath"
-                
-                set fetch_filerec_result [punkcheck::recordlist::get_file_record $punkcheck_target_relpath $punkcheck_records]
-                #change to use extract_or_create_fileset_record ?
-                set existing_filerec_posn [dict get $fetch_filerec_result position]
-                if {$existing_filerec_posn == -1} {
-                    puts stdout "NO existing record for $punkcheck_target_relpath"
-                    set has_filerec 0
-                    set new_filerec [dict create tag FILEINFO -targets $punkcheck_target_relpath]
-                    set filerec $new_filerec
-                } else {
-                    set has_filerec 1
-                    #puts stdout "  TDL existing FILEINFO record for $punkcheck_target_relpath"
-                    #puts stdout "  $existing_install_record"
-                    set filerec [dict get $fetch_filerec_result record]
-                }
-                set filerec [punkcheck::recordlist::file_record_set_defaults $filerec]
-             
-                #new INSTALLREC must be tagged as INSTALL-INPROGRESS to use recordlist::installfile_ method
-                set new_install_record   [dict create tag INSTALL-INPROGRESS -tsiso $ts_start_iso -ts $ts_start -installer $opt_installer -eventid $punkcheck_eventid]
-                dict lappend filerec body $new_install_record ;#can't use recordlist::file_record_add_installrecord as '*-INPROGRESS' isn't a final tag - so pruning would be mucked up. No need to prune now anyway.
-                unset new_install_record
-
-
-
-
-
-                set relative_source_path [lib::path_relative $punkcheck_folder $current_source_dir/$m]
-                #puts stdout "  rel_source: $relative_source_path"
-                if {[file pathtype $relative_source_path] ne "relative"} {
-                    #different volume or root
-                }
-                #Note this isn't a recordlist function - so it doesn't purely operate on the records
-                #this hits the filesystem for the sourcepath - gets checksums/timestamps depending on config. 
-                #It doesn't save to .punkcheck (the only punkcheck::installfile_ method which doesn't)
-                set filerec [punkcheck::installfile_add_source_and_fetch_metadata $punkcheck_folder $relative_source_path $filerec]
-
-
-
-                #changeinfo comes from last record in body - which is the record we are working on and so will always exist
-                set changeinfo [punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $filerec body] end]]
-                set changed [dict get $changeinfo changed]
-                set unchanged [dict get $changeinfo unchanged]
-
-                if {[llength $unchanged]} {
-                    lappend sources_unchanged $current_source_dir/$m
-                }
-
-                set is_skip 0
-                if {$overwrite_what eq "all-targets"} {
-                    file copy -force $current_source_dir/$m $current_target_dir
-                    lappend files_copied $current_source_dir/$m
-                } else {
-                    if {![file exists $current_target_dir/$m]} {
-                        file copy $current_source_dir/$m $current_target_dir
-                        set new_tgt_cksum_info [punk::mix::base::lib::cksum_path $current_target_dir/$m]
-                        lappend files_copied $current_source_dir/$m
-                        incr filecount_new
-                    } else {
-                        if {$overwrite_what eq "installedsourcechanged-targets"} {
-                            if {[llength $changed]} {
-                                #An unrecorded installation is considered a source change (from unknown/unrecorded source to recorded)
-                                file copy -force $current_source_dir/$m $current_target_dir
-                                set new_tgt_cksum_info [punk::mix::base::lib::cksum_path $current_target_dir/$m]
-                                lappend files_copied $current_source_dir/$m
-                            } else {
-                                set is_skip 1
-                                lappend files_skipped $current_source_dir/$m
-                            }
-                        } elseif {$overwrite_what eq "synced-targets"} {
-                            if {[llength $changed]} {
-                                #only overwrite if the target checksum equals the last installed checksum (ie target is in sync with source and so hasn't been customized)
-                                set existing_tgt_cksum_info [punk::mix::base::lib::cksum_path $current_target_dir/$m]
-                                set is_target_unmodified_since_install 0
-                                set target_cksum_compare "unknown"
-                                set latest_install_record [punkcheck::recordlist::file_record_latest_installrecord $filerec] ;#may be no such record - in which case we get an empty list
-                                if {[dict exists $latest_install_record -targets_cksums]} {
-                                set last_install_cksum [dict get $latest_install_record -targets_cksums] ;#in this case we know there is only one as 'install' always uses targetset size of 1. (FILEINFO record per file in source folder)
-                                    if {[dict get $existing_tgt_cksum_info cksum] eq $last_install_cksum} {
-                                        set is_target_unmodified_since_install 1
-                                        set target_cksum_compare "match"
-                                    } else {
-                                        set target_cksum_compare "nomatch"
-                                    }
-                                } else {
-                                    set target_cksum_compare "norecord"
-                                }
-                                if {$is_target_unmodified_since_install} {
-                                    file copy -force $current_source_dir/$m $current_target_dir
-                                    set new_tgt_cksum_info [punk::mix::base::lib::cksum_path $current_target_dir/$m]
-                                    lappend files_copied $current_source_dir/$m
-                                } else {
-                                    #either cksum is different or we were unable to verify the record. Either way we can't know if the target is in sync so we must skip it
-                                    set is_skip 1
-                                    puts stderr "Skipping file copy $m target $current_target_dir/$m - require synced_target to overwrite - current target cksum compared to previous install: $target_cksum_compare" 
-                                    lappend files_skipped $current_source_dir/$m
-                                }
-                            } else {
-                                set is_skip 1
-                                lappend files_skipped $current_source_dir/$m
-                            }
-                        } else {
-                            set is_skip 1
-                            puts stderr "Skipping file copy $m target $current_target_dir/$m already exists (use -overwrite all-targets  to overwrite)"
-                            #TODO! implement newer-targets older-targets? (note ctimes/mtimes are unreliable - may not be worth implementing)
-                            lappend files_skipped $current_source_dir/$m
-                        }
-                    }
-                }
-
-
-                set ts_now    [clock microseconds]
-                set elapsed_us [expr {$ts_now - $ts_start}]
-
-                #if {$store_source_cksums} {
-                #}
-
-                set install_records [dict get $filerec body] 
-                set current_install_record [lindex $install_records end]
-                #change the tag from *-INPROGRESS to INSTALL-RECORD/SKIPPED
-                if {$is_skip} {
-                    set tag INSTALL-SKIPPED
-                } else {
-                    set tag INSTALL-RECORD
-                }
-                dict set current_install_record tag $tag
-                dict set current_install_record -elapsed_us $elapsed_us
-                if {[llength $new_tgt_cksum_info]} {
-                    dict set current_install_record -targets_cksums [list [dict get $new_tgt_cksum_info cksum]]
-                    dict set current_install_record -cksum_all_opts [dict get $new_tgt_cksum_info opts]
-                }
-                lset install_records end $current_install_record
-                dict set filerec body $install_records
-                set filerec [punkcheck::recordlist::file_record_prune $filerec] ;#prune now that tag is finalized
-                if {!$has_filerec} {
-                    #not found in original recordlist - append
-                    lappend punkcheck_records $filerec
-                } else {
-                    lset punkcheck_records $existing_filerec_posn $filerec
-                }
-
-            }
-
-            if {$CALLDEPTH >= $max_depth} {
-                #don't process any more subdirs
-                set subdirs [list]
-            } else {
-                set subdirs [glob -nocomplain -dir $current_source_dir -type d -tail *]
-                set hiddensubdirs [glob -nocomplain -dir $current_source_dir -type {hidden d} -tail *]
-                foreach h $hiddensubdirs {
-                    if {$h in [list "." ".."]} {
-                        continue
-                    }
-                    if {$h ni $subdirs} {
-                        lappend subdirs $h
-                    }
-                }
-            }
-            #puts stderr "subdirs: $subdirs"
-            foreach d $subdirs {
-                set skipd 0
-                foreach dg [concat $opt_antiglob_dir_core $opt_antiglob_dir] {
-                    if {[string match $dg $d]} {
-                        puts stdout "SKIPPING FOLDER $d due to antiglob_dir-match: $dg "
-                        set skipd 1
-                        break
-                    }
-                }
-                if {$skipd} {
-                    continue
-                }
-
-
-                if {![file exists $current_target_dir/$d]} {
-                    file mkdir $current_target_dir/$d
-                }
-                
-
-                set sub_opts_1 [list\
-                    -call-depth-internal [expr {$CALLDEPTH + 1}]\
-                    -subdirlist [list {*}$subdirlist $d]\
-                    -glob $fileglob\
-                    -antiglob_file_core $opt_antiglob_file_core\
-                    -antiglob_file $opt_antiglob_file\
-                    -antiglob_dir_core  $opt_antiglob_dir_core\
-                    -antiglob_dir $opt_antiglob_dir\
-                    -overwrite $overwrite_what\
-                    -source_checksum $opt_source_checksum\
-                    -punkcheck_folder $punkcheck_folder\
-                    -punkcheck_eventid $punkcheck_eventid\
-                    -punkcheck_records $punkcheck_records\
-                    -installer $opt_installer\
-                    ]
-                set sub_opts [list\
-                    -call-depth-internal [expr {$CALLDEPTH + 1}]\
-                    -subdirlist [list {*}$subdirlist $d]\
-                    -punkcheck_folder $punkcheck_folder\
-                    -punkcheck_eventid $punkcheck_eventid\
-                    -punkcheck_records $punkcheck_records\
-                ]                
-                set sub_opts [dict merge $opts $sub_opts]
-                set sub_result [punkcheck::install $srcdir $tgtdir {*}$sub_opts]
-
-                lappend files_copied {*}[dict get $sub_result files_copied]
-                lappend files_skipped {*}[dict get $sub_result files_skipped]
-                lappend sources_unchanged {*}[dict get $sub_result sources_unchanged]
-                lappend antiglob_paths_matched {*}[dict get $sub_result antiglob_paths_matched]
-                set punkcheck_records [dict get $sub_result punkcheck_records]
-            }
-            
-            if {[string match *store* $opt_source_checksum]} {
-                #puts "subdirlist: $subdirlist"
-                if {$CALLDEPTH == 0} {
-                    if {[llength $files_copied] || [llength $files_skipped]} {
-                        #puts stdout ">>>>>>>>>>>>>>>>>>>"
-                        set saveresult [punkcheck::save_records_to_file $punkcheck_records $punkcheck_file]
-                        puts stdout "punkcheck::install [dict get $saveresult recordcount] records saved as [dict get $saveresult linecount] lines to $punkcheck_file copied: [llength $files_copied] skipped: [llength $files_skipped]"
-                        #puts stdout ">>>>>>>>>>>>>>>>>>>"
-                    } else {
-                        #todo - write db INSTALLER record if -debug true
-                        
-                    }
-                    #puts stdout "sources_unchanged"
-                    #puts stdout "$sources_unchanged"
-                    #puts stdout "- -- --- --- --- ---"
-                }
-            }
-
-            return [list files_copied $files_copied files_skipped $files_skipped sources_unchanged $sources_unchanged antiglob_paths_matched $antiglob_paths_matched punkcheck_records $punkcheck_records punkcheck_folder $punkcheck_folder srcdir $srcdir tgtdir $tgtdir]
-        }
-        proc summarize_install_resultdict {resultdict} {
-            set msg ""
-            if {[dict size $resultdict]} {
-                set copied [dict get $resultdict files_copied]
-                append msg "--------------------------" \n
-                append msg  "[dict keys $resultdict]" \n
-                set tgtdir [dict get $resultdict tgtdir]
-                set checkfolder [dict get $resultdict punkcheck_folder]
-                append msg "Copied [llength $copied] files from [dict get $resultdict srcdir] to [dict get $resultdict tgtdir]" \n
-                foreach f $copied {
-                    append msg "COPIED [punkcheck::lib::path_relative $checkfolder $f]" \n
-                    append msg "    TO $tgtdir" \n
-                }
-                append msg "[llength [dict get $resultdict sources_unchanged]] unchanged source files" \n
-                append msg "[llength [dict get $resultdict files_skipped]] skipped files" \n
-                append msg "--------------------------" \n
-            }
-            return $msg
-        }
-
-        namespace eval recordlist {
-            set pkg punkcheck
-            namespace path ::punkcheck
-
-            proc records_as_target_dict {record_list} {
-                set result [dict create]
-                foreach rec $record_list {
-                    if {[dict get $rec tag] eq "FILEINFO"} {
-                        set tgtlist [dict get $rec -targets]
-                        dict set result $tgtlist $rec
-                    }
-                }
-                return $result
-            }
-
-
-
-
-            #will only match if same base was used.. and same targetlist
-            proc get_file_record {targetlist record_list} {
-                set posn 0
-                set found_posn -1
-                set record ""
-                foreach rec $record_list {
-                    if {[dict get $rec tag] eq "FILEINFO"} {
-                        if {[dict get $rec -targets] eq $targetlist} {
-                            set found_posn $posn
-                            set record $rec
-                            break
-                        }
-                    }
-                    incr posn
-                }
-                return [list position $found_posn record $record]
-            }
-            proc file_install_record_source_changes {install_record} {
-                #reject INSTALLFAILED items ?
-                if {[dict get $install_record tag] ni [list "QUERY-INPROGRESS" "INSTALL-RECORD" "INSTALL-SKIPPED" "INSTALL-INPROGRESS" "MODIFY-INPROGRESS" "MODIFY-RECORD" "MODIFY-SKIPPED" "VIRTUAL-INPROGRESS" "VIRTUAL-RECORD" "VIRTUAL-SKIPPED" "DELETE-RECORD" "DELETE-INPROGRESS" "DELETE-SKIPPED"]} {
-                    error "file_install_record_source_changes bad install record: tag '[dict get $install_record tag]' not INSTALL-RECORD|SKIPPED|INSTALL-INPROGRESS|MODIFY-RECORD|MODIFY-INPROGRESS|VIRTUAL-RECORD|VIRTUAL-INPROGRESS|DELETE-RECORD|DELETE-INPROGRESS"
-                }
-                set source_list [dict_getwithdefault $install_record body [list]]
-                set changed [list]
-                set unchanged [list]
-                foreach src $source_list {
-                    if {[dict exists $src -changed]} {
-                        if {[dict get $src -changed] !=0} {
-                            lappend changed [dict get $src -path]
-                        } else {
-                            lappend unchanged [dict get $src -path]
-                        }
-                    } else {
-                        lappend changed [dict get $src -path]
-                    }
-                }
-                return [dict create changed $changed unchanged $unchanged]
-            }
-
-            #assume only one for name - use first encountered
-            proc get_installer_record {name record_list} {
-                set posn 0
-                set found_posn -1
-                set record ""
-                #puts ">>>> checking [llength $record_list] punkcheck records"
-                foreach rec $record_list {
-                    if {[dict get $rec tag] eq "INSTALLER"} {
-                        if {[dict get $rec -name] eq $name} {
-                            set found_posn $posn
-                            set record $rec
-                            break
-                        }
-                    }
-                    incr posn
-                }
-                return [list position $found_posn record $record]
-            }
-
-            proc new_installer_record {name args} {
-                if {[llength $args] %2 !=0} {
-                    error "punkcheck new_installer_record args must be name-value pairs"
-                }
-                set ts [clock microseconds]
-                set seconds [expr {$ts / 1000000}]
-                set tsiso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-
-                #put -tsiso first so it lines up with -tsiso in event records
-                set defaults [list\
-                    -tsiso $tsiso\
-                    -ts $ts\
-                    -name $name\
-                    -keep_events 5\
-                    ]
-                set opts [dict merge $defaults $args]
-
-                #set this_installer_record_list [punk::tdl::prettyparse [list INSTALLER name $opt_installer ts $ts tsiso $tsiso keep_events 5 {}]]
-                #set this_installer_record [lindex $this_installer_record_list 0]
-
-                set record [dict create tag INSTALLER {*}$opts body {}]
-
-
-                return $record
-            }
-            proc new_installer_event_record {type args} {
-                if {[llength $args] %2 !=0} {
-                    error "punkcheck new_installer_event_record args must be name-value pairs"
-                }
-                set ts [clock microseconds]
-                set seconds [expr {$ts / 1000000}]
-                set tsiso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-                set defaults [list\
-                    -tsiso $tsiso\
-                    -ts $ts\
-                    -type $type\
-                    ]
-                set opts [dict merge $defaults $args]
-
-                set record [dict create tag EVENT {*}$opts]
-            }
-            #need to scan entire set if filerecords to check if event is still referenced
-            proc installer_record_pruneevents {installer_record record_list} {
-                set keep 5
-                if {[dict exists $installer_record -keep_events]} {
-                    set keep [dict get $installer_record -keep_events]
-                }
-
-                if {[dict exists $installer_record body]} {
-                    set body_items [dict get $installer_record body]
-                } else {
-                    set body_items [list]
-                }
-                set kept_body_items [list]
-                set kcount 0
-                foreach item [lreverse $body_items] {
-                    if {[dict get $item tag] eq "EVENT"} {
-                        incr kcount
-                        if {$keep < 0 || $kcount <= $keep} {
-                            lappend kept_body_items $item
-                        } else {
-                            set eventid ""
-                            if {[dict exists $item -id]} {
-                                set eventid [dict get $item -id]
-                            }
-                            if {$eventid ne "" && $eventid ne "unspecified"} {
-                                #keep if referenced, discard if not, or if eventid empty/unspecified
-                                set is_referenced 0
-                                foreach rec $record_list {
-                                    if {[dict get $rec tag] eq "FILEINFO"} {
-                                        if {[dict exists $rec body]} {
-                                            foreach install [dict get $rec body] {
-                                                if {[dict exists $install -eventid] && [dict get $install -eventid] eq $eventid} {
-                                                    set is_referenced 1
-                                                    break
-                                                }
-                                            }
-                                        }
-                                    }
-                                    if {$is_referenced} {
-                                        break
-                                    }
-                                }
-                                if {$is_referenced} {
-                                    lappend kept_body_items $item
-                                }
-                            }
-                        }
-                    } else {
-                        lappend kept_body_items $item
-                    }
-                }
-                set kept_body_items [lreverse $kept_body_items]
-                dict set installer_record body $kept_body_items
-                return $installer_record
-            }
-            proc installer_record_add_event {installer_record event} {
-                if {[dict get $installer_record tag] ne "INSTALLER"} {
-                    error "installer_record_add_event bad installer record: tag not INSTALLER"
-                }
-                if {[dict get $event tag] ne "EVENT"} {
-                    error "installer_record_add_event bad event record: tag not EVENT"
-                }
-                if {[dict exists $installer_record body]} {
-                    set body_items [dict get $installer_record body]
-                } else {
-                    set body_items [list]
-                }
-                lappend body_items $event
-                dict set installer_record body $body_items
-                return $installer_record
-            }
-            proc file_record_latest_installrecord {file_record} {
-                tailcall file_record_latest_operationrecord INSTALL $file_record
-            }
-            proc file_record_latest_operationrecord {operation file_record} {
-                set operation [string toupper $operation]
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    error "file_record_latest_operationrecord bad file_record: tag not FILEINFO"
-                }
-                if {![dict exists $file_record body]} {
-                    return [list]
-                }
-                set body_items [dict get $file_record body]
-                foreach item [lreverse $body_items] {
-                    if {[dict get $item tag] eq "$operation-RECORD"} {
-                        return $item
-                    }
-                }
-                return [list]
-            }
-
-
-            proc file_record_set_defaults {file_record} {
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    error "file_record_set_defaults bad file_record: tag not FILEINFO"
-                }
-                set defaults [list -keep_installrecords 3 -keep_skipped 1 -keep_inprogress 2] 
-                dict for {k v} $defaults {
-                    if {![dict exists $file_record $k]} {
-                        dict set file_record $k $v
-                    }
-                }
-                return $file_record
-            }
-
-            #negative keep_ value will keep all
-            proc file_record_prune {file_record} {
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    error "file_record_prune bad file_record: tag not FILEINFO"
-                }
-                set file_record [file_record_set_defaults $file_record]
-                set kmap [list -keep_installrecords *-RECORD -keep_skipped *-SKIPPED -keep_inprogress *-INPROGRESS]
-                foreach {key rtype} $kmap {
-                    set keep [dict get $file_record $key]
-                    if {[dict exists $file_record body]} {
-                        set body_items [dict get $file_record body]
-                    } else {
-                        set body_items [list]
-                    }
-                    set kept_body_items [list]
-                    set kcount 0
-                    foreach item [lreverse $body_items] {
-                        if {[string match $rtype [dict get $item tag]]} {
-                            incr kcount
-                            if {$keep < 0 || $kcount <= $keep} {
-                                lappend kept_body_items $item
-                            }
-                        } else {
-                            lappend kept_body_items $item
-                        }
-                    }
-                    set kept_body_items [lreverse $kept_body_items]
-                    dict set file_record body $kept_body_items
-                }
-                return $file_record
-            }
-
-            #extract new or existing filerecord for path given
-            #review - locking/concurrency
-            proc extract_or_create_fileset_record {relative_target_paths recordset} {
-                set fetch_record_result [punkcheck::recordlist::get_file_record $relative_target_paths $recordset]
-                set existing_posn [dict get $fetch_record_result position]
-                if {$existing_posn == -1} {
-                    #puts stdout "NO existing record for $relative_target_paths"
-                    set isnew 1
-                    set fileset_record [dict create tag FILEINFO -targets $relative_target_paths body {}]
-                } else {
-                    set recordset [lreplace $recordset[unset recordset] $existing_posn $existing_posn]
-                    set isnew 0
-                    set fileset_record [dict get $fetch_record_result record]
-                }
-                return [list record $fileset_record recordset $recordset isnew $isnew oldposition $existing_posn]
-            }
-
-        }
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punkcheck [namespace eval punkcheck {
-    set pkg punkcheck
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/set-2.2.3.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/set-2.2.3.tm
deleted file mode 100644
index 2ed2c260..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/set-2.2.3.tm
+++ /dev/null
@@ -1,189 +0,0 @@
-#----------------------------------------------------------------------
-#
-# sets.tcl --
-#
-#	Definitions for the processing of sets.
-#
-# Copyright (c) 2004-2008 by Andreas Kupries.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: sets.tcl,v 1.17 2008/03/09 04:24:37 andreas_kupries Exp $
-#
-#----------------------------------------------------------------------
-
-# @mdgen EXCLUDE: sets_c.tcl
-
-package require Tcl 8.5-
-
-namespace eval ::struct::set {}
-
-# ### ### ### ######### ######### #########
-## Management of set implementations.
-
-# ::struct::set::LoadAccelerator --
-#
-#	Loads a named implementation, if possible.
-#
-# Arguments:
-#	key	Name of the implementation to load.
-#
-# Results:
-#	A boolean flag. True if the implementation
-#	was successfully loaded; and False otherwise.
-
-proc ::struct::set::LoadAccelerator {key} {
-    variable accel
-    set r 0
-    switch -exact -- $key {
-	critcl {
-	    # Critcl implementation of set requires Tcl 8.4.
-	    if {![package vsatisfies [package provide Tcl] 8.4]} {return 0}
-	    if {[catch {package require tcllibc}]} {return 0}
-	    set r [llength [info commands ::struct::set_critcl]]
-	}
-	tcl {
-	    variable selfdir
-	    source [file join $selfdir sets_tcl.tcl]
-	    set r 1
-	}
-        default {
-            return -code error "invalid accelerator/impl. package $key:\
-                must be one of [join [KnownImplementations] {, }]"
-        }
-    }
-    set accel($key) $r
-    return $r
-}
-
-# ::struct::set::SwitchTo --
-#
-#	Activates a loaded named implementation.
-#
-# Arguments:
-#	key	Name of the implementation to activate.
-#
-# Results:
-#	None.
-
-proc ::struct::set::SwitchTo {key} {
-    variable accel
-    variable loaded
-
-    if {[string equal $key $loaded]} {
-	# No change, nothing to do.
-	return
-    } elseif {![string equal $key ""]} {
-	# Validate the target implementation of the switch.
-
-	if {![info exists accel($key)]} {
-	    return -code error "Unable to activate unknown implementation \"$key\""
-	} elseif {![info exists accel($key)] || !$accel($key)} {
-	    return -code error "Unable to activate missing implementation \"$key\""
-	}
-    }
-
-    # Deactivate the previous implementation, if there was any.
-
-    if {![string equal $loaded ""]} {
-	rename ::struct::set ::struct::set_$loaded
-    }
-
-    # Activate the new implementation, if there is any.
-
-    if {![string equal $key ""]} {
-	rename ::struct::set_$key ::struct::set
-    }
-
-    # Remember the active implementation, for deactivation by future
-    # switches.
-
-    set loaded $key
-    return
-}
-
-proc ::struct::set::Loaded {} {
-    variable loaded
-    return  $loaded
-}
-
-# ::struct::set::Implementations --
-#
-#	Determines which implementations are
-#	present, i.e. loaded.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	A list of implementation keys.
-
-proc ::struct::set::Implementations {} {
-    variable accel
-    set res {}
-    foreach n [array names accel] {
-	if {!$accel($n)} continue
-	lappend res $n
-    }
-    return $res
-}
-
-# ::struct::set::KnownImplementations --
-#
-#	Determines which implementations are known
-#	as possible implementations.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	A list of implementation keys. In the order
-#	of preference, most prefered first.
-
-proc ::struct::set::KnownImplementations {} {
-    return {critcl tcl}
-}
-
-proc ::struct::set::Names {} {
-    return {
-	critcl {tcllibc based}
-	tcl    {pure Tcl}
-    }
-}
-
-# ### ### ### ######### ######### #########
-## Initialization: Data structures.
-
-namespace eval ::struct::set {
-    variable  selfdir [file dirname [info script]]
-    variable  accel
-    array set accel   {tcl 0 critcl 0}
-    variable  loaded  {}
-}
-
-# ### ### ### ######### ######### #########
-## Initialization: Choose an implementation,
-## most prefered first. Loads only one of the
-## possible implementations. And activates it.
-
-namespace eval ::struct::set {
-    variable e
-    foreach e [KnownImplementations] {
-	if {[LoadAccelerator $e]} {
-	    SwitchTo $e
-	    break
-	}
-    }
-    unset e
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-namespace eval ::struct {
-    # Export the constructor command.
-    namespace export set
-}
-
-package provide struct::set 2.2.3
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/sets.tcl b/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/sets.tcl
deleted file mode 100644
index 2ed2c260..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/sets.tcl
+++ /dev/null
@@ -1,189 +0,0 @@
-#----------------------------------------------------------------------
-#
-# sets.tcl --
-#
-#	Definitions for the processing of sets.
-#
-# Copyright (c) 2004-2008 by Andreas Kupries.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: sets.tcl,v 1.17 2008/03/09 04:24:37 andreas_kupries Exp $
-#
-#----------------------------------------------------------------------
-
-# @mdgen EXCLUDE: sets_c.tcl
-
-package require Tcl 8.5-
-
-namespace eval ::struct::set {}
-
-# ### ### ### ######### ######### #########
-## Management of set implementations.
-
-# ::struct::set::LoadAccelerator --
-#
-#	Loads a named implementation, if possible.
-#
-# Arguments:
-#	key	Name of the implementation to load.
-#
-# Results:
-#	A boolean flag. True if the implementation
-#	was successfully loaded; and False otherwise.
-
-proc ::struct::set::LoadAccelerator {key} {
-    variable accel
-    set r 0
-    switch -exact -- $key {
-	critcl {
-	    # Critcl implementation of set requires Tcl 8.4.
-	    if {![package vsatisfies [package provide Tcl] 8.4]} {return 0}
-	    if {[catch {package require tcllibc}]} {return 0}
-	    set r [llength [info commands ::struct::set_critcl]]
-	}
-	tcl {
-	    variable selfdir
-	    source [file join $selfdir sets_tcl.tcl]
-	    set r 1
-	}
-        default {
-            return -code error "invalid accelerator/impl. package $key:\
-                must be one of [join [KnownImplementations] {, }]"
-        }
-    }
-    set accel($key) $r
-    return $r
-}
-
-# ::struct::set::SwitchTo --
-#
-#	Activates a loaded named implementation.
-#
-# Arguments:
-#	key	Name of the implementation to activate.
-#
-# Results:
-#	None.
-
-proc ::struct::set::SwitchTo {key} {
-    variable accel
-    variable loaded
-
-    if {[string equal $key $loaded]} {
-	# No change, nothing to do.
-	return
-    } elseif {![string equal $key ""]} {
-	# Validate the target implementation of the switch.
-
-	if {![info exists accel($key)]} {
-	    return -code error "Unable to activate unknown implementation \"$key\""
-	} elseif {![info exists accel($key)] || !$accel($key)} {
-	    return -code error "Unable to activate missing implementation \"$key\""
-	}
-    }
-
-    # Deactivate the previous implementation, if there was any.
-
-    if {![string equal $loaded ""]} {
-	rename ::struct::set ::struct::set_$loaded
-    }
-
-    # Activate the new implementation, if there is any.
-
-    if {![string equal $key ""]} {
-	rename ::struct::set_$key ::struct::set
-    }
-
-    # Remember the active implementation, for deactivation by future
-    # switches.
-
-    set loaded $key
-    return
-}
-
-proc ::struct::set::Loaded {} {
-    variable loaded
-    return  $loaded
-}
-
-# ::struct::set::Implementations --
-#
-#	Determines which implementations are
-#	present, i.e. loaded.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	A list of implementation keys.
-
-proc ::struct::set::Implementations {} {
-    variable accel
-    set res {}
-    foreach n [array names accel] {
-	if {!$accel($n)} continue
-	lappend res $n
-    }
-    return $res
-}
-
-# ::struct::set::KnownImplementations --
-#
-#	Determines which implementations are known
-#	as possible implementations.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	A list of implementation keys. In the order
-#	of preference, most prefered first.
-
-proc ::struct::set::KnownImplementations {} {
-    return {critcl tcl}
-}
-
-proc ::struct::set::Names {} {
-    return {
-	critcl {tcllibc based}
-	tcl    {pure Tcl}
-    }
-}
-
-# ### ### ### ######### ######### #########
-## Initialization: Data structures.
-
-namespace eval ::struct::set {
-    variable  selfdir [file dirname [info script]]
-    variable  accel
-    array set accel   {tcl 0 critcl 0}
-    variable  loaded  {}
-}
-
-# ### ### ### ######### ######### #########
-## Initialization: Choose an implementation,
-## most prefered first. Loads only one of the
-## possible implementations. And activates it.
-
-namespace eval ::struct::set {
-    variable e
-    foreach e [KnownImplementations] {
-	if {[LoadAccelerator $e]} {
-	    SwitchTo $e
-	    break
-	}
-    }
-    unset e
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-namespace eval ::struct {
-    # Export the constructor command.
-    namespace export set
-}
-
-package provide struct::set 2.2.3
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/sets_c.tcl b/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/sets_c.tcl
deleted file mode 100644
index c9837e94..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/sets_c.tcl
+++ /dev/null
@@ -1,93 +0,0 @@
-#----------------------------------------------------------------------
-#
-# sets_tcl.tcl --
-#
-#       Definitions for the processing of sets. C implementation.
-#
-# Copyright (c) 2007 by Andreas Kupries.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: sets_c.tcl,v 1.3 2008/03/25 07:15:34 andreas_kupries Exp $
-#
-#----------------------------------------------------------------------
-
-package require critcl
-# @sak notprovided struct_setc
-package provide struct_setc 2.1.1
-package require Tcl 8.5-
-
-namespace eval ::struct {
-    # Supporting code for the main command.
-
-    catch {
-        #critcl::cheaders -g
-        #critcl::debug memory symbols
-    }
-
-    critcl::cheaders sets/*.h
-    critcl::csources sets/*.c
-
-    critcl::ccode {
-        /* -*- c -*- */
-
-        #include <m.h>
-    }
-
-    # Main command, set creation.
-
-    critcl::ccommand set_critcl {dummy interp objc objv} {
-	/* Syntax - dispatcher to the sub commands.
-	 */
-
-        static CONST char* methods [] = {
-            "add",      "contains",     "difference",   "empty",
-            "equal","exclude",  "include",      "intersect",
-            "intersect3",       "size", "subsetof",     "subtract",
-            "symdiff",  "union",
-            NULL
-        };
-        enum methods {
-            S_add,      S_contains,     S_difference,   S_empty,
-            S_equal,S_exclude,  S_include,      S_intersect,
-            S_intersect3,       S_size, S_subsetof,     S_subtract,
-            S_symdiff,  S_union
-        };
-
-	int m;
-
-        if (objc < 2) {
-            Tcl_WrongNumArgs (interp, objc, objv, "cmd ?arg ...?");
-            return TCL_ERROR;
-        } else if (Tcl_GetIndexFromObj (interp, objv [1], methods, "option",
-            0, &m) != TCL_OK) {
-            return TCL_ERROR;
-        }
-
-        /* Dispatch to methods. They check the #args in detail before performing
-         * the requested functionality
-         */
-
-        switch (m) {
-            case S_add:        return sm_ADD        (NULL, interp, objc, objv);
-            case S_contains:   return sm_CONTAINS   (NULL, interp, objc, objv);
-            case S_difference: return sm_DIFFERENCE (NULL, interp, objc, objv);
-            case S_empty:      return sm_EMPTY      (NULL, interp, objc, objv);
-            case S_equal:      return sm_EQUAL      (NULL, interp, objc, objv);
-            case S_exclude:    return sm_EXCLUDE    (NULL, interp, objc, objv);
-            case S_include:    return sm_INCLUDE    (NULL, interp, objc, objv);
-            case S_intersect:  return sm_INTERSECT  (NULL, interp, objc, objv);
-            case S_intersect3: return sm_INTERSECT3 (NULL, interp, objc, objv);
-            case S_size:       return sm_SIZE       (NULL, interp, objc, objv);
-            case S_subsetof:   return sm_SUBSETOF   (NULL, interp, objc, objv);
-            case S_subtract:   return sm_SUBTRACT   (NULL, interp, objc, objv);
-            case S_symdiff:    return sm_SYMDIFF    (NULL, interp, objc, objv);
-            case S_union:      return sm_UNION      (NULL, interp, objc, objv);
-        }
-        /* Not coming to this place */
-    }
-}
-
-# ### ### ### ######### ######### #########
-## Ready
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/sets_tcl.tcl b/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/sets_tcl.tcl
deleted file mode 100644
index ad76704f..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/struct/sets_tcl.tcl
+++ /dev/null
@@ -1,452 +0,0 @@
-#----------------------------------------------------------------------
-#
-# sets_tcl.tcl --
-#
-#	Definitions for the processing of sets.
-#
-# Copyright (c) 2004-2008 by Andreas Kupries.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: sets_tcl.tcl,v 1.4 2008/03/09 04:38:47 andreas_kupries Exp $
-#
-#----------------------------------------------------------------------
-
-package require Tcl 8.5-
-
-namespace eval ::struct::set {
-    # Only export one command, the one used to instantiate a new tree
-    namespace export set_tcl
-}
-
-##########################
-# Public functions
-
-# ::struct::set::set --
-#
-#	Command that access all set commands.
-#
-# Arguments:
-#	cmd	Name of the subcommand to dispatch to.
-#	args	Arguments for the subcommand.
-#
-# Results:
-#	Whatever the result of the subcommand is.
-
-proc ::struct::set::set_tcl {cmd args} {
-    # Do minimal args checks here
-    if { [llength [info level 0]] == 1 } {
-	return -code error "wrong # args: should be \"$cmd ?arg arg ...?\""
-    }
-    ::set sub S_$cmd
-    if { [llength [info commands ::struct::set::$sub]] == 0 } {
-	::set optlist [info commands ::struct::set::S_*]
-	::set xlist {}
-	foreach p $optlist {
-	    lappend xlist [string range $p 17 end]
-	}
-	return -code error \
-		"bad option \"$cmd\": must be [linsert [join [lsort $xlist] ", "] "end-1" "or"]"
-    }
-    return [uplevel 1 [linsert $args 0 ::struct::set::$sub]]
-}
-
-##########################
-# Implementations of the functionality.
-#
-
-# ::struct::set::S_empty --
-#
-#       Determines emptiness of the set
-#
-# Parameters:
-#       set	-- The set to check for emptiness.
-#
-# Results:
-#       A boolean value. True indicates that the set is empty.
-#
-# Side effects:
-#       None.
-#
-# Notes:
-
-proc ::struct::set::S_empty {set} {
-    return [expr {[llength $set] == 0}]
-}
-
-# ::struct::set::S_size --
-#
-#	Computes the cardinality of the set.
-#
-# Parameters:
-#	set	-- The set to inspect.
-#
-# Results:
-#       An integer greater than or equal to zero.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_size {set} {
-    return [llength [Cleanup $set]]
-}
-
-# ::struct::set::S_contains --
-#
-#	Determines if the item is in the set.
-#
-# Parameters:
-#	set	-- The set to inspect.
-#	item	-- The element to look for.
-#
-# Results:
-#	A boolean value. True indicates that the element is present.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_contains {set item} {
-    return [expr {[lsearch -exact $set $item] >= 0}]
-}
-
-# ::struct::set::S_union --
-#
-#	Computes the union of the arguments.
-#
-# Parameters:
-#	args	-- List of sets to unify.
-#
-# Results:
-#	The union of the arguments.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_union {args} {
-    switch -exact -- [llength $args] {
-	0 {return {}}
-	1 {return [lindex $args 0]}
-    }
-    foreach setX $args {
-	foreach x $setX {::set ($x) {}}
-    }
-    return [array names {}]
-}
-
-
-# ::struct::set::S_intersect --
-#
-#	Computes the intersection of the arguments.
-#
-# Parameters:
-#	args	-- List of sets to intersect.
-#
-# Results:
-#	The intersection of the arguments
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_intersect {args} {
-    switch -exact -- [llength $args] {
-	0 {return {}}
-	1 {return [lindex $args 0]}
-    }
-    ::set res [lindex $args 0]
-    foreach set [lrange $args 1 end] {
-	if {[llength $res] && [llength $set]} {
-	    ::set res [Intersect $res $set]
-	} else {
-	    # Squash 'res'. Otherwise we get the wrong result if res
-	    # is not empty, but 'set' is.
-	    ::set res {}
-	    break
-	}
-    }
-    return $res
-}
-
-proc ::struct::set::Intersect {A B} {
-    if {[llength $A] == 0} {return {}}
-    if {[llength $B] == 0} {return {}}
-
-    # This is slower than local vars, but more robust
-    if {[llength $B] > [llength $A]} {
-	::set res $A
-	::set A $B
-	::set B $res
-    }
-    ::set res {}
-    foreach x $A {::set ($x) {}}
-    foreach x $B {
-	if {[info exists ($x)]} {
-	    lappend res $x
-	}
-    }
-    return $res
-}
-
-# ::struct::set::S_difference --
-#
-#	Compute difference of two sets.
-#
-# Parameters:
-#	A, B	-- Sets to compute the difference for.
-#
-# Results:
-#	A - B
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_difference {A B} {
-    if {[llength $A] == 0} {return {}}
-    if {[llength $B] == 0} {return $A}
-
-    array set tmp {}
-    foreach x $A {::set tmp($x) .}
-    foreach x $B {catch {unset tmp($x)}}
-    return [array names tmp]
-}
-
-if {0} {
-    # Tcllib SF Bug 1002143. We cannot use the implementation below.
-    # It will treat set elements containing '(' and ')' as array
-    # elements, and this screws up the storage of elements as the name
-    # of local vars something fierce. No way around this. Disabling
-    # this code and always using the other implementation (s.a.) is
-    # the only possible fix.
-
-    if {[package vcompare [package provide Tcl] 8.4] < 0} {
-	# Tcl 8.[23]. Use explicit array to perform the operation.
-    } else {
-	# Tcl 8.4+, has 'unset -nocomplain'
-
-	proc ::struct::set::S_difference {A B} {
-	    if {[llength $A] == 0} {return {}}
-	    if {[llength $B] == 0} {return $A}
-
-	    # Get the variable B out of the way, avoid collisions
-	    # prepare for "pure list optimization"
-	    ::set ::struct::set::tmp [lreplace $B -1 -1 unset -nocomplain]
-	    unset B
-
-	    # unset A early: no local variables left
-	    foreach [lindex [list $A [unset A]] 0] {.} {break}
-
-	    eval $::struct::set::tmp
-	    return [info locals]
-	}
-    }
-}
-
-# ::struct::set::S_symdiff --
-#
-#	Compute symmetric difference of two sets.
-#
-# Parameters:
-#	A, B	-- The sets to compute the s.difference for.
-#
-# Results:
-#	The symmetric difference of the two input sets.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_symdiff {A B} {
-    # symdiff == (A-B) + (B-A) == (A+B)-(A*B)
-    if {[llength $A] == 0} {return $B}
-    if {[llength $B] == 0} {return $A}
-    return [S_union \
-	    [S_difference $A $B] \
-	    [S_difference $B $A]]
-}
-
-# ::struct::set::S_intersect3 --
-#
-#	Return intersection and differences for two sets.
-#
-# Parameters:
-#	A, B	-- The sets to inspect.
-#
-# Results:
-#	List containing A*B, A-B, and B-A
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_intersect3 {A B} {
-    return [list \
-	    [S_intersect $A $B] \
-	    [S_difference $A $B] \
-	    [S_difference $B $A]]
-}
-
-# ::struct::set::S_equal --
-#
-#	Compares two sets for equality.
-#
-# Parameters:
-#	a	First set to compare.
-#	b	Second set to compare.
-#
-# Results:
-#	A boolean. True if the lists are equal.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_equal {A B} {
-    ::set A [Cleanup $A]
-    ::set B [Cleanup $B]
-
-    # Equal if of same cardinality and difference is empty.
-
-    if {[::llength $A] != [::llength $B]} {return 0}
-    return [expr {[llength [S_difference $A $B]] == 0}]
-}
-
-
-proc ::struct::set::Cleanup {A} {
-    # unset A to avoid collisions
-    if {[llength $A] < 2} {return $A}
-    # We cannot use variables to avoid an explicit array. The set
-    # elements may look like namespace vars (i.e. contain ::), and
-    # such elements break that, cannot be proc-local variables.
-    array set S {}
-    foreach item $A {set S($item) .}
-    return [array names S]
-}
-
-# ::struct::set::S_include --
-#
-#	Add an element to a set.
-#
-# Parameters:
-#	Avar	-- Reference to the set variable to extend.
-#	element	-- The item to add to the set.
-#
-# Results:
-#	None.
-#
-# Side effects:
-#       The set in the variable referenced by Avar is extended
-#	by the element (if the element was not already present).
-
-proc ::struct::set::S_include {Avar element} {
-    # Avar = Avar + {element}
-    upvar 1 $Avar A
-    if {![info exists A] || ![S_contains $A $element]} {
-	lappend A $element
-    }
-    return
-}
-
-# ::struct::set::S_exclude --
-#
-#	Remove an element from a set.
-#
-# Parameters:
-#	Avar	-- Reference to the set variable to shrink.
-#	element	-- The item to remove from the set.
-#
-# Results:
-#	None.
-#
-# Side effects:
-#       The set in the variable referenced by Avar is shrunk,
-#	the element remove (if the element was actually present).
-
-proc ::struct::set::S_exclude {Avar element} {
-    # Avar = Avar - {element}
-    upvar 1 $Avar A
-    if {![info exists A]} {return -code error "can't read \"$Avar\": no such variable"}
-    while {[::set pos [lsearch -exact $A $element]] >= 0} {
-	::set A [lreplace [K $A [::set A {}]] $pos $pos]
-    }
-    return
-}
-
-# ::struct::set::S_add --
-#
-#	Add a set to a set. Similar to 'union', but the first argument
-#	is a variable.
-#
-# Parameters:
-#	Avar	-- Reference to the set variable to extend.
-#	B	-- The set to add to the set in Avar.
-#
-# Results:
-#	None.
-#
-# Side effects:
-#       The set in the variable referenced by Avar is extended
-#	by all the elements in B.
-
-proc ::struct::set::S_add {Avar B} {
-    # Avar = Avar + B
-    upvar 1 $Avar A
-    if {![info exists A]} {set A {}}
-    ::set A [S_union [K $A [::set A {}]] $B]
-    return
-}
-
-# ::struct::set::S_subtract --
-#
-#	Remove a set from a set. Similar to 'difference', but the first argument
-#	is a variable.
-#
-# Parameters:
-#	Avar	-- Reference to the set variable to shrink.
-#	B	-- The set to remove from the set in Avar.
-#
-# Results:
-#	None.
-#
-# Side effects:
-#       The set in the variable referenced by Avar is shrunk,
-#	all elements of B are removed.
-
-proc ::struct::set::S_subtract {Avar B} {
-    # Avar = Avar - B
-    upvar 1 $Avar A
-    if {![info exists A]} {return -code error "can't read \"$Avar\": no such variable"}
-    ::set A [S_difference [K $A [::set A {}]] $B]
-    return
-}
-
-# ::struct::set::S_subsetof --
-#
-#	A predicate checking if the first set is a subset
-#	or equal to the second set.
-#
-# Parameters:
-#	A	-- The possible subset.
-#	B	-- The set to compare to.
-#
-# Results:
-#	A boolean value, true if A is subset of or equal to B
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_subsetof {A B} {
-    # A subset|== B <=> (A == A*B)
-    return [S_equal $A [S_intersect $A $B]]
-}
-
-# ::struct::set::K --
-# Performance helper command.
-
-proc ::struct::set::K {x y} {::set x}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-namespace eval ::struct {
-    # Put 'set::set' into the general structure namespace
-    # for pickup by the main management.
-
-    namespace import -force set::set_tcl
-}
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil-0.9.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil-0.9.tm
deleted file mode 100644
index 59258514..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil-0.9.tm
+++ /dev/null
@@ -1,80 +0,0 @@
-# textutil.tcl --
-#
-#	Utilities for manipulating strings, words, single lines,
-#	paragraphs, ...
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2002      by Joe English <jenglish@users.sourceforge.net>
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: textutil.tcl,v 1.17 2006/09/21 06:46:24 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-## All through sub-packages imported here.
-
-package require textutil::string
-package require textutil::repeat
-package require textutil::adjust
-package require textutil::split
-package require textutil::tabify
-package require textutil::trim
-package require textutil::wcswidth
-
-namespace eval ::textutil {
-    # Import the miscellaneous string command for public export
-
-    namespace import -force string::chop string::tail
-    namespace import -force string::cap string::uncap string::capEachWord
-    namespace import -force string::longestCommonPrefix
-    namespace import -force string::longestCommonPrefixList
-
-    # Import the repeat commands for public export
-
-    namespace import -force repeat::strRepeat repeat::blank
-
-    # Import the adjust commands for public export
-
-    namespace import -force adjust::adjust adjust::indent adjust::undent
-
-    # Import the split commands for public export
-
-    namespace import -force split::splitx split::splitn
-
-    # Import the trim commands for public export
-
-    namespace import -force trim::trim trim::trimleft trim::trimright
-    namespace import -force trim::trimPrefix trim::trimEmptyHeading
-
-    # Import the tabify commands for public export
-
-    namespace import -force tabify::tabify tabify::untabify
-    namespace import -force tabify::tabify2 tabify::untabify2
-
-    # Re-export all the imported commands
-
-    namespace export chop tail cap uncap capEachWord
-    namespace export longestCommonPrefix longestCommonPrefixList
-    namespace export strRepeat blank
-    namespace export adjust indent undent
-    namespace export splitx splitn
-    namespace export trim trimleft trimright trimPrefix trimEmptyHeading
-    namespace export tabify untabify tabify2 untabify2
-}
-
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil 0.9
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/adjust-0.7.3.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/adjust-0.7.3.tm
deleted file mode 100644
index d47c82f8..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/adjust-0.7.3.tm
+++ /dev/null
@@ -1,761 +0,0 @@
-# trim.tcl --
-#
-#	Various ways of trimming a string.
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2002-2004 by Johannes-Heinrich Vogeler <vogeler@users.sourceforge.net>
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: adjust.tcl,v 1.16 2011/12/13 18:12:56 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-package require textutil::repeat
-package require textutil::string
-
-namespace eval ::textutil::adjust {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-
-namespace eval ::textutil::adjust {
-    namespace import -force ::textutil::repeat::strRepeat
-}
-
-proc ::textutil::adjust::adjust {text args} {
-    if {[string length [string trim $text]] == 0} {
-        return ""
-    }
-
-    Configure $args
-    Adjust text newtext
-
-    return $newtext
-}
-
-proc ::textutil::adjust::Configure {args} {
-    variable Justify      left
-    variable Length       72
-    variable FullLine     0
-    variable StrictLength 0
-    variable Hyphenate    0
-    variable HyphPatterns    ; # hyphenation patterns (TeX)
-
-    set args [ lindex $args 0 ]
-    foreach { option value } $args {
-	switch -exact -- $option {
-	    -full {
-		if { ![ string is boolean -strict $value ] } then {
-		    error "expected boolean but got \"$value\""
-		}
-		set FullLine [ string is true $value ]
-	    }
-	    -hyphenate {
-		# the word exceeding the length of line is tried to be
-		# hyphenated; if a word cannot be hyphenated to fit into
-		# the line processing stops! The length of the line should
-		# be set to a reasonable value!
-
-		if { ![ string is boolean -strict $value ] } then {
-		    error "expected boolean but got \"$value\""
-		}
-		set Hyphenate [string is true $value]
-		if { $Hyphenate && ![info exists HyphPatterns(_LOADED_)]} {
-		    error "hyphenation patterns not loaded!"
-		}
-	    }
-	    -justify {
-		set lovalue [ string tolower $value ]
-		switch -exact -- $lovalue {
-		    left -
-		    right -
-		    center -
-		    plain {
-			set Justify $lovalue
-		    }
-		    default {
-			error "bad value \"$value\": should be center, left, plain or right"
-		    }
-		}
-	    }
-	    -length {
-		if { ![ string is integer $value ] } then {
-		    error "expected positive integer but got \"$value\""
-		}
-		if { $value < 1 } then {
-		    error "expected positive integer but got \"$value\""
-		}
-		set Length $value
-	    }
-	    -strictlength {
-		# the word exceeding the length of line is moved to the
-		# next line without hyphenation; words longer than given
-		# line length are cut into smaller pieces
-
-		if { ![ string is boolean -strict $value ] } then {
-		    error "expected boolean but got \"$value\""
-		}
-		set StrictLength [ string is true $value ]
-	    }
-	    default {
-		error "bad option \"$option\": must be -full, -hyphenate, \
-			-justify, -length, or -strictlength"
-	    }
-	}
-    }
-
-    return ""
-}
-
-# ::textutil::adjust::Adjust
-#
-# History:
-#      rewritten on 2004-04-13 for bugfix tcllib-bugs-882402 (jhv)
-
-proc ::textutil::adjust::Adjust { varOrigName varNewName } {
-    variable Length
-    variable FullLine
-    variable StrictLength
-    variable Hyphenate
-
-    upvar $varOrigName orig
-    upvar $varNewName  text
-
-    set pos 0;                                   # Cursor after writing
-    set line ""
-    set text ""
-
-
-    if {!$FullLine} {
-	regsub -all -- "(\n)|(\t)"     $orig   " "  orig
-	regsub -all -- " +"            $orig  " "   orig
-	regsub -all -- "(^ *)|( *\$)"  $orig  ""    orig
-    }
-
-    set words [split $orig]
-    set numWords [llength $words]
-    set numline 0
-
-    for {set cnt 0} {$cnt < $numWords} {incr cnt} {
-
-	set w [lindex $words $cnt]
-	set wLen [string length $w]
-
-	# the word $w doesn't fit into the present line
-	# case #1: we try to hyphenate
-
-	if {$Hyphenate && ($pos+$wLen >= $Length)} {
-	    # Hyphenation instructions
-	    set w2 [textutil::adjust::Hyphenation $w]
-
-	    set iMax [llength $w2]
-	    if {$iMax == 1 && [string length $w] > $Length} {
-		# word cannot be hyphenated and exceeds linesize
-
-		error "Word \"$w2\" can\'t be hyphenated\
-			and exceeds linesize $Length!"
-	    } else {
-		# hyphenating of $w was successfull, but we have to look
-		# that every sylable would fit into the line
-
-		foreach x $w2 {
-		    if {[string length $x] >= $Length} {
-			error "Word \"$w\" can\'t be hyphenated\
-				to fit into linesize $Length!"
-		    }
-		}
-	    }
-
-	    for {set i 0; set w3 ""} {$i < $iMax} {incr i} {
-		set syl [lindex $w2 $i]
-		if {($pos+[string length " $w3$syl-"]) > $Length} {break}
-		append w3 $syl
-	    }
-	    for {set w4 ""} {$i < $iMax} {incr i} {
-		set syl [lindex $w2 $i]
-		append w4 $syl
-	    }
-
-	    if {[string length $w3] && [string length $w4]} {
-		# hyphenation was successfull: redefine
-		# list of words w => {"$w3-" "$w4"}
-
-		set x [lreplace $words $cnt $cnt "$w4"]
-		set words [linsert $x $cnt "$w3-"]
-		set w [lindex $words $cnt]
-		set wLen [string length $w]
-		incr numWords
-	    }
-	}
-
-	# the word $w doesn't fit into the present line
-	# case #2: we try to cut the word into pieces
-
-	if {$StrictLength && ([string length $w] > $Length)} {
-	    # cut word into two pieces
-	    set w2 $w
-
-	    set over [expr {$pos+2+$wLen-$Length}]
-
-	    incr Length -1
-	    set w3   [string range $w2 0 $Length]
-	    incr Length
-	    set w4   [string range $w2 $Length end]
-
-	    set x [lreplace $words $cnt $cnt $w4]
-	    set words [linsert $x $cnt $w3 ]
-	    set w [lindex $words $cnt]
-	    set wLen [string length $w]
-	    incr numWords
-	}
-
-	# continuing with the normal procedure
-
-	if {($pos+$wLen < $Length)} {
-	    # append word to current line
-
-	    if {$pos} {append line " "; incr pos}
-	    append line $w
-	    incr pos $wLen
-	} else {
-	    # line full => write buffer and  begin a new line
-
-	    if {[string length $text]} {append text "\n"}
-	    append text [Justification $line [incr numline]]
-	    set line $w
-	    set pos $wLen
-	}
-    }
-
-    # write buffer and return!
-
-    if {[string length $text]} {append text "\n"}
-    append text [Justification $line end]
-    return $text
-}
-
-# ::textutil::adjust::Justification
-#
-# justify a given line
-#
-# Parameters:
-#      line    text for justification
-#      index   index for line in text
-#
-# Returns:
-#      the justified line
-#
-# Remarks:
-#      Only lines with size not exceeding the max. linesize provided
-#      for text formatting are justified!!!
-
-proc ::textutil::adjust::Justification { line index } {
-    variable Justify
-    variable Length
-    variable FullLine
-
-    set len [string length $line];               # length of current line
-
-    if { $Length <= $len } then {
-	# the length of current line ($len) is equal as or greater than
-	# the value provided for text formatting ($Length) => to avoid
-	# inifinite loops we leave $line unchanged and return!
-
-	return $line
-    }
-
-    # Special case:
-    # for the last line, and if the justification is set to 'plain'
-    # the real justification is 'left' if the length of the line
-    # is less than 90% (rounded) of the max length allowed. This is
-    # to avoid expansion of this line when it is too small: without
-    # it, the added spaces will 'unbeautify' the result.
-    #
-
-    set justify $Justify
-    if { ( "$index" == "end" ) && \
-	    ( "$Justify" == "plain" ) && \
-	    ( $len < round($Length * 0.90) ) } then {
-	set justify left
-    }
-
-    # For a left justification, nothing to do, but to
-    # add some spaces at the end of the line if requested
-
-    if { "$justify" == "left" } then {
-	set jus ""
-	if { $FullLine } then {
-	    set jus [strRepeat " " [ expr { $Length - $len } ]]
-	}
-	return "${line}${jus}"
-    }
-
-    # For a right justification, just add enough spaces
-    # at the beginning of the line
-
-    if { "$justify" == "right" } then {
-	set jus [strRepeat " " [ expr { $Length - $len } ]]
-	return "${jus}${line}"
-    }
-
-    # For a center justification, add half of the needed spaces
-    # at the beginning of the line, and the rest at the end
-    # only if needed.
-
-    if { "$justify" == "center" } then {
-	set mr [ expr { ( $Length - $len ) / 2 } ]
-	set ml [ expr { $Length - $len - $mr } ]
-	set jusl [strRepeat " " $ml]
-	set jusr [strRepeat " " $mr]
-	if { $FullLine } then {
-	    return "${jusl}${line}${jusr}"
-	} else {
-	    return "${jusl}${line}"
-	}
-    }
-
-    # For a plain justification, it's a little bit complex:
-    #
-    # if some spaces are missing, then
-    #
-    # 1) sort the list of words in the current line by decreasing size
-    # 2) foreach word, add one space before it, except if it's the
-    #    first word, until enough spaces are added
-    # 3) rebuild the line
-
-    if { "$justify" == "plain" } then {
-	set miss [ expr { $Length - [ string length $line ] } ]
-
-	# Bugfix tcllib-bugs-860753 (jhv)
-
-	set words [split $line]
-	set numWords [llength $words]
-
-	if {$numWords < 2} {
-	    # current line consists of less than two words - we can't
-	    # insert blanks to achieve a plain justification => leave
-	    # $line unchanged and return!
-
-	    return $line
-	}
-
-	for {set i 0; set totalLen 0} {$i < $numWords} {incr i} {
-	    set w($i) [lindex $words $i]
-	    if {$i > 0} {set w($i) " $w($i)"}
-	    set wLen($i) [string length $w($i)]
-	    set totalLen [expr {$totalLen+$wLen($i)}]
-	}
-
-	set miss [expr {$Length - $totalLen}]
-
-	# len walks through all lengths of words of the line under
-	# consideration
-
-	for {set len 1} {$miss > 0} {incr len} {
-	    for {set i 1} {($i < $numWords) && ($miss > 0)} {incr i} {
-		if {$wLen($i) == $len} {
-		    set w($i) " $w($i)"
-		    incr wLen($i)
-		    incr miss -1
-		}
-	    }
-	}
-
-	set line ""
-	for {set i 0} {$i < $numWords} {incr i} {
-	    set line "$line$w($i)"
-	}
-
-	# End of bugfix
-
-	return "${line}"
-    }
-
-    error "Illegal justification key \"$justify\""
-}
-
-proc ::textutil::adjust::SortList { list dir index } {
-
-    if { [ catch { lsort -integer -$dir -index $index $list } sl ] != 0 } then {
-        error "$sl"
-    }
-
-    return $sl
-}
-
-# Hyphenation utilities based on Knuth's algorithm
-#
-# Copyright (C) 2001-2003 by Dr.Johannes-Heinrich Vogeler (jhv)
-# These procedures may be used as part of the tcllib
-
-# textutil::adjust::Hyphenation
-#
-#      Hyphenate a string using Knuth's algorithm
-#
-# Parameters:
-#      str     string to be hyphenated
-#
-# Returns:
-#      the hyphenated string
-
-proc ::textutil::adjust::Hyphenation { str } {
-
-    # if there are manual set hyphenation marks e.g. "Recht\-schrei\-bung"
-    # use these for hyphenation and return
-
-    if {[regexp {[^\\-]*[\\-][.]*} $str]} {
-	regsub -all {(\\)(-)} $str {-} tmp
-	return [split $tmp -]
-    }
-
-    # Don't hyphenate very short words! Minimum length for hyphenation
-    # is set to 3 characters!
-
-    if { [string length $str] < 4 } then { return $str }
-
-    # otherwise follow Knuth's algorithm
-
-    variable HyphPatterns;                       # hyphenation patterns (TeX)
-
-    set w ".[string tolower $str].";             # transform to lower case
-    set wLen [string length $w];                 # and add delimiters
-
-    # Initialize hyphenation weights
-
-    set s {}
-    for {set i 0} {$i < $wLen} {incr i} {
-	lappend s 0
-    }
-
-    for {set i 0} {$i < $wLen} {incr i} {
-	set kmax [expr {$wLen-$i}]
-	for {set k 1} {$k < $kmax} {incr k} {
-	    set sw [string range $w $i [expr {$i+$k}]]
-	    if {[info exists HyphPatterns($sw)]} {
-		set hw $HyphPatterns($sw)
-		set hwLen [string length $hw]
-		for {set l1 0; set l2 0} {$l1 < $hwLen} {incr l1} {
-		    set c [string index $hw $l1]
-		    if {[string is digit $c]} {
-			set sPos [expr {$i+$l2}]
-			if {$c > [lindex $s $sPos]} {
-			    set s [lreplace $s $sPos $sPos $c]
-			}
-		    } else {
-			incr l2
-		    }
-		}
-	    }
-	}
-    }
-
-    # Replace all even hyphenation weigths by zero
-
-    for {set i 0} {$i < [llength $s]} {incr i} {
-	set c [lindex $s $i]
-	if {!($c%2)} { set s [lreplace $s $i $i 0] }
-    }
-
-    # Don't start with a hyphen! Take also care of words enclosed in quotes
-    # or that someone has forgotten to put a blank between a punctuation
-    # character and the following word etc.
-
-    for {set i 1} {$i < ($wLen-1)} {incr i} {
-	set c [string range $w $i end]
-	if {[regexp {^[:alpha:][.]*} $c]} {
-	    for {set k 1} {$k < ($i+1)} {incr k} {
-		set s [lreplace $s $k $k 0]
-	    }
-	    break
-	}
-    }
-
-    # Don't separate the last character of a word with a hyphen
-
-    set max [expr {[llength $s]-2}]
-    if {$max} {set s [lreplace $s $max end 0]}
-
-    # return the syllabels of the hyphenated word as a list!
-
-    set ret ""
-    set w ".$str."
-    for {set i 1} {$i < ($wLen-1)} {incr i} {
-	if {[lindex $s $i]} { append ret - }
-	append ret [string index $w $i]
-    }
-    return [split $ret -]
-}
-
-# textutil::adjust::listPredefined
-#
-#      Return the names of the hyphenation files coming with the package.
-#
-# Parameters:
-#      None.
-#
-# Result:
-#       List of filenames (without directory)
-
-proc ::textutil::adjust::listPredefined {} {
-    variable here
-    return [glob -type f -directory $here -tails *.tex]
-}
-
-# textutil::adjust::getPredefined
-#
-#      Retrieve the full path for a predefined hyphenation file
-#       coming with the package.
-#
-# Parameters:
-#      name     Name of the predefined file.
-#
-# Results:
-#       Full path to the file, or an error if it doesn't
-#       exist or is matching the pattern *.tex.
-
-proc ::textutil::adjust::getPredefined {name} {
-    variable here
-
-    if {![string match *.tex $name]} {
-        return -code error \
-                "Illegal hyphenation file \"$name\""
-    }
-    set path [file join $here $name]
-    if {![file exists $path]} {
-        return -code error \
-                "Unknown hyphenation file \"$path\""
-    }
-    return $path
-}
-
-# textutil::adjust::readPatterns
-#
-#      Read hyphenation patterns from a file and store them in an array
-#
-# Parameters:
-#      filNam  name of the file containing the patterns
-
-proc ::textutil::adjust::readPatterns { filNam } {
-
-    variable HyphPatterns;                       # hyphenation patterns (TeX)
-
-    # HyphPatterns(_LOADED_) is used as flag for having loaded
-    # hyphenation patterns from the respective file (TeX format)
-
-    if {[info exists HyphPatterns(_LOADED_)]} {
-	unset HyphPatterns(_LOADED_)
-    }
-
-    # the array xlat provides translation from TeX encoded characters
-    # to those of the ISO-8859-1 character set
-
-    set xlat(\"s) \337;  # 223 := sharp s    "
-    set xlat(\`a) \340;  # 224 := a, grave
-    set xlat(\'a) \341;  # 225 := a, acute
-    set xlat(\^a) \342;  # 226 := a, circumflex
-    set xlat(\"a) \344;  # 228 := a, diaeresis "
-    set xlat(\`e) \350;  # 232 := e, grave
-    set xlat(\'e) \351;  # 233 := e, acute
-    set xlat(\^e) \352;  # 234 := e, circumflex
-    set xlat(\`i) \354;  # 236 := i, grave
-    set xlat(\'i) \355;  # 237 := i, acute
-    set xlat(\^i) \356;  # 238 := i, circumflex
-    set xlat(\~n) \361;  # 241 := n, tilde
-    set xlat(\`o) \362;  # 242 := o, grave
-    set xlat(\'o) \363;  # 243 := o, acute
-    set xlat(\^o) \364;  # 244 := o, circumflex
-    set xlat(\"o) \366;  # 246 := o, diaeresis "
-    set xlat(\`u) \371;  # 249 := u, grave
-    set xlat(\'u) \372;  # 250 := u, acute
-    set xlat(\^u) \373;  # 251 := u, circumflex
-    set xlat(\"u) \374;  # 252 := u, diaeresis "
-
-    set fd [open $filNam RDONLY]
-    set status 0
-
-    while {[gets $fd line] >= 0} {
-
-	switch -exact $status {
-	    PATTERNS {
-		if {[regexp {^\}[.]*} $line]} {
-		    # End of patterns encountered: set status
-		    # and ignore that line
-		    set status 0
-		    continue
-		} else {
-		    # This seems to be pattern definition line; to process it
-		    # we have first to do some editing
-		    #
-		    # 1) eat comments in a pattern definition line
-		    # 2) eat braces and coded linefeeds
-
-		    set z [string first "%" $line]
-		    if {$z > 0} { set line [string range $line 0 [expr {$z-1}]] }
-
-		    regsub -all {(\\n|\{|\})} $line {} tmp
-		    set line $tmp
-
-		    # Now $line should consist only of hyphenation patterns
-		    # separated by white space
-
-		    # Translate TeX encoded characters to ISO-8859-1 characters
-		    # using the array xlat defined above
-
-		    foreach x [array names xlat] {
-			regsub -all {$x} $line $xlat($x) tmp
-			set line $tmp
-		    }
-
-		    # split the line and create a lookup array for
-		    # the repective hyphenation patterns
-
-		    foreach item [split $line] {
-			if {[string length $item]} {
-			    if {![string match {\\} $item]} {
-				# create index for hyphenation patterns
-
-				set var $item
-				regsub -all {[0-9]} $var {} idx
-				# store hyphenation patterns as elements of an array
-
-				set HyphPatterns($idx) $item
-			    }
-			}
-		    }
-		}
-	    }
-	    EXCEPTIONS {
-		if {[regexp {^\}[.]*} $line]} {
-		    # End of patterns encountered: set status
-		    # and ignore that line
-		    set status 0
-		    continue
-		} else {
-		    # to be done in the future
-		}
-	    }
-	    default {
-		if {[regexp {^\\endinput[.]*} $line]} {
-		    # end of data encountered, stop processing and
-		    # ignore all the following text ..
-		    break
-		} elseif {[regexp {^\\patterns[.]*} $line]} {
-		    # begin of patterns encountered: set status
-		    # and ignore that line
-		    set status PATTERNS
-		    continue
-		} elseif {[regexp {^\\hyphenation[.]*} $line]} {
-		    # some particular cases to be treated separately
-		    set status EXCEPTIONS
-		    continue
-		} else {
-		    set status 0
-		}
-	    }
-	}
-    }
-
-    close $fd
-    set HyphPatterns(_LOADED_) 1
-
-    return
-}
-
-#######################################################
-
-# @c The specified <a text>block is indented
-# @c by <a prefix>ing each line. The first
-# @c <a hang> lines ares skipped.
-#
-# @a text:   The paragraph to indent.
-# @a prefix: The string to use as prefix for each line
-# @a prefix: of <a text> with.
-# @a skip:   The number of lines at the beginning to leave untouched.
-#
-# @r Basically <a text>, but indented a certain amount.
-#
-# @i indent
-# @n This procedure is not checked by the testsuite.
-
-proc ::textutil::adjust::indent {text prefix {skip 0}} {
-    set text [string trimright $text]
-
-    set res [list]
-    foreach line [split $text \n] {
-	if {[string compare "" [string trim $line]] == 0} {
-	    lappend res {}
-	} else {
-	    set line [string trimright $line]
-	    if {$skip <= 0} {
-		lappend res $prefix$line
-	    } else {
-		lappend res $line
-	    }
-	}
-	if {$skip > 0} {incr skip -1}
-    }
-    return [join $res \n]
-}
-
-# Undent the block of text: Compute LCP (restricted to whitespace!)
-# and remove that from each line. Note that this preverses the
-# shaping of the paragraph (i.e. hanging indent are _not_ flattened)
-# We ignore empty lines !!
-
-proc ::textutil::adjust::undent {text} {
-
-    if {$text == {}} {return {}}
-
-    set lines [split $text \n]
-    set ne [list]
-    foreach l $lines {
-	if {[string length [string trim $l]] == 0} continue
-	lappend ne $l
-    }
-    set lcp [::textutil::string::longestCommonPrefixList $ne]
-
-    if {[string length $lcp] == 0} {return $text}
-
-    regexp "^(\[\t \]*)" $lcp -> lcp
-
-    if {[string length $lcp] == 0} {return $text}
-
-    set len [string length $lcp]
-
-    set res [list]
-    foreach l $lines {
-	if {[string length [string trim $l]] == 0} {
-	    lappend res {}
-	} else {
-	    lappend res [string range $l $len end]
-	}
-    }
-    return [join $res \n]
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::adjust {
-    variable here [file dirname [info script]]
-
-    variable Justify      left
-    variable Length       72
-    variable FullLine     0
-    variable StrictLength 0
-    variable Hyphenate    0
-    variable HyphPatterns
-
-    namespace export adjust indent undent
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::adjust 0.7.3
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/dehypht.tex b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/dehypht.tex
deleted file mode 100644
index 8f1dfb04..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/dehypht.tex
+++ /dev/null
@@ -1,902 +0,0 @@
-% This is `dehypht.tex' as of 03 March 1999.
-%
-% Copyright (C) 1988,1991 Rechenzentrum der Ruhr-Universitaet Bochum
-%               [german hyphen patterns]
-% Copyright (C) 1993,1994,1999 Bernd Raichle/DANTE e.V.
-%               [macros, adaption for TeX 2]
-%
-% -----------------------------------------------------------------
-% IMPORTANT NOTICE:
-%
-% This program can be redistributed and/or modified under the terms
-% of the LaTeX Project Public License Distributed from CTAN
-% archives in directory macros/latex/base/lppl.txt; either
-% version 1 of the License, or any later version.
-% -----------------------------------------------------------------
-%
-%
-% This file contains german hyphen patterns following traditional
-% hyphenation rules and includes umlauts and sharp s, but without
-% `c-k' and triple consonants.  It is based on hyphen patterns
-% containing 5719 german hyphen patterns with umlauts in the
-% recommended version of September 27, 1990.
-%
-% For use with TeX generated by
-%
-%          Norbert Schwarz
-%          Rechenzentrum Ruhr-Universitaet Bochum
-%          Universitaetsstrasse 150
-%          D-44721 Bochum, FRG
-%
-%
-% Adaption of these patterns for TeX, Version 2.x and 3.x and
-% all fonts in T1/`Cork'/EC/DC and/or OT1/CM encoding by
-%
-%          Bernd Raichle
-%          Stettener Str. 73
-%          D-73732 Esslingen, FRG
-%   Email: raichle@Informatik.Uni-Stuttgart.DE
-%
-%
-% Error reports in case of UNCHANGED versions to
-%
-%          DANTE e.V., Koordinator `german.sty'
-%          Postfach 10 18 40
-%          D-69008 Heidelberg, FRG
-%   Email: german@Dante.DE
-%
-% or one of the addresses given above.
-%
-%
-% Changes:
-%  1990-09-27 First version of `ghyphen3.tex' (Norbert Schwarz)
-%  1991-02-13 PC umlauts changed to ^^xx  (Norbert Schwarz)
-%  1993-08-27 Umlauts/\ss changed to "a/\3 macros, added macro
-%             definitions and additional logic to select correct
-%             patterns/encoding  (Bernd Raichle)
-%  1994-02-13 Release of `ghyph31.tex' V3.1a (Bernd Raichle)
-%  1999-03-03 Renamed file to `dehypht.tex' according to the
-%             naming scheme using the ISO country code `de', the
-%             common part `hyph' for all hyphenation patterns files,
-%             and the additional postfix `t' for traditional,
-%             removed wrong catcode change of ^^e (the comment
-%             character %) and ^^f (the character &),
-%             do _not_ change \catcode, \lccode, \uccode to avoid
-%             problems with other hyphenation pattern files,
-%             changed code to distinguish TeX 2.x/3.x,
-%             changed license conditions to LPPL (Bernd Raichle)
-%
-%
-% For more information see the additional documentation
-% at the end of this file.
-%
-% -----------------------------------------------------------------
-%
-\message{German Traditional Hyphenation Patterns %
-         `dehypht' Version 3.2a <1999/03/03>}
-\message{(Formerly known under the name `ghyph31' and `ghyphen'.)}
-%
-%
-% Next we define some commands which are used inside the patterns.
-% To keep them local, we enclose the rest of the file in a group
-% (The \patterns command globally changes the hyphenation trie!).
-%
-\begingroup
-%
-%
-% Make sure that doublequote is not active:
-\catcode`\"=12
-%
-%
-% Because ^^e4 is used in the following macros which is read by
-% TeX 2.x as ^^e or %, the comment character of TeX, some trick
-% has to be found to avoid this problem.  The same is true for the
-% character ^^f or & in the TeX 2.x code.
-% Therefore in the code the exclamationmark ! is used instead of
-% the circumflex ^ and its \catcode is set appropriately
-% (normally \catcode`\!=12, in the code \catcode`\!=7).
-%
-% The following \catcode, \lccode assignments and macro definitions
-% are defined in such a way that the following \pattern{...} list
-% can be used for both, TeX 2.x and TeX 3.x.
-%
-% We first change the \lccode of ^^Y to make sure that we can
-% include this character in the hyphenation patterns.
-%
-\catcode`\^^Y=11 \lccode`\^^Y=`\^^Y
-%
-% Then we have to define some macros depending on the TeX version.
-% Therefore we have to distinguish TeX version 2.x and 3.x:
-%
-\ifnum`\@=`\^^40 % true => TeX 3.x
-  %
-  % For TeX 3:
-  % ----------
-  %
-  % Assign appropriate \catcode and \lccode values for all
-  % accented characters used in the patterns (\uccode changes are
-  % not used within \patterns{...} and thus not necessary):
-  %
-  \catcode"E4=11 \catcode"C4=11 % \"a \"A
-  \catcode"F6=11 \catcode"D6=11 % \"o \"O
-  \catcode"FC=11 \catcode"DC=11 % \"u \"U
-  \catcode"FF=11 \catcode"DF=11 % \ss  SS
-  %
-  \lccode"C4="E4 \uccode"C4="C4  \lccode"E4="E4 \uccode"E4="C4
-  \lccode"D6="F6 \uccode"D6="D6  \lccode"F6="F6 \uccode"F6="D6
-  \lccode"DC="FC \uccode"DC="DC  \lccode"FC="FC \uccode"FC="DC
-  \lccode"DF="FF \uccode"DF="DF  \lccode"FF="FF \uccode"FF="DF
-  %
-  % In the following definitions we use ??xy instead of ^^xy
-  % to avoid errors when reading the following macro definitions
-  % with TeX 2.x (remember ^^e(4) is the comment character):
-  %
-  \catcode`\?=7
-  %
-  % Define the accent macro " in such a way that it
-  % expands to single letters in font encoding T1.
-  \catcode`\"=13
-  \def"#1{\ifx#1a??e4\else \ifx#1o??f6\else \ifx#1u??fc\else
-      \errmessage{Hyphenation pattern file corrupted!}%
-    \fi\fi\fi}
-  %
-  %   - patterns with umlauts are ok
-  \def\n#1{#1}
-  %
-  % For \ss which exists in T1 _and_ OT1 encoded fonts but with
-  % different glyph codes, duplicated patterns for both encodings
-  % are included.  Thus you can use these hyphenation patterns for
-  % T1 and OT1 encoded fonts:
-  %   - define \3 to be code `\^^ff (\ss in font encoding T1)
-  %   - define \9 to be code `\^^Y  (\ss in font encoding OT1)
-  \def\3{??ff}
-  \def\9{??Y}
-  %   - duplicated patterns to support font encoding OT1 are ok
-  \def\c#1{#1}
-  %   >>>>>>  UNCOMMENT the next line, if you do not want
-  %   >>>>>>  to use fonts in font encoding OT1
-  %\def\c#1{}
-  %
-  \catcode`\?=12
-  %
-\else
-  %
-  % For TeX 2:
-  % ----------
-  %
-  % Define the accent macro " to throw an error message.
-  \catcode`\"=13
-  \def"#1{\errmessage{Hyphenation pattern file corrupted!}}
-  %
-  %   - ignore all patterns with umlauts
-  \def\n#1{}
-  %
-  % With TeX 2 fonts in encoding T1 can be used, but all glyphs
-  % in positions > 127 can not be used in hyphenation patterns.
-  % Thus only patterns with glyphs in OT1 positions are included:
-  %   - define \3 to be code ^^Y (\ss in CM font encoding)
-  %   - define \9 to throw an error message
-  \def\3{^^Y}
-  \def\9{\errmessage{Hyphenation pattern file corrupted!}}
-  %   - ignore all duplicated patterns with \ss in T1 encoding
-  \def\c#1{}
-  %
-\fi
-%
-%
-\patterns{%
-.aa6l .ab3a4s .ab3ei .abi2 .ab3it .ab1l .ab1r .ab3u .ad3o4r .alti6
-.ana3c .an5alg .an1e .ang8s .an1s .ap1p .ar6sc .ar6ta .ar6tei .as2z
-.au2f1 .au2s3 .be5erb .be3na .ber6t5r .bie6r5 .bim6s5t .brot3 .bru6s
-.ch6 .che6f5 .da8c .da2r .dar5in .dar5u .den6ka .de5r6en .des6pe
-.de8spo .de3sz .dia3s4 .dien4 .dy2s1 .ehren5 .eine6 .ei6n5eh .ei8nen
-.ein5sa .en6der .en6d5r .en3k4 .en8ta8 .en8tei .en4t3r .epo1 .er6ban
-.er6b5ei .er6bla .er6d5um .er3ei .er5er .er3in .er3o4b .erwi5s .es1p
-.es8t .ex1a2 .ex3em .fal6sc .fe6st5a .flu4g3 .furch8 .ga6ner .ge3n4a
-\n{.ge5r"o} .ges6 .halb5 .halbe6 .hal6br .haup4 .hau4t .heima6 .he4r3e
-.her6za .he5x .hin3 .hir8sc .ho4c .hu3sa .hy5o .ibe5 .ima6ge .in1
-.ini6 .is5chi .jagd5 .kal6k5o .ka6ph .ki4e .kop6f3 .kraf6 \n{.k"u5ra}
-.lab6br .liie6 .lo6s5k \n{.l"o4s3t} .ma5d .mi2t1 .no6th .no6top
-.obe8ri .ob1l .obs2 .ob6st5e .or3c .ort6s5e .ost3a .oste8r .pe4re
-.pe3ts .ph6 .po8str .rau4m3 .re5an .ro8q .ru5the \n{.r"u5be}
-\n{.r"u8stet} .sch8 .se6e .se5n6h .se5ra .si2e .spi6ke .st4 .sy2n
-.tages5 .tan6kl .ta8th .te6e .te8str .to6der .to8nin .to6we .um1
-.umpf4 .un1 .une6 .unge5n .ur1c .ur5en .ve6rin .vora8 .wah6l5 .we8ges
-.wo6r .wor3a .wun4s .zi4e .zuch8 \n{."ande8re} \n{."och8} aa1c aa2gr
-aal5e aa6r5a a5arti aa2s1t aat2s 6aba ab3art 1abdr 6abel aben6dr
-ab5erk ab5err ab5esse 1abf 1abg \n{1abh"a} ab1ir 1abko a1bl ab1la
-5ablag a6bla\3 \c{a6bla\9} ab4ler ab1lu \n{a8bl"a} \n{5a6bl"o} abma5c
-1abn ab1ra ab1re 5a6brec ab1ro ab1s ab8sk abs2z 3abtei ab1ur 1abw
-5abze 5abzu \n{ab1"an} \n{ab"au8} a4ce.  a5chal ach5art ach5au a1che
-a8chent ach6er.  a6ch5erf a1chi ach1l ach3m ach5n a1cho ach3re a1chu
-ach1w a1chy \n{ach5"af} ack1o acks6t ack5sta a1d 8ad.  a6d5ac ad3ant
-ad8ar 5addi a8dein ade5o8 adi5en 1adj 1adle ad1op a2dre 3adres adt1
-1adv \n{a6d"a} a1e2d ae1r a1er.  1aero 8afa a3fal af1an a5far a5fat
-af1au a6fentl a2f1ex af1fr af5rau af1re 1afri af6tent af6tra aft5re
-a6f5um \n{8af"a} ag5abe 5a4gent ag8er ages5e 1aggr ag5las ag1lo a1gn
-ag2ne 1agog a6g5und a1ha a1he ah5ein a4h3erh a1hi ahl1a ah1le ah4m3ar
-ahn1a a5ho ahra6 ahr5ab ah1re ah8rei ahren8s ahre4s3 ahr8ti ah1ru a1hu
-\n{ah8"o} ai3d2s ai1e aif6 a3inse ai4re.  a5isch.  ais8e a3ismu ais6n
-aiso6 a1j 1akad a4kade a1ke a1ki 1akko 5akro1 a5lal al5ans 3al8arm
-al8beb al8berw alb5la 3album al1c a1le a6l5e6be a4l3ein a8lel a8lerb
-a8lerh a6lert 5a6l5eth 1algi al4gli al3int al4lab al8lan al4l3ar
-alle3g a1lo a4l5ob al6schm al4the altist5 al4t3re 8a1lu alu5i a6lur
-alu3ta \n{a1l"a} a6mate 8ame.  5a6meise am6m5ei am6mum am2n ampf3a
-am6schw am2ta a1mu \n{a1m"a} a3nac a1nad anadi5e an3ako an3alp 3analy
-an3ame an3ara a1nas an5asti a1nat anat5s an8dent ande4s3 an1ec an5eis
-an1e2k 4aner.  a6n5erd a8nerf a6n5erke 1anfa 5anfert \n{1anf"a} 3angab
-5angebo an3gli ang6lis an2gn 3angri ang5t6 \n{5anh"a} ani5g ani4ka
-an5i8on an1kl an6kno an4kro 1anl anma5c anmar4 3annah anne4s3 a1no
-5a6n1o2d 5a6n3oma 5a6nord 1anr an1sa 5anschl an4soz an1st 5anstal
-an1s2z 5antenn an1th \n{5anw"a} a5ny an4z3ed 5anzeig 5anzieh 3anzug
-\n{an1"a} \n{5an"as} \n{a1n"o} \n{an"o8d} a1os a1pa 3apfel a2ph1t
-\n{aph5"a6} a1pi 8apl apo1c apo1s a6poste a6poth 1appa ap1pr a1pr
-\n{a5p"a} \n{a3p"u} a1ra a4r3af ar3all 3arbei 2arbt ar1c 2a1re ar3ein
-ar2gl 2a1ri ari5es ar8kers ar6les ar4nan ar5o6ch ar1o2d a1rol ar3ony
-a8ror a3ros ar5ox ar6schl 8artei ar6t5ri a1ru a1ry 1arzt arz1w
-\n{ar8z"a} \n{ar"a8m} \n{ar"o6} \n{ar5"om} \n{ar1"u2} a1sa a6schec
-asch5l asch3m a6schn a3s4hi as1pa asp5l a8steb as5tev 1asth a6stoc
-a1str ast3re 8a1ta ata5c ata3la a6tapf ata5pl a1te a6teli aten5a
-ate5ran 6atf 6atg a1th at3hal 1athl 2a1ti 5atlant 3atlas 8atmus 6atn
-a1to a6t5ops ato6ra a6t5ort.  4a1tr a6t5ru at2t1h \n{at5t6h"a} 6a1tu
-atz1w \n{a1t"a} \n{a1t"u} au1a au6bre auch3a au1e aue4l 5aufent
-\n{3auff"u} 3aufga 1aufn auf1t 3auftr 1aufw 3auge.  au4kle aule8s 6aum
-au8mar aum5p 1ausb 3ausd 1ausf 1ausg au8sin 3auss au4sta 1ausw 1ausz
-aut5eng au1th 1auto au\3e8 \c{au\9e8} a1v ave5r6a aver6i a1w a6wes a1x
-a2xia a6xio a1ya a1z azi5er.  8a\3 \c{8a\9} 1ba 8ba8del ba1la ba1na
-ban6k5r ba5ot bardi6n ba1ro basten6 bau3sp 2b1b bb6le b2bli 2b1c 2b1d
-1be be1a be8at.  be1ch 8becht 8becke.  be5el be1en bee8rei be5eta bef2
-8beff be1g2 \n{beh"o8} bei1s 6b5eisen bei3tr b8el bel8o belu3t be3nac
-bend6o be6ners be6nerw be4nor ben4se6 bens5el \n{be1n"a} \n{be1n"u}
-be1o2 b8er.  be1ra be8rac ber8gab.  ber1r \n{be1r"u} bes8c bes5erh
-bes2p be5tha bet5sc be1un be1ur 8bex be6zwec 2b1f8 bfe6st5e 2b1g2
-bga2s5 bge1 2b1h bhole6 1bi bi1bl b6ie bi1el bi1la \n{bil"a5} bi1na
-bi4nok bi5str bi6stu bi5tr bit4t5r b1j 2b1k2 \n{bk"u6} bl8 b6la.
-6b1lad 6blag 8blam 1blat b8latt 3blau.  b6lav 3ble.  b1leb b1led
-8b1leg 8b1leh 8bleid 8bleih 6b3lein blei3s ble4m3o 4blich b4lind
-8bling b2lio 5blit b4litz b1loh 8b1los 1blu 5blum 2blun blut3a blut5sc
-\n{3bl"a} \n{bl"as5c} \n{5bl"o} \n{3bl"u} \n{bl"u8sc} 2b1m 2b1n 1bo
-bo1ch bo5d6s boe5 8boff 8bonk bo1ra b1ort 2b1p2 b1q 1br brail6 brast8
-bre4a b5red 8bref 8b5riem b6riga bro1s b1rup b2ruz \n{8br"oh}
-\n{br"os5c} 8bs b1sa b8sang b2s1ar b1sc bs3erl bs3erz b8sof b1s2p
-bst1h b3stru \n{b5st"a} b6sun 2b1t b2t1h 1bu bu1ie bul6k b8ure bu6sin
-6b1v 2b1w 1by1 by6te.  8b1z bzi1s \n{1b"a} \n{b5"a6s5} \n{1b"u}
-\n{b6"u5bere} \n{b"uge6} \n{b"ugel5e} \n{b"ur6sc} 1ca cag6 ca5la ca6re
-ca5y c1c 1ce celi4c celich5 ce1ro c8h 2ch.  1chae ch1ah ch3akt cha6mer
-8chanz 5chara 3chari 5chato 6chb 1chef 6chei ch3eil ch3eis 6cherkl
-6chf 4chh 5chiad 5chias 6chins 8chj chl6 5chlor 6ch2m 2chn6 ch8nie
-5cho.  8chob choi8d 6chp ch3ren ch6res \n{ch3r"u} 2chs 2cht cht5ha
-cht3hi 5chthon ch6tin 6chuh chu4la 6ch3unt chut6t 8chw 1ci ci5tr c2k
-2ck.  ck1ei 4ckh ck3l ck3n ck5o8f ck1r 2cks ck5stra ck6s5u c2l 1c8o
-con6ne 8corb cos6t c3q 1c6r 8c1t 1cu 1cy \n{5c"a1} \n{c"o5} 1da.
-8daas 2dabg 8dabr 6dabt 6dabw 1dac da2gr 6d5alk 8d5amt dan6ce.
-dani5er dan8ker 2danl danla6 6dans 8danzi 6danzu d1ap da2r1a8 2d1arb
-d3arc dar6men 4d3art 8darz 1dat 8datm 2d1auf 2d1aus 2d1b 2d1c 2d1d
-d5de d3d2h \n{dd"amme8} 1de 2deal de5an de3cha de1e defe6 6deff 2d1ehr
-5d4eic de5isc de8lar del6s5e del6spr de4mag de8mun de8nep dene6r
-8denge.  8dengen de5o6d 2deol de5ram 8derdb der5ein de1ro der1r d8ers
-der5um de4s3am de4s3an de4sau de6sil de4sin de8sor de4spr de2su 8deul
-de5us.  2d1f df2l 2d1g 2d1h 1di dia5c di5ara dice5 di3chr di5ena di1gn
-di1la dil8s di1na 8dind 6dinf 4d3inh 2d1ins di5o6d di3p4t di8sen dis1p
-di5s8per di6s5to dis5tra di8tan di8tin d1j 6dje 2dju 2d1k 2d1l 2d1m
-2d1n6 dni6 dnje6 1do 6d5obe do6berf 6d5ony do3ran 6dord 2d1org dor4t3h
-do6ste 6doth dott8e 2d1p d5q dr4 1drah 8drak d5rand 6dre.  4drech
-d6reck 4d3reg 8d3reic d5reife 8drem 8d1ren 2drer 8dres.  6d5rh 1dria
-d1ric 8drind droi6 dro5x 1dru 8drut \n{dr"os5c} \n{1dr"u} \n{dr"u5b}
-\n{dr"u8sc} 2ds d1sa d6san dsat6 d1sc 5d6scha.  5dschik dse8e d8serg
-8dsl d1sp d4spak ds2po \n{d8sp"a} d1st \n{d1s"u} 2dt d1ta d1te d1ti
-d1to dt1s6 d1tu \n{d5t"a} 1du du5als du1b6 du1e duf4t3r 4d3uh du5ie
-8duml 8dumw 2d1und du8ni 6d5unt dur2c durch3 6durl 6dursa 8durt du1s
-du8schr 2d1v 2d1w dwa8l 2d1z \n{1d"a} \n{6d"ah} \n{8d"and} \n{d"a6r}
-\n{d"o8bl} \n{d5"ol} \n{d"or6fl} \n{d"o8sc} \n{d5"o4st} \n{d"os3te}
-\n{1d"u} ea4ben e1ac e1ah e1akt e1al.  e5alf e1alg e5a8lin e1alk e1all
-e5alp e1alt e5alw e1am e1and ea6nim e1ar.  e5arf e1ark e5arm e3art
-e5at.  e6ate e6a5t6l e8ats e5att e6au.  e1aus e1b e6b5am ebens5e
-eb4lie eb4ser eb4s3in e1che e8cherz e1chi ech3m 8ech3n ech1r ech8send
-ech4su e1chu eck5an e5cl e1d ee5a ee3e ee5g e1ei ee5isc eei4s3t
-ee6lend e1ell \n{ee5l"o} e1erd ee3r4e ee8reng eere6s5 \n{ee5r"a}
-ee6tat e1ex e1f e6fau e8fe8b 3effek ef3rom ege6ra eglo6si 1egy e1ha
-e6h5ach eh5ans e6hap eh5auf e1he e1hi ehl3a eh1le ehl5ein eh1mu ehn5ec
-e1ho ehr1a eh1re ehre6n eh1ri eh1ru ehr5um e1hu eh1w e1hy \n{e1h"a}
-\n{e1h"o} \n{e3h"ut} ei1a eia6s ei6bar eich3a eich5r ei4dar ei6d5ei
-ei8derf ei3d4sc ei1e 8eifen 3eifri 1eign eil1d ei6mab ei8mag ein1a4
-ei8nat ei8nerh ei8ness ei6nete ein1g e8ini ein1k ei6n5od ei8nok ei4nor
-\n{e3ins"a} ei1o e1irr ei5ru ei8sab ei5schn ei6s5ent ei8sol ei4t3al
-eit3ar eit1h ei6thi ei8tho eit8samt ei6t5um e1j 1ekd e1ke e1ki e1k2l
-e1kn ekni4 e1la e2l1al 6elan e6lanf e8lanl e6l5ans el3arb el3arm
-e6l3art 5e6lasti e6lauge elbst5a e1le 6elef ele6h e6l5ehe e8leif
-e6l5einh 1elek e8lel 3eleme e6lemen e6lente el5epi e4l3err e6l5ersc
-elf2l elg2 e6l5ins ell8er 4e1lo e4l3ofe el8soh el8tent 5eltern e1lu
-elut2 \n{e1l"a} \n{e1l"u} em8dei em8meis 4emo emo5s 1emp1f 1empt 1emto
-e1mu emurk4 emurks5 \n{e1m"a} en5a6ben en5achs en5ack e1nad en5af
-en5all en3alt en1am en3an.  en3ant en3anz en1a6p en1ar en1a6s 6e1nat
-en3auf en3aus en2ce enda6l end5erf end5erg en8dess 4ene.  en5eck
-e8neff e6n5ehr e6n5eim en3eis 6enem.  6enen e4nent 4ener.  e8nerd
-e6n3erf e4nerg 5energi e6n5erla en5ers e6nerst en5erw 6enes e6n5ess
-e2nex en3glo 2eni enni6s5 ennos4 enns8 e1no e6nober eno8f en5opf
-e4n3ord en8sers ens8kl en1sp ens6por en5t6ag enta5go en8terbu en6tid
-3entla ent5ric 5entwic 5entwu 1entz enu5i e3ny en8zan \n{en1"of}
-\n{e1n"os} \n{e1n"ug} eo1c e5o6fe e5okk e1on.  e3onf e5onk e5onl e5onr
-e5opf e5ops e5or.  e1ord e1org eo5r6h eo1t e1pa e8pee e6p5e6g ep5ent
-e1p2f e1pi 5epid e6pidem e1pl 5epos e6pos.  ep4p3a e1pr \n{e1p"a} e1q
-e1ra.  er5aal 8eraba e5rabel er5a6ben e5rabi er3abs er3ach era5e
-era5k6l er3all er3amt e3rand e3rane er3ans e5ranz.  e1rap er3arc
-e3rari er3a6si e1rat erat3s er3auf e3raum 3erbse er1c e1re 4e5re.
-er3eck er5egg er5e2h 2erei e3rei.  e8reine er5einr 6eren.  e4r3enm
-4erer.  e6r5erm er5ero er5erst e4r3erz er3ess \n{5erf"ul} er8gan.
-5ergebn er2g5h \n{5erg"anz} \n{5erh"ohu} 2e1ri eri5ak e6r5iat e4r3ind
-e6r5i6n5i6 er5ins e6r5int er5itio er1kl \n{3erkl"a} \n{5erl"os.}
-ermen6s er6nab 3ernst 6e1ro.  e1rod er1o2f e1rog 6e3roi ero8ide e3rol
-e1rom e1ron e3rop8 e2r1or e1ros e1rot er5ox ersch4 5erstat er6t5ein
-er2t1h er5t6her 2e1ru eruf4s3 e4r3uhr er3ums e5rus 5erwerb e1ry er5zwa
-er3zwu \n{er"a8m} \n{er5"as} \n{er"o8} \n{e3r"os.} \n{e6r1"u2b} e1sa
-esa8b e8sap e6s5a6v e1sc esch4l ese1a es5ebe eserve5 e8sh es5ill
-es3int es4kop e2sl eso8b e1sp espei6s5 es2po es2pu 5essenz e6stabs
-e6staf e6st5ak est3ar e8stob e1str est5res es3ur e2sz \n{e1s"u} e1ta
-et8ag etari5e eta8ta e1te eten6te et5hal e5thel e1ti 1etn e1to e1tr
-et3rec e8tscha et8se et6tei et2th et2t1r e1tu etu1s et8zent et8zw
-\n{e1t"a} \n{e1t"o} \n{e1t"u} eu1a2 eu1e eue8rei eu5fe euin5 euk2
-e1um.  eu6nio e5unter eu1o6 eu5p 3europ eu1sp eu5str eu8zo e1v eval6s
-eve5r6en ever4i e1w e2wig ex1or 1exp 1extr ey3er.  e1z \n{e1"a2}
-\n{e5"o8} \n{e1"u} e8\3es \c{e8\9es} fa6ch5i fade8 fa6del fa5el.
-fal6lo falt8e fa1na fan4gr 6fanl 6fap far6ba far4bl far6r5a 2f1art
-fa1sc fau8str fa3y 2f1b2 6f1c 2f1d 1fe 2f1eck fe6dr feh6lei f6eim
-8feins f5eis fel5en 8feltern 8femp fe5rant 4ferd.  ferri8 fe8stof
-fe6str fe6stum fe8tag fet6ta fex1 2ff f1fa f6f5arm f5fe ffe5in ffe6la
-ffe8ler ff1f f1fla ff3lei ff4lie ff8sa ff6s5ta 2f1g2 fgewen6 4f1h 1fi
-fid4 fi3ds fieb4 fi1la fi8lei fil4m5a f8in.  fi1na 8finf fi8scho fi6u
-6f1j 2f1k2 f8lanz fl8e 4f3lein 8flib 4fling f2lix 6f3lon 5flop 1flor
-\n{5f8l"ac} \n{3fl"ot} 2f1m 2f1n 1fo foh1 f2on fo6na 2f1op fo5ra
-for8mei for8str for8th for6t5r fo5ru 6f5otte 2f1p8 f1q fr6 f5ram
-1f8ran f8ra\3 \c{f8ra\9} f8re.  frei1 5frei.  f3reic f3rest f1rib
-8f1ric 6frig 1fris fro8na \n{fr"as5t} 2fs f1sc f2s1er f5str
-\n{fs3t"at} 2ft f1tak f1te ft5e6h ftere6 ft1h f1ti f5to f1tr ft5rad
-ft1sc ft2so f1tu ftwi3d4 ft1z 1fu 6f5ums 6funf fun4ka fu8\3end
-\c{fu8\9end} 6f1v 2f1w 2f1z \n{1f"a} \n{f"a1c} \n{8f"arm} \n{6f"aug}
-\n{f"a8\3} \n{\c{f"a8\9}} \n{f"ode3} \n{8f"of} \n{3f"or} \n{1f"u}
-\n{f"un4f3u} 1ga ga6bl 6gabw 8gabz g3a4der ga8ho ga5isc 4gak ga1la
-6g5amt ga1na gan5erb gan6g5a ga5nj 6ganl 8gansc 6garb 2g1arc 2g1arm
-ga5ro 6g3arti ga8sa ga8sc ga6stre 2g1atm 6g5auf gau5fr g5aus 2g1b g5c
-6gd g1da 1ge ge1a2 ge6an ge8at.  ge1e2 ge6es gef2 8geff ge1g2l ge1im
-4g3eise geist5r gel8bra gelt8s \n{ge5l"o} ge8nin gen3k 6g5entf
-\n{ge3n"a} ge1or ge1ra ge6rab ger8au \n{8gerh"o} ger8ins ge1ro 6g5erz.
-\n{ge1r"a} \n{ge1r"u} ge1s ges2p ge5unt 4g3ex3 2g1f8 2g1g g1ha 6g1hei
-5ghel.  g5henn 6g1hi g1ho 1ghr \n{g1h"o} 1gi gi5la gi8me.  gi1na
-4g3ins gi3str g1j 2g1k 8gl.  1glad g5lag glan4z3 1glas 6glass 5glaub
-g3lauf 1gle.  g5leb 3gleic g3lein 5gleis 1glem 2gler 8g3leu gli8a
-g2lie 3glied 1g2lik 1g2lim g6lio 1gloa 5glom 1glon 1glop g1los g4loss
-g5luf 1g2ly \n{1gl"u} 2g1m gn8 6gn.  1gna 8gnach 2gnah g1nas g8neu
-g2nie g3nis 1gno 8gnot 1go goe1 8gof 2gog 5gogr 6g5oh goni5e 6gonist
-go1ra 8gord 2g1p2 g1q 1gr4 g5rahm gra8m gra4s3t 6g1rec gre6ge 4g3reic
-g5reit 8grenn gri4e g5riem 5grif 2grig g5ring 6groh 2grot gro6\3
-\c{gro6\9} 4grut 2gs gs1ab g5sah gs1ak gs1an gs8and gs1ar gs1au g1sc
-gs1ef g5seil gs5ein g2s1er gs1in g2s1o gso2r gs1pr g2s1u 2g1t g3te
-g2t1h 1gu gu5as gu2e 2gue.  6gued 4g3uh 8gums 6g5unt gu1s gut3h gu2tu
-4g1v 2g1w gy1n g1z \n{1g"a} \n{8g"a8m} \n{6g"arm} \n{1g"o} \n{1g"u}
-\n{6g"ub} 1haa hab8r ha8del hade4n 8hae ha5el.  haf6tr 2hal.  ha1la
-hal4b5a 6hale 8han.  ha1na han6dr han6ge.  2hani h5anth 6hanz 6harb
-h3arbe h3arme ha5ro ha2t1h h1atm hau6san ha8\3 \c{ha8\9} h1b2 h1c h1d
-he2bl he3cho h3echt he5d6s 5heft h5e6he.  hei8ds h1eif 2hein he3ism
-he5ist.  heit8s3 hek6ta hel8lau 8helt he6mer 1hemm 6h1emp hen5end
-hen5klo hen6tri he2nu 8heo he8q her3ab he5rak her3an 4herap her3au
-h3erbi he1ro he8ro8b he4r3um her6z5er he4spe he1st heta6 het5am he5th
-heu3sc he1xa hey5e h1f2 h1g hgol8 h1h h1iat hie6r5i hi5kt hil1a2
-hil4fr hi5nak hin4ta hi2nu hi5ob hirn5e hir6ner hi1sp hi1th hi5tr
-5hitz h1j h6jo h1k2 hlabb4 hla4ga hla6gr h5lai hl8am h1las h1la\3
-\c{h1la\9} hl1c h1led h3lein h5ler.  h2lif h2lim h8linf hl5int h2lip
-h2lit h4lor h3lose \n{h1l"as} hme5e h2nee h2nei hn3eig h2nel hne8n
-hne4p3f hn8erz h6netz h2nip h2nit h1nol hn5sp h2nuc h2nud h2nul hoch1
-1hoh hoh8lei 2hoi ho4l3ar 1holz h2on ho1ra 6horg 5horn.  ho3sl hos1p
-ho4spi h1p hpi6 h1q 6hr h1rai h8rank h5raum hr1c hrcre8 h1red h3reg
-h8rei.  h4r3erb h8rert hrg2 h1ric hr5ins h2rom hr6t5erl hr2t1h hr6t5ra
-hr8tri h6rum hr1z hs3ach h6s5amt h1sc h6s5ec h6s5erl hs8erle h4sob
-h1sp h8spa\3 \c{h8spa\9} h8spel hs6po h4spun h1str h4s3tum hs3und
-\n{h1s"u} h5ta.  h5tab ht3ac ht1ak ht3ang h5tanz ht1ar ht1at h5taub
-h1te h2t1ec ht3eff ht3ehe h4t3eif h8teim h4t3ein ht3eis h6temp h8tentf
-hte8ren \n{h6terf"u} h8tergr h4t3erh h6t5ersc h8terst h8tese h8tess
-h2t1eu h4t3ex ht1he ht5hu h1ti ht5rak hts3ah ht1sc ht6sex ht8sk ht8so
-h1tu htz8 \n{h5t"um} hub5l hu6b5r huh1l h5uhr.  huld5a6 hu8lent
-\n{hu8l"a} h5up.  h1v h5weib h3weis h1z \n{h"a8kl} \n{h"al8s}
-\n{h"ama8tu8} \n{h"a8sche.} \n{h"at1s} \n{h"au4s3c} \n{2h"o.}
-\n{2h"oe} \n{8h"oi} \n{h"o6s} \n{h"os5c} \n{h"uhne6} \n{h"ul4s3t}
-\n{h"utte8re} i5adn i1af i5ak.  i1al.  i1al1a i1alb i1ald i5alei i1alf
-i1alg i3alh i1alk i1all i1alp i1alr i1als i1alt i1alv i5alw i3alz
-i1an.  ia5na i3and ian8e ia8ne8b i1ang i3ank i5ann i1ant i1anz i6apo
-i1ar.  ia6rab i5arr i1as.  i1asm i1ass i5ast.  i1at.  i5ats i1au i5azz
-i6b5eig i6b5eis ib2le i4blis i6brig i6b5unt \n{i6b"ub} i1che ich5ei
-i6cherb i1chi ich5ins ich1l ich3m ich1n i1cho icht5an icht3r i1chu
-ich1w ick6s5te ic5l i1d id3arm 3ideal ide8na 3ideol \n{ide5r"o} i6diot
-id5rec id1t ie1a ie6b5ar iebe4s3 ie2bl ieb1r ie8bra ie4bre \n{ie8b"a}
-ie2dr ie1e8 ie6f5ad ief5f ie2f1l ie4fro ief1t i1ei ie4l3ec ie8lei
-ie4lek i3ell i1en.  i1end ien6e i3enf i5enn ien6ne.  i1enp i1enr
-i5ensa ien8stal i5env i1enz ie5o ier3a4b ie4rap i2ere ie4rec ie6r5ein
-ie6r5eis ier8er i3ern.  ie8rum ie8rund ie6s5che ie6tau ie8tert ie5the
-ie6t5ri i1ett ie5un iex5 2if i1fa if5ang i6fau if1fr if5lac i5f6lie
-i1fre ift5a if6t5r ig3art 2ige i8gess ig5he i5gla ig2ni i5go ig3rot
-ig3s2p i1ha i8ham i8hans i1he i1hi ih1n ih1r i1hu i8hum ih1w 8i1i ii2s
-ii2t i1j i1k i6kak i8kerz i6kes ik4ler i6k5unt 2il i5lac i1lag il3ans
-i5las i1lau il6auf i1le ile8h i8lel il2fl il3ipp il6l5enn i1lo ilt8e
-i1lu \n{i1l"a} i8mart imb2 i8mele i8mid imme6l5a i1mu \n{i1m"a}
-\n{i5m"o} ina5he i1nat in1au inau8s 8ind.  in4d3an 5index ind2r 3indus
-i5nec i2n1ei i8nerw 3infek 1info 5ingeni ing5s6o 5inhab ini5er.  5inj
-\n{in8k"at} in8nan i1no inoi8d in3o4ku in5sau in1sp 5inspe 5instit
-5instru ins4ze 5intere 5interv in3the in5t2r i5ny \n{in"a2} \n{i1n"ar}
-\n{in1"as} \n{in"o8} \n{in5"od} \n{i1n"os} 2io io1a8 io1c iode4 io2di
-ioi8 i1ol.  i1om.  i1on.  i5onb ion2s1 i1ont i5ops i5o8pt i1or.
-i3oral io3rat i5orc i1os.  i1ot.  i1o8x 2ip i1pa i1pi i1p2l i1pr i1q
-i1ra ir6bl i1re i1ri ir8me8d ir2m1o2 ir8nak i1ro ir5rho ir6schl
-ir6sch5r i5rus i5ry \n{i5r"a} i1sa i8samt i6sar i2s1au i8scheh i8schei
-isch5m isch3r \n{isch"a8} is8ele ise3ra i4s3erh is3err isi6de i8sind
-is4kop ison5e is6por i8s5tum i5sty \n{i5s"o} i1ta it5ab.  i2t1a2m
-i8tax i1te i8tersc i1thi i1tho i5thr \n{it8h"a} i1ti i8ti8d iti6kl
-itmen4 i1to i8tof it3ran it3rau i1tri itri5o it1sc it2se it5spa it8tru
-i1tu it6z5erg it6z1w \n{i1t"a} \n{it"a6r5e} \n{it"at2} \n{it"ats5}
-\n{i1t"u} i1u iu6r 2i1v i6vad iva8tin i8vei i6v5ene i8verh i2vob i8vur
-i1w iwi2 i5xa i1xe i1z ize8n i8zir i6z5w \n{i"a8m} \n{i1"a6r}
-\n{i5"at.} \n{i5"av} \n{i1"o8} \n{i"u8} i6\35ers \c{i6\95ers} ja5la
-je2t3r 6jm 5jo jo5as jo1ra jou6l ju5cha jugen4 jugend5 jung5s6 ju1s
-\n{3j"a} 1ka 8kachs 8kakz ka1la kal5d kam5t ka1na 2kanl 8kapf ka6pl
-ka5r6a 6k3arbe ka1ro kar6p5f 4k3arti 8karz \n{ka1r"a} kasi5e ka6teb
-kat8ta kauf6s kau3t2 2k1b 2k1c 4k1d kehr6s kehrs5a 8keic 2k1eig 6k5ein
-6k5eis ke6lar ke8leis ke8lo 8kemp k5ente.  k3entf 8k5ents 6kentz ke1ra
-k5erlau 2k1f8 2k1g 2k1h ki5fl 8kik king6s5 6kinh ki5os ki5sp ki5th
-\n{8ki8"o} 2k1k2 kl8 1kla 8klac k5lager kle4br k3leib 3kleid kle5isc
-4k3leit k3lek 6k5ler.  5klet 2klic 8klig k2lim k2lin 5klip 5klop k3lor
-\n{1kl"a} 2k1m kmani5e kn8 6kner k2ni \n{kn"a8} 1k2o ko1a2 ko6de.
-ko1i koi8t ko6min ko1op ko1or ko6pht ko3ra kor6d5er ko5ru ko5t6sc k3ou
-3kow 6k5ox 2k1p2 k1q 1kr8 4k3rad 2k1rec 4k3reic kre5ie 2krib 6krig
-2krip 6kroba 2ks k1sa k6sab ksal8s k8samt k6san k1sc k2s1ex k5spat
-k5spe k8spil ks6por k1spr kst8 k2s1uf 2k1t kta8l kt5a6re k8tein kte8re
-k2t1h k8tinf kt3rec kt1s 1ku ku1ch kuck8 k3uhr ku5ie kum2s1 kunfts5
-kun2s kunst3 ku8rau ku4ro kurz1 ku1st 4kusti ku1ta ku8\3 \c{ku8\9}
-6k1v 2k1w ky5n 2k1z \n{1k"a} \n{k"a4m} \n{4k3"ami} \n{k"ase5} \n{1k"o}
-\n{k"o1c} \n{k"o1s} \n{1k"u} \n{k"u1c} \n{k"ur6sc} \n{k"u1s} 1la.
-8labf 8labh lab2r 2l1abs lach3r la8dr 5ladu 8ladv 6laff laf5t la2gn
-5laken 8lamb la6mer 5lampe.  2l1amt la1na 1land lan4d3a lan4d3r lan4gr
-8lanme 6lann 8lanw \n{6lan"a} 8lappa lap8pl lap6pr l8ar.  la5ra lar4af
-la8rag la8ran la6r5a6s l3arbe la8rei 6larm.  la8sa la1sc la8sta lat8i
-6l5atm 4lauss 4lauto 1law 2lb l8bab l8bauf l8bede l4b3ins l5blo
-lbst5an lbst3e 8lc l1che l8chert l1chi lch3m l5cho lch5w 6ld l4d3ei
-ld1re \n{l6d"ub} le2bl le8bre lecht6s5 led2r 6leff le4gas 1lehr lei6br
-le8inf 8leinn 5leistu 4lektr le6l5ers lemo2 8lemp l8en.  8lends
-6lendun le8nend len8erw 6l5ents 4l3entw 4lentz 8lenzy 8leoz 6lepi
-le6pip 8lepo 1ler l6er.  8lerbs 6l5erde le8reis le8rend le4r3er 4l3erg
-l8ergr 6lerkl 6l5erzie \n{8ler"o} 8lesel lesi5e le3sko le3tha let1s
-5leuc 4leuro leu4s3t le5xe 6lexp l1f 2l1g lgend8 l8gh lglie3 lglied6
-6l1h 1li li1ar li1as 2lick li8dr li1en lien6n li8ers li8ert 2lie\3
-\c{2lie\9} 3lig li8ga8b li1g6n li1l8a 8limb li1na 4l3indu lings5
-4l3inh 6linj link4s3 4linkt 2lint 8linv lion5s6t 4lipp 5lipt 4lisam
-livi5e 6l1j 6l1k l8keim l8kj lk2l lko8f lkor8 lk2sa lk2se 6ll l1la
-ll3a4be l8labt ll8anl ll1b ll1c ll1d6 l1le l4l3eim l6l5eise ller3a
-l4leti l5lip l1lo ll3ort ll5ov ll6spr llte8 l1lu ll3urg \n{l1l"a}
-\n{l5l"u} \n{l6l"ub} 2l1m l6m5o6d 6ln l1na l1no 8lobl lo6br 3loch.
-l5o4fen 5loge.  5lohn 4l3ohr 1lok l2on 4l3o4per lo1ra 2l1ord 6lorg
-4lort lo1ru 1los.  lo8sei 3losig lo6ve lowi5 6l1p lp2f l8pho l8pn
-lp4s3te l2pt l1q 8l1r 2ls l1sa l6sarm l1sc l8sec l6s5erg l4s3ers l8sh
-l5s6la l1sp ls4por ls2pu l1str l8suni \n{l1s"u} 2l1t lt5amp l4t3ein
-l5ten l6t5eng l6t5erp l4t3hei lt3her l2t1ho l6t5i6b lti1l \n{l8tr"o}
-lt1sc lt6ser lt4s3o lt5ums lu8br lu2dr lu1en8 8lu8fe luft3a luf8tr
-lu6g5r 2luh l1uhr lu5it 5luk 2l1umf 2l1umw 1lun 6l5u6nio 4l3unte lu5ol
-4lurg 6lurs l3urt lu4sto lu3str lu6st5re lu8su lu6tal lu6t5e6g lu8terg
-lu3the lu6t5or lu2t1r lu6\35 \c{lu6\95} l1v lve5r6u 2l1w 1ly lya6
-6lymp ly1no l8zess l8zo8f l3zwei lz5wu \n{3l"and} \n{l"a5on}
-\n{l"a6sc} \n{l"at1s} \n{5l"auf} \n{2l"aug} \n{l"au6s5c} \n{l"a5v}
-\n{l1"ol} \n{1l"os} \n{l"o1\36t} \n{\c{l"o1\96t}} \n{6l1"ube} 1ma
-8mabg ma5chan mad2 ma5el 4magg mag8n ma1la ma8lau mal5d 8malde mali5e
-malu8 ma8lut 2m1amp 3man mand2 man3ds 8mangr mani5o 8m5anst 6mappa
-4m3arbe mar8kr ma1r4o mar8schm 3mas ma1sc \n{ma1t"o} 4m5auf ma5yo 2m1b
-mb6r 2m1c 2m1d \n{md6s"a} 1me me1ch me5isc 5meld mel8sa 8memp me5nal
-men4dr men8schl men8schw 8mentsp me1ra mer4gl me1ro 3mes me6s5ei me1th
-me8\3 \c{me8\9} 2m1f6 2m1g 2m1h 1mi mi1a mi6ale mi1la 2m1imm mi1na
-\n{mi5n"u} mi4s3an mit1h mi5t6ra 3mitt mitta8 mi6\35 \c{mi6\95} 6mj
-2m1k8 2m1l 2m1m m6mad m6m5ak m8menth m8mentw mme6ra m2mn mm5sp mm5ums
-mmut5s \n{m8m"an} m1n8 m5ni 1mo mo5ar mo4dr 8mof mo8gal mo4kla mol5d
-m2on mon8do mo4n3od mont8a 6m5ony mopa6 mo1ra mor8d5a mo1sc mo1sp 5mot
-moy5 2mp m1pa mpfa6 mpf3l mphe6 m1pi mpin6 m1pl mp2li m2plu mpo8ste
-m1pr \n{mpr"a5} mp8th mput6 mpu5ts \n{m1p"o} 8m1q 2m1r 2ms ms5au m1sc
-msch4l ms6po m3spri m1str 2m1t mt1ar m8tein m2t1h mt6se \n{mt8s"a}
-mu5e 6m5uh mumi1 1mun mun6dr muse5e mu1ta 2m1v mvol2 mvoll3 2m1w 1my
-2m1z \n{m"a6kl} \n{1m"an} \n{m"a1s} \n{m"a5tr} \n{m"au4s3c} \n{3m"a\3}
-\n{\c{3m"a\9}} \n{m"ob2} \n{6m"ol} \n{1m"u} \n{5m"un} \n{3m"ut} 1na.
-n5ab.  8nabn n1abs n1abz \n{na6b"a} na2c nach3e 3nacht 1nae na5el
-n1afr 1nag 1n2ah na8ha na8ho 1nai 6nair na4kol n1akt nal1a 8naly 1nama
-na4mer na1mn n1amp 8n1amt 5nanc nan6ce n1and n6and.  2n1ang 1nani
-1nann n1ans 8nanw 5napf.  1n2ar.  na2ra 2n1arc n8ard 1nari n8ark
-6n1arm 5n6ars 2n1art n8arv 6natm nat6s5e 1naue 4nauf n3aug 5naui n5auk
-na5um 6nausb 6nauto 1nav 2nax 3naz 1na\3 \c{1na\9} n1b2 nbau5s n1c
-nche5e nch5m 2n1d nda8d n2d1ak nd5ans n2d1ei nde8lac ndel6sa n8derhi
-nde4se nde8stal n2dj ndnis5 n6d5or6t nd3rec nd3rot nd8samt nd6sau
-ndt1h n8dumd 1ne ne5as ne2bl 6n5ebn 2nec 5neei ne5en ne1g4l 2negy
-4n1ein 8neis 4n3e4lem 8nemb 2n1emp nen1a 6n5energ nen3k 8nentb
-4n3en3th 8nentl 8n5entn 8n5ents ne1ra ne5r8al ne8ras 8nerbi 6n5erde.
-nere5i6d nerfor6 \n{6n5erh"o} \n{8nerl"o} 2n1err n8ers.  6n5ertra
-2n1erz nesi3e net1h neu4ra neu5sc 8neu\3 \c{8neu\9} n1f nf5f nf2l
-nflei8 nf5lin nft8st n8g5ac ng5d ng8en nge8ram ngg2 ng1h n6glic ng3rip
-ng8ru ng2se4 ng2si n2g1um n1gy \n{n8g"al} n1h nhe6r5e 1ni ni1bl
-\n{ni5ch"a} ni8dee n6ie ni1en nie6s5te niet5h ni8etn 4n3i6gel n6ik
-ni1la 2n1imp ni5na 2n1ind 8ninf 6n5inh ni8nit 6n5inn 2n1ins 4n1int
-n6is ni3str ni1th ni1tr n1j n6ji n8kad nk5ans n1ke n8kerla n1ki nk5inh
-\n{n5kl"o} n1k2n n8k5not nk3rot \n{n8kr"u} nk5spo nk6t5r n8kuh
-\n{n6k"ub} n5l6 nli4mi n1m nmen4s n1na n8nerg nni5o n1no nn4t3ak nnt1h
-nnu1e n1ny \n{n1n"a} \n{n1n"o} \n{n1n"u} no5a no4b3la 4n3obs 2nobt
-noche8 no6die no4dis no8ia no5isc 6n5o6leu no4mal noni6er 2n1onk n1ony
-4n3o4per 6nopf 6nopti no3ra no4ram nor6da 4n1org 2n1ort n6os no1st
-8nost.  no8tan no8ter noty6pe 6n5ox n1p2 n1q n1r \n{nr"os3} 6ns n1sac
-ns3ang n1sc n8self n8s5erf n8serg n6serk ns5erw n8sint n1s2pe n1spr
-n6s5tat.  n5s6te.  n6stob n1str n1ta n4t3a4go nt5anh nt3ark nt3art
-n1te nt3eis nte5n6ar nte8nei nter3a nte6rei nt1ha nt6har n3ther nt5hie
-n3thus n1ti nti1c n8tinh nti1t ntlo6b ntmen8 n1to nt3o4ti n1tr ntra5f
-ntra5ut nt8rea nt3rec nt8rep n4t3rin nt8rop n4t3rot \n{n4tr"u} nt1s
-nts6an nt2sk n1tu nt1z \n{n1t"a} \n{n1t"o} \n{n8t"ol} \n{n1t"u} 1nu
-nu1a nu5el nu5en 4n1uhr nu5ie 8numl 6n5ums 6n5umw 2n1und 6nuni 6n5unr
-2n1unt 2nup 2nu6r n5uri nu3skr nu5ta n1v 8n1w 1nys n1za n6zab n2z1ar
-n6zaus nzi4ga n8zof n6z5unt n1zw n6zwir \n{1n"ac} \n{5n"ae} \n{5n"ai}
-\n{n8"al} \n{n"a6m} \n{n"a6re} \n{n5"arz} \n{5n"aus} \n{n1"ol}
-\n{1n"ot} \n{n5"oz} \n{5n"u.} \n{6n1"u2b} \n{5n"u\3} \n{\c{5n"u\9}}
-o5ab.  oa2l o8ala o1a2m o1an ob1ac obe4ra o6berh 5o4bers o4beru
-obe6ser 1obj o1bl o2bli ob5sk 3obst.  ob8sta obst5re ob5sz o1che
-oche8b o8chec o3chi och1l och3m ocho8f o3chro och3to o3chu och1w o1d
-o2d1ag od2dr ode5i ode6n5e od1tr o5e6b o5e6der.  oe8du o1ef o1e2l
-o1e2p o1er.  o5e8x o1fa of8fan 1offi of8fin of6f5la o5fla o1fr 8o1g
-og2n o1ha o1he o6h5eis o1hi ohl1a oh1le oh4l3er 5ohm.  oh2ni o1ho
-oh1re oh1ru o1hu oh1w o1hy \n{o1h"a} o5ia o1id.  o8idi oi8dr o5ids
-o5isch.  oiset6 o1ism o3ist.  o5i6tu o1j o1k ok2l ok3lau \n{o8kl"a}
-1okta o1la old5am old5r o1le ole5in ole1r ole3u ol6gl ol2kl olk4s1
-ol8lak ol8lauf.  ol6lel ol8less o1lo ol1s ol6sk o1lu oly1e2 5olym
-o2mab om6an o8mau ombe4 o8merz om5sp o1mu o8munt \n{o1m"a} \n{o1m"o}
-o1na ona8m on1ax on8ent o6n5erb 8oni oni5er.  on1k on6n5a6b o1no ono1c
-o4nokt 1ons onts8 \n{o1n"a} oo8f 1oog oo2pe oo2sa o1pa 3o4pera o3pfli
-opf3lo opf3r o1pi o1pl o2pli o5p6n op8pa op6pl o1pr o3p4ter 1opti
-\n{o1p"a} \n{o5p"o} o1q o1ra.  o3rad o8radd 1oram o6rang o5ras o8rauf
-or5cha or4d3a4m or8dei or8deu 1ordn or4dos o1re o5re.  ore2h o8r5ein
-ore5isc or6enn or8fla or8fli 1orga 5orgel.  or2gl o1ri 5o6rient or8nan
-\n{or8n"a} o1ro or1r2h or6t5an or8tau or8tere o1rus o1ry \n{o1r"a}
-\n{or1"u2} o1sa osa3i 6ose o8serk o1sk o6ske o6ski os2kl os2ko os2kr
-osni5e o2s1o2d o3s4per o4stam o6stau o3stra ost3re osu6 o6s5ur o5s6ze
-o1ta ot3auf o6taus o1te o6terw o1th othe5u o2th1r o1ti o1to oto1a
-ot1re o1tri o1tro ot1sc o3tsu ot6t5erg ot2t3h ot2t5r \n{ot8t"o} o1tu
-ou3e ouf1 ou5f6l o5u6gr ou5ie ou6rar ou1t6a o1v o1wa o1we o6wer.  o1wi
-owid6 o1wo o5wu o1xe oy5al.  oy1e oy1i o5yo o1z oza2r 1o2zea ozo3is
-\n{o"o8} o\35elt \c{o\95elt} o\31t \c{o\91t} 3paa pa6ce 5pad pag2 1pak
-pa1la pa8na8t pani5el pa4nor pan1s2 1pap pap8s pa8rei par8kr paro8n
-par5o6ti part8e 5partei 3partn pas6sep pa4tha 1pau 6paug pau3sc p1b
-8p5c 4p1d 1pe 4peic pe5isc 2pek pen3k pen8to8 p8er pe1ra pere6 per5ea
-per5eb pe4rem 2perr per8ran 3pers 4persi \n{pe3r"u} pe4sta pet2s
-p2f1ec p4fei pf1f pf2l 5pflanz pf8leg pf3lei 2pft pf3ta p1g 1ph 2ph.
-2p1haf 6phb 8phd 6p5heit ph5eme 6phg phi6e 8phk 6phn p5holl pht2
-ph3tha 4ph3the phu6 6phz pi1en pi5err pi1la pi1na 5pinse pioni8e 1pis
-pi1s2k pi1th p1k pl8 5pla p2lau 4plei p3lein 2pler 6p5les 2plig p6lik
-6p5ling p2liz plo8min 6p1m p1n 1p2o 8poh 5pol po8lan poly1 po3ny po1ra
-2porn por4t3h \n{po5r"o} 5poti p1pa p6p5ei ppe6la pp5f p2p1h p1pi pp1l
-ppp6 pp5ren pp1s \n{p5p"o} pr6 3preis 1pres 2p3rig 5prinz 1prob 1prod
-5prog pro8pt pro6t5a prote5i 8pro\3 \c{8pro\9} \n{pr"a3l} \n{1pr"as}
-\n{pr"ate4} \n{1pr"uf} p5schl 2pst 1p2sy p1t p8to8d pt1s 5p6ty 1pu
-pu1b2 2puc pu2dr puf8fr 6p5uh pun8s pu8rei pu5s6h pu1ta p1v p3w 5py
-py5l p1z \n{p"a6der} \n{p5"a6m} \n{p"a8nu} \n{8p"ar} \n{p"at5h}
-\n{p"at1s} qu6 1qui 8rabk ra6bla 3rable ra2br r1abt 6rabz ra4dan ra2dr
-5rafal ra4f3er ra5gla ra2g3n 6raha ral5am 5rald 4ralg ra8lins 2rall
-ral5t 8ramei r3anal r6and ran8der ran4dr 8ranf 6ranga 5rangi ran8gli
-r3angr rans5pa 8ranw r8anz.  ra5or 6rapf ra5pl rap6s5er 2r1arb 1rarh
-r1arm ra5ro 2r1art 6r1arz ra8tei ra6t5he 6ratl ra4t3ro r5atta raue4n
-6raus.  r5austa rau8tel raut5s ray1 r1b rb5lass r6bler rb4lie rbon6n
-r8brecht \n{rb6s5t"a} r8ces r1che rch1l rch3m rch3re rch3tr rch1w 8rd
-r1da r8dachs r8dap rda5ro rde5ins rdio5 r8dir rd3ost r1dr r8drau 1re.
-re1ak 3reakt re3als re6am.  re1as 4reben re6bl rech5a r8edi re3er
-8reff 3refl 2reh 5reha r4ei.  reich6s5 8reier 6reign re5imp 4r3eina
-6r3einb 6reing 6r5einn 6reinr 4r3eins r3eint reli3e 8r5elt 6rempf
-2remt ren5a6b ren8gl r3enni 1reno 5rente 4r3enth 8rentl 4r3entw 8rentz
-ren4zw re1on requi5 1rer rer4bl 6rerbs 4r3erd \n{8rerh"o} 8rerkl
-4r3erla \n{8rerl"o} 4r3erns \n{6r5ern"a} rer5o 6r5erreg r5ertr r5erwec
-\n{r5er"o} re2sa re8schm 2ress re5u8ni 6rewo 2r1ex r1f r8ferd rf4lie
-8r1g r8gah rge4bl rge5na rgest4 rg6ne r2gni2 r8gob r4g3ret rg8sel r1h8
-r2hy 5rhyt ri1ar ri5cha rid2g r2ie rieg4s5 ri8ei ri1el ri6ele ri1en
-ri3er.  ri5ers.  ri6fan ri8fer ri8fr 1r2ig ri8kn ri5la \n{rim"a8}
-ri1na r8inde rin4ga rin6gr 1rinn 6rinner rino1 r8insp 4rinst
-\n{ri1n"a} ri5o6ch ri1o2d ri3o6st 2r1ir r2is ri3sko ri8spr \n{ri8st"u}
-ri5sv r2it 6r5i6tal ri5tr ri6ve.  8r1j 6rk r1ke rkehrs5 r1ki r3klin
-r1k2n rk3str rk4t3an rk6to r6kuh \n{rk"a4s3t} r1l r5li rline5a 6r1m
-r6manl rma4p r4m3aph r8minf r8mob rm5sa 2rn r1na rna8be r5ne rn2ei
-r6neif r6nex r6nh rn1k r1no r6n5oc rn1sp \n{r1n"a} \n{r1n"u} ro6bern
-6robs ro1ch 3rock.  ro5de ro1e 4rofe ro8hert 1rohr ro5id ro1in ro5isc
-6rolym r2on 6roog ro6phan r3ort ro1s2p ro5s6w ro4tau ro1tr ro6ts 5rout
-r1p rpe8re rp2f r2ps r2pt r1q 2rr r1ra r1re rrer6 rr6hos \n{r5rh"o}
-r1ri r1ro rro8f rr8or rror5a r1ru r3ry \n{r1r"a} \n{r1r"o} \n{r1r"u}
-2r1s r6sab r4sanf rse6e rse5na r2sh r6ska r6ski rs2kl r8sko r2sl rs2p
-r6stauf r8sterw r8stran rswi3d4 r2sz 2r1t rt3art r8taut r5tei rt5eige
-r8tepe r4t3erh r8terla r4t3hei r5t6hu r4t3int rt5reif rt1sc rt6ser
-rt6s5o rt6s5u rt5und r8turt rube6 ru1en 1r4uf ruf4st ru1ie 2r1umg
-2r1uml 2rums run8der run4d5r 6rundz 6runf 8runs 2r1unt 2r1ur r6us
-ru6sta ru3str ru6tr 1ruts r1v rven1 rvi2c r1w r1x r1za rz5ac r6z5al
-r8z1ar r8zerd r6z5erf rz8erh rz4t3h r8zum \n{r"a4ste} \n{r"au8sc}
-\n{r1"of} \n{5r"ohr} \n{r"o5le} \n{3r"oll} \n{5r"omis} \n{r1"or}
-\n{r"o2sc} \n{3r"ump} 1sa.  1saa s3a4ben sa2bl 2s1abs 6s1abt 6sabw
-3sack.  6s3a4der 1saf sa1fa 4s1aff sa5fr 1sag 1sai sa1i2k1 4s1akt 1sal
-sa1la 4s3alpi 6salter salz3a 1sam s5anb san2c 1sand s5angeh 6sanl
-2s1ans 6s3antr 8s1anw s1ap s6aph 8sapo sap5p6 s8ar.  2s1arb 3sarg
-s1arm sa5ro 2s1art 6s1arz 1sas 1sat sat8a 2s1atl sa8tom 3s8aue s5auff
-sau5i s6aur 2s1aus 5s6ause 2s1b2 2sca s4ce 8sch.  3scha.  5schade
-3schaf 3schal sch5ame 8schanc 8schb 1sche 6schef 8schex 2schf 2schg
-2schh 1schi 2schk 5schlag 5schlu \n{6schm"a\3} \n{\c{6schm"a\9}}
-6schna\3 \c{6schna\9} 1scho 6schord 6schp 3schri 8schric 8schrig
-8schrou 6schs 2scht sch3ta sch3tr 1schu 8schunt 6schv 2schz \n{5sch"o}
-\n{5sch"u} 2sco scre6 6scu 2s1d 1se se5an se1ap se6ben se5ec see5i6g
-se3erl 8seff se6han se8hi \n{se8h"o} 6s5eid.  2s1eig s8eil 5sein.
-sei5n6e 6s5einh 3s8eit 3sel.  se4lar selb4 6s3e4lem se8lerl 2s1emp
-sen3ac se5nec 6s5ents 4sentz s8er.  se8reim ser5inn \n{8serm"a}
-8s5erzi \n{6ser"of} se1um 8sexa 6sexp 2s1f2 sfal8ler 2s3g2 sge5b2 s1h
-s8hew 5s6hip 5s4hop 1si 2siat si1b sicht6s 6s5i6dee siege6s5 si1en
-si5err si1f2 si1g2n si6g5r si8kau sik1i si4kin si2kl \n{si8k"u} si1la
-sil6br si1na 2s1inf sin5gh 2s1inh sinne6s5 2s1ins si5ru si5str 4s1j
-s1k2 6sk.  2skau skel6c skelch5 s6kele 1s2ki.  3s4kin.  s6kiz s8kj
-6skn 2skow 3skrib 3skrip 2sku \n{8sk"u} s1l s8lal slei3t s4low 2s1m
-s1n 6sna 6snot 1so so1ch 2s1odo so4dor 6s5o4fen solo3 s2on so5of 4sope
-so1ra 2s1ord 4sorga sou5c so3un 4s3ox sp2 8spaa 5spal 1span 2spap
-s2pec s4peis 1spek s6perg 4spers s6pes 2s1pf 8sphi \n{1s2ph"a} 1spi
-spi4e 6s5pig 6spinse 2spis 2spla 2spol 5s6pom 6s5pos 6spoti 1spra
-3s8prec 6spreis 5spring 6sprob 1spru s2pul 1s2pur 6spy \n{5sp"an}
-\n{1sp"u} s1q 2s1r 2s1s2 sse8nu ssini6s ssoi6r 2st.  1sta 4stafe 2stag
-sta3la 6stale 4stalg 8stalk 8stamt 6st5anf 4stans 6stanw 6starb sta4te
-6staus 2stb 6stc 6std 1ste 4steil 3s2tel st3elb 8stemb 6steppi 8stese
-8stesse 6stf 2stg 2sth st1ha st3hei s8t1hi st1ho st5hu 1sti sti4el
-4stigm sti3na 6stind 4stinf sti8r 2stk 2stl 2stm 1sto 6stoll.  4st3ope
-6stopf.  6stord 6stp 5stra.  4strai 3s4tral 6s5traum 3stra\3
-\c{3stra\9} 3strec 6s3tref 8streib 5streif 6streno 6stres 6strev
-5s6tria 6strig 5strik 8strisi 3s4troa s8troma st5rose 4struf 3strum
-\n{6str"ag} 2st1s6 2stt 1stu stu5a 4stuc 2stue 8stun.  2stv 2stw s2tyl
-6stz \n{1st"a} \n{8st"ag} \n{1st"o} \n{1st"u} \n{8st"uch} \n{4st"ur.}
-1su su2b1 3suc su1e su2fe su8mar 6sumfa 8sumk 2s1unt sup1p2 6s5u6ran
-6surte 2s1v 2s1w 1sy 8syl.  sy5la syn1 sy2na syne4 s1z s4zend 5s6zene.
-8szu \n{1s"a} \n{6s5"and} \n{6s"augi} \n{6s"au\3} \n{\c{6s"au\9}}
-\n{5s"om} \n{2s1"u2b} \n{1s"uc} \n{s"u8di} \n{1s"un} \n{5s"u\3}
-\n{\c{5s"u\9}} taats3 4tab.  taba6k ta8ban tab2l ta6bre 4tabs t3absc
-8tabz 6t3acht ta6der 6tadr tad6s tad2t 1tafe4 1tag ta6ga6 ta8gei
-tage4s tag6s5t tah8 tahl3 tai6ne.  ta5ir.  tak8ta tal3au 1tale ta8leng
-tal5ert 6t5a6mer 6tamp tampe6 2t1amt tan5d6a tan8dr tands5a tani5e
-6tanl 2tanr t3ans 8t5antr tanu6 t5anw 8tanwa tan8zw ta8rau 6tarbe
-1tari 2tark 2t1arm ta1ro 2tart t3arti 6tarz ta1sc ta6sien ta8stem
-ta8sto t5aufb 4taufn 8taus.  5tause 8tausf 6tausg t5ausl 2t1b2 2t1c
-t6chu 2t1d te2am tea4s te8ben 5techn 4teff te4g3re te6hau 2tehe te4hel
-2t1ehr te5id.  teig5l 6teign tei8gr 1teil 4teinh t5einhe 4teis t5eisen
-8teiw te8lam te4lar 4telek 8telem te6man te6n5ag ten8erw ten5k tens4p
-ten8tro 4t3entw 8tentz te6pli 5teppi ter5a6b te3ral ter5au 8terbar
-t5erbe.  6terben 8terbs 4t3erbt t5erde.  ter5ebe ter5ein te8rers terf4
-\n{8terh"o} \n{6terkl"a} ter8nor ter6re.  t8erscha t5e6sel te8stau
-t3euro te1xa tex3e 8texp tex6ta 2t1f2 2t1g2 2th.  th6a 5tha.  2thaa
-6t1hab 6t5haf t5hah 8thak 3thal.  6thals 6t3hand 2t1hau 1the.  3t4hea
-t1heb t5heil t3heit t3helf 1theo 5therap 5therf 6t5herz 1thes 1thet
-5thi.  2t1hil t3him 8thir 3this t5hj 2th1l 2th1m th1n t5hob t5hof
-4tholz 6thopti 1thr6 4ths t1hum 1thy \n{4t1h"a} \n{2t1h"o} \n{t1h"u}
-ti1a2m ti1b tie6fer ti1en ti8gerz tig3l ti8kin ti5lat 1tilg t1ind
-tin4k3l ti3spa ti5str 5tite ti5tr ti8vel ti8vr 2t1j 2t1k2 2t1l tl8a
-2t1m8 2t1n 3tobe 8tobj to3cha 5tocht 8tock tode4 to8del to8du to1e
-6t5o6fen to1in toi6r 5toll.  to8mene t2ons 2t1ony to4per 5topf.  6topt
-to1ra to1s to6ska tos2l 2toti to1tr t8ou 2t1p2 6t1q tr6 tra5cha
-tra8far traf5t 1trag tra6gl tra6gr t3rahm 1trai t6rans tra3sc tra6st
-3traue t4re.  2trec t3rech t8reck 6t1red t8ree 4t1reg 3treib 4treif
-8t3reis 8trepo tre6t5r t3rev 4t3rez 1trib t6rick tri6er 2trig t8rink
-tri6o5d trizi5 tro1a 3troc trocke6 troi8d tro8man.  tro3ny 5tropf
-6t5rosa t5ro\3 \c{t5ro\9} 5trub 5trup trut5 \n{1tr"ag} \n{6t1r"oh}
-\n{5tr"ub} \n{tr"u3bu} \n{t1r"uc} \n{t1r"us} 2ts ts1ab t1sac tsa8d
-ts1ak t6s5alt ts1an ts1ar ts3auf t3schr \n{t5sch"a} tse6e tsee5i
-tsein6s ts3ent ts1er t8serf t4serk t8sh 5t6sik t4s3int ts5ort.
-t5s6por t6sprei t1st t6s5tanz ts1th t6stit t4s3tor 1t2sua t2s1uf
-t8sum.  t2s1u8n t2s1ur 2t1t tt5eif tte6sa tt1ha tt8ret tt1sc tt8ser
-tt5s6z 1tuc tuch5a 1tu1e 6tuh t5uhr tu1i tu6it 1tumh 6t5umr 1tums
-8tumt 6tund 6tunf 2t1unt tu5ra tu6rau tu6re.  tu4r3er 2t1v 2t1w 1ty1
-ty6a ty8la 8tym 6ty6o 2tz tz5al tz1an tz1ar t8zec tzeh6 tzehn5 t6z5ei.
-t6zor t4z3um \n{t6z"au} \n{5t"ag} \n{6t"ah} \n{t5"alt} \n{t8"an}
-\n{t"are8} \n{8t"a8st} \n{6t"au\3} \n{\c{6t"au\9}} \n{t5"offen}
-\n{8t"o8k} \n{1t"on} \n{4t"ub} \n{t6"u5ber.} \n{5t"uch} \n{1t"ur.}
-u3al.  u5alb u5alf u3alh u5alk u3alp u3an.  ua5na u3and u5ans u5ar.
-ua6th u1au ua1y u2bab ubi5er.  u6b5rit ubs2k \n{u5b"o} \n{u8b"ub} 2uc
-u1che u6ch5ec u1chi uch1l uch3m uch5n uch1r uch5to ucht5re u1chu uch1w
-uck1a uck5in u1d ud4a u1ei u6ela uene8 u6ep u1er uer1a ue8rerl uer5o
-u8esc u2est u8ev u1fa u2f1ei u4f3ent u8ferh uf1fr uf1l uf1ra uf1re
-\n{uf1r"a} \n{uf1r"u} uf1s2p uf1st uft1s u8gabt u8gad u6gap ugeb8 u8gn
-ugo3s4 u1ha u1he u1hi uh1le u1ho uh1re u1hu uh1w \n{u1h"a} \n{u1h"o}
-6ui ui5en u1ig u3ins uin8tes u5isch.  u1j 6uk u1ke u1ki u1kl u8klu
-u1k6n u5ky u1la uld8se u1le ul8lac ul6lau ul6le6l ul6lo ulni8 u1lo
-ulo6i ult6a ult8e u1lu ul2vr \n{u1l"a} \n{u1l"o} 3umfan 5umlau umo8f
-um8pho u1mu umu8s \n{u5m"o} u1n1a un2al un6at unau2 6und.  5undein
-un4d3um 3undzw \n{und"u8} \n{un8d"ub} une2b un1ec une2h un3eis 3unfal
-\n{1unf"a} 5ungea \n{3ungl"u} ung2s1 \n{un8g"a} 1u2nif un4it un8kro
-unk5s u1no unpa2 uns2p unvol4 unvoll5 u5os.  u1pa u1pi u1p2l u1pr
-up4s3t up2t1a u1q u1ra ur5abs ura8d ur5ah u6rak ur3alt u6rana u6r5ans
-u8rap ur5a6ri u8ratt u1re ur3eig ur8gri u1ri ur5ins 3urlau urmen6
-ur8nan u1ro 3ursac ur8sau ur8sei ur4sk 3urtei u1ru uru5i6 uru6r u1ry
-ur2za \n{ur6z"a} \n{ur5"a6m} \n{u5r"o} \n{u1r"u} \n{ur"uck3} u1sa
-usa4gi u2s1ar u2s1au u8schec usch5wi u2s1ei use8kel u8sl u4st3a4b
-us3tau u3s4ter u2s1uf u8surn ut1ac u1tal uta8m u1tan ut1ar u1tas ut1au
-u1te u8teic u4tent u8terf u6terin u4t3hei ut5ho ut1hu u1ti utine5
-uti6q u1to uto5c u1tr ut1sa ut1s6p ut6stro u1tu utz5w u1u u1v uve5n
-\n{uve3r4"a} u1w u1xe u5ya uy5e6 u1yi u2z1eh u8zerh \n{u5"o} u\3e6n
-\c{u\9e6n} u\3en5e \c{u\9en5e} 8vanb 6vang 6varb var8d va6t5a va8tei
-va2t1r 2v1b 6v5c 6vd 1ve 6ve5g6 ver1 ver5b verb8l ve2re2 verg8 ve2ru8
-ve1s ve2s3p ve3xe 2v1f 2v1g 6v5h vi6el vie6w5 vi1g4 vi8leh vil6le.
-8vint vi1ru vi1tr 2v1k 2v1l 2v1m 4v5n 8vo8f voi6le vol8lend vol8li
-v2or1 vo2re vo8rin vo2ro 2v1p 8vra v6re 2v1s 2v1t 2v1v 4v3w 2v1z
-waffe8 wa6g5n 1wah wah8n wa5la wal8din wal6ta wan4dr 5ware wa8ru
-war4za 1was w5c w1d 5wech we6fl 1weg we8geng weg5h weg3l we2g1r
-weh6r5er 5weise weit3r wel2t welt3r we6rat 8werc 5werdu wer4fl 5werk.
-wer4ka wer8ku wer4ta wer8term we2sp we8stend we6steu we8str
-\n{we8st"o} wet8ta wich6s5t 1wid wi2dr wiede4 wieder5 wik6 wim6ma
-win4d3r 5wirt wisch5l 1wj 6wk 2w1l 8w1n wo1c woche6 wol6f wor6t5r 6ws2
-w1sk 6w5t 5wunde.  wun6gr wu1sc wu2t1 6w5w wy5a \n{w"arme5} \n{w"a1sc}
-1xag x1ak x3a4men 8xamt x1an 8x1b x1c 1xe.  x3e4g 1xen xe1ro x1erz
-1xes 8xf x1g 8x1h 1xi 8xid xi8so 4xiste x1k 6x1l x1m 8xn 1xo 8x5o6d
-8x3p2 x1r x1s6 8x1t x6tak x8terf x2t1h 1xu xu1e x5ul 6x3w x1z 5ya.
-y5an.  y5ank y1b y1c y6cha y4chia y1d yen6n y5ern y1g y5h y5in y1j
-y1k2 y1lak yl1al yla8m y5lax y1le y1lo y5lu y8mn ym1p2 y3mu y1na yno2d
-yn1t y1on.  y1o4p y5ou ypo1 y1pr y8ps y1r yri3e yr1r2 y1s ys5iat ys8ty
-y1t y3w y1z \n{y"a8m} z5a6b zab5l 8za6d 1zah za5is 4z3ak 6z1am 5zange.
-8zanl 2z1ara 6z5as z5auf 3zaun 2z1b 6z1c 6z1d 1ze ze4dik 4z3eff 8zein
-zei4ta zei8ters ze6la ze8lec zel8th 4zemp 6z5engel zen8zin \n{8zerg"a}
-zer8i ze1ro zers8 zerta8 zer8tab zer8tag 8zerz ze8ste zeu6gr 2z1ex
-2z1f8 z1g 4z1h 1zi zi1en zi5es.  4z3imp zi1na 6z5inf 6z5inni zin6s5er
-8zinsuf zist5r zi5th zi1tr 6z1j 2z1k 2z1l 2z1m 6z1n 1zo zo6gl 4z3oh
-zo1on zor6na8 4z1p z5q 6z1r 2z1s8 2z1t z4t3end z4t3hei z8thi 1zu zu3al
-zu1b4 zu1f2 6z5uhr zun2a 8zunem zunf8 8zungl zu1o zup8fi zu1s8 zu1z
-2z1v zw8 z1wal 5zweck zwei3s z1wel z1wer z6werg 8z5wes 1zwi zwi1s
-6z1wo 1zy 2z1z zz8a zzi1s \n{1z"a} \n{1z"o} \n{6z"ol.} \n{z"o1le}
-\n{1z"u} \n{2z1"u2b} \n{"a1a6} \n{"ab1l} \n{"a1che} \n{"a3chi}
-\n{"ach8sc} \n{"ach8sp} \n{"a5chu} \n{"ack5a} \n{"ad1a} \n{"ad5era}
-\n{"a6d5ia} \n{"a1e} \n{"a5fa} \n{"af1l} \n{"aft6s} \n{"ag1h}
-\n{"ag3le} \n{"a6g5nan} \n{"ag5str} \n{"a1he} \n{"a1hi} \n{"ah1le}
-\n{"ah5ne} \n{1"ahnl} \n{"ah1re} \n{"ah5ri} \n{"ah1ru} \n{"a1hu}
-\n{"ah1w} \n{6"ai} \n{"a1isc} \n{"a6ische} \n{"a5ism} \n{"a5j}
-\n{"a1k} \n{"al1c} \n{"a1le} \n{"a8lei} \n{"al6schl} \n{"ami1e}
-\n{"am8n} \n{"am8s} \n{"a5na} \n{5"anderu} \n{"ane5i8} \n{"ang3l}
-\n{"ank5l} \n{"a1no} \n{"an6s5c} \n{"a1pa} \n{"ap6s5c} \n{3"aq}
-\n{"ar1c} \n{"a1re} \n{"are8m} \n{5"argern} \n{"ar6gl} \n{"a1ri}
-\n{3"armel} \n{"a1ro} \n{"art6s5} \n{"a1ru} \n{3"arztl} \n{"a5r"o}
-\n{"a6s5chen} \n{"asen8s} \n{"as1th} \n{"ata8b} \n{"a1te} \n{"ateri4}
-\n{"ater5it} \n{"a6thy} \n{"a1ti} \n{3"atk} \n{"a1to} \n{"at8schl}
-\n{"ats1p} \n{"a5tu} \n{"aub1l} \n{"au1e} \n{1"aug} \n{"au8ga}
-\n{"au5i} \n{"a1um.} \n{"a1us.} \n{1"au\3} \n{\c{1"au\9}} \n{"a1z}
-\n{"o1b} \n{"o1che} \n{"o5chi} \n{"och8stei} \n{"och8str} \n{"ocht6}
-\n{5"o6dem} \n{5"offn} \n{"o1he} \n{"oh1l8} \n{"oh1re} \n{"o1hu}
-\n{"o1is} \n{"o1ke} \n{1"o2ko} \n{1"ol.} \n{"ol6k5l} \n{"ol8pl}
-\n{"o1mu} \n{"o5na} \n{"onig6s3} \n{"o1no} \n{"o5o6t} \n{"opf3l}
-\n{"op6s5c} \n{"o1re} \n{"or8gli} \n{"o1ri} \n{"or8tr} \n{"o1ru}
-\n{5"osterr} \n{"o1te} \n{"o5th} \n{"o1ti} \n{"o1tu} \n{"o1v} \n{"o1w}
-\n{"owe8} \n{"o2z} \n{"ub6e2} \n{3"u4ber1} \n{"ub1l} \n{"ub1r}
-\n{5"u2bu} \n{"u1che} \n{"u1chi} \n{"u8ch3l} \n{"uch6s5c} \n{"u8ck}
-\n{"uck1a} \n{"uck5ers} \n{"ud1a2} \n{"u6deu} \n{"udi8t} \n{"u2d1o4}
-\n{"ud5s6} \n{"uge4l5a} \n{"ug1l} \n{"uh5a} \n{"u1he} \n{"u8heh}
-\n{"u6h5erk} \n{"uh1le} \n{"uh1re} \n{"uh1ru} \n{"u1hu} \n{"uh1w}
-\n{"u3k} \n{"u1le} \n{"ul4l5a} \n{"ul8lo} \n{"ul4ps} \n{"ul6s5c}
-\n{"u1lu} \n{"un8da} \n{"un8fei} \n{"unk5l} \n{"un8za} \n{"un6zw}
-\n{"u5pi} \n{"u1re} \n{"u8rei} \n{"ur8fl} \n{"ur8fr} \n{"ur8geng}
-\n{"u1ri} \n{"u1ro} \n{"ur8sta} \n{"ur8ster} \n{"u1ru} \n{"use8n}
-\n{"u8sta} \n{"u8stes} \n{"u6s5tete} \n{"u3ta} \n{"u1te} \n{"u1ti}
-\n{"ut8tr} \n{"u1tu} \n{"ut8zei} \n{"u1v} \31a8 \c{\91a8} 5\3a.
-\c{5\9a.} \38as \c{\98as} \31b8 \c{\91b8} \31c \c{\91c} \31d \c{\91d}
-1\3e \c{1\9e} \35ec \c{\95ec} 8\3e8g \c{8\9e8g} 8\3e8h \c{8\9e8h}
-2\31ei \c{2\91ei} 8\3em \c{8\9em} \31f8 \c{\91f8} \31g \c{\91g} \31h
-\c{\91h} 1\3i \c{1\9i} \31k \c{\91k} \31l \c{\91l} \31m \c{\91m}
-\3mana8 \c{\9mana8} \31n \c{\91n} \31o \c{\91o} \31p8 \c{\91p8} \35q
-\c{\95q} \31r \c{\91r} \31s2 \c{\91s2} \3st8 \c{\9st8} \31ta \c{\91ta}
-\31te \c{\91te} \3t3hei \c{\9t3hei} \31ti \c{\91ti} \35to \c{\95to}
-\31tr \c{\91tr} 1\3u8 \c{1\9u8} 6\35um \c{6\95um} \31v \c{\91v} \31w
-\c{\91w} \31z \c{\91z}
-}%
-\endgroup
-\relax\endinput
-%
-% -----------------------------------------------------------------
-%
-% =============== Additional Documentation ===============
-%
-%
-% Older Versions of German Hyphenation Patterns:
-% ----------------------------------------------
-%
-% All older versions of `ghyphen.tex' distributed as
-%
-%       ghyphen.tex/germhyph.tex   as of 1986/11/01
-%       ghyphen.min/ghyphen.max    as of 1988/10/10
-%       ghyphen3.tex               as of 1990/09/27 & 1991/02/13
-%       ghyph31.tex                as of 1994/02/13
-%
-% are out of date and it is recommended to replace them
-% with the new version `dehypht.tex' as of 1999/03/03.
-%
-% If you are using `ghyphen.min' (a minor version of `ghyphen')
-% because of limited trie memory space, try this version and if
-% the space is exceeded get a newer TeX implementation with
-% larger or configurable trie memory sizes.
-%
-%
-%
-% Trie Memory Requirements/Space for Hyphenation Patterns:
-% --------------------------------------------------------
-%
-% To load this set of german hyphenation patterns the parameters
-% of TeX has to have at least these values:
-%
-% TeX 3.x:
-%    IniTeX:    trie_size >= 9733    trie_op_size >= 207
-%    VirTeX:    trie_size >= 8375    trie_op_size >= 207
-%
-% TeX 2.x:
-%    IniTeX:    trie_size >= 8675    trie_op_size >= 198
-%    VirTeX:    trie_size >= 7560    trie_op_size >= 198
-%
-% If you want to load more than one set of hyphenation patterns
-% (in TeX 3.x), the parameters have to be set to a value larger
-% than or equal to the sum of all required values for each set.
-%
-%
-% Setting Trie Memory Parameters:
-% -------------------------------
-%
-% Some implementations allow the user to change the default value
-% of a set of the internal TeX parameters including the trie memory
-% size parameter specifying the used memory for the hyphenation
-% patterns.
-% 
-% Web2c 7.x (Source), teTeX 0.9 (Unix, Amiga), fpTeX (Win32)
-% and newer:
-%   The used memory size of the true is usually set high enough.
-%   If needed set the size of the trie using the keyword `trie_size'
-%   in the configuration file `texmf/web2c/texmf.cnf'.  For details
-%   see the included documentation.
-%
-% emTeX (OS/2, MS-DOS, Windows 3.x/9x/NT):
-%   You can set the used memory size of the trie using the
-%   `-mt<number>' option on the command line or in the
-%   TEXOPTIONS environment variable.
-%
-% PasTeX (Amiga):
-%   The values for the parameters can be set using the keywords
-%   `triesize', `itriesize' and `trieopsize' in the configuration
-%   file.
-%
-% others (binaries only):
-%   See the documentation of the implementation if it is possible
-%   and how to change these values without recompilation.
-%
-% others (with sources)
-%   If the trie memory is too small, you have to recompile TeX
-%   using larger values for `trie_size' and `trie_op_size'.
-%   Modify the change file `tex.ch' and recompile TeX.
-%   For details see the documentation included in the sources.
-%
-%
-%
-% Necessary Settings in TeX macro files:
-% --------------------------------------
-%
-% \lefthyphenmin, \righthyphenmin:
-%   You can set both parameters to 2.
-%
-% \lccode <char>:
-%   To get correct hyphenation points within words containing
-%   umlauts or \ss, it's necessary to assign values > 0 to the
-%   appropriate \lccode <char> positions.
-%
-% These changes are _not_ done when reading this file and have to
-% be included in the language switching mechanism as is done in,
-% for example, `german.sty' (\lccode change for ^^Y = \ss in OT1,
-% \left-/\righthyphenmin settings).
-%
-%
-%% \CharacterTable
-%%  {Upper-case    \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z
-%%   Lower-case    \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z
-%%   Digits        \0\1\2\3\4\5\6\7\8\9
-%%   Exclamation   \!     Double quote  \"     Hash (number) \#
-%%   Dollar        \$     Percent       \%     Ampersand     \&
-%%   Acute accent  \'     Left paren    \(     Right paren   \)
-%%   Asterisk      \*     Plus          \+     Comma         \,
-%%   Minus         \-     Point         \.     Solidus       \/
-%%   Colon         \:     Semicolon     \;     Less than     \<
-%%   Equals        \=     Greater than  \>     Question mark \?
-%%   Commercial at \@     Left bracket  \[     Backslash     \\
-%%   Right bracket \]     Circumflex    \^     Underscore    \_
-%%   Grave accent  \`     Left brace    \{     Vertical bar  \|
-%%   Right brace   \}     Tilde         \~}
-%%
-\endinput
-%% 
-%% End of file `dehypht.tex'.
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/eshyph_vo.tex b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/eshyph_vo.tex
deleted file mode 100644
index e15bdc38..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/eshyph_vo.tex
+++ /dev/null
@@ -1,1104 +0,0 @@
-.\'a2
-.\'aa2
-.\'ae2
-.\'ai2
-.\'ao2
-.\'au2
-.\'e2
-.\'ea2
-.\'ee2
-.\'ei2
-.\'eo2
-.\'eu2
-.\'i2
-.\'ia2
-.\'ie2
-.\'ii2
-.\'io2
-.\'iu2
-.\'o2
-.\'oa2
-.\'oe2
-.\'oi2
-.\'oo2
-.\'ou2
-.\'u2
-.\'ua2
-.\'ue2
-.\'ui2
-.\'uo2
-.\'uu2
-.a2
-.a\'a2
-.a\'e2
-.a\'i2
-.a\'o2
-.a\'u2
-.aa2
-.ae2
-.ai2
-.ao2
-.au2
-.e2
-.e\'a2
-.e\'e2
-.e\'i2
-.e\'o2
-.e\'u2
-.ea2
-.ee2
-.ei2
-.eo2
-.eu2
-.i2
-.i\'a2
-.i\'e2
-.i\'i2
-.i\'o2
-.i\'u2
-.ia2
-.ie2
-.ii2
-.io2
-.iu2
-.o2
-.o\'a2
-.o\'e2
-.o\'i2
-.o\'o2
-.o\'u2
-.oa2
-.oe2
-.oi2
-.oo2
-.ou2
-.u2
-.u\'a2
-.u\'e2
-.u\'i2
-.u\'o2
-.u\'u2
-.ua2
-.ue2
-.ui2
-.uo2
-.uu2
-2\'a.
-2\'aa.
-2\'ae.
-2\'ai.
-2\'ao.
-2\'au.
-2\'e.
-2\'ea.
-2\'ee.
-2\'ei.
-2\'eo.
-2\'eu.
-2\'i.
-2\'ia.
-2\'ie.
-2\'ii.
-2\'io.
-2\'iu.
-2\'o.
-2\'oa.
-2\'oe.
-2\'oi.
-2\'oo.
-2\'ou.
-2\'u.
-2\'ua.
-2\'ue.
-2\'ui.
-2\'uo.
-2\'uu.
-2\~n1\~n
-2\~n1b
-2\~n1c
-2\~n1d
-2\~n1f
-2\~n1g
-2\~n1h
-2\~n1j
-2\~n1k
-2\~n1m
-2\~n1n
-2\~n1p
-2\~n1q
-2\~n1s
-2\~n1t
-2\~n1v
-2\~n1w
-2\~n1x
-2\~n1y
-2\~n1z
-2a.
-2a\'a.
-2a\'e.
-2a\'i.
-2a\'o.
-2a\'u.
-2aa.
-2ae.
-2ai.
-2ao.
-2au.
-2b1\~n
-2b1b
-2b1c
-2b1d
-2b1f
-2b1g
-2b1h
-2b1j
-2b1k
-2b1m
-2b1n
-2b1p
-2b1q
-2b1s
-2b1t
-2b1v
-2b1w
-2b1x
-2b1y
-2b1z
-2c1\~n
-2c1b
-2c1c
-2c1d
-2c1f
-2c1g
-2c1j
-2c1k
-2c1m
-2c1n
-2c1p
-2c1q
-2c1s
-2c1t
-2c1v
-2c1w
-2c1x
-2c1y
-2c1z
-2d1\~n
-2d1b
-2d1c
-2d1d
-2d1f
-2d1g
-2d1h
-2d1j
-2d1k
-2d1m
-2d1n
-2d1p
-2d1q
-2d1s
-2d1t
-2d1v
-2d1w
-2d1x
-2d1y
-2d1z
-2e.
-2e\'a.
-2e\'e.
-2e\'i.
-2e\'o.
-2e\'u.
-2ea.
-2ee.
-2ei.
-2eo.
-2eu.
-2f1\~n
-2f1b
-2f1c
-2f1d
-2f1f
-2f1g
-2f1h
-2f1j
-2f1k
-2f1m
-2f1n
-2f1p
-2f1q
-2f1s
-2f1t
-2f1v
-2f1w
-2f1x
-2f1y
-2f1z
-2g1\~n
-2g1b
-2g1c
-2g1d
-2g1f
-2g1g
-2g1h
-2g1j
-2g1k
-2g1m
-2g1n
-2g1p
-2g1q
-2g1s
-2g1t
-2g1v
-2g1w
-2g1x
-2g1y
-2g1z
-2h1\~n
-2h1b
-2h1c
-2h1d
-2h1f
-2h1g
-2h1h
-2h1j
-2h1k
-2h1m
-2h1n
-2h1p
-2h1q
-2h1s
-2h1t
-2h1v
-2h1w
-2h1x
-2h1y
-2h1z
-2i.
-2i\'a.
-2i\'e.
-2i\'i.
-2i\'o.
-2i\'u.
-2ia.
-2ie.
-2ii.
-2io.
-2iu.
-2j1\~n
-2j1b
-2j1c
-2j1d
-2j1f
-2j1g
-2j1h
-2j1j
-2j1k
-2j1m
-2j1n
-2j1p
-2j1q
-2j1s
-2j1t
-2j1v
-2j1w
-2j1x
-2j1y
-2j1z
-2k1\~n
-2k1b
-2k1c
-2k1d
-2k1f
-2k1g
-2k1h
-2k1j
-2k1k
-2k1m
-2k1n
-2k1p
-2k1q
-2k1s
-2k1t
-2k1v
-2k1w
-2k1x
-2k1y
-2k1z
-2l1\~n
-2l1b
-2l1c
-2l1d
-2l1f
-2l1g
-2l1h
-2l1j
-2l1k
-2l1m
-2l1n
-2l1p
-2l1q
-2l1s
-2l1t
-2l1v
-2l1w
-2l1x
-2l1y
-2l1z
-2m1\~n
-2m1b
-2m1c
-2m1d
-2m1f
-2m1g
-2m1h
-2m1j
-2m1k
-2m1l
-2m1m
-2m1n
-2m1p
-2m1q
-2m1r
-2m1s
-2m1t
-2m1v
-2m1w
-2m1x
-2m1y
-2m1z
-2n1\~n
-2n1b
-2n1c
-2n1d
-2n1f
-2n1g
-2n1h
-2n1j
-2n1k
-2n1l
-2n1m
-2n1n
-2n1p
-2n1q
-2n1r
-2n1s
-2n1t
-2n1v
-2n1w
-2n1x
-2n1y
-2n1z
-2o.
-2o\'a.
-2o\'e.
-2o\'i.
-2o\'o.
-2o\'u.
-2oa.
-2oe.
-2oi.
-2oo.
-2ou.
-2p1\~n
-2p1b
-2p1c
-2p1d
-2p1f
-2p1g
-2p1h
-2p1j
-2p1k
-2p1m
-2p1n
-2p1p
-2p1q
-2p1s
-2p1t
-2p1v
-2p1w
-2p1x
-2p1y
-2p1z
-2q1\~n
-2q1b
-2q1c
-2q1d
-2q1f
-2q1g
-2q1h
-2q1j
-2q1k
-2q1m
-2q1n
-2q1p
-2q1q
-2q1s
-2q1t
-2q1v
-2q1w
-2q1x
-2q1y
-2q1z
-2r1\~n
-2r1b
-2r1c
-2r1d
-2r1f
-2r1g
-2r1h
-2r1j
-2r1k
-2r1m
-2r1n
-2r1p
-2r1q
-2r1s
-2r1t
-2r1v
-2r1w
-2r1x
-2r1y
-2r1z
-2s1\~n
-2s1b
-2s1c
-2s1d
-2s1f
-2s1g
-2s1h
-2s1j
-2s1k
-2s1m
-2s1n
-2s1p
-2s1q
-2s1s
-2s1t
-2s1v
-2s1w
-2s1x
-2s1y
-2s1z
-2t1\~n
-2t1b
-2t1c
-2t1d
-2t1f
-2t1g
-2t1h
-2t1j
-2t1k
-2t1m
-2t1n
-2t1p
-2t1q
-2t1s
-2t1t
-2t1v
-2t1w
-2t1x
-2t1y
-2t1z
-2u.
-2u\'a.
-2u\'e.
-2u\'i.
-2u\'o.
-2u\'u.
-2ua.
-2ue.
-2ui.
-2uo.
-2uu.
-2v1\~n
-2v1b
-2v1c
-2v1d
-2v1f
-2v1g
-2v1h
-2v1j
-2v1k
-2v1m
-2v1n
-2v1p
-2v1q
-2v1s
-2v1t
-2v1v
-2v1w
-2v1x
-2v1y
-2v1z
-2w1\~n
-2w1b
-2w1c
-2w1d
-2w1f
-2w1g
-2w1h
-2w1j
-2w1k
-2w1m
-2w1n
-2w1p
-2w1q
-2w1s
-2w1t
-2w1v
-2w1w
-2w1x
-2w1y
-2w1z
-2x1\~n
-2x1b
-2x1c
-2x1d
-2x1f
-2x1g
-2x1h
-2x1j
-2x1k
-2x1m
-2x1n
-2x1p
-2x1q
-2x1s
-2x1t
-2x1v
-2x1w
-2x1x
-2x1y
-2x1z
-2y1\~n
-2y1b
-2y1c
-2y1d
-2y1f
-2y1g
-2y1h
-2y1j
-2y1k
-2y1m
-2y1n
-2y1p
-2y1q
-2y1s
-2y1t
-2y1v
-2y1w
-2y1x
-2y1y
-2y1z
-2z1\~n
-2z1b
-2z1c
-2z1d
-2z1f
-2z1g
-2z1h
-2z1j
-2z1k
-2z1m
-2z1n
-2z1p
-2z1q
-2z1s
-2z1t
-2z1v
-2z1w
-2z1x
-2z1y
-2z1z
-\'a1\'i
-\'a1\'u
-\'a1\~n
-\'a1a
-\'a1b
-\'a1c
-\'a1d
-\'a1e
-\'a1f
-\'a1g
-\'a1h
-\'a1j
-\'a1k
-\'a1l
-\'a1m
-\'a1n
-\'a1o
-\'a1p
-\'a1q
-\'a1r
-\'a1s
-\'a1t
-\'a1v
-\'a1w
-\'a1x
-\'a1y
-\'a1z
-\'a2\~n.
-\'a2b.
-\'a2c.
-\'a2d.
-\'a2f.
-\'a2g.
-\'a2h.
-\'a2j.
-\'a2k.
-\'a2l.
-\'a2m.
-\'a2n.
-\'a2p.
-\'a2q.
-\'a2r.
-\'a2s.
-\'a2t.
-\'a2v.
-\'a2w.
-\'a2x.
-\'a2y.
-\'a2z.
-\'e1\'i
-\'e1\'u
-\'e1\~n
-\'e1a
-\'e1b
-\'e1c
-\'e1d
-\'e1e
-\'e1f
-\'e1g
-\'e1h
-\'e1j
-\'e1k
-\'e1l
-\'e1m
-\'e1n
-\'e1o
-\'e1p
-\'e1q
-\'e1r
-\'e1s
-\'e1t
-\'e1v
-\'e1w
-\'e1x
-\'e1y
-\'e1z
-\'e2\~n.
-\'e2b.
-\'e2c.
-\'e2d.
-\'e2f.
-\'e2g.
-\'e2h.
-\'e2j.
-\'e2k.
-\'e2l.
-\'e2m.
-\'e2n.
-\'e2p.
-\'e2q.
-\'e2r.
-\'e2s.
-\'e2t.
-\'e2v.
-\'e2w.
-\'e2x.
-\'e2y.
-\'e2z.
-\'i1\'a
-\'i1\'e
-\'i1\'o
-\'i1\~n
-\'i1a
-\'i1b
-\'i1c
-\'i1d
-\'i1e
-\'i1f
-\'i1g
-\'i1h
-\'i1j
-\'i1k
-\'i1l
-\'i1m
-\'i1n
-\'i1o
-\'i1p
-\'i1q
-\'i1r
-\'i1s
-\'i1t
-\'i1v
-\'i1w
-\'i1x
-\'i1y
-\'i1z
-\'i2\~n.
-\'i2b.
-\'i2c.
-\'i2d.
-\'i2f.
-\'i2g.
-\'i2h.
-\'i2j.
-\'i2k.
-\'i2l.
-\'i2m.
-\'i2n.
-\'i2p.
-\'i2q.
-\'i2r.
-\'i2s.
-\'i2t.
-\'i2v.
-\'i2w.
-\'i2x.
-\'i2y.
-\'i2z.
-\'o1\'i
-\'o1\'u
-\'o1\~n
-\'o1a
-\'o1b
-\'o1c
-\'o1d
-\'o1e
-\'o1f
-\'o1g
-\'o1h
-\'o1j
-\'o1k
-\'o1l
-\'o1m
-\'o1n
-\'o1o
-\'o1p
-\'o1q
-\'o1r
-\'o1s
-\'o1t
-\'o1v
-\'o1w
-\'o1x
-\'o1y
-\'o1z
-\'o2\~n.
-\'o2b.
-\'o2c.
-\'o2d.
-\'o2f.
-\'o2g.
-\'o2h.
-\'o2j.
-\'o2k.
-\'o2l.
-\'o2m.
-\'o2n.
-\'o2p.
-\'o2q.
-\'o2r.
-\'o2s.
-\'o2t.
-\'o2v.
-\'o2w.
-\'o2x.
-\'o2y.
-\'o2z.
-\'u1\'a
-\'u1\'e
-\'u1\'o
-\'u1\~n
-\'u1a
-\'u1b
-\'u1c
-\'u1d
-\'u1e
-\'u1f
-\'u1g
-\'u1h
-\'u1j
-\'u1k
-\'u1l
-\'u1m
-\'u1n
-\'u1o
-\'u1p
-\'u1q
-\'u1r
-\'u1s
-\'u1t
-\'u1v
-\'u1w
-\'u1x
-\'u1y
-\'u1z
-\'u2\~n.
-\'u2b.
-\'u2c.
-\'u2d.
-\'u2f.
-\'u2g.
-\'u2h.
-\'u2j.
-\'u2k.
-\'u2l.
-\'u2m.
-\'u2n.
-\'u2p.
-\'u2q.
-\'u2r.
-\'u2s.
-\'u2t.
-\'u2v.
-\'u2w.
-\'u2x.
-\'u2y.
-\'u2z.
-a1\'a
-a1\'e
-a1\'i
-a1\'o
-a1\'u
-a1\~n
-a1a
-a1b
-a1c
-a1d
-a1e
-a1f
-a1g
-a1h
-a1j
-a1k
-a1l
-a1m
-a1n
-a1o
-a1p
-a1q
-a1r
-a1s
-a1t
-a1v
-a1w
-a1x
-a1y
-a1z
-a2\~n.
-a2b.
-a2c.
-a2d.
-a2f.
-a2g.
-a2h.
-a2j.
-a2k.
-a2l.
-a2m.
-a2n.
-a2p.
-a2q.
-a2r.
-a2s.
-a2t.
-a2v.
-a2w.
-a2x.
-a2y.
-a2z.
-e1\'a
-e1\'e
-e1\'i
-e1\'o
-e1\'u
-e1\~n
-e1a
-e1b
-e1c
-e1d
-e1e
-e1f
-e1g
-e1h
-e1j
-e1k
-e1l
-e1m
-e1n
-e1o
-e1p
-e1q
-e1r
-e1s
-e1t
-e1v
-e1w
-e1x
-e1y
-e1z
-e2\~n.
-e2b.
-e2c.
-e2d.
-e2f.
-e2g.
-e2h.
-e2j.
-e2k.
-e2l.
-e2m.
-e2n.
-e2p.
-e2q.
-e2r.
-e2s.
-e2t.
-e2v.
-e2w.
-e2x.
-e2y.
-e2z.
-i1\~n
-i1b
-i1c
-i1d
-i1f
-i1g
-i1h
-i1j
-i1k
-i1l
-i1m
-i1n
-i1p
-i1q
-i1r
-i1s
-i1t
-i1v
-i1w
-i1x
-i1y
-i1z
-i2\~n.
-i2b.
-i2c.
-i2d.
-i2f.
-i2g.
-i2h.
-i2j.
-i2k.
-i2l.
-i2m.
-i2n.
-i2p.
-i2q.
-i2r.
-i2s.
-i2t.
-i2v.
-i2w.
-i2x.
-i2y.
-i2z.
-o1\'a
-o1\'e
-o1\'i
-o1\'o
-o1\'u
-o1\~n
-o1a
-o1b
-o1c
-o1d
-o1e
-o1f
-o1g
-o1h
-o1j
-o1k
-o1l
-o1m
-o1n
-o1o
-o1p
-o1q
-o1r
-o1s
-o1t
-o1v
-o1w
-o1x
-o1y
-o1z
-o2\~n.
-o2b.
-o2c.
-o2d.
-o2f.
-o2g.
-o2h.
-o2j.
-o2k.
-o2l.
-o2m.
-o2n.
-o2p.
-o2q.
-o2r.
-o2s.
-o2t.
-o2v.
-o2w.
-o2x.
-o2y.
-o2z.
-u1\~n
-u1b
-u1c
-u1d
-u1f
-u1g
-u1h
-u1j
-u1k
-u1l
-u1m
-u1n
-u1p
-u1q
-u1r
-u1s
-u1t
-u1v
-u1w
-u1x
-u1y
-u1z
-u2\~n.
-u2b.
-u2c.
-u2d.
-u2f.
-u2g.
-u2h.
-u2j.
-u2k.
-u2l.
-u2m.
-u2n.
-u2p.
-u2q.
-u2r.
-u2s.
-u2t.
-u2v.
-u2w.
-u2x.
-u2y.
-u2z.
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/expander-1.3.1.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/expander-1.3.1.tm
deleted file mode 100644
index 9ce76d84..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/expander-1.3.1.tm
+++ /dev/null
@@ -1,1122 +0,0 @@
-#---------------------------------------------------------------------
-# TITLE:
-#	expander.tcl
-#
-# AUTHOR:
-#	Will Duquette
-#
-# DESCRIPTION:
-#
-# An expander is an object that takes as input text with embedded
-# Tcl code and returns text with the embedded code expanded.  The
-# text can be provided all at once or incrementally.
-#
-# See  expander.[e]html for usage info.
-# Also expander.n
-#
-# LICENSE:
-#       Copyright (C) 2001 by William H. Duquette.  See expander_license.txt,
-#       distributed with this file, for license information.
-#
-# CHANGE LOG:
-#
-#       10/31/01: V0.9 code is complete.
-#       11/23/01: Added "evalcmd"; V1.0 code is complete.
-
-# Provide the package.
-
-# Create the package's namespace.
-
-namespace eval ::textutil {
-    namespace eval expander {
-	# All indices are prefixed by "$exp-".
-	#
-	# lb		    The left bracket sequence
-	# rb		    The right bracket sequence
-	# errmode	    How to handle macro errors: 
-	#		    nothing, macro, error, fail.
-        # evalcmd           The evaluation command.
-	# textcmd           The plain text processing command.
-	# level		    The context level
-	# output-$level     The accumulated text at this context level.
-	# name-$level       The tag name of this context level
-	# data-$level-$var  A variable of this context level     
-	
-	variable Info
-    
-	# In methods, the current object:
-	variable This ""
-	
-	# Export public commands
-	namespace export expander
-    }
-
-    #namespace import expander::*
-    namespace export expander
-
-    proc expander {name} {uplevel ::textutil::expander::expander [list $name]}
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	expander name
-#
-# INPUTS:
-#	name		A proc name for the new object.  If not
-#                       fully-qualified, it is assumed to be relative
-#                       to the caller's namespace.
-#
-# RETURNS:
-#	nothing
-#
-# DESCRIPTION:
-#	Creates a new expander object.
-
-proc ::textutil::expander::expander {name} {
-    variable Info
-
-    # FIRST, qualify the name.
-    if {![string match "::*" $name]} {
-        # Get caller's namespace; append :: if not global namespace.
-        set ns [uplevel 1 namespace current]
-        if {"::" != $ns} {
-            append ns "::"
-        }
-        
-        set name "$ns$name"
-    }
-
-    # NEXT, Check the name
-    if {"" != [info commands $name]} {
-        return -code error "command name \"$name\" already exists"
-    }
-
-    # NEXT, Create the object.
-    proc $name {method args} [format {
-        if {[catch {::textutil::expander::Methods %s $method $args} result]} {
-            return -code error $result
-        } else {
-            return $result
-        }
-    } $name]
-
-    # NEXT, Initialize the object
-    Op_reset $name
-    
-    return $name
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Methods name method argList
-#
-# INPUTS:
-#	name		The object's fully qualified procedure name.
-#			This argument is provided by the object command
-#			itself.
-#	method		The method to call.
-#	argList		Arguments for the specific method.
-#
-# RETURNS:
-#	Depends on the method
-#
-# DESCRIPTION:
-#	Handles all method dispatch for a expander object.
-#       The expander's object command merely passes its arguments to
-#	this function, which dispatches the arguments to the
-#	appropriate method procedure.  If the method raises an error,
-#	the method procedure's name in the error message is replaced
-#	by the object and method names.
-
-proc ::textutil::expander::Methods {name method argList} {
-    variable Info
-    variable This
-
-    switch -exact -- $method {
-        expand -
-        lb -
-        rb -
-        setbrackets -
-        errmode -
-        evalcmd -
-	textcmd -
-        cpush -
-	ctopandclear -
-        cis -
-        cname -
-        cset -
-        cget -
-        cvar -
-        cpop -
-        cappend -
-	where -
-        reset {
-            # FIRST, execute the method, first setting This to the object
-            # name; then, after the method has been called, restore the
-            # old object name.
-            set oldThis $This
-            set This $name
-
-            set retval [catch "Op_$method $name $argList" result]
-
-            set This $oldThis
-
-            # NEXT, handle the result based on the retval.
-            if {$retval} {
-                regsub -- "Op_$method" $result "$name $method" result
-                return -code error $result
-            } else {
-                return $result
-            }
-        }
-        default {
-            return -code error "\"$name $method\" is not defined"
-        }
-    }
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Get key
-#
-# INPUTS:
-#	key		A key into the Info array, excluding the
-#	                object name.  E.g., "lb"
-#
-# RETURNS:
-#	The value from the array
-#
-# DESCRIPTION:
-#	Gets the value of an entry from Info for This.
-
-proc ::textutil::expander::Get {key} {
-    variable Info
-    variable This
-
-    return $Info($This-$key)
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Set key value
-#
-# INPUTS:
-#	key		A key into the Info array, excluding the
-#	                object name.  E.g., "lb"
-#
-#	value		A Tcl value
-#
-# RETURNS:
-#	The value
-#
-# DESCRIPTION:
-#	Sets the value of an entry in Info for This.
-
-proc ::textutil::expander::Set {key value} {
-    variable Info
-    variable This
-
-    return [set Info($This-$key) $value]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Var key
-#
-# INPUTS:
-#	key		A key into the Info array, excluding the
-#	                object name.  E.g., "lb"
-#
-# RETURNS:
-#	The full variable name, suitable for setting or lappending
-
-proc ::textutil::expander::Var {key} {
-    variable Info
-    variable This
-
-    return ::textutil::expander::Info($This-$key)
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Contains list value
-#
-# INPUTS:
-#       list		any list
-#	value		any value
-#
-# RETURNS:
-#	TRUE if the list contains the value, and false otherwise.
-
-proc ::textutil::expander::Contains {list value} {
-    if {[lsearch -exact $list $value] == -1} {
-        return 0
-    } else {
-        return 1
-    }
-}
-
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_lb ?newbracket?
-#
-# INPUTS:
-#	newbracket		If given, the new bracket token.
-#
-# RETURNS:
-#	The current left bracket
-#
-# DESCRIPTION:
-#	Returns the current left bracket token.
-
-proc ::textutil::expander::Op_lb {name {newbracket ""}} {
-    if {[string length $newbracket] != 0} {
-        Set lb $newbracket
-    }
-    return [Get lb]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_rb ?newbracket?
-#
-# INPUTS:
-#	newbracket		If given, the new bracket token.
-#
-# RETURNS:
-#	The current left bracket
-#
-# DESCRIPTION:
-#	Returns the current left bracket token.
-
-proc ::textutil::expander::Op_rb {name {newbracket ""}} {
-    if {[string length $newbracket] != 0} {
-        Set rb $newbracket
-    }
-    return [Get rb]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_setbrackets lbrack rbrack
-#
-# INPUTS:
-#	lbrack		The new left bracket
-#	rbrack		The new right bracket
-#
-# RETURNS:
-#	nothing
-#
-# DESCRIPTION:
-#	Sets the brackets as a pair.
-
-proc ::textutil::expander::Op_setbrackets {name lbrack rbrack} {
-    Set lb $lbrack
-    Set rb $rbrack
-    return
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_errmode ?newErrmode?
-#
-# INPUTS:
-#	newErrmode		If given, the new error mode.
-#
-# RETURNS:
-#	The current error mode
-#
-# DESCRIPTION:
-#	Returns the current error mode.
-
-proc ::textutil::expander::Op_errmode {name {newErrmode ""}} {
-    if {[string length $newErrmode] != 0} {
-        if {![Contains "macro nothing error fail" $newErrmode]} {
-            error "$name errmode: Invalid error mode: $newErrmode"
-        }
-
-        Set errmode $newErrmode
-    }
-    return [Get errmode]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_evalcmd ?newEvalCmd?
-#
-# INPUTS:
-#	newEvalCmd		If given, the new eval command.
-#
-# RETURNS:
-#	The current eval command
-#
-# DESCRIPTION:
-#	Returns the current eval command.  This is the command used to
-#	evaluate macros; it defaults to "uplevel #0".
-
-proc ::textutil::expander::Op_evalcmd {name {newEvalCmd ""}} {
-    if {[string length $newEvalCmd] != 0} {
-        Set evalcmd $newEvalCmd
-    }
-    return [Get evalcmd]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_textcmd ?newTextCmd?
-#
-# INPUTS:
-#	newTextCmd		If given, the new text command.
-#
-# RETURNS:
-#	The current text command
-#
-# DESCRIPTION:
-#	Returns the current text command.  This is the command used to
-#	process plain text. It defaults to {}, meaning identity.
-
-proc ::textutil::expander::Op_textcmd {name args} {
-    switch -exact [llength $args] {
-	0 {}
-	1 {Set textcmd [lindex $args 0]}
-	default {
-	    return -code error "wrong#args for textcmd: name ?newTextcmd?"
-	}
-    }
-    return [Get textcmd]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_reset
-#
-# INPUTS:
-#	none
-#
-# RETURNS:
-#	nothing
-#
-# DESCRIPTION:
-#	Resets all object values, as though it were brand new.
-
-proc ::textutil::expander::Op_reset {name} {
-    variable Info 
-
-    if {[info exists Info($name-lb)]} {
-        foreach elt [array names Info "$name-*"] {
-            unset Info($elt)
-        }
-    }
-
-    set Info($name-lb) "\["
-    set Info($name-rb) "\]"
-    set Info($name-errmode) "fail"
-    set Info($name-evalcmd) "uplevel #0"
-    set Info($name-textcmd) ""
-    set Info($name-level) 0
-    set Info($name-output-0) ""
-    set Info($name-name-0) ":0"
-
-    return
-}
-
-#-------------------------------------------------------------------------
-# Context: Every expansion takes place in its own context; however, 
-# a macro can push a new context, causing the text it returns and all
-# subsequent text to be saved separately.  Later, a matching macro can
-# pop the context, acquiring all text saved since the first command,
-# and use that in its own output.
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cpush cname
-#
-# INPUTS:
-#	cname		The context name
-#
-# RETURNS:
-#	nothing
-#
-# DESCRIPTION:
-#       Pushes an empty macro context onto the stack.  All expanded text
-#       will be added to this context until it is popped.
-
-proc ::textutil::expander::Op_cpush {name cname} {
-    # FRINK: nocheck
-    incr [Var level]
-    # FRINK: nocheck
-    set [Var output-[Get level]] {}
-    # FRINK: nocheck
-    set [Var name-[Get level]] $cname
-
-    # The first level is init'd elsewhere (Op_expand)
-    if {[set [Var level]] < 2} return
-
-    # Initialize the location information, inherit from the outer
-    # context.
-
-    LocInit $cname
-    catch {LocSet $cname [LocGet $name]}
-    return    
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cis cname
-#
-# INPUTS:
-#	cname		A context name
-#
-# RETURNS:
-#	true or false
-#
-# DESCRIPTION:
-#       Returns true if the current context has the specified name, and
-#	false otherwise.
-
-proc ::textutil::expander::Op_cis {name cname} {
-    return [expr {[string compare $cname [Op_cname $name]] == 0}]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cname
-#
-# INPUTS:
-#	none
-#
-# RETURNS:
-#	The context name
-#
-# DESCRIPTION:
-#       Returns the name of the current context.
-
-proc ::textutil::expander::Op_cname {name} {
-    return [Get name-[Get level]]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cset varname value
-#
-# INPUTS:
-#	varname		The name of a context variable
-#	value		The new value for the context variable
-#
-# RETURNS:
-#	The value
-#
-# DESCRIPTION:
-#       Sets a variable in the current context.
-
-proc ::textutil::expander::Op_cset {name varname value} {
-    Set data-[Get level]-$varname $value
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cget varname
-#
-# INPUTS:
-#	varname		The name of a context variable
-#
-# RETURNS:
-#	The value
-#
-# DESCRIPTION:
-#       Returns the value of a context variable.  It's an error if
-#	the variable doesn't exist.
-
-proc ::textutil::expander::Op_cget {name varname} {
-    if {![info exists [Var data-[Get level]-$varname]]} {
-        error "$name cget: $varname doesn't exist in this context ([Get level])"
-    }
-    return [Get data-[Get level]-$varname]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cvar varname
-#
-# INPUTS:
-#	varname		The name of a context variable
-#
-# RETURNS:
-#	The index to the variable
-#
-# DESCRIPTION:
-#       Returns the index to a context variable, for use with set, 
-#	lappend, etc.
-
-proc ::textutil::expander::Op_cvar {name varname} {
-    if {![info exists [Var data-[Get level]-$varname]]} {
-        error "$name cvar: $varname doesn't exist in this context"
-    }
-
-    return [Var data-[Get level]-$varname]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cpop cname
-#
-# INPUTS:
-#	cname		The expected context name.
-#
-# RETURNS:
-#	The accumulated output in this context
-#
-# DESCRIPTION:
-#       Returns the accumulated output for the current context, first
-#	popping the context from the stack.  The expected context name
-#	must match the real name, or an error occurs.
-
-proc ::textutil::expander::Op_cpop {name cname} {
-    variable Info
-
-    if {[Get level] == 0} {
-        error "$name cpop underflow on '$cname'"
-    }
-
-    if {[string compare [Op_cname $name] $cname] != 0} {
-        error "$name cpop context mismatch: expected [Op_cname $name], got $cname"
-    }
-
-    set result [Get output-[Get level]]
-    # FRINK: nocheck
-    set [Var output-[Get level]] ""
-    # FRINK: nocheck
-    set [Var name-[Get level]] ""
-
-    foreach elt [array names "Info data-[Get level]-*"] {
-        unset Info($elt)
-    }
-
-    # FRINK: nocheck
-    incr [Var level] -1
-    return $result
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_ctopandclear
-#
-# INPUTS:
-#	None.
-#
-# RETURNS:
-#	The accumulated output in the topmost context, clears the context,
-#	but does not pop it.
-#
-# DESCRIPTION:
-#       Returns the accumulated output for the current context, first
-#	popping the context from the stack.  The expected context name
-#	must match the real name, or an error occurs.
-
-proc ::textutil::expander::Op_ctopandclear {name} {
-    variable Info
-
-    if {[Get level] == 0} {
-        error "$name cpop underflow on '[Op_cname $name]'"
-    }
-
-    set result [Get output-[Get level]]
-    Set output-[Get level] ""
-    return $result
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cappend text
-#
-# INPUTS:
-#	text		Text to add to the output
-#
-# RETURNS:
-#	The accumulated output
-#
-# DESCRIPTION:
-#       Appends the text to the accumulated output in the current context.
-
-proc ::textutil::expander::Op_cappend {name text} {
-    # FRINK: nocheck
-    append [Var output-[Get level]] $text
-}
-
-#-------------------------------------------------------------------------
-# Macro-expansion:  The following code is the heart of the module.
-# Given a text string, and the current variable settings, this code
-# returns an expanded string, with all macros replaced.
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_expand inputString ?brackets?
-#
-# INPUTS:
-#	inputString		The text to expand.
-#	brackets		A list of two bracket tokens.
-#
-# RETURNS:
-#	The expanded text.
-#
-# DESCRIPTION:
-#	Finds all embedded macros in the input string, and expands them.
-#	If ?brackets? is given, it must be list of length 2, containing
-#	replacement left and right macro brackets; otherwise the default
-#	brackets are used.
-
-proc ::textutil::expander::Op_expand {name inputString {brackets ""}} {
-    # FIRST, push a new context onto the stack, and save the current
-    # brackets.
-
-    Op_cpush $name expand
-    Op_cset $name lb [Get lb]
-    Op_cset $name rb [Get rb]
-
-    # Keep position information in context variables as well.
-    # Line we are in, counting from 1; column we are at,
-    # counting from 0, and index of character we are at,
-    # counting from 0. Tabs counts as '1' when computing
-    # the column.
-
-    LocInit $name
-
-    # SF Tcllib Bug #530056.
-    set start_level [Get level] ; # remember this for check at end
-
-    # NEXT, use the user's brackets, if given.
-    if {[llength $brackets] == 2} {
-        Set lb [lindex $brackets 0]
-        Set rb [lindex $brackets 1]
-    }
-
-    # NEXT, loop over the string, finding and expanding macros.
-    while {[string length $inputString] > 0} {
-        set plainText [ExtractToToken inputString [Get lb] exclude]
-
-        # FIRST, If there was plain text, append it to the output, and 
-        # continue.
-        if {$plainText != ""} {
-	    set input $plainText
-	    set tc [Get textcmd]
-	    if {[string length $tc] > 0} {
-		lappend tc $plainText
-
-		if {![catch "[Get evalcmd] [list $tc]" result]} {
-		    set plainText $result
-		} else {
-		    HandleError $name {plain text} $tc $result
-		}
-	    }
-            Op_cappend $name $plainText
-	    LocUpdate  $name $input
-
-            if {[string length $inputString] == 0} {
-                break
-            }
-        }
-
-        # NEXT, A macro is the next thing; process it.
-        if {[catch {GetMacro inputString} macro]} {
-	    # SF tcllib bug 781973 ... Do not throw a regular
-	    # error. Use HandleError to give the user control of the
-	    # situation, via the defined error mode. The continue
-	    # intercepts if the user allows the expansion to run on,
-	    # yet we must not try to run the non-existing macro.
-
-	    HandleError $name {reading macro} $inputString $macro
-	    continue
-        }
-
-        # Expand the macro, and output the result, or
-        # handle an error.
-        if {![catch "[Get evalcmd] [list $macro]" result]} {
-            Op_cappend $name $result 
-
-	    # We have to advance the location by the length of the
-	    # macro, plus the two brackets. They were stripped by
-	    # GetMacro, so we have to add them here again to make
-	    # computation correct.
-
-	    LocUpdate $name [Get lb]${macro}[Get rb]
-            continue
-        } 
-
-	HandleError $name macro $macro $result
-    }
-
-    # SF Tcllib Bug #530056.
-    if {[Get level] > $start_level} {
-	# The user macros pushed additional contexts, but forgot to
-	# pop them all. The main work here is to place all the still
-	# open contexts into the error message, and to produce
-	# syntactically correct english.
-
-	set c [list]
-	set n [expr {[Get level] - $start_level}]
-	if {$n == 1} {
-	    set ctx  context
-	    set verb was
-	} else {
-	    set ctx  contexts
-	    set verb were
-	}
-	for {incr n -1} {$n >= 0} {incr n -1} {
-	    lappend c [Get name-[expr {[Get level]-$n}]]
-	}
-	return -code error \
-		"The following $ctx pushed by the macros $verb not popped: [join $c ,]."
-    } elseif {[Get level] < $start_level} {
-	set n [expr {$start_level - [Get level]}]
-	if {$n == 1} {
-	    set ctx  context
-	} else {
-	    set ctx  contexts
-	}
-	return -code error \
-		"The macros popped $n more $ctx than they had pushed."
-    }
-
-    Op_lb $name [Op_cget $name lb]
-    Op_rb $name [Op_cget $name rb]
-
-    return [Op_cpop $name expand]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_where
-#
-# INPUTS:
-#	None.
-#
-# RETURNS:
-#	The current location in the input.
-#
-# DESCRIPTION:
-#	Retrieves the current location the expander
-#	is at during processing.
-
-proc ::textutil::expander::Op_where {name} {
-    return [LocGet $name]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION
-#	HandleError name title command errmsg
-#
-# INPUTS:
-#	name		The name of the expander object in question.
-#	title		A title text
-#	command		The command which caused the error.
-#	errmsg		The error message to report
-#
-# RETURNS:
-#	Nothing
-#
-# DESCRIPTIONS
-#	Is executed when an error in a macro or the plain text handler
-#	occurs. Generates an error message according to the current
-#	error mode.
-
-proc ::textutil::expander::HandleError {name title command errmsg} {
-    switch [Get errmode] {
-	nothing { }
-	macro {
-	    # The location is irrelevant here.
-	    Op_cappend $name "[Get lb]$command[Get rb]" 
-	}
-	error {
-	    foreach {ch line col} [LocGet $name] break
-	    set display [DisplayOf $command]
-
-	    Op_cappend $name "\n=================================\n"
-	    Op_cappend $name "*** Error in $title at line $line, column $col:\n"
-	    Op_cappend $name "*** [Get lb]$display[Get rb]\n--> $errmsg\n"
-	    Op_cappend $name "=================================\n"
-	}
-	fail   { 
-	    foreach {ch line col} [LocGet $name] break
-	    set display [DisplayOf $command]
-
-	    return -code error "Error in $title at line $line,\
-		    column $col:\n[Get lb]$display[Get rb]\n-->\
-		    $errmsg"
-	}
-	default {
-	    return -code error "Unknown error mode: [Get errmode]"
-	}
-    }
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	ExtractToToken string token mode
-#
-# INPUTS:
-#	string		The text to process.
-#	token		The token to look for
-#	mode		include or exclude
-#
-# RETURNS:
-#	The extracted text
-#
-# DESCRIPTION:
-# 	Extract text from a string, up to or including a particular
-# 	token.  Remove the extracted text from the string.
-# 	mode determines whether the found token is removed;
-# 	it should be "include" or "exclude".  The string is
-# 	modified in place, and the extracted text is returned.
-
-proc ::textutil::expander::ExtractToToken {string token mode} {
-    upvar $string theString
-
-    # First, determine the offset
-    switch $mode {
-        include { set offset [expr {[string length $token] - 1}] }
-        exclude { set offset -1 }
-        default { error "::expander::ExtractToToken: unknown mode $mode" }
-    }
-
-    # Next, find the first occurrence of the token.
-    set tokenPos [string first $token $theString]
-
-    # Next, return the entire string if it wasn't found, or just
-    # the part upto or including the character.
-    if {$tokenPos == -1} {
-        set theText $theString
-        set theString ""
-    } else {
-        set newEnd    [expr {$tokenPos + $offset}]
-        set newBegin  [expr {$newEnd + 1}]
-        set theText   [string range $theString 0 $newEnd]
-        set theString [string range $theString $newBegin end]
-    }
-
-    return $theText
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	GetMacro string
-#
-# INPUTS:
-#	string		The text to process.
-#
-# RETURNS:
-#	The macro, stripped of its brackets.
-#
-# DESCRIPTION:
-
-proc ::textutil::expander::GetMacro {string} {
-    upvar $string theString
-
-    # FIRST, it's an error if the string doesn't begin with a
-    # bracket.
-    if {[string first [Get lb] $theString] != 0} {
-        error "::expander::GetMacro: assertion failure, next text isn't a command! '$theString'"
-    }
-
-    # NEXT, extract a full macro
-    set macro [ExtractToToken theString [Get lb] include]
-    while {[string length $theString] > 0} {
-        append macro [ExtractToToken theString [Get rb] include]
-
-        # Verify that the command really ends with the [rb] characters,
-        # whatever they are.  If not, break because of unexpected
-        # end of file.
-        if {![IsBracketed $macro]} {
-            break;
-        }
-
-        set strippedMacro [StripBrackets $macro]
-
-        if {[info complete "puts \[$strippedMacro\]"]} {
-            return $strippedMacro
-        }
-    }
-
-    if {[string length $macro] > 40} {
-        set macro "[string range $macro 0 39]...\n"
-    }
-    error "Unexpected EOF in macro:\n$macro"
-}
-
-# Strip left and right bracket tokens from the ends of a macro,
-# provided that it's properly bracketed.
-proc ::textutil::expander::StripBrackets {macro} {
-    set llen [string length [Get lb]]
-    set rlen [string length [Get rb]]
-    set tlen [string length $macro]
-
-    return [string range $macro $llen [expr {$tlen - $rlen - 1}]]
-}
-
-# Return 1 if the macro is properly bracketed, and 0 otherwise.
-proc ::textutil::expander::IsBracketed {macro} {
-    set llen [string length [Get lb]]
-    set rlen [string length [Get rb]]
-    set tlen [string length $macro]
-
-    set leftEnd  [string range $macro 0       [expr {$llen - 1}]]
-    set rightEnd [string range $macro [expr {$tlen - $rlen}] end]
-
-    if {$leftEnd != [Get lb]} {
-        return 0
-    } elseif {$rightEnd != [Get rb]} {
-        return 0
-    } else {
-        return 1
-    }
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocInit name
-#
-# INPUTS:
-#	name		The expander object to use.
-#
-# RETURNS:
-#	No result.
-#
-# DESCRIPTION:
-#	A convenience wrapper around LocSet. Initializes the location
-#	to the start of the input (char 0, line 1, column 0).
-
-proc ::textutil::expander::LocInit {name} {
-    LocSet $name {0 1 0}
-    return
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocSet name loc
-#
-# INPUTS:
-#	name		The expander object to use.
-#	loc		Location, list containing character position,
-#			line number and column, in this order.
-#
-# RETURNS:
-#	No result.
-#
-# DESCRIPTION:
-#	Sets the current location in the expander to 'loc'.
-
-proc ::textutil::expander::LocSet {name loc} {
-    foreach {ch line col} $loc break
-    Op_cset  $name char $ch
-    Op_cset  $name line $line
-    Op_cset  $name col  $col
-    return
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocGet name
-#
-# INPUTS:
-#	name		The expander object to use.
-#
-# RETURNS:
-#	A list containing the current character position, line number
-#	and column, in this order.
-#
-# DESCRIPTION:
-#	Returns the current location as stored in the expander.
-
-proc ::textutil::expander::LocGet {name} {
-    list [Op_cget $name char] [Op_cget $name line] [Op_cget $name col]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocUpdate name text
-#
-# INPUTS:
-#	name		The expander object to use.
-#	text		The text to process.
-#
-# RETURNS:
-#	No result.
-#
-# DESCRIPTION:
-#	Takes the current location as stored in the expander, computes
-#	a new location based on the string (its length and contents
-#	(number of lines)), and makes that new location the current
-#	location.
-
-proc ::textutil::expander::LocUpdate {name text} {
-    foreach {ch line col} [LocGet $name] break
-    set numchars [string length $text]
-    #8.4+ set numlines [regexp -all "\n" $text]
-    set numlines [expr {[llength [split $text \n]]-1}]
-
-    incr ch   $numchars
-    incr line $numlines
-    if {$numlines} {
-	set col [expr {$numchars - [string last \n $text] - 1}]
-    } else {
-	incr col $numchars
-    }
-
-    LocSet $name [list $ch $line $col]
-    return
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocRange name text
-#
-# INPUTS:
-#	name		The expander object to use.
-#	text		The text to process.
-#
-# RETURNS:
-#	A text range description, compatible with the 'location' data
-#	used in the tcl debugger/checker.
-#
-# DESCRIPTION:
-#	Takes the current location as stored in the expander object
-#	and the length of the text to generate a character range.
-
-proc ::textutil::expander::LocRange {name text} {
-    # Note that the structure is compatible with
-    # the ranges uses by tcl debugger and checker.
-    # {line {charpos length}}
-
-    foreach {ch line col} [LocGet $name] break
-    return [list $line [list $ch [string length $text]]]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	DisplayOf text
-#
-# INPUTS:
-#	text		The text to process.
-#
-# RETURNS:
-#	The text, cut down to at most 30 bytes.
-#
-# DESCRIPTION:
-#	Cuts the incoming text down to contain no more than 30
-#	characters of the input. Adds an ellipsis (...) if characters
-#	were actually removed from the input.
-
-proc ::textutil::expander::DisplayOf {text} {
-    set ellip ""
-    while {[string bytelength $text] > 30} {
-	set ellip ...
-	set text [string range $text 0 end-1]
-    }
-    set display $text$ellip
-}
-
-#---------------------------------------------------------------------
-# Provide the package only if the code above was read and executed
-# without error.
-
-package provide textutil::expander 1.3.1
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/ithyph.tex b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/ithyph.tex
deleted file mode 100644
index 755e1085..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/ithyph.tex
+++ /dev/null
@@ -1,223 +0,0 @@
-
-%%%%%%%%%%%%%%%%%%%% file ithyph.tex
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%  file ithyph.tex  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% Prepared by Claudio Beccari   e-mail  beccari@polito.it
-%
-%                                       Dipartimento di Elettronica
-%                                       Politecnico di Torino
-%                                       Corso Duca degli Abruzzi, 24
-%                                       10129 TORINO
-%
-% Copyright  1998, 2001 Claudio Beccari
-%
-% This program can be redistributed and/or modified under the terms
-% of the LaTeX Project Public License Distributed from CTAN
-% archives in directory macros/latex/base/lppl.txt; either
-% version 1 of the License, or any later version.
-%
-% \versionnumber{4.8d}   \versiondate{2001/11/21}
-%
-% These hyphenation patterns for the Italian language are supposed to comply
-% with the Reccomendation UNI 6461 on hyphenation issued by the Italian
-% Standards Institution (Ente Nazionale di Unificazione UNI).  No guarantee
-% or declaration of fitness to any particular purpose is given and any
-% liability is disclaimed.
-%
-% See comments and loading instructions at the end of the file after the
-% \endinput line
-%
-{\lccode`\'=`\'      % Apostrophe has its own lccode so that it is treated
-                     % as a letter
-                     %>> 1998/04/14 inserted grouping
-                     %
-%\lccode23=23        % Compound word mark is a letter in encoding T1
-%\def\W{^^W}         % ^^W =\char23 = \char"17 =\char'27
-%
-\patterns{
-.a3p2n               % After the Garzanti dictionary: a-pnea, a-pnoi-co,...
-.anti1  .anti3m2n
-.bio1
-.ca4p3s
-.circu2m1
-.di2s3cine
-%.e2x
-.fran2k3
-.free3
-.narco1
-.opto1
-.orto3p2
-.para1
-.poli3p2
-.pre1
-.p2s
-%.ri1a2   .ri1e2    .re1i2  .ri1o2  .ri1u2
-.sha2re3
-.tran2s3c .tran2s3d .tran2s3f .tran2s3l .tran2s3n .tran2s3p .tran2s3r .tran2s3t
-.su2b3lu   .su2b3r
-.wa2g3n
-.wel2t1
-a1ia a1ie  a1io  a1iu a1uo a1ya 2at.
-e1iu e2w
-o1ia o1ie  o1io  o1iu
-%u1u
-%
-%1\W0a2 1\W0e2 1\W0i2 1\W0o2 1\W0u2
-'2
-1b   2bb   2bc   2bd  2bf  2bm  2bn  2bp  2bs  2bt  2bv
-     b2l   b2r   2b.  2b'. 2b''
-1c   2cb   2cc   2cd  2cf  2ck  2cm  2cn  2cq  2cs  2ct  2cz
-     2chh  c2h   2chb ch2r 2chn c2l  c2r  2c.  2c'. 2c'' .c2
-1d   2db   2dd   2dg  2dl  2dm  2dn  2dp  d2r  2ds  2dt  2dv  2dw
-     2d.   2d'.  2d'' .d2
-1f   2fb   2fg   2ff  2fn  f2l  f2r  2fs  2ft  2f.  2f'. 2f''
-1g   2gb   2gd   2gf  2gg  g2h  g2l  2gm  g2n  2gp  g2r  2gs  2gt
-     2gv   2gw   2gz  2gh2t     2g.  2g'. 2g''
-1h   2hb   2hd   2hh  hi3p2n    h2l  2hm  2hn  2hr  2hv  2h.  2h'.  2h''
-1j   2j.   2j'.  2j''
-1k   2kg   2kf   k2h  2kk  k2l  2km  k2r  2ks  2kt  2k.  2k'. 2k''
-1l   2lb   2lc   2ld  2l3f2     2lg  l2h  2lk  2ll  2lm  2ln  2lp
-     2lq   2lr   2ls  2lt  2lv  2lw  2lz  2l.  2l'. 2l''
-1m   2mb   2mc   2mf  2ml  2mm  2mn  2mp  2mq  2mr  2ms  2mt  2mv  2mw
-     2m.   2m'.  2m''
-1n   2nb   2nc   2nd  2nf  2ng  2nk  2nl  2nm  2nn  2np  2nq  2nr
-     2ns   2nt   2nv  2nz  n2g3n     2nheit.   2n.  2n'  2n''
-1p   2pd   p2h   p2l  2pn  3p2ne 2pp p2r  2ps  3p2sic 2pt  2pz  2p.  2p'. 2p''
-1q   2qq   2q.   2q'. 2q''
-1r   2rb   2rc   2rd  2rf  r2h  2rg  2rk  2rl  2rm  2rn  2rp
-     2rq   2rr   2rs  2rt  rt2s3 2rv 2rx  2rw  2rz  2r.  2r'. 2r''
-1s2  2shm  2s3s  s4s3m 2s3p2n   2stb 2stc 2std 2stf 2stg 2stm 2stn
-     2stp  2sts  2stt 2stv 2sz  4s.  4s'. 4s''
-1t   2tb   2tc   2td  2tf  2tg  t2h  t2l  2tm  2tn  2tp  t2r  2ts
-     3t2sch      2tt  2tv  2tw  t2z  2tzk 2tzs 2t.  2t'. 2t''
-1v   2vc   v2l   v2r  2vv  2v.  2v'. 2v''
-1w   w2h   wa2r  2w1y 2w.  2w'. 2w''
-1x   2xt   2xw   2x.   2x'. 2x''
-y1ou y1i
-1z   2zb   2zd   2zl  2zn  2zp  2zt  2zs  2zv  2zz  2z.  2z'. 2z''  .z2
-}}                          % Pattern end
-
-\endinput
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Information %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-
-                           LOADING THESE PATTERNS
-
-These patterns, as well  as  those  for  any  other  language, do not become
-effective until they are loaded in a special form into a format  file;  this
-task  is  performed  by  the  TeX  initializer;  any  TeX system has its own
-initializer with its special way  of  being activated.  Before loading these
-patterns, then, it is necessary to read very carefully the instructions that
-come with your TeX system.
-
-Here I describe how to load the  patterns with the freeware TeX system named
-MiKTeX version 2.x for Windows 9x, NT, 2000,  XP;  with  minor  changes  the
-whole  procedure  is applicable with other TeX systems, but the details must
-be deduced from your TeX system documentation at the section/chapter "How to
-build or to rebuild a format file".
-
-With MikTeX:
-
-a) copy this file and replace  the existing file ithyph.tex in the directory
-   \texmf\tex\generic\hyphen if the existing one has an older  version  date
-   and number.
-b) select Start|Programs|MiKTeX|MiKTeX options.
-c) in  the  Language tab add a check mark to the line concerning the Italian
-   language.
-d) in the Geneal tab click "Update format files".
-e) That's all!  
-
-For the activation of these  patterns  with the specific Italian typesetting
-features, use the babel package as this:
-
-\documentclass{article} % Or whatever other class
-\usepackage[italian]{babel}
-...
-\begin{document}
-...
-\end{document}
-
-
-                           ON ITALIAN HYPHENATION
-
-I have been working on patterns for the Italian language since 1987; in 1992
-I published
-
-C. Beccari, "Computer aided hyphenation for Italian and Modern
-      Latin", TUG vol. 13, n. 1, pp. 23-33 (1992)
-
-which contained a set of patterns that allowed hyphenation for both  Italian
-and  Latin;  a  slightly  modified  version of the patterns published in the
-above paper is contained in LAHYPH.TEX available on the CTAN archives.
-
-From  the  above  patterns  I  extracted  the  minimum  set  necessary   for
-hyphenating  Italian  that  was made available on the CTAN archives with the
-name ITHYPH.tex the version number  3.5  on  the  16th of August 1994.  
-
-The  original  pattern  set  required  37  ops;  being interested in a local
-version of TeX/LaTeX  capable  of  dealing  with  half  a dozen languages, I
-wanted to reduce memory occupation and therefore the number of ops.
-
-Th new version (4.0 released  in  1996)  of  ITHYPH.TEX is much simpler than
-version 3.5 and requires just 29 ops while  it  retains  all  the  power  of
-version  3.5;  it  contains  many  more new patterns that allow to hyphenate
-unusual words that generally have  a  root borrowed from a foreign language.
-Updated versions 4.x contain minor  additions  and  the  number  of  ops  is
-increased to 30 (version 4.7 of 1998/06/01).
-
-This new pattern set has been tested  with the same set of difficult Italian
-words that was used to test version 3.5 and it yields the  same  results  (a
-part  a  minor  change  that was deliberately introduced so as to reduce the
-typographical hyphenation  with  hyathi,  since  hyphenated  hyathi  are not
-appreciated by Italian readers).   A  new  enlarged  word  set  for  testing
-purposes  gets correct hyphen points that were missed or wrongly placed with
-version 3.5, although no error had  been reported, because such words are of
-very specialized nature and are seldom used.
-
-As the previous version, this new set  of  patterns  does  not  contain  any
-accented  character  so  that  the hyphenation algorithm behaves properly in
-both cases, that is with cm  and  with dc/ec fonts.  With LaTeXe terminology
-the difference is between OT1 and T1 encodings;  with  the  former  encoding
-fonts  do  not  contain  accented characters, while with the latter accented
-characters are present and sequences  such  as  \`a map directly to slot "E0
-that contains "agrave".
-
-Of course if you use dc/ec fonts (or any other real or virtual font with  T1
-encoding)  you get the full power of the hyphenation algorithm, while if you
-use cm fonts (or any other real or virtual font with OT1 encoding) you  miss
-some  possible  break  points;  this  is  not a big inconvenience in Italian
-because:
-
-1) The Regulation UNI 6015 on  accents  specifies  that  compulsory  accents
-   appear  only  on the ending vowel of oxitone words; this means that it is
-   almost indifferent to have or  to  miss  the dc/ec fonts because the only
-   difference consists in how TeX evaluates the end of the word; in practice
-   if you have these special facilities you get "qua-li-t\`a", while if  you
-   miss them, you get "qua-lit\`a" (assuming that \righthyphenmin > 1).
-
-2)  Optional  accents are so rare in Italian, that if you absolutely want to
-   use  them  in  those  rare  instances,  and  you  miss  the  T1  encoding
-   facilities, you should also provide  explicit discretionary hyphens as in
-   "s\'e\-gui\-to".
-
-There is no explicit  hyphenation  exception  list  because  these  patterns
-proved  to  hyphenate correctly a very large set of words suitably chosen in
-order to test them in the most heavy circumstances; these patterns were used
-in the preparation of a number of books and no errors were discovered.
-
-Nevertheless if you frequently use  technical terms that you want hyphenated
-differently  from  what  is  normally  done  (for  example  if  you   prefer
-etymological  hyphenation  of  prefixed  and/or  suffixed  words) you should
-insert a specific hyphenation  list  in  the  preamble of your document, for
-example:
-
-\hyphenation{su-per-in-dut-to-re su-per-in-dut-to-ri}
-
-Should you find any word that gets hyphenated in a wrong way, please, AFTER
-CHECKING ON A RELIABLE MODERN DICTIONARY, report to the author, preferably
-by e-mail.
-
-
-                       Happy multilingual typesetting !
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/patch-0.1.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/patch-0.1.tm
deleted file mode 100644
index cf68959d..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/patch-0.1.tm
+++ /dev/null
@@ -1,180 +0,0 @@
-# patch.tcl --
-#
-#	Application of a diff -ruN patch to a directory tree.
-#
-# Copyright (c) 2019 Christian Gollwitzer <auriocus@gmx.de>
-# with tweaks by Andreas Kupries
-# - Factored patch parsing into a helper
-# - Replaced `puts` with report callback.
-
-package require Tcl 8.5
-package provide textutil::patch 0.1
-
-# # ## ### ##### ######## ############# #####################
-
-namespace eval ::textutil::patch {
-    namespace export apply
-    namespace ensemble create
-}
-
-# # ## ### ##### ######## ############# #####################
-
-proc ::textutil::patch::apply {dir striplevel patch reportcmd} {
-    set patchdict [Parse $dir $striplevel $patch]
-
-    # Apply, now that we have parsed the patch.
-    dict for {fn hunks} $patchdict {
-	Report apply $fn
-	if {[catch {open $fn} fd]} {
-	    set orig {}
-	} else {
-	    set orig [split [read $fd] \n]
-	}
-	close $fd
-
-	set patched $orig
-
-	set fail false
-	set already_applied false
-	set hunknr 1
-	foreach hunk $hunks {
-	    dict with hunk {
-		set oldend [expr {$oldstart+[llength $oldcode]-1}]
-		set newend [expr {$newstart+[llength $newcode]-1}]
-		# check if the hunk matches
-		set origcode [lrange $orig $oldstart $oldend]
-		if {$origcode ne $oldcode} {
-		    set fail true
-		    # check if the patch is already applied
-		    set origcode_applied [lrange $orig $newstart $newend]
-		    if {$origcode_applied eq $newcode} {
-			set already_applied true
-			Report fail-already $fn $hunknr
-		    } else {
-			Report fail $fn $hunknr $oldcode $origcode
-		    }
-		    break
-		}
-		# apply patch
-		set patched [list \
-				 {*}[lrange $patched 0 $newstart-1] \
-				 {*}$newcode \
-				 {*}[lrange $orig $oldend+1 end]]
-	    }
-	    incr hunknr
-	}
-
-	if {!$fail} {
-	    # success - write the result back
-	    set fd [open $fn w]
-	    puts -nonewline $fd [join $patched \n]
-	    close $fd
-	}
-    }
-
-    return
-}
-
-# # ## ### ##### ######## ############# #####################
-
-proc ::textutil::patch::Report args {
-    upvar 1 reportcmd reportcmd
-    uplevel #0 [list {*}$reportcmd {*}$args]
-    ##
-    # apply        $fname
-    # fail-already $fname $hunkno
-    # fail         $fname $hunkno $expected $seen
-    ##
-}
-
-proc ::textutil::patch::Parse {dir striplevel patch} {
-    set patchlines [split $patch \n]
-    set inhunk false
-    set oldcode {}
-    set newcode {}
-    set n [llength $patchlines]
-
-    set patchdict {}
-    for {set lineidx 0} {$lineidx < $n} {incr lineidx} {
-	set line [lindex $patchlines $lineidx]
-	if {[string match ---* $line]} {
-	    # a diff block starts. Current line should be
-	    # --- oldfile date time TZ
-	    # Next line should be
-	    # +++ newfile date time TZ
-	    set in $line
-	    incr lineidx
-	    set out [lindex $patchlines $lineidx]
-
-	    if {![string match ---* $in] || ![string match +++* $out]} {
-		#puts $in
-		#puts $out
-		return -code error "Patch not in unified diff format, line $lineidx $in $out"
-	    }
-
-	    # the quoting is compatible with list
-	    lassign $in  -> oldfile
-	    lassign $out -> newfile
-
-	    set fntopatch [file join $dir {*}[lrange [file split $oldfile] $striplevel end]]
-	    set inhunk false
-	    #puts "Found diffline for $fntopatch"
-	    continue
-	}
-
-	# state machine for parsing the hunks
-	set typechar [string index $line 0]
-	set codeline [string range $line 1 end]
-	switch $typechar {
-	    @ {
-		if {![regexp {@@\s+\-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@} $line \
-			  -> oldstart oldlen newstart newlen]} {
-		    return code -error "Erroneous hunk in line $lindeidx, $line"
-		}
-		# adjust line numbers for 0-based indexing
-		incr oldstart -1
-		incr newstart -1
-		#puts "New hunk"
-		set newcode {}
-		set oldcode {}
-		set inhunk true
-	    }
-	    - { # line only in old code
-		if {$inhunk} {
-		    lappend oldcode $codeline
-		}
-	    }
-	    + { # line only in new code
-		if {$inhunk} {
-		    lappend newcode $codeline
-		}
-	    }
-	    " " { # common line
-		if {$inhunk} {
-		    lappend oldcode $codeline
-		    lappend newcode $codeline
-		}
-	    }
-	    default {
-		# puts "Junk: $codeline";
-		continue
-	    }
-	}
-	# test if the hunk is complete
-	if {[llength $oldcode]==$oldlen && [llength $newcode]==$newlen} {
-	    set hunk [dict create \
-			  oldcode $oldcode \
-			  newcode $newcode \
-			  oldstart $oldstart \
-			  newstart $newstart]
-	    #puts "hunk complete: $hunk"
-	    set inhunk false
-	    dict lappend patchdict $fntopatch $hunk
-	}
-    }
-
-    return $patchdict
-}
-
-# # ## ### ##### ######## ############# #####################
-return
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/repeat-0.7.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/repeat-0.7.tm
deleted file mode 100644
index 24f8693c..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/repeat-0.7.tm
+++ /dev/null
@@ -1,91 +0,0 @@
-# repeat.tcl --
-#
-#	Emulation of string repeat for older
-#	revisions of Tcl.
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: repeat.tcl,v 1.1 2006/04/21 04:42:28 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil::repeat {}
-
-# ### ### ### ######### ######### #########
-
-namespace eval ::textutil::repeat {
-    variable HaveBuiltin [expr {![catch {string repeat a 1}]}]
-}
-
-if {0} {
-    # Problems with the deactivated code:
-    # - Linear in 'num'.
-    # - Tests for 'string repeat' in every call!
-    #   (Ok, just the variable, still a test every call)
-    # - Fails for 'num == 0' because of undefined 'str'.
-
-    proc textutil::repeat::StrRepeat { char num } {
-	variable HaveBuiltin
-	if { $HaveBuiltin == 0 } then {
-	    for { set i 0 } { $i < $num } { incr i } {
-		append str $char
-	    }
-	} else {
-	    set str [ string repeat $char $num ]
-	}
-	return $str
-    }
-}
-
-if {$::textutil::repeat::HaveBuiltin} {
-    proc ::textutil::repeat::strRepeat {char num} {
-	return [string repeat $char $num]
-    }
-
-    proc ::textutil::repeat::blank {n} {
-	return [string repeat " " $n]
-    }
-} else {
-    proc ::textutil::repeat::strRepeat {char num} {
-	if {$num <= 0} {
-	    # No replication required
-	    return ""
-	} elseif {$num == 1} {
-	    # Quick exit for recursion
-	    return $char
-	} elseif {$num == 2} {
-	    # Another quick exit for recursion
-	    return $char$char
-	} elseif {0 == ($num % 2)} {
-	    # Halving the problem results in O (log n) complexity.
-	    set result [strRepeat $char [expr {$num / 2}]]
-	    return "$result$result"
-	} else {
-	    # Uneven length, reduce problem by one
-	    return "$char[strRepeat $char [incr num -1]]"
-	}
-    }
-
-    proc ::textutil::repeat::blank {n} {
-	return [strRepeat " " $n]
-    }
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::repeat {
-    namespace export strRepeat blank
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::repeat 0.7
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/split-0.8.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/split-0.8.tm
deleted file mode 100644
index 18ee13b5..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/split-0.8.tm
+++ /dev/null
@@ -1,176 +0,0 @@
-# split.tcl --
-#
-#	Various ways of splitting a string.
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2001      by Reinhard Max <max@suse.de>
-# Copyright (c) 2003      by Pat Thoyts <patthoyts@users.sourceforge.net>
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-# 
-# RCS: @(#) $Id: split.tcl,v 1.7 2006/04/21 04:42:28 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil::split {}
-
-########################################################################
-# This one was written by Bob Techentin (RWT in Tcl'ers Wiki):
-# http://www.techentin.net
-# mailto:techentin.robert@mayo.edu
-#
-# Later, he send me an email stated that I can use it anywhere, because
-# no copyright was added, so the code is defacto in the public domain.
-#
-# You can found it in the Tcl'ers Wiki here:
-# http://mini.net/cgi-bin/wikit/460.html
-#
-# Bob wrote:
-# If you need to split string into list using some more complicated rule
-# than builtin split command allows, use following function. It mimics
-# Perl split operator which allows regexp as element separator, but,
-# like builtin split, it expects string to split as first arg and regexp
-# as second (optional) By default, it splits by any amount of whitespace. 
-# Note that if you add parenthesis into regexp, parenthesed part of separator
-# would be added into list as additional element. Just like in Perl. -- cary 
-#
-# Speed improvement by Reinhard Max:
-# Instead of repeatedly copying around the not yet matched part of the
-# string, I use [regexp]'s -start option to restrict the match to that
-# part. This reduces the complexity from something like O(n^1.5) to
-# O(n). My test case for that was:
-# 
-# foreach i {1 10 100 1000 10000} {
-#     set s [string repeat x $i]
-#     puts [time {splitx $s .}]
-# }
-#
-
-if {[package vsatisfies [package provide Tcl] 8.3]} {
-
-    proc ::textutil::split::splitx {str {regexp {[\t \r\n]+}}} {
-        # Bugfix 476988
-        if {[string length $str] == 0} {
-            return {}
-        }
-        if {[string length $regexp] == 0} {
-            return [::split $str ""]
-        }
-	if {[regexp $regexp {}]} {
-	    return -code error \
-		"splitting on regexp \"$regexp\" would cause infinite loop"
-	}
-
-        set list  {}
-        set start 0
-        while {[regexp -start $start -indices -- $regexp $str match submatch]} {
-            foreach {subStart subEnd} $submatch break
-            foreach {matchStart matchEnd} $match break
-            incr matchStart -1
-            incr matchEnd
-            lappend list [string range $str $start $matchStart]
-            if {$subStart >= $start} {
-                lappend list [string range $str $subStart $subEnd]
-            }
-            set start $matchEnd
-        }
-        lappend list [string range $str $start end]
-        return $list
-    }
-
-} else {    
-    # For tcl <= 8.2 we do not have regexp -start...
-    proc ::textutil::split::splitx [list str [list regexp "\[\t \r\n\]+"]] {
-
-        if {[string length $str] == 0} {
-            return {}
-        }
-        if {[string length $regexp] == 0} {
-            return [::split $str {}]
-        }
-	if {[regexp $regexp {}]} {
-	    return -code error \
-		"splitting on regexp \"$regexp\" would cause infinite loop"
-	}
-
-        set list  {}
-        while {[regexp -indices -- $regexp $str match submatch]} {
-            lappend list [string range $str 0 [expr {[lindex $match 0] -1}]]
-            if {[lindex $submatch 0] >= 0} {
-                lappend list [string range $str [lindex $submatch 0] \
-                                  [lindex $submatch 1]]
-            }
-            set str [string range $str [expr {[lindex $match 1]+1}] end]
-        }
-        lappend list $str
-        return $list
-    }
-    
-}
-
-#
-# splitn --
-#
-# splitn splits the string $str into chunks of length $len.  These
-# chunks are returned as a list.
-#
-# If $str really contains a ByteArray object (as retrieved from binary
-# encoded channels) splitn must honor this by splitting the string
-# into chunks of $len bytes.
-#
-# It is an error to call splitn with a nonpositive $len.
-#
-# If splitn is called with an empty string, it returns the empty list.
-#
-# If the length of $str is not an entire multiple of the chunk length,
-# the last chunk in the generated list will be shorter than $len.
-#
-# The implementation presented here was given by Bryan Oakley, as
-# part of a ``contest'' I staged on c.l.t in July 2004.  I selected
-# this version, as it does not rely on runtime generated code, is
-# very fast for chunk size one, not too bad in all the other cases,
-# and uses [split] or [string range] which have been around for quite
-# some time.
-#
-# -- Robert Suetterlin (robert@mpe.mpg.de)
-#
-proc ::textutil::split::splitn {str {len 1}} {
-
-    if {$len <= 0} {
-        return -code error "len must be > 0"
-    }
-
-    if {$len == 1} {
-        return [split $str {}]
-    }
-
-    set result [list]
-    set max [string length $str]
-    set i 0
-    set j [expr {$len -1}]
-    while {$i < $max} {
-        lappend result [string range $str $i $j]
-        incr i $len
-        incr j $len
-    }
-
-    return $result
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::split {
-    namespace export splitx splitn
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::split 0.8
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/string-0.8.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/string-0.8.tm
deleted file mode 100644
index f1ad5a46..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/string-0.8.tm
+++ /dev/null
@@ -1,144 +0,0 @@
-# string.tcl --
-#
-#	Utilities for manipulating strings, words, single lines,
-#	paragraphs, ...
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2002      by Joe English <jenglish@users.sourceforge.net>
-# Copyright (c) 2001-2014 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-# 
-# RCS: @(#) $Id: string.tcl,v 1.2 2008/03/22 16:03:11 mic42 Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil::string {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-
-# @c Removes the last character from the given <a string>.
-#
-# @a string: The string to manipulate.
-#
-# @r The <a string> without its last character.
-#
-# @i chopping
-
-proc ::textutil::string::chop {string} {
-    return [string range $string 0 [expr {[string length $string]-2}]]
-}
-
-# @c Removes the first character from the given <a string>.
-# @c Convenience procedure.
-#
-# @a string: string to manipulate.
-#
-# @r The <a string> without its first character.
-#
-# @i tail
-
-proc ::textutil::string::tail {string} {
-    return [string range $string 1 end]
-}
-
-# @c Capitalizes first character of the given <a string>.
-# @c Complementary procedure to <p ::textutil::uncap>.
-#
-# @a string: string to manipulate.
-#
-# @r The <a string> with its first character capitalized.
-#
-# @i capitalize
-
-proc ::textutil::string::cap {string} {
-    return [string toupper [string index $string 0]][string range $string 1 end]
-}
-
-# @c unCapitalizes first character of the given <a string>.
-# @c Complementary procedure to <p ::textutil::cap>.
-#
-# @a string: string to manipulate.
-#
-# @r The <a string> with its first character uncapitalized.
-#
-# @i uncapitalize
-
-proc ::textutil::string::uncap {string} {
-    return [string tolower [string index $string 0]][string range $string 1 end]
-}
-
-# @c Capitalizes first character of each word of the given <a sentence>.
-#
-# @a sentence: string to manipulate.
-#
-# @r The <a sentence> with the first character of each word capitalized.
-#
-# @i capitalize
-
-proc ::textutil::string::capEachWord {sentence} {
-    regsub -all {\S+} [string map {\\ \\\\ \$ \\$} $sentence] {[string toupper [string index & 0]][string range & 1 end]} cmd
-    return [subst -nobackslashes -novariables $cmd]
-}
-
-# Compute the longest string which is common to all strings given to
-# the command, and at the beginning of said strings, i.e. a prefix. If
-# only one argument is specified it is treated as a list of the
-# strings to look at. If more than one argument is specified these
-# arguments are the strings to be looked at. If only one string is
-# given, in either form, the string is returned, as it is its own
-# longest common prefix.
-
-proc ::textutil::string::longestCommonPrefix {args} {
-    return [longestCommonPrefixList $args]
-}
-
-proc ::textutil::string::longestCommonPrefixList {list} {
-    if {[llength $list] <= 1} {
-	return [lindex $list 0]
-    }
-
-    set list [lsort $list]
-    set min [lindex $list 0]
-    set max [lindex $list end]
-
-    # Min and max are the two strings which are most different. If
-    # they have a common prefix, it will also be the common prefix for
-    # all of them.
-
-    # Fast bailouts for common cases.
-
-    set n [string length $min]
-    if {$n == 0} {return ""}
-    if {0 == [string compare $min $max]} {return $min}
-
-    set prefix ""
-    set i 0
-    while {[string index $min $i] == [string index $max $i]} {
-	append prefix [string index $min $i]
-	if {[incr i] > $n} {break}
-    }
-    set prefix
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::string {
-    # Export the imported commands
-
-    namespace export chop tail cap uncap capEachWord
-    namespace export longestCommonPrefix
-    namespace export longestCommonPrefixList
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::string 0.8
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/tabify-0.7.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/tabify-0.7.tm
deleted file mode 100644
index 543b96cc..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/tabify-0.7.tm
+++ /dev/null
@@ -1,289 +0,0 @@
-#
-# As the author of the procs 'tabify2' and 'untabify2' I suggest that the
-# comments explaining their behaviour be kept in this file.
-# 1) Beginners in any programming language (I am new to Tcl so I know what I
-#    am talking about) can profit enormously from studying 'correct' code.
-#    Of course comments will help a lot in this regard.
-# 2) Many problems newbies face can be solved by directing them towards
-#    available libraries - after all, libraries have been written to solve
-#    recurring problems. Then they can just use them, or have a closer look
-#    to see and to discover how things are done the 'Tcl way'.
-# 3) And if ever a proc from a library should be less than perfect, having
-#    comments explaining the behaviour of the code will surely help.
-#
-# This said, I will welcome any error reports or suggestions for improvements
-# (especially on the 'doing things the Tcl way' aspect).
-#
-# Use of these sources is licensed under the same conditions as is Tcl.
-#
-# June 2001, Helmut Giese (hgiese@ratiosoft.com)
-#
-# ----------------------------------------------------------------------------
-#
-# The original procs 'tabify' and 'untabify' each work with complete blocks
-# of $num spaces ('num' holding the tab size). While this is certainly useful
-# in some circumstances, it does not reflect the way an editor works:
-# 	Counting columns from 1, assuming a tab size of 8 and entering '12345'
-#   followed by a tab, you expect to advance to column 9. Your editor might
-#   put a tab into the file or 3 spaces, depending on its configuration.
-#	Now, on 'tabifying' you will expect to see those 3 spaces converted to a
-#	tab (and on the other hand expect the tab *at this position* to be
-#	converted to 3 spaces).
-#
-#	This behaviour is mimicked by the new procs 'tabify2' and 'untabify2'.
-#   Both have one feature in common: They accept multi-line strings (a whole
-#   file if you want to) but in order to make life simpler for the programmer,
-#   they split the incoming string into individual lines and hand each line to
-#   a proc that does the real work.
-#
-#   One design decision worth mentioning here:
-#      A single space is never converted to a tab even if its position would
-#      allow to do so.
-#   Single spaces occur very often, say in arithmetic expressions like
-#   [expr (($a + $b) * $c) < $d]. If we didn't follow the above rule we might
-#   need to replace one or more of them to tabs. However if the tab size gets
-#   changed, this expression would be formatted quite differently - which is
-#   probably not a good idea.
-#
-#   'untabifying' on the other hand might need to replace a tab with a single
-#   space: If the current position requires it, what else to do?
-#   As a consequence those two procs are unsymmetric in this aspect, but I
-#   couldn't think of a better solution. Could you?
-#
-# ----------------------------------------------------------------------------
-#
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-package require textutil::repeat
-
-namespace eval ::textutil::tabify {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-
-namespace eval ::textutil::tabify {
-    namespace import -force ::textutil::repeat::strRepeat
-}
-
-proc ::textutil::tabify::tabify { string { num 8 } } {
-    return [string map [list [MakeTabStr $num] \t] $string]
-}
-
-proc ::textutil::tabify::untabify { string { num 8 } } {
-    return [string map [list \t [MakeTabStr $num]] $string]
-}
-
-proc ::textutil::tabify::MakeTabStr { num } {
-    variable TabStr
-    variable TabLen
-
-    if { $TabLen != $num } then {
-	set TabLen $num
-	set TabStr [strRepeat " " $num]
-    }
-
-    return $TabStr
-}
-
-# ----------------------------------------------------------------------------
-#
-# tabifyLine: Works on a single line of text, replacing 'spaces at correct
-# 		positions' with tabs. $num is the requested tab size.
-#		Returns the (possibly modified) line.
-#
-# 'spaces at correct positions': Only spaces which 'fill the space' between
-# an arbitrary position and the next tab stop can be replaced. 
-# Example: With tab size 8, spaces at positions 11 - 13 will *not* be replaced,
-#          because an expansion of a tab at position 11 will jump up to 16.
-# See also the comment at the beginning of this file why single spaces are
-# *never* replaced by a tab.
-#
-# The proc works backwards, from the end of the string up to the beginning:
-#	- Set the position to start the search from ('lastPos') to 'end'.
-#	- Find the last occurrence of ' ' in 'line' with respect to 'lastPos'
-#         ('currPos' below). This is a candidate for replacement.
-#       - Find to 'currPos' the following tab stop using the expression
-#           set nextTab [expr ($currPos + $num) - ($currPos % $num)]
-#         and get the previous tab stop as well (this will be the starting 
-#         point for the next iteration).
-#	- The ' ' at 'currPos' is only a candidate for replacement if
-#	  1) it is just one position before a tab stop *and*
-#	  2) there is at least one space at its left (see comment above on not
-#	     touching an isolated space).
-#	  Continue, if any of these conditions is not met.
-#	- Determine where to put the tab (that is: how many spaces to replace?)
-#	  by stepping up to the beginning until
-#		-- you hit a non-space or
-#		-- you are at the previous tab position
-#	- Do the replacement and continue.
-#
-# This algorithm only works, if $line does not contain tabs. Otherwise our 
-# interpretation of any position beyond the tab will be wrong. (Imagine you 
-# find a ' ' at position 4 in $line. If you got 3 leading tabs, your *real*
-# position might be 25 (tab size of 8). Since in real life some strings might 
-# already contain tabs, we test for it (and eventually call untabifyLine).
-#
-
-proc ::textutil::tabify::tabifyLine { line num } {
-    if { [string first \t $line] != -1 } { 		
-	# assure array 'Spaces' is set up 'comme il faut'
-	checkArr $num
-	# remove existing tabs
-	set line [untabifyLine $line $num]
-    }
-
-    set lastPos end
-
-    while { $lastPos > 0 } {
-	set currPos [string last " " $line $lastPos]
-	if { $currPos == -1 } {
-	    # no more spaces
-	    break;
-	}
-
-	set nextTab [expr {($currPos + $num) - ($currPos % $num)}]
-	set prevTab [expr {$nextTab - $num}]
-
-	# prepare for next round: continue at 'previous tab stop - 1'
-	set lastPos [expr {$prevTab - 1}]
-
-	if { ($currPos + 1) != $nextTab } {
-	    continue			;# crit. (1)
-	}
-
-	if { [string index $line [expr {$currPos - 1}]] != " " } {
-	    continue			;# crit. (2)
-	}
-
-	# now step backwards while there are spaces
-	for {set pos [expr {$currPos - 2}]} {$pos >= $prevTab} {incr pos -1} {
-	    if { [string index $line $pos] != " " } {
-		break;
-	    }
-	}
-
-	# ... and replace them
-	set line [string replace $line [expr {$pos + 1}] $currPos \t]
-    }
-    return $line
-}
-
-#
-# Helper proc for 'untabifyLine': Checks if all needed elements of array
-# 'Spaces' exist and creates the missing ones if needed.
-#
-
-proc ::textutil::tabify::checkArr { num } {
-    variable TabLen2
-    variable Spaces
-
-    if { $num > $TabLen2 } {
-	for { set i [expr {$TabLen2 + 1}] } { $i <= $num } { incr i } {
-	    set Spaces($i) [strRepeat " " $i]
-	}
-	set TabLen2 $num
-    }
-}
-
-
-# untabifyLine: Works on a single line of text, replacing tabs with enough
-#		spaces to get to the next tab position.
-#		Returns the (possibly modified) line.
-#
-# The procedure is straight forward:
-#	- Find the next tab.
-#	- Calculate the next tab position following it.
-#	- Delete the tab and insert as many spaces as needed to get there.
-#
-
-proc ::textutil::tabify::untabifyLine { line num } {
-    variable Spaces
-
-    set currPos 0
-    while { 1 } {
-	set currPos [string first \t $line $currPos]
-	if { $currPos == -1 } {
-	    # no more tabs
-	    break
-	}
-
-	# how far is the next tab position ?
-	set dist [expr {$num - ($currPos % $num)}]
-	# replace '\t' at $currPos with $dist spaces
-	set line [string replace $line $currPos $currPos $Spaces($dist)]
-
-	# set up for next round (not absolutely necessary but maybe a trifle
-	# more efficient)
-	incr currPos $dist
-    }
-    return $line
-}
-
-# tabify2: Replace all 'appropriate' spaces as discussed above with tabs.
-#	'string' might hold any number of lines, 'num' is the requested tab size.
-#	Returns (possibly modified) 'string'.
-#
-proc ::textutil::tabify::tabify2 { string { num 8 } } {
-
-    # split string into individual lines
-    set inLst [split $string \n]
-
-    # now work on each line
-    set outLst [list]
-    foreach line $inLst {
-	lappend outLst [tabifyLine $line $num]
-    }
-
-    # return all as one string
-    return [join $outLst \n]
-}
-
-
-# untabify2: Replace all tabs with the appropriate number of spaces.
-#	'string' might hold any number of lines, 'num' is the requested tab size.
-#	Returns (possibly modified) 'string'.
-#
-proc ::textutil::tabify::untabify2 { string { num 8 } } {
-
-    # assure array 'Spaces' is set up 'comme il faut'
-    checkArr $num
-
-    set inLst [split $string \n]
-
-    set outLst [list]
-    foreach line $inLst {
-	lappend outLst [untabifyLine $line $num]
-    }
-
-    return [join $outLst \n]
-}
-
-
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::tabify {
-    variable TabLen  8
-    variable TabStr  [strRepeat " " $TabLen]
-
-    namespace export tabify untabify tabify2 untabify2
-    
-    # The proc 'untabify2' uses the following variables for efficiency.
-    # Since a tab can be replaced by one up to 'tab size' spaces, it is handy
-    # to have the appropriate 'space strings' available. This is the use of
-    # the array 'Spaces', where 'Spaces(n)' contains just 'n' spaces.
-    # The variable 'TabLen2' remembers the biggest tab size used.
-
-    variable  TabLen2 0
-    variable  Spaces
-    array set Spaces {0 ""}
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::tabify 0.7
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/trim-0.7.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/trim-0.7.tm
deleted file mode 100644
index 4aab0765..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/trim-0.7.tm
+++ /dev/null
@@ -1,112 +0,0 @@
-# trim.tcl --
-#
-#	Various ways of trimming a string.
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-# 
-# RCS: @(#) $Id: trim.tcl,v 1.5 2006/04/21 04:42:28 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil::trim {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-
-proc ::textutil::trim::trimleft {text {trim "[ \t]+"}} {
-    regsub -line -all -- [MakeStr $trim left] $text {} text
-    return $text
-}
-
-proc ::textutil::trim::trimright {text {trim "[ \t]+"}} {
-    regsub -line -all -- [MakeStr $trim right] $text {} text
-    return $text
-}
-
-proc ::textutil::trim::trim {text {trim "[ \t]+"}} {
-    regsub -line -all -- [MakeStr $trim left]  $text {} text
-    regsub -line -all -- [MakeStr $trim right] $text {} text
-    return $text
-}
-
-
-
-# @c Strips <a prefix> from <a text>, if found at its start.
-#
-# @a text: The string to check for <a prefix>.
-# @a prefix: The string to remove from <a text>.
-#
-# @r The <a text>, but without <a prefix>.
-#
-# @i remove, prefix
-
-proc ::textutil::trim::trimPrefix {text prefix} {
-    if {[string first $prefix $text] == 0} {
-	return [string range $text [string length $prefix] end]
-    } else {
-	return $text
-    }
-}
-
-
-# @c Removes the Heading Empty Lines of <a text>.
-#
-# @a text: The text block to manipulate.
-#
-# @r The <a text>, but without heading empty lines.
-#
-# @i remove, empty lines
-
-proc ::textutil::trim::trimEmptyHeading {text} {
-    regsub -- "^(\[ \t\]*\n)*" $text {} text
-    return $text
-}
-
-# ### ### ### ######### ######### #########
-## Helper commands. Internal
-
-proc ::textutil::trim::MakeStr { string pos }  {
-    variable StrU
-    variable StrR
-    variable StrL
-
-    if { "$string" != "$StrU" } {
-        set StrU $string
-        set StrR "(${StrU})\$"
-        set StrL "^(${StrU})"
-    }
-    if { "$pos" == "left" } {
-        return $StrL
-    }
-    if { "$pos" == "right" } {
-        return $StrR
-    }
-
-    return -code error "Panic, illegal position key \"$pos\""
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::trim {	    
-    variable StrU "\[ \t\]+"
-    variable StrR "(${StrU})\$"
-    variable StrL "^(${StrU})"
-
-    namespace export \
-	    trim trimright trimleft \
-	    trimPrefix trimEmptyHeading
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::trim 0.7
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/wcswidth-35.1.tm b/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/wcswidth-35.1.tm
deleted file mode 100644
index 080a8814..00000000
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/textutil/wcswidth-35.1.tm
+++ /dev/null
@@ -1,772 +0,0 @@
-###
-# This file is automatically generated by the build/build.tcl file
-# based on information in the following database:
-# http://www.unicode.org/Public/UCD/latest/ucd/EastAsianWidth.txt
-#
-# (This is the 35th edition, thus version 35 for our package)
-#
-# Author: Sean Woods <yoda@etoyoc.com>
-###
-package provide textutil::wcswidth 35.1
-proc ::textutil::wcswidth_type char {
-  if {$char == 161} { return A }
-  if {$char == 164} { return A }
-  if {$char == 167} { return A }
-  if {$char == 168} { return A }
-  if {$char == 170} { return A }
-  if {$char == 173} { return A }
-  if {$char == 174} { return A }
-  if {$char == 176} { return A }
-  if {$char == 177} { return A }
-  if {$char >= 178 && $char <= 179 } { return A }
-  if {$char == 180} { return A }
-  if {$char >= 182 && $char <= 183 } { return A }
-  if {$char == 184} { return A }
-  if {$char == 185} { return A }
-  if {$char == 186} { return A }
-  if {$char >= 188 && $char <= 190 } { return A }
-  if {$char == 191} { return A }
-  if {$char == 198} { return A }
-  if {$char == 208} { return A }
-  if {$char == 215} { return A }
-  if {$char == 216} { return A }
-  if {$char >= 222 && $char <= 225 } { return A }
-  if {$char == 230} { return A }
-  if {$char >= 232 && $char <= 234 } { return A }
-  if {$char >= 236 && $char <= 237 } { return A }
-  if {$char == 240} { return A }
-  if {$char >= 242 && $char <= 243 } { return A }
-  if {$char == 247} { return A }
-  if {$char >= 248 && $char <= 250 } { return A }
-  if {$char == 252} { return A }
-  if {$char == 254} { return A }
-  if {$char == 257} { return A }
-  if {$char == 273} { return A }
-  if {$char == 275} { return A }
-  if {$char == 283} { return A }
-  if {$char >= 294 && $char <= 295 } { return A }
-  if {$char == 299} { return A }
-  if {$char >= 305 && $char <= 307 } { return A }
-  if {$char == 312} { return A }
-  if {$char >= 319 && $char <= 322 } { return A }
-  if {$char == 324} { return A }
-  if {$char >= 328 && $char <= 331 } { return A }
-  if {$char == 333} { return A }
-  if {$char >= 338 && $char <= 339 } { return A }
-  if {$char >= 358 && $char <= 359 } { return A }
-  if {$char == 363} { return A }
-  if {$char == 462} { return A }
-  if {$char == 464} { return A }
-  if {$char == 466} { return A }
-  if {$char == 468} { return A }
-  if {$char == 470} { return A }
-  if {$char == 472} { return A }
-  if {$char == 474} { return A }
-  if {$char == 476} { return A }
-  if {$char == 593} { return A }
-  if {$char == 609} { return A }
-  if {$char == 708} { return A }
-  if {$char == 711} { return A }
-  if {$char >= 713 && $char <= 715 } { return A }
-  if {$char == 717} { return A }
-  if {$char == 720} { return A }
-  if {$char >= 728 && $char <= 731 } { return A }
-  if {$char == 733} { return A }
-  if {$char == 735} { return A }
-  if {$char >= 768 && $char <= 879 } { return A }
-  if {$char >= 913 && $char <= 929 } { return A }
-  if {$char >= 931 && $char <= 937 } { return A }
-  if {$char >= 945 && $char <= 961 } { return A }
-  if {$char >= 963 && $char <= 969 } { return A }
-  if {$char == 1025} { return A }
-  if {$char >= 1040 && $char <= 1103 } { return A }
-  if {$char == 1105} { return A }
-  if {$char >= 4352 && $char <= 4447 } { return W }
-  if {$char == 8208} { return A }
-  if {$char >= 8211 && $char <= 8213 } { return A }
-  if {$char == 8214} { return A }
-  if {$char == 8216} { return A }
-  if {$char == 8217} { return A }
-  if {$char == 8220} { return A }
-  if {$char == 8221} { return A }
-  if {$char >= 8224 && $char <= 8226 } { return A }
-  if {$char >= 8228 && $char <= 8231 } { return A }
-  if {$char == 8240} { return A }
-  if {$char >= 8242 && $char <= 8243 } { return A }
-  if {$char == 8245} { return A }
-  if {$char == 8251} { return A }
-  if {$char == 8254} { return A }
-  if {$char == 8308} { return A }
-  if {$char == 8319} { return A }
-  if {$char >= 8321 && $char <= 8324 } { return A }
-  if {$char == 8361} { return H }
-  if {$char == 8364} { return A }
-  if {$char == 8451} { return A }
-  if {$char == 8453} { return A }
-  if {$char == 8457} { return A }
-  if {$char == 8467} { return A }
-  if {$char == 8470} { return A }
-  if {$char >= 8481 && $char <= 8482 } { return A }
-  if {$char == 8486} { return A }
-  if {$char == 8491} { return A }
-  if {$char >= 8531 && $char <= 8532 } { return A }
-  if {$char >= 8539 && $char <= 8542 } { return A }
-  if {$char >= 8544 && $char <= 8555 } { return A }
-  if {$char >= 8560 && $char <= 8569 } { return A }
-  if {$char == 8585} { return A }
-  if {$char >= 8592 && $char <= 8596 } { return A }
-  if {$char >= 8597 && $char <= 8601 } { return A }
-  if {$char >= 8632 && $char <= 8633 } { return A }
-  if {$char == 8658} { return A }
-  if {$char == 8660} { return A }
-  if {$char == 8679} { return A }
-  if {$char == 8704} { return A }
-  if {$char >= 8706 && $char <= 8707 } { return A }
-  if {$char >= 8711 && $char <= 8712 } { return A }
-  if {$char == 8715} { return A }
-  if {$char == 8719} { return A }
-  if {$char == 8721} { return A }
-  if {$char == 8725} { return A }
-  if {$char == 8730} { return A }
-  if {$char >= 8733 && $char <= 8736 } { return A }
-  if {$char == 8739} { return A }
-  if {$char == 8741} { return A }
-  if {$char >= 8743 && $char <= 8748 } { return A }
-  if {$char == 8750} { return A }
-  if {$char >= 8756 && $char <= 8759 } { return A }
-  if {$char >= 8764 && $char <= 8765 } { return A }
-  if {$char == 8776} { return A }
-  if {$char == 8780} { return A }
-  if {$char == 8786} { return A }
-  if {$char >= 8800 && $char <= 8801 } { return A }
-  if {$char >= 8804 && $char <= 8807 } { return A }
-  if {$char >= 8810 && $char <= 8811 } { return A }
-  if {$char >= 8814 && $char <= 8815 } { return A }
-  if {$char >= 8834 && $char <= 8835 } { return A }
-  if {$char >= 8838 && $char <= 8839 } { return A }
-  if {$char == 8853} { return A }
-  if {$char == 8857} { return A }
-  if {$char == 8869} { return A }
-  if {$char == 8895} { return A }
-  if {$char == 8978} { return A }
-  if {$char >= 8986 && $char <= 8987 } { return W }
-  if {$char == 9001} { return W }
-  if {$char == 9002} { return W }
-  if {$char >= 9193 && $char <= 9196 } { return W }
-  if {$char == 9200} { return W }
-  if {$char == 9203} { return W }
-  if {$char >= 9312 && $char <= 9371 } { return A }
-  if {$char >= 9372 && $char <= 9449 } { return A }
-  if {$char >= 9451 && $char <= 9471 } { return A }
-  if {$char >= 9472 && $char <= 9547 } { return A }
-  if {$char >= 9552 && $char <= 9587 } { return A }
-  if {$char >= 9600 && $char <= 9615 } { return A }
-  if {$char >= 9618 && $char <= 9621 } { return A }
-  if {$char >= 9632 && $char <= 9633 } { return A }
-  if {$char >= 9635 && $char <= 9641 } { return A }
-  if {$char >= 9650 && $char <= 9651 } { return A }
-  if {$char == 9654} { return A }
-  if {$char == 9655} { return A }
-  if {$char >= 9660 && $char <= 9661 } { return A }
-  if {$char == 9664} { return A }
-  if {$char == 9665} { return A }
-  if {$char >= 9670 && $char <= 9672 } { return A }
-  if {$char == 9675} { return A }
-  if {$char >= 9678 && $char <= 9681 } { return A }
-  if {$char >= 9698 && $char <= 9701 } { return A }
-  if {$char == 9711} { return A }
-  if {$char >= 9725 && $char <= 9726 } { return W }
-  if {$char >= 9733 && $char <= 9734 } { return A }
-  if {$char == 9737} { return A }
-  if {$char >= 9742 && $char <= 9743 } { return A }
-  if {$char >= 9748 && $char <= 9749 } { return W }
-  if {$char == 9756} { return A }
-  if {$char == 9758} { return A }
-  if {$char == 9792} { return A }
-  if {$char == 9794} { return A }
-  if {$char >= 9800 && $char <= 9811 } { return W }
-  if {$char >= 9824 && $char <= 9825 } { return A }
-  if {$char >= 9827 && $char <= 9829 } { return A }
-  if {$char >= 9831 && $char <= 9834 } { return A }
-  if {$char >= 9836 && $char <= 9837 } { return A }
-  if {$char == 9839} { return A }
-  if {$char == 9855} { return W }
-  if {$char == 9875} { return W }
-  if {$char >= 9886 && $char <= 9887 } { return A }
-  if {$char == 9889} { return W }
-  if {$char >= 9898 && $char <= 9899 } { return W }
-  if {$char >= 9917 && $char <= 9918 } { return W }
-  if {$char == 9919} { return A }
-  if {$char >= 9924 && $char <= 9925 } { return W }
-  if {$char >= 9926 && $char <= 9933 } { return A }
-  if {$char == 9934} { return W }
-  if {$char >= 9935 && $char <= 9939 } { return A }
-  if {$char == 9940} { return W }
-  if {$char >= 9941 && $char <= 9953 } { return A }
-  if {$char == 9955} { return A }
-  if {$char >= 9960 && $char <= 9961 } { return A }
-  if {$char == 9962} { return W }
-  if {$char >= 9963 && $char <= 9969 } { return A }
-  if {$char >= 9970 && $char <= 9971 } { return W }
-  if {$char == 9972} { return A }
-  if {$char == 9973} { return W }
-  if {$char >= 9974 && $char <= 9977 } { return A }
-  if {$char == 9978} { return W }
-  if {$char >= 9979 && $char <= 9980 } { return A }
-  if {$char == 9981} { return W }
-  if {$char >= 9982 && $char <= 9983 } { return A }
-  if {$char == 9989} { return W }
-  if {$char >= 9994 && $char <= 9995 } { return W }
-  if {$char == 10024} { return W }
-  if {$char == 10045} { return A }
-  if {$char == 10060} { return W }
-  if {$char == 10062} { return W }
-  if {$char >= 10067 && $char <= 10069 } { return W }
-  if {$char == 10071} { return W }
-  if {$char >= 10102 && $char <= 10111 } { return A }
-  if {$char >= 10133 && $char <= 10135 } { return W }
-  if {$char == 10160} { return W }
-  if {$char == 10175} { return W }
-  if {$char >= 11035 && $char <= 11036 } { return W }
-  if {$char == 11088} { return W }
-  if {$char == 11093} { return W }
-  if {$char >= 11094 && $char <= 11097 } { return A }
-  if {$char >= 11904 && $char <= 11929 } { return W }
-  if {$char >= 11931 && $char <= 12019 } { return W }
-  if {$char >= 12032 && $char <= 12245 } { return W }
-  if {$char >= 12272 && $char <= 12283 } { return W }
-  if {$char == 12288} { return F }
-  if {$char >= 12289 && $char <= 12291 } { return W }
-  if {$char == 12292} { return W }
-  if {$char == 12293} { return W }
-  if {$char == 12294} { return W }
-  if {$char == 12295} { return W }
-  if {$char == 12296} { return W }
-  if {$char == 12297} { return W }
-  if {$char == 12298} { return W }
-  if {$char == 12299} { return W }
-  if {$char == 12300} { return W }
-  if {$char == 12301} { return W }
-  if {$char == 12302} { return W }
-  if {$char == 12303} { return W }
-  if {$char == 12304} { return W }
-  if {$char == 12305} { return W }
-  if {$char >= 12306 && $char <= 12307 } { return W }
-  if {$char == 12308} { return W }
-  if {$char == 12309} { return W }
-  if {$char == 12310} { return W }
-  if {$char == 12311} { return W }
-  if {$char == 12312} { return W }
-  if {$char == 12313} { return W }
-  if {$char == 12314} { return W }
-  if {$char == 12315} { return W }
-  if {$char == 12316} { return W }
-  if {$char == 12317} { return W }
-  if {$char >= 12318 && $char <= 12319 } { return W }
-  if {$char == 12320} { return W }
-  if {$char >= 12321 && $char <= 12329 } { return W }
-  if {$char >= 12330 && $char <= 12333 } { return W }
-  if {$char >= 12334 && $char <= 12335 } { return W }
-  if {$char == 12336} { return W }
-  if {$char >= 12337 && $char <= 12341 } { return W }
-  if {$char >= 12342 && $char <= 12343 } { return W }
-  if {$char >= 12344 && $char <= 12346 } { return W }
-  if {$char == 12347} { return W }
-  if {$char == 12348} { return W }
-  if {$char == 12349} { return W }
-  if {$char == 12350} { return W }
-  if {$char >= 12353 && $char <= 12438 } { return W }
-  if {$char >= 12441 && $char <= 12442 } { return W }
-  if {$char >= 12443 && $char <= 12444 } { return W }
-  if {$char >= 12445 && $char <= 12446 } { return W }
-  if {$char == 12447} { return W }
-  if {$char == 12448} { return W }
-  if {$char >= 12449 && $char <= 12538 } { return W }
-  if {$char == 12539} { return W }
-  if {$char >= 12540 && $char <= 12542 } { return W }
-  if {$char == 12543} { return W }
-  if {$char >= 12549 && $char <= 12591 } { return W }
-  if {$char >= 12593 && $char <= 12686 } { return W }
-  if {$char >= 12688 && $char <= 12689 } { return W }
-  if {$char >= 12690 && $char <= 12693 } { return W }
-  if {$char >= 12694 && $char <= 12703 } { return W }
-  if {$char >= 12704 && $char <= 12730 } { return W }
-  if {$char >= 12736 && $char <= 12771 } { return W }
-  if {$char >= 12784 && $char <= 12799 } { return W }
-  if {$char >= 12800 && $char <= 12830 } { return W }
-  if {$char >= 12832 && $char <= 12841 } { return W }
-  if {$char >= 12842 && $char <= 12871 } { return W }
-  if {$char >= 12872 && $char <= 12879 } { return A }
-  if {$char == 12880} { return W }
-  if {$char >= 12881 && $char <= 12895 } { return W }
-  if {$char >= 12896 && $char <= 12927 } { return W }
-  if {$char >= 12928 && $char <= 12937 } { return W }
-  if {$char >= 12938 && $char <= 12976 } { return W }
-  if {$char >= 12977 && $char <= 12991 } { return W }
-  if {$char >= 12992 && $char <= 13054 } { return W }
-  if {$char >= 13056 && $char <= 13311 } { return W }
-  if {$char >= 13312 && $char <= 19893 } { return W }
-  if {$char >= 19894 && $char <= 19903 } { return W }
-  if {$char >= 19968 && $char <= 40943 } { return W }
-  if {$char >= 40944 && $char <= 40959 } { return W }
-  if {$char >= 40960 && $char <= 40980 } { return W }
-  if {$char == 40981} { return W }
-  if {$char >= 40982 && $char <= 42124 } { return W }
-  if {$char >= 42128 && $char <= 42182 } { return W }
-  if {$char >= 43360 && $char <= 43388 } { return W }
-  if {$char >= 44032 && $char <= 55203 } { return W }
-  if {$char >= 57344 && $char <= 63743 } { return A }
-  if {$char >= 63744 && $char <= 64109 } { return W }
-  if {$char >= 64110 && $char <= 64111 } { return W }
-  if {$char >= 64112 && $char <= 64217 } { return W }
-  if {$char >= 64218 && $char <= 64255 } { return W }
-  if {$char >= 65024 && $char <= 65039 } { return A }
-  if {$char >= 65040 && $char <= 65046 } { return W }
-  if {$char == 65047} { return W }
-  if {$char == 65048} { return W }
-  if {$char == 65049} { return W }
-  if {$char == 65072} { return W }
-  if {$char >= 65073 && $char <= 65074 } { return W }
-  if {$char >= 65075 && $char <= 65076 } { return W }
-  if {$char == 65077} { return W }
-  if {$char == 65078} { return W }
-  if {$char == 65079} { return W }
-  if {$char == 65080} { return W }
-  if {$char == 65081} { return W }
-  if {$char == 65082} { return W }
-  if {$char == 65083} { return W }
-  if {$char == 65084} { return W }
-  if {$char == 65085} { return W }
-  if {$char == 65086} { return W }
-  if {$char == 65087} { return W }
-  if {$char == 65088} { return W }
-  if {$char == 65089} { return W }
-  if {$char == 65090} { return W }
-  if {$char == 65091} { return W }
-  if {$char == 65092} { return W }
-  if {$char >= 65093 && $char <= 65094 } { return W }
-  if {$char == 65095} { return W }
-  if {$char == 65096} { return W }
-  if {$char >= 65097 && $char <= 65100 } { return W }
-  if {$char >= 65101 && $char <= 65103 } { return W }
-  if {$char >= 65104 && $char <= 65106 } { return W }
-  if {$char >= 65108 && $char <= 65111 } { return W }
-  if {$char == 65112} { return W }
-  if {$char == 65113} { return W }
-  if {$char == 65114} { return W }
-  if {$char == 65115} { return W }
-  if {$char == 65116} { return W }
-  if {$char == 65117} { return W }
-  if {$char == 65118} { return W }
-  if {$char >= 65119 && $char <= 65121 } { return W }
-  if {$char == 65122} { return W }
-  if {$char == 65123} { return W }
-  if {$char >= 65124 && $char <= 65126 } { return W }
-  if {$char == 65128} { return W }
-  if {$char == 65129} { return W }
-  if {$char >= 65130 && $char <= 65131 } { return W }
-  if {$char >= 65281 && $char <= 65283 } { return F }
-  if {$char == 65284} { return F }
-  if {$char >= 65285 && $char <= 65287 } { return F }
-  if {$char == 65288} { return F }
-  if {$char == 65289} { return F }
-  if {$char == 65290} { return F }
-  if {$char == 65291} { return F }
-  if {$char == 65292} { return F }
-  if {$char == 65293} { return F }
-  if {$char >= 65294 && $char <= 65295 } { return F }
-  if {$char >= 65296 && $char <= 65305 } { return F }
-  if {$char >= 65306 && $char <= 65307 } { return F }
-  if {$char >= 65308 && $char <= 65310 } { return F }
-  if {$char >= 65311 && $char <= 65312 } { return F }
-  if {$char >= 65313 && $char <= 65338 } { return F }
-  if {$char == 65339} { return F }
-  if {$char == 65340} { return F }
-  if {$char == 65341} { return F }
-  if {$char == 65342} { return F }
-  if {$char == 65343} { return F }
-  if {$char == 65344} { return F }
-  if {$char >= 65345 && $char <= 65370 } { return F }
-  if {$char == 65371} { return F }
-  if {$char == 65372} { return F }
-  if {$char == 65373} { return F }
-  if {$char == 65374} { return F }
-  if {$char == 65375} { return F }
-  if {$char == 65376} { return F }
-  if {$char == 65377} { return H }
-  if {$char == 65378} { return H }
-  if {$char == 65379} { return H }
-  if {$char >= 65380 && $char <= 65381 } { return H }
-  if {$char >= 65382 && $char <= 65391 } { return H }
-  if {$char == 65392} { return H }
-  if {$char >= 65393 && $char <= 65437 } { return H }
-  if {$char >= 65438 && $char <= 65439 } { return H }
-  if {$char >= 65440 && $char <= 65470 } { return H }
-  if {$char >= 65474 && $char <= 65479 } { return H }
-  if {$char >= 65482 && $char <= 65487 } { return H }
-  if {$char >= 65490 && $char <= 65495 } { return H }
-  if {$char >= 65498 && $char <= 65500 } { return H }
-  if {$char >= 65504 && $char <= 65505 } { return F }
-  if {$char == 65506} { return F }
-  if {$char == 65507} { return F }
-  if {$char == 65508} { return F }
-  if {$char >= 65509 && $char <= 65510 } { return F }
-  if {$char == 65512} { return H }
-  if {$char >= 65513 && $char <= 65516 } { return H }
-  if {$char >= 65517 && $char <= 65518 } { return H }
-  if {$char == 65533} { return A }
-  if {$char >= 94176 && $char <= 94177 } { return W }
-  if {$char >= 94208 && $char <= 100337 } { return W }
-  if {$char >= 100352 && $char <= 101106 } { return W }
-  if {$char >= 110592 && $char <= 110847 } { return W }
-  if {$char >= 110848 && $char <= 110878 } { return W }
-  if {$char >= 110960 && $char <= 111355 } { return W }
-  if {$char == 126980} { return W }
-  if {$char == 127183} { return W }
-  if {$char >= 127232 && $char <= 127242 } { return A }
-  if {$char >= 127248 && $char <= 127277 } { return A }
-  if {$char >= 127280 && $char <= 127337 } { return A }
-  if {$char >= 127344 && $char <= 127373 } { return A }
-  if {$char == 127374} { return W }
-  if {$char >= 127375 && $char <= 127376 } { return A }
-  if {$char >= 127377 && $char <= 127386 } { return W }
-  if {$char >= 127387 && $char <= 127404 } { return A }
-  if {$char >= 127488 && $char <= 127490 } { return W }
-  if {$char >= 127504 && $char <= 127547 } { return W }
-  if {$char >= 127552 && $char <= 127560 } { return W }
-  if {$char >= 127568 && $char <= 127569 } { return W }
-  if {$char >= 127584 && $char <= 127589 } { return W }
-  if {$char >= 127744 && $char <= 127776 } { return W }
-  if {$char >= 127789 && $char <= 127797 } { return W }
-  if {$char >= 127799 && $char <= 127868 } { return W }
-  if {$char >= 127870 && $char <= 127891 } { return W }
-  if {$char >= 127904 && $char <= 127946 } { return W }
-  if {$char >= 127951 && $char <= 127955 } { return W }
-  if {$char >= 127968 && $char <= 127984 } { return W }
-  if {$char == 127988} { return W }
-  if {$char >= 127992 && $char <= 127994 } { return W }
-  if {$char >= 127995 && $char <= 127999 } { return W }
-  if {$char >= 128000 && $char <= 128062 } { return W }
-  if {$char == 128064} { return W }
-  if {$char >= 128066 && $char <= 128252 } { return W }
-  if {$char >= 128255 && $char <= 128317 } { return W }
-  if {$char >= 128331 && $char <= 128334 } { return W }
-  if {$char >= 128336 && $char <= 128359 } { return W }
-  if {$char == 128378} { return W }
-  if {$char >= 128405 && $char <= 128406 } { return W }
-  if {$char == 128420} { return W }
-  if {$char >= 128507 && $char <= 128511 } { return W }
-  if {$char >= 128512 && $char <= 128591 } { return W }
-  if {$char >= 128640 && $char <= 128709 } { return W }
-  if {$char == 128716} { return W }
-  if {$char >= 128720 && $char <= 128722 } { return W }
-  if {$char >= 128747 && $char <= 128748 } { return W }
-  if {$char >= 128756 && $char <= 128761 } { return W }
-  if {$char >= 129296 && $char <= 129342 } { return W }
-  if {$char >= 129344 && $char <= 129392 } { return W }
-  if {$char >= 129395 && $char <= 129398 } { return W }
-  if {$char == 129402} { return W }
-  if {$char >= 129404 && $char <= 129442 } { return W }
-  if {$char >= 129456 && $char <= 129465 } { return W }
-  if {$char >= 129472 && $char <= 129474 } { return W }
-  if {$char >= 129488 && $char <= 129535 } { return W }
-  if {$char >= 131072 && $char <= 173782 } { return W }
-  if {$char >= 173783 && $char <= 173823 } { return W }
-  if {$char >= 173824 && $char <= 177972 } { return W }
-  if {$char >= 177973 && $char <= 177983 } { return W }
-  if {$char >= 177984 && $char <= 178205 } { return W }
-  if {$char >= 178206 && $char <= 178207 } { return W }
-  if {$char >= 178208 && $char <= 183969 } { return W }
-  if {$char >= 183970 && $char <= 183983 } { return W }
-  if {$char >= 183984 && $char <= 191456 } { return W }
-  if {$char >= 191457 && $char <= 194559 } { return W }
-  if {$char >= 194560 && $char <= 195101 } { return W }
-  if {$char >= 195102 && $char <= 195103 } { return W }
-  if {$char >= 195104 && $char <= 196605 } { return W }
-  if {$char >= 196608 && $char <= 262141 } { return W }
-  if {$char >= 917760 && $char <= 917999 } { return A }
-  if {$char >= 983040 && $char <= 1048573 } { return A }
-  if {$char >= 1048576 && $char <= 1114109 } { return A }
-  return N
-}
-proc ::textutil::wcswidth_char char {
-  if {$char >= 4352 && $char <= 4447 } { return 2 }
-  if {$char >= 8986 && $char <= 8987 } { return 2 }
-  if {$char == 9001} { return 2 }
-  if {$char == 9002} { return 2 }
-  if {$char >= 9193 && $char <= 9196 } { return 2 }
-  if {$char == 9200} { return 2 }
-  if {$char == 9203} { return 2 }
-  if {$char >= 9725 && $char <= 9726 } { return 2 }
-  if {$char >= 9748 && $char <= 9749 } { return 2 }
-  if {$char >= 9800 && $char <= 9811 } { return 2 }
-  if {$char == 9855} { return 2 }
-  if {$char == 9875} { return 2 }
-  if {$char == 9889} { return 2 }
-  if {$char >= 9898 && $char <= 9899 } { return 2 }
-  if {$char >= 9917 && $char <= 9918 } { return 2 }
-  if {$char >= 9924 && $char <= 9925 } { return 2 }
-  if {$char == 9934} { return 2 }
-  if {$char == 9940} { return 2 }
-  if {$char == 9962} { return 2 }
-  if {$char >= 9970 && $char <= 9971 } { return 2 }
-  if {$char == 9973} { return 2 }
-  if {$char == 9978} { return 2 }
-  if {$char == 9981} { return 2 }
-  if {$char == 9989} { return 2 }
-  if {$char >= 9994 && $char <= 9995 } { return 2 }
-  if {$char == 10024} { return 2 }
-  if {$char == 10060} { return 2 }
-  if {$char == 10062} { return 2 }
-  if {$char >= 10067 && $char <= 10069 } { return 2 }
-  if {$char == 10071} { return 2 }
-  if {$char >= 10133 && $char <= 10135 } { return 2 }
-  if {$char == 10160} { return 2 }
-  if {$char == 10175} { return 2 }
-  if {$char >= 11035 && $char <= 11036 } { return 2 }
-  if {$char == 11088} { return 2 }
-  if {$char == 11093} { return 2 }
-  if {$char >= 11904 && $char <= 11929 } { return 2 }
-  if {$char >= 11931 && $char <= 12019 } { return 2 }
-  if {$char >= 12032 && $char <= 12245 } { return 2 }
-  if {$char >= 12272 && $char <= 12283 } { return 2 }
-  if {$char == 12288} { return 2 }
-  if {$char >= 12289 && $char <= 12291 } { return 2 }
-  if {$char == 12292} { return 2 }
-  if {$char == 12293} { return 2 }
-  if {$char == 12294} { return 2 }
-  if {$char == 12295} { return 2 }
-  if {$char == 12296} { return 2 }
-  if {$char == 12297} { return 2 }
-  if {$char == 12298} { return 2 }
-  if {$char == 12299} { return 2 }
-  if {$char == 12300} { return 2 }
-  if {$char == 12301} { return 2 }
-  if {$char == 12302} { return 2 }
-  if {$char == 12303} { return 2 }
-  if {$char == 12304} { return 2 }
-  if {$char == 12305} { return 2 }
-  if {$char >= 12306 && $char <= 12307 } { return 2 }
-  if {$char == 12308} { return 2 }
-  if {$char == 12309} { return 2 }
-  if {$char == 12310} { return 2 }
-  if {$char == 12311} { return 2 }
-  if {$char == 12312} { return 2 }
-  if {$char == 12313} { return 2 }
-  if {$char == 12314} { return 2 }
-  if {$char == 12315} { return 2 }
-  if {$char == 12316} { return 2 }
-  if {$char == 12317} { return 2 }
-  if {$char >= 12318 && $char <= 12319 } { return 2 }
-  if {$char == 12320} { return 2 }
-  if {$char >= 12321 && $char <= 12329 } { return 2 }
-  if {$char >= 12330 && $char <= 12333 } { return 2 }
-  if {$char >= 12334 && $char <= 12335 } { return 2 }
-  if {$char == 12336} { return 2 }
-  if {$char >= 12337 && $char <= 12341 } { return 2 }
-  if {$char >= 12342 && $char <= 12343 } { return 2 }
-  if {$char >= 12344 && $char <= 12346 } { return 2 }
-  if {$char == 12347} { return 2 }
-  if {$char == 12348} { return 2 }
-  if {$char == 12349} { return 2 }
-  if {$char == 12350} { return 2 }
-  if {$char >= 12353 && $char <= 12438 } { return 2 }
-  if {$char >= 12441 && $char <= 12442 } { return 2 }
-  if {$char >= 12443 && $char <= 12444 } { return 2 }
-  if {$char >= 12445 && $char <= 12446 } { return 2 }
-  if {$char == 12447} { return 2 }
-  if {$char == 12448} { return 2 }
-  if {$char >= 12449 && $char <= 12538 } { return 2 }
-  if {$char == 12539} { return 2 }
-  if {$char >= 12540 && $char <= 12542 } { return 2 }
-  if {$char == 12543} { return 2 }
-  if {$char >= 12549 && $char <= 12591 } { return 2 }
-  if {$char >= 12593 && $char <= 12686 } { return 2 }
-  if {$char >= 12688 && $char <= 12689 } { return 2 }
-  if {$char >= 12690 && $char <= 12693 } { return 2 }
-  if {$char >= 12694 && $char <= 12703 } { return 2 }
-  if {$char >= 12704 && $char <= 12730 } { return 2 }
-  if {$char >= 12736 && $char <= 12771 } { return 2 }
-  if {$char >= 12784 && $char <= 12799 } { return 2 }
-  if {$char >= 12800 && $char <= 12830 } { return 2 }
-  if {$char >= 12832 && $char <= 12841 } { return 2 }
-  if {$char >= 12842 && $char <= 12871 } { return 2 }
-  if {$char == 12880} { return 2 }
-  if {$char >= 12881 && $char <= 12895 } { return 2 }
-  if {$char >= 12896 && $char <= 12927 } { return 2 }
-  if {$char >= 12928 && $char <= 12937 } { return 2 }
-  if {$char >= 12938 && $char <= 12976 } { return 2 }
-  if {$char >= 12977 && $char <= 12991 } { return 2 }
-  if {$char >= 12992 && $char <= 13054 } { return 2 }
-  if {$char >= 13056 && $char <= 13311 } { return 2 }
-  if {$char >= 13312 && $char <= 19893 } { return 2 }
-  if {$char >= 19894 && $char <= 19903 } { return 2 }
-  if {$char >= 19968 && $char <= 40943 } { return 2 }
-  if {$char >= 40944 && $char <= 40959 } { return 2 }
-  if {$char >= 40960 && $char <= 40980 } { return 2 }
-  if {$char == 40981} { return 2 }
-  if {$char >= 40982 && $char <= 42124 } { return 2 }
-  if {$char >= 42128 && $char <= 42182 } { return 2 }
-  if {$char >= 43360 && $char <= 43388 } { return 2 }
-  if {$char >= 44032 && $char <= 55203 } { return 2 }
-  if {$char >= 63744 && $char <= 64109 } { return 2 }
-  if {$char >= 64110 && $char <= 64111 } { return 2 }
-  if {$char >= 64112 && $char <= 64217 } { return 2 }
-  if {$char >= 64218 && $char <= 64255 } { return 2 }
-  if {$char >= 65040 && $char <= 65046 } { return 2 }
-  if {$char == 65047} { return 2 }
-  if {$char == 65048} { return 2 }
-  if {$char == 65049} { return 2 }
-  if {$char == 65072} { return 2 }
-  if {$char >= 65073 && $char <= 65074 } { return 2 }
-  if {$char >= 65075 && $char <= 65076 } { return 2 }
-  if {$char == 65077} { return 2 }
-  if {$char == 65078} { return 2 }
-  if {$char == 65079} { return 2 }
-  if {$char == 65080} { return 2 }
-  if {$char == 65081} { return 2 }
-  if {$char == 65082} { return 2 }
-  if {$char == 65083} { return 2 }
-  if {$char == 65084} { return 2 }
-  if {$char == 65085} { return 2 }
-  if {$char == 65086} { return 2 }
-  if {$char == 65087} { return 2 }
-  if {$char == 65088} { return 2 }
-  if {$char == 65089} { return 2 }
-  if {$char == 65090} { return 2 }
-  if {$char == 65091} { return 2 }
-  if {$char == 65092} { return 2 }
-  if {$char >= 65093 && $char <= 65094 } { return 2 }
-  if {$char == 65095} { return 2 }
-  if {$char == 65096} { return 2 }
-  if {$char >= 65097 && $char <= 65100 } { return 2 }
-  if {$char >= 65101 && $char <= 65103 } { return 2 }
-  if {$char >= 65104 && $char <= 65106 } { return 2 }
-  if {$char >= 65108 && $char <= 65111 } { return 2 }
-  if {$char == 65112} { return 2 }
-  if {$char == 65113} { return 2 }
-  if {$char == 65114} { return 2 }
-  if {$char == 65115} { return 2 }
-  if {$char == 65116} { return 2 }
-  if {$char == 65117} { return 2 }
-  if {$char == 65118} { return 2 }
-  if {$char >= 65119 && $char <= 65121 } { return 2 }
-  if {$char == 65122} { return 2 }
-  if {$char == 65123} { return 2 }
-  if {$char >= 65124 && $char <= 65126 } { return 2 }
-  if {$char == 65128} { return 2 }
-  if {$char == 65129} { return 2 }
-  if {$char >= 65130 && $char <= 65131 } { return 2 }
-  if {$char >= 65281 && $char <= 65283 } { return 2 }
-  if {$char == 65284} { return 2 }
-  if {$char >= 65285 && $char <= 65287 } { return 2 }
-  if {$char == 65288} { return 2 }
-  if {$char == 65289} { return 2 }
-  if {$char == 65290} { return 2 }
-  if {$char == 65291} { return 2 }
-  if {$char == 65292} { return 2 }
-  if {$char == 65293} { return 2 }
-  if {$char >= 65294 && $char <= 65295 } { return 2 }
-  if {$char >= 65296 && $char <= 65305 } { return 2 }
-  if {$char >= 65306 && $char <= 65307 } { return 2 }
-  if {$char >= 65308 && $char <= 65310 } { return 2 }
-  if {$char >= 65311 && $char <= 65312 } { return 2 }
-  if {$char >= 65313 && $char <= 65338 } { return 2 }
-  if {$char == 65339} { return 2 }
-  if {$char == 65340} { return 2 }
-  if {$char == 65341} { return 2 }
-  if {$char == 65342} { return 2 }
-  if {$char == 65343} { return 2 }
-  if {$char == 65344} { return 2 }
-  if {$char >= 65345 && $char <= 65370 } { return 2 }
-  if {$char == 65371} { return 2 }
-  if {$char == 65372} { return 2 }
-  if {$char == 65373} { return 2 }
-  if {$char == 65374} { return 2 }
-  if {$char == 65375} { return 2 }
-  if {$char == 65376} { return 2 }
-  if {$char >= 65504 && $char <= 65505 } { return 2 }
-  if {$char == 65506} { return 2 }
-  if {$char == 65507} { return 2 }
-  if {$char == 65508} { return 2 }
-  if {$char >= 65509 && $char <= 65510 } { return 2 }
-  if {$char >= 94176 && $char <= 94177 } { return 2 }
-  if {$char >= 94208 && $char <= 100337 } { return 2 }
-  if {$char >= 100352 && $char <= 101106 } { return 2 }
-  if {$char >= 110592 && $char <= 110847 } { return 2 }
-  if {$char >= 110848 && $char <= 110878 } { return 2 }
-  if {$char >= 110960 && $char <= 111355 } { return 2 }
-  if {$char == 126980} { return 2 }
-  if {$char == 127183} { return 2 }
-  if {$char == 127374} { return 2 }
-  if {$char >= 127377 && $char <= 127386 } { return 2 }
-  if {$char >= 127488 && $char <= 127490 } { return 2 }
-  if {$char >= 127504 && $char <= 127547 } { return 2 }
-  if {$char >= 127552 && $char <= 127560 } { return 2 }
-  if {$char >= 127568 && $char <= 127569 } { return 2 }
-  if {$char >= 127584 && $char <= 127589 } { return 2 }
-  if {$char >= 127744 && $char <= 127776 } { return 2 }
-  if {$char >= 127789 && $char <= 127797 } { return 2 }
-  if {$char >= 127799 && $char <= 127868 } { return 2 }
-  if {$char >= 127870 && $char <= 127891 } { return 2 }
-  if {$char >= 127904 && $char <= 127946 } { return 2 }
-  if {$char >= 127951 && $char <= 127955 } { return 2 }
-  if {$char >= 127968 && $char <= 127984 } { return 2 }
-  if {$char == 127988} { return 2 }
-  if {$char >= 127992 && $char <= 127994 } { return 2 }
-  if {$char >= 127995 && $char <= 127999 } { return 2 }
-  if {$char >= 128000 && $char <= 128062 } { return 2 }
-  if {$char == 128064} { return 2 }
-  if {$char >= 128066 && $char <= 128252 } { return 2 }
-  if {$char >= 128255 && $char <= 128317 } { return 2 }
-  if {$char >= 128331 && $char <= 128334 } { return 2 }
-  if {$char >= 128336 && $char <= 128359 } { return 2 }
-  if {$char == 128378} { return 2 }
-  if {$char >= 128405 && $char <= 128406 } { return 2 }
-  if {$char == 128420} { return 2 }
-  if {$char >= 128507 && $char <= 128511 } { return 2 }
-  if {$char >= 128512 && $char <= 128591 } { return 2 }
-  if {$char >= 128640 && $char <= 128709 } { return 2 }
-  if {$char == 128716} { return 2 }
-  if {$char >= 128720 && $char <= 128722 } { return 2 }
-  if {$char >= 128747 && $char <= 128748 } { return 2 }
-  if {$char >= 128756 && $char <= 128761 } { return 2 }
-  if {$char >= 129296 && $char <= 129342 } { return 2 }
-  if {$char >= 129344 && $char <= 129392 } { return 2 }
-  if {$char >= 129395 && $char <= 129398 } { return 2 }
-  if {$char == 129402} { return 2 }
-  if {$char >= 129404 && $char <= 129442 } { return 2 }
-  if {$char >= 129456 && $char <= 129465 } { return 2 }
-  if {$char >= 129472 && $char <= 129474 } { return 2 }
-  if {$char >= 129488 && $char <= 129535 } { return 2 }
-  if {$char >= 131072 && $char <= 173782 } { return 2 }
-  if {$char >= 173783 && $char <= 173823 } { return 2 }
-  if {$char >= 173824 && $char <= 177972 } { return 2 }
-  if {$char >= 177973 && $char <= 177983 } { return 2 }
-  if {$char >= 177984 && $char <= 178205 } { return 2 }
-  if {$char >= 178206 && $char <= 178207 } { return 2 }
-  if {$char >= 178208 && $char <= 183969 } { return 2 }
-  if {$char >= 183970 && $char <= 183983 } { return 2 }
-  if {$char >= 183984 && $char <= 191456 } { return 2 }
-  if {$char >= 191457 && $char <= 194559 } { return 2 }
-  if {$char >= 194560 && $char <= 195101 } { return 2 }
-  if {$char >= 195102 && $char <= 195103 } { return 2 }
-  if {$char >= 195104 && $char <= 196605 } { return 2 }
-  if {$char >= 196608 && $char <= 262141 } { return 2 }
-  return 1
-}
-
-proc ::textutil::wcswidth {string} {
-  set width 0
-  set len [string length $string]
-  foreach c [split $string {}] {
-    scan $c %c char
-    set n [::textutil::wcswidth_char $char]
-    if {$n < 0} {
-      return -1
-    }
-    incr width $n
-  }
-  return $width
-}
-
diff --git a/src/mixtemplates/layouts/basic/src/build.tcl b/src/mixtemplates/layouts/basic/src/build.tcl
deleted file mode 100644
index ee541f5b..00000000
--- a/src/mixtemplates/layouts/basic/src/build.tcl
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/sh
-# -*- tcl -*- \
-# 'build.tcl' name as required by kettle
-# Can be run directly - but also using `pmix Kettle ...`  or `pmix KettleShell  ...`\
-exec ./kettle -f "$0" "${1+$@}"
-kettle doc
diff --git a/src/mixtemplates/layouts/basic/src/make.tcl b/src/mixtemplates/layouts/basic/src/make.tcl
deleted file mode 100644
index c01c9775..00000000
--- a/src/mixtemplates/layouts/basic/src/make.tcl
+++ /dev/null
@@ -1,989 +0,0 @@
-# tcl
-#
-#make any tclkits and modules in src and place them and associated data files/scripts in the parent folder of src.
-#e.g in 'bin' and 'modules' folders at same level as 'src' folder.
-
-set hashline "# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###"
-puts $hashline
-puts "    punkshell make script " 
-puts $hashline\n
-namespace eval ::punkmake {
-    variable scriptfolder [file normalize [file dirname [info script]]]
-    variable foldername [file tail $scriptfolder]
-    variable pkg_requirements [list]; variable pkg_missing [list];variable pkg_loaded [list]
-    variable non_help_flags [list -k]
-    variable help_flags     [list -help --help /?]
-    variable known_commands [list project get-project-info shell bootsupport]
-}
-if {"::try" ni [info commands ::try]} {
-    puts stderr "Tcl interpreter possibly too old - 'try' command not found - aborting"
-    exit 1
-}
-
-#------------------------------------------------------------------------------
-#Module loading from /src/bootsupport or src/*.vfs if script is within a .vfs folder
-#------------------------------------------------------------------------------
-#If the there is a folder  under the current directory /src/bootsupport/modules which contains .tm files 
-# - then it will attempt to preference these modules
-# This allows a source update via 'fossil update' 'git pull' etc to pull in a minimal set of support modules for the make script
-# and load these in preference to ones that may have been in the interp's tcl::tm::list or auto_path due to environment variables
-set startdir [pwd]
-if {[file exists [file join $startdir src bootsupport]]} {
-    set bootsupport_mod [file join $startdir src bootsupport modules]
-    set bootsupport_lib [file join $startdir src bootsupport lib]
-} else {
-    set bootsupport_mod [file join $startdir bootsupport modules]
-    set bootsupport_lib [file join $startdir bootsupport lib]
-}
-if {[file exists $bootsupport_mod] || [file exists $bootsupport_lib]} {
-
-    set original_tm_list [tcl::tm::list]
-    tcl::tm::remove {*}$original_tm_list
-    set original_auto_path $::auto_path
-    set ::auto_path [list $bootsupport_lib]
-
-    set support_modules [glob -nocomplain -dir $bootsupport_mod -type f -tail *.tm]
-    set tcl_core_packages [list tcl::zlib zlib tcl::oo TclOO tcl::tommath tcl::zipfs Tcl Tk] ;#packages we 
-    if {[llength $support_modules] || [llength [glob -nocomplain -dir $bootsupport_lib  -tail *]]} {
-        #only forget all *unloaded* package names
-        foreach pkg [package names] {
-            if {$pkg in $tcl_core_packages} {
-                continue
-            }
-            if {![llength [package versions $pkg]]} {
-                #puts stderr "Got no versions for pkg $pkg"
-                continue
-            }
-            if {![string length [package provide $pkg]]} {
-                #no returned version indicates it wasn't loaded - so we can forget its index
-                package forget $pkg
-            }
-        }
-        tcl::tm::add $bootsupport_mod
-    }
-
-
-    if {[file exists [pwd]/modules]} {
-        tcl::tm::add [pwd]/modules
-    }
-
-    #package require Thread
-    # - the full repl requires Threading and punk,shellfilter,shellrun to call and display properly.
-    
-    
-    # tm list already indexed - need 'package forget' to find modules based on current tcl::tm::list
-    #These are strong dependencies 
-    package forget  punk::mix
-    package require punk::mix
-    package forget  punk::repo 
-    package require punk::repo
-    package forget  punkcheck 
-    package require punkcheck
-
-
-
-    #restore module paths and auto_path in addition to the bootsupport ones
-    set tm_list_now [tcl::tm::list]
-    foreach p $original_tm_list {
-        if {$p ni $tm_list_now} {
-            tcl::tm::add $p
-        }
-    }
-    set ::auto_path [list $bootsupport_lib {*}$original_auto_path]
-    #------------------------------------------------------------------------------
-}
-
-# ** *** *** *** *** *** *** *** *** *** *** ***
-#*temporarily* hijack package command
-# ** *** *** *** *** *** *** *** *** *** *** ***
-try {
-    rename ::package ::punkmake::package_temp_aside
-    proc ::package {args} {
-        if {[lindex $args 0] eq "require"} {
-            lappend ::punkmake::pkg_requirements [lindex $args 1]
-        }
-    }
-    package require punk::mix
-    package require punk::repo
-} finally {
-    catch {rename ::package ""}
-    catch {rename ::punkmake::package_temp_aside ::package}
-}
-# ** *** *** *** *** *** *** *** *** *** *** ***
-foreach pkg $::punkmake::pkg_requirements {
-    if {[catch {package require $pkg} errM]} {
-        puts stderr "missing pkg: $pkg"
-        lappend ::punkmake::pkg_missing $pkg 
-    } else {
-        lappend ::punkmake::pkg_loaded $pkg
-    }
-}
-
-
-
-
-
-proc punkmake_gethelp {args} {
-    set scriptname [file tail [info script]]
-    append h "Usage:" \n 
-    append h "" \n
-    append h "  $scriptname -help  or $scriptname --help or $scriptname /? or just $scriptname" \n
-    append h "  - This help." \n \n
-    append h "  $scriptname project ?-k?" \n
-    append h "  - this is the literal word project - and confirms you want to run the project build" \n
-    append h "  - the optional -k flag will terminate processes running as the executable being built (if applicable)" \n \n
-    append h "  $scriptname bootsupport"  \n
-    append h "  - update the src/bootsupport modules as well as the mixtemplates/layouts/<layoutname>/src/bootsupport modules if the folder exists" \n \n
-    append h "  $scriptname get-project-info" \n
-    append h "  - show the name and base folder of the project to be built" \n
-    append h "" \n
-    if {[llength $::punkmake::pkg_missing]} {
-        append h "* ** NOTE ** ***" \n
-        append h "    punkmake has detected that the following packages could not be loaded:" \n
-        append h "    " [join $::punkmake::pkg_missing "\n    "] \n
-        append h "* ** *** *** ***" \n
-        append h "    These packages are required for punk make to function" \n \n
-        append h "* ** *** *** ***" \n\n
-        append h "Successfully Loaded packages:" \n
-        append h "    " [join $::punkmake::pkg_loaded "\n    "] \n
-    }
-    return $h
-}
-set scriptargs $::argv
-set do_help 0
-if {![llength $scriptargs]} {
-    set do_help 1
-} else {
-    foreach h $::punkmake::help_flags {
-        if {[lsearch $scriptargs $h] >= 0} {
-            set do_help 1
-            break
-        }
-    }
-}
-set commands_found [list]
-foreach a $scriptargs {
-    if {![string match -* $a]} {
-        lappend commands_found $a
-    } else {
-        if {$a ni $::punkmake::non_help_flags} {
-            set do_help 1
-        }
-    }
-}
-if {[llength $commands_found] != 1 } {
-    set do_help 1
-} elseif {[lindex $commands_found 0] ni $::punkmake::known_commands} {
-    puts stderr "Unknown command: [lindex $commands_found 0]\n\n"
-    set do_help 1
-}
-if {$do_help} {
-    puts stderr [punkmake_gethelp] 
-    exit 0
-}
-
-set ::punkmake::command [lindex $commands_found 0]
-
-
-if {[lsearch $::argv -k] >= 0} {
-    set forcekill 1
-} else {
-    set forcekill 0
-}
-#puts stdout "::argv  $::argv"
-# ----------------------------------------
-
-set scriptfolder $::punkmake::scriptfolder
-
-
-
-#first look for a project root (something under fossil or git revision control AND matches punk project folder structure)
-#If that fails - just look for a 'project shaped folder' ie meets minimum requirements of /src /src/lib /src/modules /lib /modules
-if {![string length [set projectroot [punk::repo::find_project $scriptfolder]]]} {
-    if {![string length [set projectroot [punk::repo::find_candidate $scriptfolder]]]} {
-        puts stderr "punkmake script unable to determine an approprite project root at or above the path '$scriptfolder' ensure the make script is within a project folder structure"
-        puts stderr " -aborted- "
-        exit 2
-        #todo?
-        #ask user for a project name and create basic structure?
-        #call punk::mix::cli::new $projectname on parent folder?
-    } else {
-        puts stderr "WARNING punkmake script operating in project space that is not under version control"
-    }
-} else {
-    
-}
-
-set sourcefolder $projectroot/src
-
-if {$::punkmake::command eq "get-project-info"} {
-    puts stdout "- -- --- --- --- --- --- --- --- --- ---"
-    puts stdout "- -- get-project-info -- -"
-    puts stdout "- -- --- --- --- --- --- --- --- --- ---"
-    puts stdout "- projectroot     : $projectroot"
-    if {[punk::repo::find_fossil $scriptfolder] eq $projectroot} {
-        set vc "fossil"
-        set rev [punk::repo::fossil_revision $scriptfolder]
-        set rem [punk::repo::fossil_remote $scriptfolder]
-    } elseif {[punk::repo::find_git $scriptfolder] eq $projectroot} {
-        set vc "git"
-        set rev [punk::repo::git_revision $scriptfolder]
-        set rem [punk::repo::git_remote  $scriptfolder]
-    } else {
-        set vc " - none found -"
-        set rev "n/a"
-        set remotes "n/a"
-    }
-    puts stdout "- version control : $vc"
-    puts stdout "- revision        : $rev"
-    puts stdout "- remote          : $rem"
-    puts stdout "- -- --- --- --- --- --- --- --- --- ---"
-
-    exit 0
-}
-
-if {$::punkmake::command eq "shell"} {
-    package require punk
-    package require punk::repl
-    puts stderr "make shell not fully implemented - dropping into ordinary punk shell"
-    repl::start stdin
-
-    exit 1
-}
-
-if {$::punkmake::command eq "bootsupport"} {
-    puts "projectroot: $projectroot"
-    puts "script: [info script]"
-    #puts "-- [tcl::tm::list] --"
-    puts stdout "Updating bootsupport from local files"
-
-    proc bootsupport_localupdate {projectroot} {
-        set bootsupport_modules [list]
-        set bootsupport_module_folders [list]
-        set bootsupport_config  $projectroot/src/bootsupport/include_modules.config ;#
-        if {[file exists $bootsupport_config]} {
-            set targetroot $projectroot/src/bootsupport/modules
-            source $bootsupport_config ;#populate $bootsupport_modules with project-specific list
-            if {![llength $bootsupport_modules]} {
-                puts stderr "No local bootsupport modules configured for updating"
-            } else {
-
-                if {[catch {
-                    #----------
-                    set boot_installer [punkcheck::installtrack new make.tcl $projectroot/src/bootsupport/.punkcheck]
-                    $boot_installer set_source_target $projectroot $projectroot/src/bootsupport
-                    set boot_event [$boot_installer start_event {-make_step bootsupport}]
-                    #----------
-                } errM]} {
-                    puts stderr "Unable to use punkcheck for bootsupport error: $errM"
-                    set boot_event ""
-                }
-
-                foreach {relpath module} $bootsupport_modules {
-                    set module [string trim $module :]
-                    set module_subpath [string map [list :: /] [namespace qualifiers $module]]
-                    set srclocation [file join $projectroot $relpath $module_subpath]
-                    #puts stdout "$relpath  $module $module_subpath $srclocation"
-                    set pkgmatches [glob -nocomplain -dir $srclocation -tail [namespace tail $module]-*]
-                    #lsort won't sort version numbers properly e.g with -dictionary 0.1.1 comes before 0.1
-                    if {![llength $pkgmatches]} {
-                        puts stderr "Missing source for bootsupport module $module - not found in $srclocation"
-                        continue
-                    }
-                    set latestfile [lindex $pkgmatches 0]
-                    set latestver [lindex [split [file rootname $latestfile] -] 1]
-                    foreach m $pkgmatches {
-                        lassign [split [file rootname $m] -] _pkg ver
-                        #puts "comparing $ver vs $latestver"
-                        if {[package vcompare $ver $latestver] == 1} {
-                            set latestver $ver
-                            set latestfile $m
-                        } 
-                    }
-                    set srcfile [file join $srclocation $latestfile]
-                    set tgtfile [file join $targetroot $module_subpath $latestfile]
-                    if {$boot_event ne ""} {
-                        #----------
-                        $boot_event targetset_init INSTALL   $tgtfile
-                        $boot_event targetset_addsource      $srcfile
-                        #----------
-                        if {\
-                                [llength [dict get [$boot_event targetset_source_changes] changed]]\
-                            || [llength [$boot_event get_targets_exist]] < [llength [$boot_event get_targets]]\
-                            } {
-                            file mkdir [file dirname $tgtfile] ;#ensure containing folder for target exists
-                            $boot_event targetset_started
-                            # -- --- --- --- --- ---
-                            puts "BOOTSUPPORT update: $srcfile -> $tgtfile"
-                            if {[catch {
-                                file copy -force $srcfile  $tgtfile
-                            } errM]} {
-                                $boot_event targetset_end FAILED
-                            } else {
-                                $boot_event targetset_end OK
-                            }
-                            # -- --- --- --- --- ---
-                        } else {
-                            puts -nonewline stderr "."
-                            $boot_event targetset_end SKIPPED
-                        }
-                        $boot_event end
-                    } else {
-                        file copy -force $srcfile  $tgtfile
-                    }
-                }
-                if {$boot_event ne ""} {
-                    puts \n
-                    $boot_event destroy
-                    $boot_installer destroy
-                }
-            }
-
-            foreach folder $bootsupport_module_folders {
-                #explicitly ignore punk/mix/templates folder even if specified in config. 
-                #punk/mix/templates contains modules including punk/mix/templates itself - the actual templates aren't needed for the bootsupport system,
-                # as make.tcl shouldn't be building new projects from the one being made.
-                #review.
-                #should we be autodetecting such recursive folder structures - (or is the bootsupport copying in need of a rethink?)
-                if {[string trim $folder /] eq "punk/mix/templates"} {
-                    puts stderr "IGNORING punk/mix/templates - not needed/desirable in bootsupport"
-                    continue
-                }
-                set src [file join $projectroot/modules $folder]
-                if {![file isdirectory $src]} {
-                    puts stderr "bootsupport folder not found: $src"
-                    continue
-                }
-                set tgt [file join $targetroot $folder]
-                file mkdir $tgt
-
-                puts stdout "BOOTSUPPORT non_tm_files $src - copying to $tgt (if source file changed)"
-                set overwrite "installedsourcechanged-targets"
-                set resultdict [punkcheck::install_non_tm_files $src $tgt -installer make.tcl -overwrite $overwrite -punkcheck_folder $projectroot/src/bootsupport]
-                puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-            }
-
-        }
-    }
-
-    bootsupport_localupdate $projectroot
-
-    #/modules/punk/mix/templates/layouts only applies if the project has it's own copy of the punk/mix modules. Generally this should only apply to the punkshell project itself.
-    set layout_bases [list\
-        $sourcefolder/mixtemplates/layouts\
-        $sourcefolder/modules/punk/mix/templates/layouts\
-    ]
-    foreach project_layout_base $layout_bases {
-        if {[file exists $project_layout_base]} {
-            set project_layouts [glob -nocomplain -dir $project_layout_base -type d -tail *]
-            foreach layoutname $project_layouts {
-                if {[file exists  [file join $project_layout_base $layoutname/src/bootsupport]]} {
-                    set antipaths [list\
-                        README.md\
-                    ]
-                    set sourcemodules $projectroot/src/bootsupport/modules
-                    set targetroot [file join $project_layout_base $layoutname/src/bootsupport/modules]
-                    file mkdir $targetroot
-
-                    puts stdout "BOOTSUPPORT layouts/$layoutname: copying from $sourcemodules to $targetroot (if source file changed)"
-                    set resultdict [punkcheck::install $sourcemodules $targetroot -overwrite installedsourcechanged-targets -antiglob_paths $antipaths]
-                    puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-                    flush stdout
-                }
-            }
-        } else {
-            puts stderr "No layout base at $project_layout_base"
-        }
-    }
-    puts stdout " bootsupport done "
-    flush stderr
-    flush stdout
-    #punk86 can hang if calling make.tcl via 'run' without this 'after' delay. punk87 unaffected. cause unknown.
-    #after 500
-    ::exit 0
-}
-
-
-
-if {$::punkmake::command ne "project"} {
-    puts stderr "Command $::punkmake::command not implemented - aborting."
-    flush stderr
-    after 100
-    exit 1
-}
-
-
-
-#only a single consolidated /modules folder used for target
-set target_modules_base $projectroot/modules
-file mkdir $target_modules_base
-
-#external libs and modules first - and any supporting files - no 'building' required
-if {[file exists $sourcefolder/vendorlib]} {
-    #exclude README.md from source folder - but only the root one
-    #-antiglob_paths takes relative patterns e.g
-    # */test.txt  will only match test.txt exactly one level deep.
-    # */*/*.foo will match any path ending in .foo that is exactly 2 levels deep.
-    # **/test.txt will match at any level below the root (but not in the root)
-    set antipaths [list\
-        README.md\
-    ]
-
-    puts stdout "VENDORLIB: copying from $sourcefolder/vendorlib to $projectroot/lib (if source file changed)"
-    set resultdict [punkcheck::install $sourcefolder/vendorlib $projectroot/lib -overwrite installedsourcechanged-targets -antiglob_paths $antipaths]
-    puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-} else {
-    puts stderr "VENDORLIB: No src/vendorlib folder found."
-}
-
-if {[file exists $sourcefolder/vendormodules]} {
-    #install .tm *and other files*
-    puts stdout "VENDORMODULES: copying from $sourcefolder/vendormodules to $target_modules_base (if source file changed)"
-    set resultdict [punkcheck::install $sourcefolder/vendormodules  $target_modules_base -installer make.tcl -overwrite installedsourcechanged-targets -antiglob_paths {README.md}]
-    puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-} else {
-    puts stderr "VENDORMODULES: No src/vendormodules folder found."
-}
-
-########################################################
-#templates
-#e.g The default project layout is mainly folder structure and readme files - but has some scripts developed under the main src that we want to sync
-#src to  src/modules/punk/mix/templates/layouts/project/src
-
-set layout_update_list    [list\
-    [list project $sourcefolder/modules/punk/mix/templates]\
-    [list basic $sourcefolder/mixtemplates]\
-    ]  
-
-foreach layoutinfo $layout_update_list {
-    lassign $layoutinfo layout templatebase
-    if {![file exists $templatebase]} {
-        continue
-    }
-    set config [dict create\
-        -make-step sync_templates\
-    ]
-    #----------
-    set tpl_installer [punkcheck::installtrack new make.tcl $templatebase/.punkcheck]
-    $tpl_installer set_source_target $sourcefolder $templatebase
-    set tpl_event [$tpl_installer start_event $config]
-    #----------
-    set pairs [list]
-    set pairs [list\
-        [list $sourcefolder/build.tcl  $templatebase/layouts/$layout/src/build.tcl]\
-        [list $sourcefolder/make.tcl  $templatebase/layouts/$layout/src/make.tcl]\
-    ]
-
-    foreach filepair $pairs {
-        lassign $filepair srcfile tgtfile
-        file mkdir [file dirname $tgtfile]
-        #----------
-        $tpl_event targetset_init INSTALL   $tgtfile
-        $tpl_event targetset_addsource      $srcfile
-        #----------
-        if {\
-               [llength [dict get [$tpl_event targetset_source_changes] changed]]\
-            || [llength [$tpl_event get_targets_exist]] < [llength [$tpl_event get_targets]]\
-            } {
-            $tpl_event targetset_started
-            # -- --- --- --- --- ---
-            puts stdout "punk module templates: Copying from $srcfile to $tgtfile"
-            if {[catch {
-                file copy -force $srcfile $tgtfile
-            } errM]} {
-                $tpl_event targetset_end FAILED -note "copy failed with err: $errM"
-            } else {
-                $tpl_event targetset_end OK -note "test"
-            }
-            # -- --- --- --- --- ---
-        } else {
-            puts stderr "."
-            $tpl_event targetset_end SKIPPED
-        }
-    }
-
-    $tpl_event end
-    $tpl_event destroy
-    $tpl_installer destroy
-}
-########################################################
-
-
-#default source module folder is at projectroot/src/modules
-#There may be multiple other src module folders at same level (e.g folder not being other special-purpose folder and not matching name vendor* that contains at least one .tm file in its root) 
-set source_module_folderlist [punk::mix::cli::lib::find_source_module_paths $projectroot]
-foreach src_module_dir $source_module_folderlist {
-    puts stderr "Processing source module dir: $src_module_dir"
-    set dirtail [file tail $src_module_dir]
-    #modules and associated files belonging to this package/app
-    set copied [punk::mix::cli::lib::build_modules_from_source_to_base $src_module_dir $target_modules_base -glob *.tm] ;#will only accept a glob ending in .tm
-    #set copied [list]
-    puts stdout "--------------------------"
-    puts stderr "Copied [llength $copied] tm modules from src/$dirtail to $target_modules_base "
-    puts stdout "--------------------------"
-
-    set overwrite "installedsourcechanged-targets"
-    #set overwrite "ALL-TARGETS"
-    puts stdout "MODULEFOLDER non_tm_files $src_module_dir - copying to $target_modules_base (if source file changed)"
-    set resultdict [punkcheck::install_non_tm_files $src_module_dir $target_modules_base -installer make.tcl -overwrite $overwrite -antiglob_paths {README.md}]
-    puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-}
-
-set installername "make.tcl"
-
-# ----------------------------------------
-if {[punk::repo::is_fossil_root $projectroot]} {
-    set config [dict create\
-        -make-step configure_fossil\
-    ]
-    #----------
-    set installer [punkcheck::installtrack new $installername $projectroot/.punkcheck]
-    $installer set_source_target $projectroot $projectroot
-
-    set event [$installer start_event $config]
-    $event targetset_init VIRTUAL fossil_settings_mainmenu ;#VIRTUAL - since there is no actual target file
-    set menufile $projectroot/.fossil-custom/mainmenu
-    $event targetset_addsource $menufile
-    #----------
-
-    if {\
-            [llength [dict get [$event targetset_source_changes] changed]]\
-        } {
-        $event targetset_started
-        # -- --- --- --- --- ---
-        puts stdout "Configuring fossil setting: mainmenu from: $menufile"
-        if {[catch {
-            set fd [open $menufile r]
-            fconfigure $fd -translation binary
-            set data [read $fd]
-            close $fd
-            exec fossil settings mainmenu $data
-        } errM]} {
-            $event targetset_end FAILED -note "fossil update failed: $errM"
-        } else {
-            $event targetset_end OK
-        }
-        # -- --- --- --- --- ---
-    } else {
-        puts stderr "."
-        $event targetset_end SKIPPED
-    }
-    $event end
-    $event destroy
-    $installer destroy
-}
-
-set buildfolder [punk::mix::cli::lib::get_build_workdir $sourcefolder]
-if {$buildfolder ne "$sourcefolder/_build"} {
-    puts stderr "$sourcefolder/_build doesn't match the project buildfolder $buildfolder - check project filestructure"
-    puts stdout " -aborted- "
-    exit 2
-}
-
-
-#find runtimes
-set rtfolder $sourcefolder/runtime
-set runtimes [glob -nocomplain -dir $rtfolder -types {f x} -tail *]
-if {![llength $runtimes]} {
-    puts stderr "No executable runtimes found in $rtfolder - unable to build any .vfs folders into executables."
-    puts stderr "Add runtimes to $sourcefolder/runtime if required"
-    exit 0
-}
-
-if {[catch {exec sdx help} errM]} {
-    puts stderr "FAILED to find usable sdx command - check that sdx executable is on path"
-    puts stderr "err: $errM"
-    exit 1
-}
-
-# -- --- --- --- --- --- --- --- --- ---
-#load mapvfs.config file (if any) in runtime folder to map runtimes to vfs folders.
-#build a dict keyed on runtime executable name. 
-#If no mapfile (or no mapfile entry for that runtime) - the runtime will be paired with a matching .vfs folder in src folder.  e.g punk.exe to src/punk.vfs
-#If vfs folders or runtime executables which are explicitly listed in the mapfile don't exist - warn on stderr - but continue. if such nonexistants found; prompt user for whether to continue or abort.
-set mapfile $rtfolder/mapvfs.config
-set runtime_vfs_map [dict create]
-set vfs_runtime_map [dict create]
-if {[file exists $mapfile]} {
-    set fdmap [open $mapfile r]
-    fconfigure $fdmap -translation binary
-    set mapdata [read $fdmap]
-    close $fdmap
-    set mapdata [string map [list \r\n \n] $mapdata]
-    set missing [list]
-    foreach ln [split $mapdata \n] {
-        set ln [string trim $ln]
-        if {$ln eq "" || [string match #* $ln]} {
-            continue
-        }
-        set vfspaths [lassign $ln runtime]
-        if {[string match *.exe $runtime]} {
-            #.exe is superfluous but allowed
-            #drop windows .exe suffix so same config can work cross platform - extension will be re-added if necessary later
-            set runtime [string range $runtime 0 end-4]
-        }
-        if {$runtime ne "-"} {
-            set runtime_test $runtime
-            if {"windows" eq $::tcl_platform(platform)} {
-                set runtime_test $runtime.exe
-            }
-            if {![file exists [file join $rtfolder $runtime_test]]} {
-                puts stderr "WARNING: Missing runtime file $rtfolder/$runtime_test (line in mapvfs.config: $ln)"
-                lappend missing $runtime
-            }
-        }
-        foreach vfs $vfspaths {
-            if {![file isdirectory [file join $sourcefolder $vfs]]} {
-                puts stderr "WARNNING: Missing vfs folder [file join $sourcefolder $vfs] specified in mapvfs.config for runtime $runtime"
-                lappend missing $vfs
-            } 
-            dict lappend vfs_runtime_map $vfs $runtime
-        }
-        if {[dict exists $runtime_vfs_map $runtime]} {
-            puts stderr "CONFIG FILE ERROR. runtime: $runtime was specified more than once in $mapfile."
-            exit 3
-        }
-        dict set runtime_vfs_map $runtime $vfspaths
-    }
-    if {[llength $missing]} {
-        puts stderr "WARNING [llength $missing] missing items from $mapfile. (TODO - prompt user to continue/abort)"
-        foreach m $missing {
-            puts stderr "    $m"
-        }
-        puts stderr "continuing..."
-    }
-}
-# -- --- --- --- --- --- --- --- --- ---
-
-set vfs_folders [glob -nocomplain -dir $sourcefolder -types d -tail *.vfs]
-#add any extra .vfs folders found in runtime/mapvfs.config file (e.g myotherruntimes/something.vfs)
-foreach vfs [dict keys $vfs_runtime_map] {
-    if {$vfs ni $vfs_folders} {
-        lappend vfs_folders $vfs
-    }
-}
-if {![llength $vfs_folders]} {
-    puts stdout "No .vfs folders found at '$sourcefolder' - no kits to build"
-    puts stdout " -done- "
-    exit 0
-}
-
-set vfs_folder_changes [dict create] ;#cache whether each .vfs folder has changes so we don't re-run tests if building from same .vfs with multiple runtime executables
-
-# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-#set runtimefile [lindex $runtimes 0]
-foreach  runtimefile $runtimes {
-    #runtimefile e.g tclkit86bi.exe on windows tclkit86bi on other platforms
-
-    #sdx *may* be pointed to use the runtime we use to build the kit, or the user may manually use this runtime if they don't have tclsh
-    #sdx will complain if the same runtime is used for the shell as is used in the -runtime argument - so we make a copy (REVIEW)
-    #if {![file exists $buildfolder/buildruntime.exe]} {
-    #    file copy $rtfolder/$runtimefile $buildfolder/buildruntime.exe
-    #}
-
-    set basedir $buildfolder
-    set config [dict create\
-        -make-step copy_runtime\
-    ]
-    #----------
-    set installer [punkcheck::installtrack new $installername $basedir/.punkcheck]
-    $installer set_source_target $rtfolder $buildfolder
-    set event [$installer start_event $config]
-    $event targetset_init INSTALL $buildfolder/build_$runtimefile
-    $event targetset_addsource $rtfolder/$runtimefile
-    #----------
-
-    #set changed_unchanged [punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $file_record body] end]]
-    if {\
-            [llength [dict get [$event targetset_source_changes] changed]]\
-         || [llength [$event get_targets_exist]] < [llength [$event get_targets]]\
-        } {
-        $event targetset_started
-        # -- --- --- --- --- ---
-        puts stdout "Copying runtime from $rtfolder/$runtimefile to $buildfolder/build_$runtimefile"
-        if {[catch {
-            file copy -force $rtfolder/$runtimefile $buildfolder/build_$runtimefile
-        } errM]} {
-            $event targetset_end FAILED
-        } else {
-            $event targetset_end OK
-        }
-        # -- --- --- --- --- ---
-    } else {
-        puts stderr "."
-        $event targetset_end SKIPPED
-    }
-    $event end
-
-}
-
-# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-#
-# loop over vfs_folders and for each one, loop over configured (or matching)  runtimes - build with sdx if source .vfs or source runtime exe has changed.
-# we are using punkcheck to install result to buildfolder so we create a .punkcheck file at the target folder to store metadata.
-# punkcheck allows us to not rely purely on timestamps (which may be unreliable)  
-#
-set startdir [pwd]
-puts stdout "Found [llength $vfs_folders] .vfs folders - building executable for each..."
-cd [file dirname $buildfolder] 
-#root folder mtime is insufficient for change detection. Tree mtime of folders only is a barely  passable mechanism for vfs change detection in some circumstances - e.g if files added/removed but never edited in place
-#a hash of full tree file & dir mtime may be more reasonable - but it remains to be seen if just tar & checksum is any/much slower.
-#Simply rebuilding all the time may be close the speed of detecting change anyway - and almost certainly much faster when there is a change.
-#Using first mtime encountered that is later than target is another option - but likely to be highly variable in speed. Last file in the tree could happen to be the latest, and this mechanism doesn't handle build on reversion to older source.
-set exe_names_seen [list]
-foreach vfs $vfs_folders {
-    
-    set vfsname [file rootname $vfs]
-    puts stdout "  Processing vfs $sourcefolder/$vfs"
-    puts stdout "  ------------------------------------"
-    set skipped_vfs_build 0
-    # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    set basedir $buildfolder
-    set config [dict create\
-        -make-step build_vfs\
-    ]
-
-    set runtimes  [list]
-    if {[dict exists $vfs_runtime_map $vfs]} {
-        set runtimes [dict get $vfs_runtime_map $vfs] ;#map dict is unsuffixed (.exe stripped or was not present)
-        if {"windows" eq $::tcl_platform(platform)} {
-            set runtimes_raw $runtimes
-            set runtimes [list]
-            foreach rt $runtimes_raw {
-                if {![string match *.exe $rt] && $rt ne "-"} {
-                    set rt $rt.exe
-                }
-                lappend runtimes $rt
-            }
-        }
-    } else {
-        #only match this vfs to a correspondingly named runtime if there was no explicit entry for that runtime
-        set matchrt [file rootname [file tail $vfs]] ;#e.g project.vfs -> project
-        if {![dict exists $runtime_vfs_map $matchrt]} {
-            if {"windows" eq $::tcl_platform(platform)} {
-                if {[file exists $rtfolder/$matchrt.exe]} {
-                    lappend runtimes $matchrt.exe
-                }
-            } else {
-                lappend runtimes $matchrt
-            }
-        }   
-    }
-    #assert $runtimes is a list of executable names suffixed with .exe if on windows - whether or not specified with .exe in the mapvfs.config
-
-
-    #todo - non kit based - zipkit?
-    # $runtimes may now include a dash entry "-" (from mapvfs.config file)
-    foreach rtname $runtimes {
-        #rtname of "-" indicates build a kit without a runtime
-
-        #first configured runtime will be the one to use the same name as .vfs folder for output executable. Additional runtimes on this .vfs will need to suffix the runtime name to disambiguate.
-        #review: This mechanism may not be great for multiplatform builds ? We may be better off consistently combining vfsname and rtname and letting a later platform-specific step choose ones to install in bin with simpler names.
-        if {$rtname eq "-"} {
-            set targetkit $vfsname.kit
-        } else {
-            if {$::tcl_platform(platform) eq "windows"} {
-                set targetkit ${vfsname}.exe
-            } else {
-                set targetkit $vfsname
-            }
-            if {$targetkit in $exe_names_seen} {
-                #more than one runtime for this .vfs 
-                set targetkit ${vfsname}_$rtname
-            }
-        }
-        lappend exe_names_seen $targetkit
-        # -- ----------
-        set vfs_installer [punkcheck::installtrack new $installername $basedir/.punkcheck]
-        $vfs_installer set_source_target $sourcefolder $buildfolder
-        set vfs_event [$vfs_installer start_event {-make-step build_vfs}]
-        $vfs_event targetset_init INSTALL $buildfolder/$targetkit
-        $vfs_event targetset_addsource $sourcefolder/$vfs
-        if {$rtname ne "-"} {
-            $vfs_event targetset_addsource $buildfolder/build_$rtname
-        }
-        # -- ----------
-
-        set changed_unchanged [$vfs_event targetset_source_changes]
-
-        if {[llength [dict get $changed_unchanged changed]] ||  [llength [$vfs_event get_targets_exist]] < [llength [$vfs_event get_targets]]} {
-            #source .vfs folder has changes
-            $vfs_event targetset_started
-            # -- --- --- --- --- ---
-
-            #use 
-            if {[file exists $buildfolder/$vfsname.new]} {
-                puts stderr "deleting existing $buildfolder/$vfsname.new"
-                file delete $buildfolder/$vfsname.new
-            }
-
-            puts stdout "building $vfsname with sdx.. vfsdir:$vfs cwd: [pwd]"
-
-
-            if {[catch {
-                if {$rtname ne "-"} {
-                    exec sdx wrap $buildfolder/$vfsname.new -vfs $sourcefolder/$vfs -runtime $buildfolder/build_$rtname -verbose
-                } else {
-                    exec sdx wrap $buildfolder/$vfsname.new -vfs $sourcefolder/$vfs  -verbose
-                }
-                } result]} {
-                if {$rtname ne "-"} {
-                    puts stderr "sdx wrap $buildfolder/$vfsname.new -vfs $sourcefolder/$vfs -runtime $buildfolder/build_$rtname -verbose failed with msg: $result"
-                } else {
-                    puts stderr "sdx wrap $buildfolder/$vfsname.new -vfs $sourcefolder/$vfs  -verbose failed with msg: $result"
-                }
-            } else {
-                puts stdout "ok - finished sdx"
-                set separator [string repeat = 40]
-                puts stdout $separator
-                puts stdout $result
-                puts stdout $separator
-            }
-
-            if {![file exists $buildfolder/$vfsname.new]} {
-                puts stderr "|err> make.tcl build didn't seem to produce output at $sourcefolder/_build/$vfsname.new"
-                $vfs_event targetset_end FAILED
-                exit 2
-            }
-
-            # -- --- ---
-            if {$::tcl_platform(platform) eq "windows"} {
-                set pscmd "tasklist"
-            } else {
-                set pscmd "ps"
-            }
-
-            #killing process doesn't apply to .kit build 
-            if {$rtname ne "-"} {
-                if {![catch {
-                        exec $pscmd | grep $vfsname
-                    } still_running]} {
-
-                    puts stdout "found $vfsname instances still running\n"
-                    set count_killed 0
-                    foreach ln [split $still_running \n] {
-                        puts stdout "    $ln"
-                        
-                        if {$::tcl_platform(platform) eq "windows"} {
-                            set pid [lindex $ln 1]
-                            if {$forcekill} {
-                                set killcmd [list taskkill /F /PID $pid]
-                            } else {
-                                set killcmd [list taskkill /PID $pid]
-                            }
-                        } else {
-                            set pid [lindex $ln 0]
-                            #review!
-                            if {$forcekill} {
-                                set killcmd [list kill -9 $pid]
-                            } else {
-                                set killcmd [list kill $pid]
-                            }
-                        }
-                        puts stdout "    pid: $pid (attempting to kill now using '$killcmd')"
-                        if {[catch {
-                                exec {*}$killcmd
-                                } errMsg]} {
-                            puts stderr "$killcmd returned an error:"
-                            puts stderr $errMsg
-                            if {!$forcekill} {
-                                puts stderr "(try '[info script] -k' option to force kill)"
-                            }
-                            #avoid exiting if the kill failure was because the task has already exited
-                            #review - *no running instance* works with windows taskkill - "*No such process*" works with kill -9 on FreeBSD and linux - other platforms?
-                            if {![string match "*no running instance*" $errMsg] && ![string match "*No such process*" $errMsg]} {
-                                exit 4
-                            }
-                        } else {
-                            puts stderr "$killcmd ran without error"
-                            incr count_killed
-                        }
-                    }
-                    if {$count_killed > 0} {
-                        puts stderr "\nKilled $count_killed processes. Waiting a short time before attempting to delete executable"
-                        after 1000
-                    }
-                } else {
-                    puts stderr "Ok.. no running '$vfsname' processes found"
-                }
-            }
-
-            if {[file exists $buildfolder/$targetkit]} {
-                puts stderr "deleting existing $buildfolder/$targetkit"
-                if {[catch {
-                    file delete $buildfolder/$targetkit
-                } msg]} {
-                    puts stderr "Failed to delete $buildfolder/$targetkit"
-                    exit 4
-                }
-            }
-            #WINDOWS filesystem 'tunneling' (file replacement within 15secs) could cause targetkit to copy ctime & shortname metadata from previous file!
-            #This is probably harmless - but worth being aware of.
-            file rename $buildfolder/$vfsname.new $buildfolder/$targetkit
-            # -- --- --- --- --- ---
-            $vfs_event targetset_end OK
-
-
-            after 200
-            set deployment_folder [file dirname $sourcefolder]/bin
-            file mkdir $deployment_folder
-
-            # -- ----------
-            set bin_installer [punkcheck::installtrack new "make.tcl" $deployment_folder/.punkcheck]
-            $bin_installer set_source_target $buildfolder $deployment_folder
-            set bin_event [$bin_installer start_event {-make-step final_kit_install}]
-            $bin_event targetset_init INSTALL $deployment_folder/$targetkit
-            #todo - move final deployment step outside of the build vfs loop? (final deployment can fail and then isn't rerun even though _build and deployed versions differ, unless .vfs modified again)
-            #set last_completion [$bin_event targetset_last_complete]
-
-            $bin_event targetset_addsource $buildfolder/$targetkit
-            $bin_event targetset_started
-            # -- ----------
-
-
-            set delete_failed 0
-            if {[file exists $deployment_folder/$targetkit]} {
-                puts stderr "deleting existing deployed at $deployment_folder/$targetkit"
-                if {[catch {
-                    file delete $deployment_folder/$targetkit
-                    } errMsg]} {
-                    puts stderr "deletion of deployed version at $deployment_folder/$targetkit failed: $errMsg"
-                    set delete_failed 1
-                }
-            }
-            if {!$delete_failed} {
-                puts stdout "copying.."
-                puts stdout "$buildfolder/$targetkit"
-                puts stdout "to:"
-                puts stdout "$deployment_folder/$targetkit"
-                after 300
-                file copy $buildfolder/$targetkit $deployment_folder/$targetkit
-                # -- ----------
-                $bin_event targetset_end OK
-                # -- ----------
-            } else {
-                $bin_event targetset_end FAILED -note "could not delete"
-                exit 5
-            }
-            $bin_event destroy
-            $bin_installer destroy
-
-        } else {
-            set skipped_vfs_build 1
-            puts stderr "."
-            puts stdout "Skipping build for vfs $vfs with runtime $rtname - no change detected"
-            $vfs_event targetset_end SKIPPED
-        }
-        $vfs_event destroy
-        $vfs_installer destroy
-    } ;#end foreach rtname in runtimes
-    # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-}
-cd $startdir
-
-puts stdout "done"
-exit 0
-
-
diff --git a/src/modules/flagfilter-0.3.tm b/src/modules/flagfilter-0.3.tm
index ac7d833d..cae485f9 100644
--- a/src/modules/flagfilter-0.3.tm
+++ b/src/modules/flagfilter-0.3.tm
@@ -2126,7 +2126,7 @@ namespace eval flagfilter {
         if {[llength $required]} {
             if {[lsearch -nocase $keywords_in_required "all"] >= 0} {
                 #'all' can be present with other flags - and indicates we also require all the flags from -defaults
-                foreach k [dict keys $defaults] {
+                dict for {k -} $defaults {
                     if {$k ni $calc_required} {
                         lappend calc_required $k
                     }
@@ -2489,7 +2489,7 @@ namespace eval flagfilter {
             set tail_unallocated [list]
         }
         set extraflags [list]
-        #set extraflags [dict_merge_ordered $defaults $tail_unallocated]
+        #set extraflags [punk::lib::dict_merge_ordered $defaults $tail_unallocated]
         #dict merge based operation can't work if there are solo_flags 
         if {[llength $tail_unallocated]} {
             for {set i $a} {$i <=$b} {incr i} {
@@ -2532,7 +2532,7 @@ namespace eval flagfilter {
 
         set extraflags [list]
 
-        #set extraflags [dict_merge_ordered $defaults $tail_unallocated]
+        #set extraflags [punk::lib::dict_merge_ordered $defaults $tail_unallocated]
         #dict merge based operation can't work if there are solo_flags with no value set
         if {[llength $tail_unallocated]} {
             for {set i $a} {$i <=$b} {incr i} {
@@ -2571,24 +2571,7 @@ namespace eval flagfilter {
 
 namespace eval flagfilter {
 
-    #The standard dict merge accepts multiple dicts with values from dicts to the right taking precedence.
-    #When merging with a dict of default values - this means that any default key/vals that weren't in the main dict appear in the output before the main data.
-    #This function merges maintaining the key order of main followed by defaults.
-    proc dict_merge_ordered {defaults main} {
-      set keys [dict keys $main]
-      dict for {k v} $defaults {
-        if {$k ni $keys} {
-          lappend keys $k
-        }
-      }
-      #use normal merge mechanism - but then pick out values using our ordered key list
-      set combined_values [dict merge $defaults $main]
-      set merged [list]
-      foreach k $keys {
-        lappend merged $k [dict get $combined_values $k]
-      }
-      return $merged
-    }
+    #punk::lib::dict_merge_ordered
 
 
 
diff --git a/src/modules/patternpunk-1.1.tm b/src/modules/patternpunk-1.1.tm
index 742eec8e..a265858a 100644
--- a/src/modules/patternpunk-1.1.tm
+++ b/src/modules/patternpunk-1.1.tm
@@ -13,18 +13,14 @@
 
 package require pattern
 package require overtype
+package require punk::lib
 pattern::init
 
-package provide patternpunk  [namespace eval punk {
-    variable version 
-
-    set version 1.1
-}]
 
 
 ::>pattern .. Create ::>punk
 ::>punk .. Property license {Public Domain}
-::>punk .. Property logo2 {
+::>punk .. Property logo2 [string trim {
 +-----------------------+
 |     Pattern PUNK      |
 |   .      \\\_     .   |
@@ -35,8 +31,8 @@ package provide patternpunk  [namespace eval punk {
 |  .*.      / \    .=.  |
 |   .     _+   +_   .   |
 +-----------------------+
-}
-set ::punk::bannerTemplate {
+} \n]
+set ::punk::bannerTemplate [string trim {
 +-----------------------+
 |   .000000000000000.   |
 |  .*.     \\\_    .=.  |
@@ -47,7 +43,7 @@ set ::punk::bannerTemplate {
 |   .       / \     .   |
 |111111111_+   +_2222222|
 +-----------------------+
-}
+} \n]
 
 >punk .. Method banner {args} {
     set defaults [list -title "Pattern PUNK" -left "" -right ""]
@@ -68,7 +64,7 @@ set ::punk::bannerTemplate {
 >punk .. Property versionLogo 	[>punk . banner -left "  Ver" -right "$::punk::version  "]
 >punk .. Property version		$::punk::version
 
->punk .. Property front {
+>punk .. Property front [string trim {
    _|_   
   @ v @  
     ~    
@@ -76,8 +72,17 @@ set ::punk::bannerTemplate {
  |_\ /_| 
    / \   
  _+   +_ 
-}
->punk .. Property back {
+} \n]
+>punk .. Property front_2003 [string trim [string map [list % \u2003] {
+   _|_   
+  @%v%@  
+   %~%   
+  -%%%-  
+ |_\%/_| 
+   / \   
+ _+   +_ 
+}] \n]
+>punk .. Property back [string trim {
     |    
   ( | )  
     |    
@@ -85,8 +90,8 @@ set ::punk::bannerTemplate {
  |_\ /_| 
    / \   
  _-   -_ 
-}
->punk .. Property rhs {
+} /n]
+>punk .. Property rhs [string trim {
    \\\_  
    \@  > 
     | ~  
@@ -94,14 +99,23 @@ set ::punk::bannerTemplate {
     \\ / 
     / \  
   _+   +_
-}
+} \n]
+>punk .. Property rhs_2003 [string trim [string map [list % \u2003] {
+   \\\_  
+   \@%%> 
+    |%~  
+\_-%%%-_ 
+    \\ / 
+    / \  
+  _+   +_
+}] \n]
 >punk .. Property right
 >punk .. PropertyRead right {} {
     return $o_rhs
 }
 
 
->punk .. Property lhs {
+>punk .. Property lhs [string trim {
   _///   
  <  @/   
   ~ |    
@@ -109,13 +123,22 @@ set ::punk::bannerTemplate {
  \ //    
   / \    
 _+   +_  
-}
+} \n]
+>punk .. Property lhs_2003 [string trim [string map [list % \u2003] {
+  _///   
+ <%%@/   
+  ~%|    
+ _-%%%-_/
+ \ //    
+  / \    
+_+   +_  
+}] \n]
 >punk .. Property left
 >punk .. PropertyRead left {} {
     return $o_lhs
 }
 
->punk .. Property rhs_air {
+>punk .. Property rhs_air [string trim {
    \\\_  
    \@  > 
     | ~  
@@ -123,8 +146,8 @@ _+   +_
     \\   
     / \  
   _+   +_
-}
->punk .. Property lhs_air {
+} \n]
+>punk .. Property lhs_air [string trim {
   _///   
  <  @/   
   ~ |    
@@ -132,9 +155,9 @@ _+   +_
    //    
   / \    
 _+   +_  
-}
+} \n]
 
->punk .. Property lhs_hips {
+>punk .. Property lhs_hips [string trim {
    _///  
   <  @/  
    ~ |   
@@ -142,8 +165,8 @@ _+   +_
  \ | | / 
    / \   
  _+   +_ 
-}
->punk .. Property rhs_hips {
+} \n]
+>punk .. Property rhs_hips [string trim {
   \\\_   
   \@  >  
    | ~   
@@ -151,10 +174,10 @@ _+   +_
  \ | | / 
    / \   
  _+   +_ 
-}
+} \n]
 
 
->punk .. Property piss {
+>punk .. Property piss [string trim {
    \\\_      
    \@  >     
     | ~      
@@ -162,9 +185,9 @@ _+   +_
     \\_ ..   
     / \   .. 
   _+   +_   .
-}
+} \n]
 
->punk .. Property poop {
+>punk .. Property poop [string trim {
  _///    
 <  @/    
  ^ |     
@@ -172,9 +195,9 @@ _-   -_
  \ \\ /  
    //. ~ 
  _+_+ @  
-}
+} \n]
 
->punk .. Property fossil {
+>punk .. Property fossil [string trim {
   ..       
  > <       
  \ /  v    
@@ -182,46 +205,19 @@ v \\_/
  \/\\  v  .
 v_ /|\/  / 
      \__/  
-}
->punk .. Method gcross {{size 3}} {
-    if {$size % 2 == 0} {
-        incr size
-    }
-    package require punk::char
-    set x [punk::char::charshort boxd_ldc]
-    set bs [punk::char::charshort boxd_ldgullr]
-    set fs [punk::char::charshort boxd_ldgurll]
-
-    set armsize [expr {int(floor($size /2))}]
-    set row [lrepeat $size " "]    
-    #toparm
-    for {set i 0} {$i < $armsize} {incr i} {
-        set r $row
-        lset r $i $bs
-        lset r end-$i $fs
-        append out [join $r ""] \n
-    }
-
-    set r $row
-    lset r $armsize $x
-    append out [join $r ""] \n
-
-    for {set i [expr {$armsize -1}]} {$i >= 0} {incr i -1} {
-        set r $row
-        lset r $i $fs
-        lset r end-$i $bs
-        append out [join $r ""] \n
-    }
-
-    return $out
+} \n]
+>punk .. Method gcross {{size 1} args} {
+    package require textblock
+    textblock::gcross $size {*}$args
 }
 
 >punk .. Method dumpProperties {{object ::>punk}} {
+    set text ""
     foreach {p v} [$object .. Properties . pairs] {
-        puts $p
-        puts [set $v]
-        puts \n
+        append text $p \n
+        append text [set $v] \n \n
     }
+    return $text
 }
 >punk .. Method listProperties {{object ::>punk}} {
     set result {}
@@ -239,7 +235,7 @@ v_ /|\/  /
 #Cute names for file I/O
 proc <- filename {
     set fp [open $filename]
-    ::pattern::K [read $fp] [close $fp]
+    ::patternpunk:lib::K [read $fp] [close $fp]
 }
 proc -> {filename string} {
    set	fp	[open $filename w]
@@ -261,7 +257,14 @@ proc ->> {filename string} {
     uplevel #0 $args
 }
 ::> .. DefaultMethod item
+namespace eval patternpunk::lib {
+    proc K {x y} {return $x}
+}
+package provide patternpunk  [namespace eval patternpunk {
+    variable version 
 
+    set version 1.1
+}]
 #]]>
 #</code>
 #<files>
diff --git a/src/modules/punk-0.1.tm b/src/modules/punk-0.1.tm
index cee6a094..9ae10ec9 100644
--- a/src/modules/punk-0.1.tm
+++ b/src/modules/punk-0.1.tm
@@ -141,6 +141,7 @@ namespace eval punk {
         append str2 $str {}
         string length $str2
     }
+    #-----------------------------------------------------------------------------------
 
     #get a copy of the item without affecting internal rep
     proc objclone {obj} {
@@ -5105,10 +5106,6 @@ namespace eval punk {
 
     #namespace ensemble create
 
-    proc hasglobs {str} {
-        regexp {[*?]} [append obj2 $str {}] ;# int-rep preserving
-        #expr {[string first * $str]>=0 || [string first ? $str]>=0}
-    }
 
 
 
@@ -5237,8 +5234,8 @@ namespace eval punk {
 
 
     #dirfiles dirfiles_dict always deliberately return absolute *unnormalized* path
-    #e.g when cwd is c:/repo/jn/shellspy  dirfiles ../../  will return something like:
-    #    c:/repo/jn/shellspy/../../blah
+    #e.g when cwd is c:/repo/jn/punk  dirfiles ../../  will return something like:
+    #    c:/repo/jn/punk/../../blah
     #dirfiles assumes we don't have glob chars in the filenames or paths - dirfiles_dict can be called directly with explicit -tailglob in the rare case that assumption doesn't hold
     # dirfiles will test last segment (tail) of supplied searchspecs for fileness vs folderness (when no globchars present in tail) so that it can pass the appropriate flags downstream
     proc dirfiles {args} {
@@ -7098,7 +7095,7 @@ namespace eval punk {
     proc help_chunks {args} {
         set chunks [list]
         set linesep [string repeat - 76]
-        set mascotblock " "
+        set mascotblock ""
         catch {
             package require patternpunk
             #lappend chunks [list stderr [>punk . rhs]]
@@ -7131,7 +7128,7 @@ namespace eval punk {
 
         #todo - load from source code annotation?
         set cmdinfo [list]
-        lappend cmdinfo [list pmix       "(ensemble command to make new projects/modules and to generate docs)"]
+        lappend cmdinfo [list deck       "(ensemble command to make new projects/modules and to generate docs)"]
         lappend cmdinfo [list ./         "view/change directory"]
         lappend cmdinfo [list ../        "go up one directory"]
         lappend cmdinfo [list ./new      "make new directory and switch to it"]
@@ -7150,6 +7147,8 @@ namespace eval punk {
             append text "  [overtype::left $col1 $c][overtype::left $col2 $d]" \n
         }
 
+
+        if 0 {
         set indent "  "
         set sep    "  "
         if {[catch {
@@ -7164,15 +7163,20 @@ namespace eval punk {
                 ]\
                 $text\
             ]
-            }] } {
-                set introblock $text
-            }
-
-        lappend chunks [list stdout $introblock]
+        }] } {
+            set introblock $text
+        }
+        }
+        package require textblock
+        set introblock [textblock::join " " $mascotblock "  " $text]
+        #set introblock $text
 
         if {[punkrepl::has_script_var_bug]} {
-            append text "Has script var bug! (string rep for list variable in script generated when script changed)"
+            append introblock \n "minor warning: punkrepl::has_script_var_bug returned true! (string rep for list variable in script generated when script changed)"
         }
+
+        lappend chunks [list stdout $introblock]
+
         return $chunks
     }
     proc help {args} {
diff --git a/src/modules/punk/ansi-999999.0a1.0.tm b/src/modules/punk/ansi-999999.0a1.0.tm
index 242f58ab..53e8ee40 100644
--- a/src/modules/punk/ansi-999999.0a1.0.tm
+++ b/src/modules/punk/ansi-999999.0a1.0.tm
@@ -124,7 +124,7 @@ namespace eval punk::ansi {
     #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
     #The intent is that it's not rendered to the terminal - so on balance it seems best to strip it out. 
     #todo - review - printing_length calculations affected by whether terminal honours PMs or not. detect and accomodate.
-
+    #candidate for zig/c implementation?
     proc stripansi {text} {
         #*** !doctools
         #[call [fun stripansi] [arg text] ]
@@ -285,7 +285,7 @@ namespace eval punk::ansi {
                 set map1 [overtype::centre -transparent 1 $map1 "[a black $bgname]Standard colours[a]"]
                 set map2 [colourmap2 $bgname]
                 set map2 [overtype::centre -transparent 1 $map2 "[a black $bgname]High-intensity colours[a]"]
-                append out [textblock::join [textblock::join $map1 "   "] $map2] \n
+                append out [textblock::join $map1 "   " $map2] \n
                 #append out $map1[a] \n
                 #append out $map2[a] \n
 
@@ -596,6 +596,61 @@ namespace eval punk::ansi {
         #(doesn't work on many terminals - seems to work in FreeBSD 13.2 and wezterm on windows)
         return \x1b#8
     }
+    
+    #length of text for printing characters only
+    #review - unicode and other non-printing chars and combining sequences?
+    #certain unicode chars are full-width (single char 2 columns wide) e.g see "Halfwdith and fullwidth forms" and ascii_fuillwidth blocks in punk::char::charset_names
+    #review - is there an existing library or better method? print to a terminal and query cursor position?
+    #Note this length calculation is only suitable for lines being appended to other strings if the line is pre-processed to account for backspace and carriage returns first
+    #If the raw line is appended to another string without such processing - the backspaces & carriage returns can affect data prior to the start of the string. 
+    proc printing_length {line} {
+        if {[string first \n $line] >= 0} {
+            error "line_print_length must not contain newline characters"
+        }
+
+        #review - 
+        set line [punk::ansi::stripansi $line]
+
+        set line [punk::char::strip_nonprinting_ascii $line] ;#only strip nonprinting after stripansi - some like BEL are part of ansi
+        #backspace 0x08 only erases* printing characters anyway - so presumably order of processing doesn't matter
+        #(* more correctly - moves cursor back)
+        #backspace will not move beyond a preceding newline - but we have disallowed newlines for this function already
+        #leading backspaces will eat into any string (even prompt in non-standard tclsh shell) that is prepended to the line
+        # - but for the purposes of overtype we wouldn't want that - so we strip it here in the length calculation and should strip leading backspaces in the actual data concatenation operations too.
+        #curiously - a backspace sequence at the end of a string also doesn't reduce the printing width - so we can also strip from RHS
+
+        #Note that backspace following a \t will only shorten the string by one (ie it doesn't move back the whole tab width like it does interactively in the terminal)
+        #for this reason - it would seem best to normalize the tabs to spaces prior to performing the backspace calculation - otherwise we won't account for the 'short' tabs it effectivley produces
+        #normalize tabs to an appropriate* width
+        #*todo - handle terminal/context where tabwidth != the default 8 spaces
+        set line [textutil::tabify::untabify2 $line]
+
+        set bs [format %c 0x08]
+        #set line [string map [list "\r${bs}" "\r"] $line] ;#backsp following a \r will have no effect
+        set line [string trim $line $bs]
+        set n 0
+
+        set chars [split $line ""] 
+        #build an output 
+        set idx 0
+        set outchars [list]
+        set outsizes [list]
+        foreach c $chars {
+            if {$c eq $bs} {
+                if {$idx > 0} {
+                    incr idx -1
+                }
+            } elseif {$c eq "\r"} {
+                set idx 0
+            } else {
+                punk::ansi::internal::printing_length_addchar $idx $c
+                incr idx
+            }
+        }
+        set line2 [join $outchars ""]
+        return [punk::char::string_width $line2]
+    }
+
 
     #*** !doctools
     #[list_end] [comment {--- end definitions namespace punk::ansi ---}]
@@ -671,12 +726,13 @@ namespace eval punk::ansi {
     }
     namespace eval sequence_type {
         proc is_Fe {code} {
+            # C1 control codes
             if {[regexp {^\033\[[\u0040-\u005F]}]} {
                 #7bit - typical case
                 return 1
             }
             #8bit
-            #todo - all C1 escapes ? 0x80-0x90F
+            #review - all C1 escapes ? 0x80-0x90F
             #This is possibly problematic as it is affected by encoding.
             #According to https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
             #"However, in character encodings used on modern devices such as UTF-8 or CP-1252, those codes are often used for other purposes, so only the 2-byte sequence is typically used."
@@ -781,9 +837,9 @@ namespace eval punk::ansi::ta {
     }
     #todo - handle newlines
     #not in perl ta
-    proc printing_length {text} {
-
-    }
+    #proc printing_length {text} {
+    #
+    #}
 
     proc trunc {text width args} {
 
@@ -795,7 +851,7 @@ namespace eval punk::ansi::ta {
         variable re_esc_osc1
         variable re_esc_osc2
         variable re_csi_code
-        textutil::splitx $text "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
+        punk::ansi::internal::splitx $text "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
     }
     
     # -- --- --- --- --- --- 
@@ -893,6 +949,47 @@ namespace eval punk::ansi::internal {
         }
         return $result
     }
+    proc splitx {str {regexp {[\t \r\n]+}}} {
+        #from textutil::split::splitx
+        # Bugfix 476988
+        if {[string length $str] == 0} {
+            return {}
+        }
+        if {[string length $regexp] == 0} {
+            return [::split $str ""]
+        }
+        if {[regexp $regexp {}]} {
+            return -code error \
+            "splitting on regexp \"$regexp\" would cause infinite loop"
+        }
+        set list  {}
+        set start 0
+        while {[regexp -start $start -indices -- $regexp $str match submatch]} {
+            foreach {subStart subEnd} $submatch break
+            foreach {matchStart matchEnd} $match break
+            incr matchStart -1
+            incr matchEnd
+            lappend list [string range $str $start $matchStart]
+            if {$subStart >= $start} {
+                lappend list [string range $str $subStart $subEnd]
+            }
+            set start $matchEnd
+        }
+        lappend list [string range $str $start end]
+        return $list
+    }
+
+    proc printing_length_addchar {i c} {
+        upvar outchars outc 
+        upvar outsizes outs
+        set nxt [llength $outc] 
+        if {$i < $nxt} {
+            lset outc $i $c
+        } else {
+            lappend outc $c
+        }
+    }
+
     #string to 2digit hex - e.g used by XTGETTCAP
     proc str2hex {input} {
         set 2hex ""
diff --git a/src/modules/punk/args-999999.0a1.0.tm b/src/modules/punk/args-999999.0a1.0.tm
index f7dc4151..946aa3d4 100644
--- a/src/modules/punk/args-999999.0a1.0.tm
+++ b/src/modules/punk/args-999999.0a1.0.tm
@@ -155,7 +155,8 @@ namespace eval punk::args {
         #[para]ARGUMENTS:
         #[list_begin arguments]
         #[arg_def multiline-string optionspecs]
-        #[para] This a block of text with records delimited by newlines (lf or crlf)
+        #[para] This a block of text with records delimited by newlines (lf or crlf) - but with multiline values allowed if properly quoted/braced
+        #[para]'info complete' is used to determine if a record spans multiple lines due to multiline values
         #[para]Each optionspec line must be of the form:
         #[para]-optionname -key val -key2 val2...
         #[para]where the valid keys for each option specification are: -default -type -range -choices -optional 
@@ -164,6 +165,13 @@ namespace eval punk::args {
         #[list_end]
         #[para]
 
+        #consider line-processing example below for we need info complete to determine record boundaries 
+        #punk::args::opt_values {
+        #    -opt1 -default {}
+        #    -opt2 -default {
+        #        etc
+        #    } -multiple 1
+        #} $args
 
         set optionspecs [string map [list \r\n \n] $optionspecs]
         set known_argspecs [list -default -type -range -choices -nocase -optional -multiple -validate_without_ansi -allow_ansi -strip_ansi]
@@ -177,10 +185,24 @@ namespace eval punk::args {
         set required_opts [list]
         set required_vals [list]
         set arg_info [dict create]
-        set defaults_dict [dict create]
+        set defaults_dict_opts [dict create]
+        set defaults_dict_values [dict create]
         #first process dashed and non-dashed argspecs without regard to whether non-dashed are at the beginning or end
         set value_names [list]
-        foreach ln [split $optionspecs \n] {
+
+        set records [list]
+        set linebuild ""
+        foreach rawline [split $optionspecs \n] {
+            set recordsofar [string cat $linebuild $rawline]
+            if {![info complete $recordsofar]} {
+                append linebuild [string trimleft $rawline] \n
+            } else {
+                lappend records [string cat $linebuild $rawline] 
+                set linebuild ""
+            }
+        }
+
+        foreach ln $records {
             set trimln [string trim $ln]
             if {$trimln eq ""} {
                 continue
@@ -216,7 +238,11 @@ namespace eval punk::args {
                 }
             }
             if {[dict exists $arg_info $argname -default]} {
-                dict set defaults_dict $argname [dict get $arg_info $argname -default]
+                if {$is_opt} {
+                    dict set defaults_dict_opts $argname [dict get $arg_info $argname -default]
+                } else {
+                    dict set defaults_dict_values $argname [dict get $arg_info $argname -default]
+                }
             }
         }
 
@@ -363,13 +389,16 @@ namespace eval punk::args {
                 }
             }
         }
-        set opts [dict merge $defaults_dict $checked_args]
+        set opts [dict merge $defaults_dict_opts $checked_args]
         #assert - checked_args keys are full-length option names if -anyopts was false or if the supplied option as a shortname matched one of our defined options 
 
+        set values [dict merge $defaults_dict_values $values_dict]
+
         #todo - allow defaults outside of choices/ranges
 
         #check types,ranges,choices
-        set opts_and_values [concat $opts $values_dict]
+        set opts_and_values [concat $opts $values]
+        set combined_defaults [concat $defaults_dict_values $defaults_dict_opts] ;#can be no key collisions - we don't allow a value key beginning with dash - opt names must begin with dash
         dict for {o v} $opts_and_values {
             if {[dict exists $arg_info $o -multiple] && [dict get $arg_info $o -multiple]} {
                 set vlist $v
@@ -409,7 +438,7 @@ namespace eval punk::args {
 
             set is_default 0
             foreach e $vlist e_check $vlist_check  {
-                if {[dict exists $defaults_dict $o] && ($e_check eq [dict get $defaults_dict $o])} {
+                if {[dict exists $combined_defaults $o] && ($e_check eq [dict get $combined_defaults $o])} {
                     incr is_default 
                 }
             }
@@ -512,20 +541,20 @@ namespace eval punk::args {
                     if {[dict get $arg_info $o -ARGTYPE] eq "option"} {
                         dict set opts $o $stripped_list                        
                     } else {
-                        dict set values_dict $o $stripped_list
+                        dict set values $o $stripped_list
                     }
                 } else {
                     if {[dict get $arg_info $o -ARGTYPE] eq "option"} {
                         dict set opts $o [lindex $stripped_list 0]
                     } else {
-                        dict set values_dict [lindex $stripped_list 0]
+                        dict set values [lindex $stripped_list 0]
                     }
                 }
             }
         }
 
         #maintain order of opts $opts values $values as caller may use lassign.
-        return [dict create opts $opts values $values_dict]
+        return [dict create opts $opts values $values]
     }
 
     #proc sample1 {p1 args} {
diff --git a/src/modules/punk/cap/handlers/templates-999999.0a1.0.tm b/src/modules/punk/cap/handlers/templates-999999.0a1.0.tm
index 973173d4..aa66bc33 100644
--- a/src/modules/punk/cap/handlers/templates-999999.0a1.0.tm
+++ b/src/modules/punk/cap/handlers/templates-999999.0a1.0.tm
@@ -53,7 +53,7 @@ namespace eval punk::cap::handlers::templates {
                     }
                     set pathtype [dict get $capdict pathtype]
                     set vendor   [dict get $capdict vendor]
-                    set known_pathtypes [list currentproject_multivendor currentproject shellproject_multivendor shellproject  module absolute]
+                    set known_pathtypes [list adhoc currentproject_multivendor currentproject shellproject_multivendor shellproject  module absolute]
                     if {$pathtype ni $known_pathtypes} {
                         puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg'  is attempting to register with punk::cap as a provider of '$capname' capability, but 'pathtype' value '$pathtype' is not recognised. Known type: $known_pathtypes"
                         return 0
@@ -62,11 +62,26 @@ namespace eval punk::cap::handlers::templates {
                     set path [dict get $capdict path]
 
                     set cname [string map [list . _] $capname]
-                    set final_paths [list]
 
                     set multivendor_package_whitelist [list punk::mix::templates]
 
-                    if {$pathtype eq "module"} {
+
+                    #for template pathtype module & shellproject* we can resolve whether it's within a project at registration time and store the projectbase rather than rechecking it each time the templates handler api is called
+                    #for template pathtype absolute - we can do the same. 
+                    #There is a small chance for a long-running shell that a project is later created which makes the absolute path within a project - but it seems an unlikely case, and probably won't surprise the user that they need to relaunch the shell or reload the capsystem to see the change.  
+
+                    #adhoc and currentproject* paths are relative to cwd - so no projectbase information can be stored at registration time.
+                    #not all template item types will need projectbase information - as the item data may be self-contained within the template structure - 
+                    #but project_layout will need it - or at least need to know if there is no project - because project_layout data is never stored in the template folder structure directly.
+
+                    if {$pathtype eq "adhoc"} {
+                        if {[file pathtype $path] ne "relative"} {
+                            puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be a relative path"
+                            return 0
+                        }
+                        set extended_capdict $capdict
+                        dict set extended_capdict vendor $vendor
+                    } elseif {$pathtype eq "module"} {
                         set provide_statement [package ifneeded $pkg [package require $pkg]]
                         set tmfile [lindex $provide_statement end]
                         if {![file exists $tmfile]} {
@@ -81,10 +96,13 @@ namespace eval punk::cap::handlers::templates {
                         #todo - handle wrapped or unwrapped tarjar files - in which case we have to adjust tmfolder appropriately
                         #set tpath [file normalize [file join $tmfile [dict get $capdict relpath]]] ;#relpath is relative to the tm *file* - not it's containing folder
 
-
+                        set projectinfo    [punk::repo::find_repos $tmfolder]
+                        set projectbase [dict get $projectinfo closest]
+                        #store the projectbase even if it's empty string
                         set extended_capdict $capdict
                         set resolved_path [file join $tmfolder $path]
                         dict set extended_capdict resolved_path $resolved_path
+                        dict set extended_capdict projectbase $projectbase
                     } elseif {$pathtype eq "currentproject_multivendor"} {
                         #currently only intended for punk::mix::templates - review if 3rd party _multivendor trees even make sense
                         if {$pkg ni $multivendor_package_whitelist} {
@@ -114,8 +132,13 @@ namespace eval punk::cap::handlers::templates {
                             puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be a relative path"
                             return 0
                         }
+                        set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
+                        set projectinfo [punk::repo::find_repos $shellbase]
+                        set projectbase [dict get $projectinfo closest]
+                        
                         set extended_capdict $capdict
                         dict set extended_capdict vendor $vendor
+                        dict set extended_capdict projectbase $projectbase
                     } elseif {$pathtype eq "shellproject_multivendor"} {
                         #currently only intended for punk::templates - review if 3rd party _multivendor trees even make sense
                         if {$pkg ni $multivendor_package_whitelist} {
@@ -126,21 +149,34 @@ namespace eval punk::cap::handlers::templates {
                             puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be a relative path"
                             return 0
                         }
+                        set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
+                        set projectinfo [punk::repo::find_repos $shellbase]
+                        set projectbase [dict get $projectinfo closest]
+
                         set extended_capdict $capdict
                         dict set extended_capdict vendor $vendor 
+                        dict set extended_capdict projectbase $projectbase
                     } elseif {$pathtype eq "absolute"} {
                         if {[file pathtype $path] ne "absolute"} {
                             puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' of type $pathtype which doesn't seem to be absolute"
                             return 0
                         }
-                        if {!file exists [file normalize $path]} {
+                        set normpath [file normalize $path]
+                        if {!file exists $normpath} {
                             puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' which doesn't seem to exist"
                             return 0
                         }
+                        set projectinfo    [punk::repo::find_repos $normpath]
+                        set projectbase [dict get $projectinfo closest]
+
                         #todo - verify no other provider has registered same absolute path - if sharing a project-external location is needed - they need their own subfolder
                         set extended_capdict $capdict
-                        dict set extended_capdict resolved_path [file normalize $path]
+                        dict set extended_capdict resolved_path $normpath 
                         dict set extended_capdict vendor $vendor
+                        dict set extended_capdict projectbase $projectbase
+                    } else {
+                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg' is attempting to register with punk::cap as a provider of '$capname' capability but provided a path '$path' with unrecognised type $pathtype"
+                        return 0
                     }
 
                     # -- --- --- --- --- --- --- ---- ---
@@ -157,16 +193,6 @@ namespace eval punk::cap::handlers::templates {
                         dict lappend provider_info $pkg $extended_capdict
                     }
 
-                    #we don't check all final_paths - as currentproject* and shellproject* paths are dynamic based on pwd and script respectively
-
-                    #temporary debug
-                    foreach fp $final_paths {
-                        set norm_path [file normalize $fp] 
-                        if {![file isdirectory $norm_path]} {
-                            puts stderr "punk::cap::handlers::templates::capsystem pkg_register WARNING - unable to validate pathtype:$pathtype path:$path ($norm_path) for package '$pkg' which is attempting to register with punk::cap as a provider of '$capname' capability"
-                        }
-                    }
-
 
                     # -- --- --- --- --- --- --- ---- ---
                     # instantiation of api at punk::cap::handlers::templates::api_$capname 
@@ -207,7 +233,22 @@ namespace eval punk::cap::handlers::templates {
                 set cname [string map [list . _] $capname]
                 set capabilityname $capname
             }
-            method folders {} {
+            method folders {args} {
+                lassign [punk::args::opts_values {
+                    -startdir -default ""
+                } $args -maxvalues 0] _o opts 
+                set opt_startdir [dict get $opts -startdir]
+                if {$opt_startdir eq ""} {
+                    set startdir [pwd]
+                } else {
+                    if {[file pathtype $opt_startdir] eq "relative"} {
+                        set startdir [file join [pwd] $opt_startdir]
+                    } else {
+                        set startdir $opt_startdir
+                    }
+                }
+
+
                 variable capabilityname
                 variable cname
                 upvar ::punk::cap::handlers::templates::provider_info_$cname my_provider_info
@@ -220,6 +261,7 @@ namespace eval punk::cap::handlers::templates {
                 set folderdict [dict create]
 
                 #maintain separate paths for different override levels - all keyed on vendor (or pseudo-vendor '_project')
+                set found_paths_adhoc [dict create]
                 set found_paths_module [dict create]
                 set found_paths_currentproject_multivendor [dict create]
                 set found_paths_currentproject [dict create]
@@ -238,11 +280,18 @@ namespace eval punk::cap::handlers::templates {
                         set path     [dict get $capdecl_extended path]
                         set pathtype [dict get $capdecl_extended pathtype]
                         set vendor   [dict get $capdecl_extended vendor]
-                        if {$pathtype eq "module"} {
-                            #lappend found_paths [dict get $capdecl_extended resolved_path]
-                            dict lappend found_paths_module $vendor [list pkg $pkg path [dict get $capdecl_extended resolved_path] pathtype $pathtype]
+                        # projectbase not present in capdecl_extended for all template pathtypes
+                        if {$pathtype eq "adhoc"} {
+                            #e.g (cwd)/templates
+                            set targetpath [file join $startdir [dict get $capdecl_extended path]]
+                            if {[file isdirectory $targetpath]} {
+                                dict lappend found_paths_adhoc $vendor [list pkg $pkg path $targetpath pathtype $pathtype]
+                            }
+                        } elseif {$pathtype eq "module"} {
+                            set module_projectroot [dict get $capdecl_extended projectbase]
+                            dict lappend found_paths_module $vendor [list pkg $pkg path [dict get $capdecl_extended resolved_path] pathtype $pathtype projectbase $module_projectroot]
                         } elseif {$pathtype eq "currentproject_multivendor"} {
-                            set searchbase [pwd]
+                            set searchbase $startdir 
                             set pathinfo    [punk::repo::find_repos $searchbase]
                             set pwd_projectroot [dict get $pathinfo closest]
                             if {$pwd_projectroot ne ""} {
@@ -256,12 +305,10 @@ namespace eval punk::cap::handlers::templates {
                                     set vendorfolders [glob -nocomplain -dir $vendorbase -type d -tails *]
                                     foreach vf $vendorfolders {
                                         if {$vf ne "_project"} {
-                                            #lappend found_paths [file join $vendorbase $vf]
                                             dict lappend found_paths_currentproject_multivendor $vf [list pkg $pkg path [file join $vendorbase $vf] pathtype $pathtype]
                                         }
                                     }
                                     if {[file isdirectory [file join $vendorbase _project]]} {
-                                        #lappend  found_paths [file join $vendorbase _project]
                                         dict lappend found_paths_currentproject_multivendor _project [list pkg $pkg path [file join $vendorbase _project] pathtype $pathtype]
                                     }
                                 }
@@ -270,35 +317,34 @@ namespace eval punk::cap::handlers::templates {
                                     set customfolders [glob -nocomplain -dir $custombase -type d -tails *]
                                     foreach cf $customfolders {
                                         if {$cf ne "_project"} {
-                                            #lappend found_paths [file join $custombase $cf]
                                             dict lappend found_paths_currentproject_multivendor $cf [list pkg $pkg path [file join $custombase $cf] pathtype $pathtype]
                                         }
                                     }
                                     if {[file isdirectory [file join $custombase _project]]} {
-                                        #lappend  found_paths [file join $custombase _project]
                                         dict lappend found_paths_currentproject_multivendor _project [list pkg $pkg path [file join $custombase _project] pathtype $pathtype]
                                     }
                                 }
                             }
                         } elseif {$pathtype eq "currentproject"} {
-                            set searchbase [pwd]
+                            set searchbase $startdir 
                             set pathinfo    [punk::repo::find_repos $searchbase]
                             set pwd_projectroot [dict get $pathinfo closest]
                             if {$pwd_projectroot ne ""} {
                                 #path relative to projectroot already validated by handler as being within a currentproject_multivendor tree
                                 set targetfolder [file join $pwd_projectroot $path]
                                 if {[file isdirectory $targetfolder]} {
-                                    #lappend found_paths $targetfolder 
                                     dict lappend found_paths_currentproject $vendor [list pkg $pkg path $targetfolder pathtype $pathtype]
                                 }
                             }
                         } elseif {$pathtype eq "shellproject_multivendor"} {
                             #review - consider also [info script]  - but it can be empty if we just start a tclsh, load packages and start a repl
-                            set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
-                            set pathinfo [punk::repo::find_repos $shellbase]
-                            set pwd_projectroot [dict get $pathinfo closest]
-                            if {$pwd_projectroot ne ""} {
-                                set deckbase [file join $pwd_projectroot $path]
+                            #set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
+                            #set pathinfo [punk::repo::find_repos $shellbase]
+                            #set pwd_projectroot [dict get $pathinfo closest]
+
+                            set shell_projectroot [dict get $capdecl_extended projectbase]
+                            if {$shell_projectroot ne ""} {
+                                set deckbase [file join $shell_projectroot $path]
                                 if {![file exists $deckbase]} {
                                    continue 
                                 }
@@ -308,11 +354,11 @@ namespace eval punk::cap::handlers::templates {
                                     set vendorfolders [glob -nocomplain -dir $vendorbase -type d -tails *]
                                     foreach vf $vendorfolders {
                                         if {$vf ne "_project"} {
-                                            dict lappend found_paths_shellproject_multivendor $vf [list pkg $pkg path [file join $vendorbase $vf] pathtype $pathtype]
+                                            dict lappend found_paths_shellproject_multivendor $vf [list pkg $pkg path [file join $vendorbase $vf] pathtype $pathtype projectbase $shell_projectroot]
                                         }
                                     }
                                     if {[file isdirectory [file join $vendorbase _project]]} {
-                                        dict lappend found_paths_shellproject_multivendor _project [list pkg $pkg path [file join $vendorbase _project] pathtype $pathtype]
+                                        dict lappend found_paths_shellproject_multivendor _project [list pkg $pkg path [file join $vendorbase _project] pathtype $pathtype projectbase $shell_projectroot]
                                     }
                                 }
                                 set custombase [file join $deckbase custom]
@@ -320,11 +366,11 @@ namespace eval punk::cap::handlers::templates {
                                     set customfolders [glob -nocomplain -dir $custombase -type d -tails *]
                                     foreach cf $customfolders {
                                         if {$cf ne "_project"} {
-                                            dict lappend found_paths_shellproject_multivendor $cf [list pkg $pkg path [file join $custombase $cf] pathtype $pathtype]
+                                            dict lappend found_paths_shellproject_multivendor $cf [list pkg $pkg path [file join $custombase $cf] pathtype $pathtype projectbase $shell_projectroot]
                                         }
                                     }
                                     if {[file isdirectory [file join $custombase _project]]} {
-                                        dict lappend found_paths_shellproject_multivendor _project [list pkg $pkg path [file join $custombase _project] pathtype $pathtype]
+                                        dict lappend found_paths_shellproject_multivendor _project [list pkg $pkg path [file join $custombase _project] pathtype $pathtype projectbase $shell_projectroot]
                                     }
                                 }
 
@@ -332,18 +378,21 @@ namespace eval punk::cap::handlers::templates {
 
                         } elseif {$pathtype eq "shellproject"} {
                             #review - consider also [info script]  - but it can be empty if we just start a tclsh, load packages and start a repl
-                            set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
-                            set pathinfo [punk::repo::find_repos $shellbase]
-                            set pwd_projectroot [dict get $pathinfo closest]
-                            if {$pwd_projectroot ne ""} {
-                                set targetfolder [file join $pwd_projectroot $path]
+                            #set shellbase         [file dirname [file dirname [file normalize [set ::argv0]/__]]] ;#review
+                            #set pathinfo [punk::repo::find_repos $shellbase]
+                            #set pwd_projectroot [dict get $pathinfo closest]
+
+                            set shell_projectroot [dict get $capdecl_extended projectbase]
+                            if {$shell_projectroot ne ""} {
+                                set targetfolder [file join $shell_projectroot $path]
                                 if {[file isdirectory $targetfolder]} {
-                                    dict lappend found_paths_shellproject $vendor [list pkg $pkg path $targetfolder pathtype $pathtype]
+                                    dict lappend found_paths_shellproject $vendor [list pkg $pkg path $targetfolder pathtype $pathtype projectbase $shell_projectroot]
                                 }
                             }
                         } elseif {$pathtype eq "absolute"} {
                             #lappend found_paths [dict get $capdecl_extended resolved_path]
-                            dict lappend found_paths_absolute $vendor [list pkg $pkg path [dict get $capdecl_extended resolved_path] pathtype $pathtype]
+                            set abs_projectroot [dict get $capdecl_extended projectbase]
+                            dict lappend found_paths_absolute $vendor [list pkg $pkg path [dict get $capdecl_extended resolved_path] pathtype $pathtype projectbase $abs_projectroot]
                         }
 
                     }
@@ -356,21 +405,22 @@ namespace eval punk::cap::handlers::templates {
                 }
 
                 #add in order of preference low priority to high
+
                 dict for {vendor pathinfolist} $found_paths_module {
                     foreach pathinfo $pathinfolist {
-                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] vendor $vendor]
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] projectbase [dict get $pathinfo projectbase] vendor $vendor]
                     }
                 }
 
                 #Templates within project of shell we launched with has lower priority than 'currentproject' (which depends on our CWD)
                 dict for {vendor pathinfolist} $found_paths_shellproject_multivendor {
                     foreach pathinfo $pathinfolist {
-                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] vendor $vendor]
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] projectbase [dict get $pathinfo projectbase] vendor $vendor]
                     }
                 }
                 dict for {vendor pathinfolist} $found_paths_shellproject {
                     foreach pathinfo $pathinfolist {
-                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] vendor $vendor]
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] projectbase [dict get $pathinfo projectbase] vendor $vendor]
                     }
                 }
 
@@ -385,12 +435,289 @@ namespace eval punk::cap::handlers::templates {
                     }
                 }
                 dict for {vendor pathinfolist} $found_paths_absolute {
+                    foreach pathinfo $pathinfolist {
+                        dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] projectbase [dict get $pathinfo projectbase] vendor $vendor]
+                    }
+                }
+                #adhoc paths relative to cwd (or specified -startdir) can override any
+                dict for {vendor pathinfolist} $found_paths_adhoc {
                     foreach pathinfo $pathinfolist {
                         dict set folderdict [dict get $pathinfo path] [list source [dict get $pathinfo pkg] sourcetype package pathtype [dict get $pathinfo pathtype] vendor $vendor]
                     }
                 }
                 return $folderdict
             }
+            method get_itemdict_projectlayouts {args} {
+                lassign [punk::args::opts_values { 
+                    -startdir -default ""
+                    #peek -startdir while allowing all other opts/vals to be verified down-the-line instead of here
+                } $args -maxvalues -1 -anyopts 1] _o opts _v values 
+                set opt_startdir [dict get $opts -startdir]
+                if {$opt_startdir eq ""} {
+                    set searchbase [pwd]
+                } else {
+                    set searchbase $opt_startdir 
+                }
+
+                set refdict [my get_itemdict_projectlayoutrefs {*}$args]
+                set layoutdict [dict create]
+
+                set projectinfo    [punk::repo::find_repos $searchbase]
+                set projectroot [dict get $projectinfo closest]
+
+                dict for {layoutname refinfo} $refdict {
+                    set templatepathtype [dict get $refinfo sourceinfo pathtype]
+                    set sourceinfo [dict get $refinfo sourceinfo]
+                    set path [dict get $refinfo path]
+                    set reftail [file tail $path]
+                    set atparts [split [file rootname $reftail] @]
+                    #may be two @s if referencing a renamed layout override?
+                    # e.g ref may be @vendor+punks+othersample@sample-0.1  or layoutalias-1.1@vendor+punk+othersample@sample-0.1
+                    #there must always be an @ before vendor or custom . There is either a template-name alias or empty string before this first @
+                    #trim off first @ part
+                    set tailats [join [lrange $atparts 1 end] @] 
+                    # @ parts after the first are part of the path within the project_layouts structure
+                    set subpathlist [split $tailats +]
+                    if {[dict exists $refinfo sourceinfo projectbase]} {
+                        #some template pathtypes refer to the projectroot from the template - not the cwd
+                        set projectroot [dict get $refinfo sourceinfo projectbase]
+                    }
+
+                    if {$projectroot ne ""} {
+                        set layoutroot [file join $projectroot src/project_layouts]
+                        set layoutfolder [file join $layoutroot {*}$subpathlist]
+                        if {[file isdirectory $layoutfolder]} {
+                            #todo - check if layoutname already in layoutdict append .ref path to list of refs that linked to this layout?
+                            set layoutinfo [list path $layoutfolder basefolder $layoutroot sourceinfo $sourceinfo]
+                            dict set layoutdict $layoutname $layoutinfo
+                        }
+                    }
+                }
+                return $layoutdict
+            }
+            method get_itemdict_projectlayoutrefs {args} {
+                set config {
+                    -templatefolder_subdir "layout_refs"\
+                    -command_get_items_from_base {apply {{base} {
+                        set matched_files [glob -nocomplain -dir $base -type f *@*.ref]
+                        set items [list]
+                        foreach rf $matched_files {
+                            #puts stderr "--> $rf"
+                            if {[string match ignore* $rf]} {
+                                continue
+                            }
+                            #we silently skip .ref files that don't match - todo - more verification - and warn of invalid .refs?
+                            if {[string match *@vendor+* $rf] || [string match *@custom+* $rf]} {
+                                lappend items $rf
+                            }
+                        }
+                        return $items
+                    }}}\
+                    -command_get_item_name {apply {{vendor basefolder itempath} {
+                        set itemtail [file rootname [file tail $itempath]]
+                        set alias [lindex [split $itemtail @] 0]
+                        if {$alias eq ""} {
+                            set itemname [lindex [split $itemtail +] end]
+                        } else {
+                            set itemname $alias
+                        }
+                        if {$vendor ne "_project"} {
+                            set itemname $vendor.$itemname
+                        }
+                        return $itemname 
+                    }}}
+                }
+                set arglist [concat $config $args]
+                my _get_itemdict {*}$arglist
+            }
+            method get_itemdict_scriptappwrappers {args} {
+                set config {
+                    -templatefolder_subdir "utility/scriptappwrappers"\
+                    -command_get_items_from_base {apply {{base} {
+
+                        set matched_files [punk::path::treefilenames  -dir $base *]
+                        set wrappers [list]
+                        foreach tf $matched_files {
+                            if {[string match ignore* $tf]} {
+                                continue
+                            }
+                            set ext [file extension $tf]
+                            if {[string tolower $ext] in [list "" ".bat" ".cmd" ".sh" ".bash" ".pl" ".ps1" ".tcl"]} {
+                                lappend wrappers $tf
+                            }
+                        }
+                        return $wrappers
+                    }}}\
+                    -command_get_item_name {apply {{vendor basefolder itempath} {
+
+                        set relativepath [punk::path::relative $basefolder $itempath]
+                        set ftail [file tail $itempath]
+                        set tname $relativepath
+                        if {$vendor ne "_project"} {
+                            set tname ${vendor}.$tname
+                        }
+                        return $tname
+                    }}}
+                }
+                set arglist [concat $config $args]
+                my _get_itemdict {*}$arglist
+            }
+            method get_itemdict_moduletemplates {args} {
+                set config {
+                    -templatefolder_subdir "modules"\
+                    -command_get_items_from_base {apply {{base} {
+
+                        set matched_files [punk::path::treefilenames -dir $base template_*.tm]
+                        set tfiles [list]
+                        foreach tf $matched_files {
+                            if {[string match ignore* $tf]} {
+                                continue
+                            }
+                            set ext [file extension $tf]
+                            if {[string tolower $ext] in [list ".tm"]} {
+                                #we will ignore any .tm files that don't have versions that tcl understands - but warn
+                                #this reduces the cases we have to test later
+                                set fname [file tail $tf]
+                                lassign [split [punk::mix::cli::lib::split_modulename_version $fname]] mname ver
+                                if {[catch {punk::mix::cli::lib::validate_modulename $mname} errM]} {
+                                    puts stderr "Invalid module name/version $tf - please rename with standard Tcl .tm module name and version (or leave out version)"
+                                    if {[string match *-* $mname]} {
+                                        puts stderr "Tcl module name cannot contain dash character - except between name and version"
+                                    }
+                                } else {
+                                    lappend tfiles $tf
+                                }
+                            }
+                        }
+                        return $tfiles
+
+                    }}}\
+                    -command_get_item_name {apply {{vendor basefolder itempath} {
+
+                        set relativepath [punk::path::relative $basefolder $itempath] 
+                        set dirs [file dirname $relativepath]
+                        if {$dirs eq "."} {
+                            set dirs ""
+                        }
+                        set moduleprefix [join $dirs ::]
+                        set ftail [file rootname [file tail $itempath]]
+                        set tname [string range $ftail [string length template_] end]
+                        if {$moduleprefix ne ""} {
+                            set tname ${moduleprefix}::$tname
+                        }
+                        if {$vendor ne "_project"} {
+                            set tname ${vendor}.$tname
+                        } 
+                        return $tname
+                    }}}
+                }
+                set arglist [concat $config $args]
+                my _get_itemdict {*}$arglist
+            }
+
+            #shared algorithm for get_itemdict_* methods
+            #requires a -templatefolder_subdir indicating a directory within each template base folder in which to search  
+            #and a file selection mechanism command -command_get_items_from_base
+            #and a name determining command -command_get_item_name
+            method _get_itemdict {args} {
+                lassign [punk::args::opts_values { 
+                    -startdir -default ""
+                    -templatefolder_subdir -optional 0
+                    -command_get_items_from_base -optional 0
+                    -command_get_item_name -optional 0
+                    -not -default "" -multiple 1 
+                    globsearches -default * -multiple 1
+                } $args -maxvalues -1] _o opts _v values 
+                set globsearches [dict get $values globsearches]; #note that in this case our globsearch won't reduce the machine's effort in scannning the filesystem - as we need to search on the renamed results
+                # -- --- --- --- --- --- --- --- ---
+                set opt_startdir [dict get $opts -startdir]
+                set opt_templatefolder_subdir   [dict get $opts -templatefolder_subdir]
+                if {[file pathtype $opt_templatefolder_subdir] ne "relative"} {
+                    error templates::_get_itemdict
+                }
+                # -- --- --- --- --- --- --- --- ---
+                set opt_command_get_items_from_base [dict get $opts -command_get_items_from_base]
+                set opt_command_get_item_name       [dict get $opts -command_get_item_name]
+                set opt_not                         [dict get $opts -not]
+                # -- --- --- --- --- --- --- --- ---
+                set itembases [list]
+                #set tbasedict [punk::mix::base::lib::get_template_basefolders $opt_startdir]
+                set tbasedict [my folders -startdir $opt_startdir ]
+                #turn the dict into a list we can temporarily reverse sort while we expand the items from within each path
+                dict for {tbase folderinfo} $tbasedict {
+                    lappend itembases [list basefolder [file join $tbase $opt_templatefolder_subdir] sourceinfo $folderinfo]
+                }
+
+                set items [list]
+                set itemdict [dict create]
+                set seen_dict [dict create]
+
+                #flip the priority order for layout folders encountered so we can set the trailing #<int> dup/overridden indicators
+                foreach baseinfo [lreverse $itembases] {
+                    set basefolder [dict get $baseinfo basefolder]
+                    set sourceinfo [dict get $baseinfo sourceinfo]
+                    set vendor [dict get $sourceinfo vendor]
+                    #call the custom script from our caller which determines resultset of files we are interested in
+                    set matches  [{*}$opt_command_get_items_from_base $basefolder]
+                    set items_here [dict create] ;#maintain a list keyed on name for sorting within this base only
+                    foreach itempath $matches {
+                        set itemname [{*}$opt_command_get_item_name $vendor $basefolder $itempath]
+                        dict set items_here $itemname [list item $itempath baseinfo $baseinfo] 
+                        #lappend items [list item $itempath baseinfo $baseinfo]
+                    }
+                    set ordered_names [lsort [dict keys $items_here]]
+                    #add to the outer items list 
+                    foreach nm $ordered_names { 
+                        set iteminfo [dict get $items_here $nm]
+                        lappend items [list originalname $nm iteminfo $iteminfo]
+                    }
+                }
+
+                #append #n instance/duplicate name indicators based on cyling through entire list of found items
+                foreach itemrecord $items {
+                    set oname [dict get $itemrecord originalname]
+                    set iteminfo [dict get $itemrecord iteminfo]
+                    set itempath [dict get $iteminfo item]
+                    set baseinfo [dict get $iteminfo baseinfo]
+                    if {![dict exists $seen_dict $oname]} {
+                        dict set seen_dict $oname 1    
+                        dict set itemdict $oname [list path $itempath {*}$baseinfo] ; #first seen of oname gets no number 
+                    } else {
+                        set n [dict get $seen_dict $oname]
+                        incr n
+                        dict incr seen_dict $oname
+                        dict set itemdict ${oname}#$n [list path $itempath {*}$baseinfo]
+                    }
+                }
+
+                #assert path is first key of itemdict {callers are allowed to rely on it being first}
+                #assert itemdict has keys path,basefolder,sourceinfo
+                set result [dict create]
+                set keys [lreverse [dict keys $itemdict]]
+                foreach k $keys {
+                    set maybe "" 
+                    foreach g $globsearches {
+                        if {[string match $g $k]} {
+                            set maybe $k
+                            break
+                        }
+                    }
+                    set not ""
+                    if {$maybe ne ""} {
+                        foreach n $opt_not {
+                            if {[string match $n $k]} {
+                                set not $k
+                                break
+                            }
+                        }
+                    } 
+                    if {$maybe ne "" && $not eq ""} {
+                        dict set result $k [dict get $itemdict $k]
+                    }
+
+                }
+                return $result
+            }
         }
     }
 
diff --git a/src/modules/punk/char-999999.0a1.0.tm b/src/modules/punk/char-999999.0a1.0.tm
index 9e9b9480..237df9ad 100644
--- a/src/modules/punk/char-999999.0a1.0.tm
+++ b/src/modules/punk/char-999999.0a1.0.tm
@@ -12,21 +12,76 @@
 # Meta license      <unspecified>
 # @@ Meta End
 
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin punkshell_module_punk::char 0 999999.0a1.0]
+#[copyright "2024"]
+#[titledesc {character-set and unicode utilities}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {character-set nad unicode}]             [comment {-- Description at end of page heading --}] 
+#[require punk::char]
+#[keywords module encodings]
+#[description]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of punk::char
+#[subsection Concepts]
+#[para] -
 
 
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Requirements
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Requirements
 ##e.g package require frobz
-package require mime
-package require overtype
 
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by punk::char
+#[list_begin itemized]
+#[item] [package {Tcl 8.6}]
+
+#
+
+#*** !doctools
+#[item] [package {overtype}]
+#[para] -  
+#[item] [package {textblock}]
+#[para] -  
+#[item] [package console]
+#[para] - 
+
+package require Tcl 8.6
+
+#*** !doctools
+#[list_end]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 
+#*** !doctools
+#[section API]
 
 #Note that ansi escapes can begin with \033\[ (\u001b\[)  or the single character "Control Sequence Introducer" 0x9b
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 namespace eval punk::char {
     namespace export *
+
+    # -- --------------------------------------------------------------------------
+    variable encmimens  ;#namespace of mime package providing reversemapencoding and mapencoding functions
+    #tcllib mime requires tcl::chan::memchan,events,core and/or Trf
+    if {![catch {package require punk::encmime} errM]} {
+        set encmimens ::punk::encmime
+    } else {
+        package require mime
+        set encmimens ::mime
+    }
+    # -- --------------------------------------------------------------------------
+
     variable invalid "???" ;# ideally this would be 0xFFFD - which should display as black diamond/rhombus with question mark. As at 2023 - this tends to display indistinguishably from other missing glyph boxes - so we use a longer sequence we can detect by length and to display obviously
     variable invalid_display_char \u25ab; #todo - change to 0xFFFD once diamond glyph more common?
 
@@ -137,7 +192,8 @@ namespace eval punk::char {
         foreach enc $encnames {
             dict set d $enc [list]
         }
-        set mimenames [array get ::mime::reversemap]
+        variable encmimens
+        set mimenames [array get ${encmimens}::reversemap]
         dict for {mname encname} $mimenames {
             if {$encname in $encnames} {
                 set enclist [dict get $d $encname]
@@ -147,7 +203,7 @@ namespace eval punk::char {
             }
         } 
         foreach enc [lsort $encnames] {
-            set mime_enc [mime::mapencoding $enc]
+            set mime_enc [${encmimens}::mapencoding $enc]
             if {$mime_enc ne ""} {
                 set enclist [dict get $d $enc]
                 if {$mime_enc ni $enclist} {
@@ -309,8 +365,9 @@ namespace eval punk::char {
         if {[lsearch -nocase [page_names] $encname] < 0} {
             error "Unknown encoding '$encname' - use 'punk::char::page_names' to see valid encoding names on this system"
         }
+        variable encmimens
         if {$encname ni [encoding names]} {
-            set encname [mime::reversemapencoding $encname]
+            set encname [${encmimens}::reversemapencoding $encname]
         }
         return $encname
     }
@@ -1437,6 +1494,7 @@ namespace eval punk::char {
     }
     #with glob searches of desc and short
     proc char_range {start end args} {
+        package require overtype
         if {![string is integer -strict $start] || ![string is integer -strict $end]} {
             error "char_range error start and end must be integers"
         }
@@ -1481,6 +1539,7 @@ namespace eval punk::char {
         return  $matched_names
     }
     proc charsets {{namesearch *}} {
+        package require textblock
         variable charsets
         set charset_names [charset_names $namesearch]
         set settype_list [list]
@@ -1491,10 +1550,7 @@ namespace eval punk::char {
         set charset_names [linsert $charset_names 0 "Set Name"]
         set settype_list  [linsert $settype_list 0 "Set Type"]
 
-
-        set b1 [textblock::join $charset_names [lrepeat [llength $charset_names] " "]]
-        set b2 [textblock::join $b1 $settype_list]
-        return $b2
+        return [textblock::join [list_as_lines -- $charset_names] " " [list_as_lines $settype_list]]
     }
     proc charset_defget {exactname} {
         variable charsets
@@ -1638,6 +1694,7 @@ namespace eval punk::char {
 
     #allows search on both name and an anded list of globs to be applied to description & short
     proc charset {namesearch args} {
+        package require overtype
         variable  charsets
         set matched_names [charset_names $namesearch]
         if {![llength $matched_names]} {
@@ -1799,6 +1856,19 @@ namespace eval punk::char {
         return [expr {[string length $text] + $doublewidth_char_count - $zerowidth_char_count}]
     }
 
+    #This shouldn't be called on text containing ansi codes!
+    proc strip_nonprinting_ascii {str} {
+        #review - some single-byte 'control' chars have visual representations e.g ETX as heart
+        #It is currently used for screen display width calculations
+        #equivalent for various unicode combining chars etc?
+        set map [list\
+            \007 ""\
+            [format %c 0] ""\
+            [format %c 0x7f] ""\
+        ]
+        return [string map $map $str]
+    }
+
     proc char_width {char} {
         error "char_width unimplemented"
     }
@@ -1837,20 +1907,15 @@ namespace eval punk::char {
 
 
 
-
-
-
-
-
-
-
-
-
-
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
 package provide punk::char [namespace eval punk::char {
     variable version
     set version 999999.0a1.0 
 }]
-return
\ No newline at end of file
+return
+
+#*** !doctools
+#[manpage_end]
+
+
diff --git a/src/modules/punk/du-999999.0a1.0.tm b/src/modules/punk/du-999999.0a1.0.tm
index 00141442..db187362 100644
--- a/src/modules/punk/du-999999.0a1.0.tm
+++ b/src/modules/punk/du-999999.0a1.0.tm
@@ -825,7 +825,7 @@ namespace eval punk::du {
             ]
             set errors [dict create]
             set known_opts [dict keys $defaults] 
-            foreach k [dict keys $args] {
+            dict for {k -} $args {
                 if {$k ni $known_opts} {
                     error  "du_dirlisting_generic unknown-option $k"
                 }
diff --git a/src/modules/punk/encmime-999999.0a1.0.tm b/src/modules/punk/encmime-999999.0a1.0.tm
new file mode 100644
index 00000000..ef1db01c
--- /dev/null
+++ b/src/modules/punk/encmime-999999.0a1.0.tm
@@ -0,0 +1,437 @@
+# -*- tcl -*-
+# Maintenance Instruction: leave the 999999.xxx.x as is and use punkshell 'pmix make' or bin/punkmake  to update from <pkg>-buildversion.txt
+# module template: punkshell/src/decktemplates/vendor/punk/modules/template_module-0.0.2.tm
+#
+# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
+# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# (C) 2024
+#
+# @@ Meta Begin
+# Application punk::encmime 999999.0a1.0
+# Meta platform     tcl
+# Meta license      <unspecified>
+# @@ Meta End
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin punkshell_module_punk::encmime 0 999999.0a1.0]
+#[copyright "2024"]
+#[titledesc {mime encodings related subset of tcllib mime}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {mime encoding names and aliases}]             [comment {-- Description at end of page heading --}] 
+#[require punk::encmime]
+#[keywords module encodings]
+#[description]
+#[para] This is a workaround package to provide the mime encoding names used in tcllib's mime package - without additional dependencies
+#[para]tcllib mime loads either Trf or tcl::memchan functions. punk::encmime needs to work in a context where tcllib may not yet be loaded/available, and even these few dependencies are too much. 
+#[para]MAINTENANCE NOTE: The data in this module needs to be checked against the latest tcllib mime package
+#[para]taken from tcllib mime version: 1.7.2 in 2024
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of punk::encmime
+#[subsection Concepts]
+#[para] Where practical - the actual tcllib mime package should be used instead.
+#[para]This set of encoding related functions is a snapshot of the data from the mime package - and may not be up to date.
+#[para]This pseudo-package was created to minimize dependencies for punk::char and punk::overtype
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Requirements
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by punk::encmime
+#[list_begin itemized]
+
+package require Tcl 8.6
+#*** !doctools
+#[item] [package {Tcl 8.6}]
+
+# #package require frobz
+# #*** !doctools
+# #[item] [package {frobz}]
+
+#*** !doctools
+#[list_end]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section API]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# oo::class namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+namespace eval punk::encmime::class {
+    #*** !doctools
+    #[subsection {Namespace punk::encmime::class}]
+    #[para] class definitions
+    if {[info commands [namespace current]::interface_sample1] eq ""} {
+        #*** !doctools
+        #[list_begin enumerated]
+
+        # oo::class create interface_sample1 {
+        #     #*** !doctools
+        #     #[enum] CLASS [class interface_sample1]
+        #     #[list_begin definitions]
+
+        #     method test {arg1} {
+        #         #*** !doctools
+        #         #[call class::interface_sample1    [method test] [arg arg1]]
+        #         #[para] test method
+        #         puts "test: $arg1"
+        #     }
+
+        #     #*** !doctools
+        #     #[list_end] [comment {-- end definitions interface_sample1}]
+        # }
+
+        #*** !doctools
+        #[list_end] [comment {--- end class enumeration ---}]
+    }
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# Base namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+namespace eval punk::encmime {
+    namespace export *
+
+    variable encList {
+        ascii US-ASCII
+        big5 Big5
+        cp1250 Windows-1250
+        cp1251 Windows-1251
+        cp1252 Windows-1252
+        cp1253 Windows-1253
+        cp1254 Windows-1254
+        cp1255 Windows-1255
+        cp1256 Windows-1256
+        cp1257 Windows-1257
+        cp1258 Windows-1258
+        cp437 IBM437
+        cp737 {}
+        cp775 IBM775
+        cp850 IBM850
+        cp852 IBM852
+        cp855 IBM855
+        cp857 IBM857
+        cp860 IBM860
+        cp861 IBM861
+        cp862 IBM862
+        cp863 IBM863
+        cp864 IBM864
+        cp865 IBM865
+        cp866 IBM866
+        cp869 IBM869
+        cp874 {}
+        cp932 {}
+        cp936 GBK
+        cp949 {}
+        cp950 {}
+        dingbats {}
+        ebcdic {}
+        euc-cn EUC-CN
+        euc-jp EUC-JP
+        euc-kr EUC-KR
+        gb12345 GB12345
+        gb1988 GB1988
+        gb2312 GB2312
+        iso2022 ISO-2022
+        iso2022-jp ISO-2022-JP
+        iso2022-kr ISO-2022-KR
+        iso8859-1 ISO-8859-1
+        iso8859-2 ISO-8859-2
+        iso8859-3 ISO-8859-3
+        iso8859-4 ISO-8859-4
+        iso8859-5 ISO-8859-5
+        iso8859-6 ISO-8859-6
+        iso8859-7 ISO-8859-7
+        iso8859-8 ISO-8859-8
+        iso8859-9 ISO-8859-9
+        iso8859-10 ISO-8859-10
+        iso8859-13 ISO-8859-13
+        iso8859-14 ISO-8859-14
+        iso8859-15 ISO-8859-15
+        iso8859-16 ISO-8859-16
+        jis0201 JIS_X0201
+        jis0208 JIS_C6226-1983
+        jis0212 JIS_X0212-1990
+        koi8-r KOI8-R
+        koi8-u KOI8-U
+        ksc5601 KS_C_5601-1987
+        macCentEuro {}
+        macCroatian {}
+        macCyrillic {}
+        macDingbats {}
+        macGreek {}
+        macIceland {}
+        macJapan {}
+        macRoman {}
+        macRomania {}
+        macThai {}
+        macTurkish {}
+        macUkraine {}
+        shiftjis Shift_JIS
+        symbol {}
+        tis-620 TIS-620
+        unicode {}
+        utf-8 UTF-8
+    }
+    variable encodings
+    array set encodings $encList
+    variable reversemap
+    variable encAliasList {
+        ascii ANSI_X3.4-1968
+        ascii iso-ir-6
+        ascii ANSI_X3.4-1986
+        ascii ISO_646.irv:1991
+        ascii ASCII
+        ascii ISO646-US
+        ascii us
+        ascii IBM367
+        ascii cp367
+        cp437 cp437
+        cp437 437
+        cp775 cp775
+        cp850 cp850
+        cp850 850
+        cp852 cp852
+        cp852 852
+        cp855 cp855
+        cp855 855
+        cp857 cp857
+        cp857 857
+        cp860 cp860
+        cp860 860
+        cp861 cp861
+        cp861 861
+        cp861 cp-is
+        cp862 cp862
+        cp862 862
+        cp863 cp863
+        cp863 863
+        cp864 cp864
+        cp865 cp865
+        cp865 865
+        cp866 cp866
+        cp866 866
+        cp869 cp869
+        cp869 869
+        cp869 cp-gr
+        cp936 CP936
+        cp936 MS936
+        cp936 Windows-936
+        iso8859-1 ISO_8859-1:1987
+        iso8859-1 iso-ir-100
+        iso8859-1 ISO_8859-1
+        iso8859-1 latin1
+        iso8859-1 l1
+        iso8859-1 IBM819
+        iso8859-1 CP819
+        iso8859-2 ISO_8859-2:1987
+        iso8859-2 iso-ir-101
+        iso8859-2 ISO_8859-2
+        iso8859-2 latin2
+        iso8859-2 l2
+        iso8859-3 ISO_8859-3:1988
+        iso8859-3 iso-ir-109
+        iso8859-3 ISO_8859-3
+        iso8859-3 latin3
+        iso8859-3 l3
+        iso8859-4 ISO_8859-4:1988
+        iso8859-4 iso-ir-110
+        iso8859-4 ISO_8859-4
+        iso8859-4 latin4
+        iso8859-4 l4
+        iso8859-5 ISO_8859-5:1988
+        iso8859-5 iso-ir-144
+        iso8859-5 ISO_8859-5
+        iso8859-5 cyrillic
+        iso8859-6 ISO_8859-6:1987
+        iso8859-6 iso-ir-127
+        iso8859-6 ISO_8859-6
+        iso8859-6 ECMA-114
+        iso8859-6 ASMO-708
+        iso8859-6 arabic
+        iso8859-7 ISO_8859-7:1987
+        iso8859-7 iso-ir-126
+        iso8859-7 ISO_8859-7
+        iso8859-7 ELOT_928
+        iso8859-7 ECMA-118
+        iso8859-7 greek
+        iso8859-7 greek8
+        iso8859-8 ISO_8859-8:1988
+        iso8859-8 iso-ir-138
+        iso8859-8 ISO_8859-8
+        iso8859-8 hebrew
+        iso8859-9 ISO_8859-9:1989
+        iso8859-9 iso-ir-148
+        iso8859-9 ISO_8859-9
+        iso8859-9 latin5
+        iso8859-9 l5
+        iso8859-10 iso-ir-157
+        iso8859-10 l6
+        iso8859-10 ISO_8859-10:1992
+        iso8859-10 latin6
+        iso8859-14 iso-ir-199
+        iso8859-14 ISO_8859-14:1998
+        iso8859-14 ISO_8859-14
+        iso8859-14 latin8
+        iso8859-14 iso-celtic
+        iso8859-14 l8
+        iso8859-15 ISO_8859-15
+        iso8859-15 Latin-9
+        iso8859-16 iso-ir-226
+        iso8859-16 ISO_8859-16:2001
+        iso8859-16 ISO_8859-16
+        iso8859-16 latin10
+        iso8859-16 l10
+        jis0201 X0201
+        jis0208 iso-ir-87
+        jis0208 x0208
+        jis0208 JIS_X0208-1983
+        jis0212 x0212
+        jis0212 iso-ir-159
+        ksc5601 iso-ir-149
+        ksc5601 KS_C_5601-1989
+        ksc5601 KSC5601
+        ksc5601 korean
+        shiftjis MS_Kanji
+        utf-8 UTF8
+    }
+
+    #*** !doctools
+    #[subsection {Namespace punk::encmime}]
+    #[para] Core API functions for punk::encmime 
+    #[list_begin definitions]
+
+    # ::mime::mapencoding --
+    #
+    #    mime::mapencodings maps tcl encodings onto the proper names for their
+    #    MIME charset type.  This is only done for encodings whose charset types
+    #    were known.  The remaining encodings return {} for now.
+    #
+    # Arguments:
+    #       enc      The tcl encoding to map.
+    #
+    # Results:
+    #    Returns the MIME charset type for the specified tcl encoding, or {}
+    #       if none is known.
+    proc mapencoding {enc} {
+        #*** !doctools
+        #[call mapencoding [arg enc]]
+        #[para]maps tcl encodings onto the proper names for their MIME charset type.
+        #[para]This is only done for encodings whose charset types were known.
+        #[para]The remaining encodings return {} for now.
+        #[para]NOTE: consider using tcllib's mime::mapencoding instead if mime package available
+
+        variable encodings
+        if {[info exists encodings($enc)]} {
+            return $encodings($enc)
+        }
+        return {}
+    }
+
+    proc reversemapencoding {mimeType} {
+        #*** !doctools
+        #[call reversemapencoding [arg mimeType]]
+        #[para]mime::reversemapencodings maps MIME charset types onto tcl encoding names.
+        #[para]Returns the tcl encoding name for the specified mime charset, or {} if none is known
+        #[para] Arguments:
+        #       [list_begin arguments]
+        #       [arg_def string mimeType]       The MIME charset to convert into a tcl encoding type.
+        #       [list_end]
+        #[para]NOTE: consider using tcllib's mime::reversemapencoding instead if mime package available
+
+        variable reversemap
+
+        set lmimeType [string tolower $mimeType]
+        if {[info exists reversemap($lmimeType)]} {
+            return $reversemap($lmimeType)
+        }
+        return {}
+    }
+
+
+
+    #*** !doctools
+    #[list_end] [comment {--- end definitions namespace punk::encmime ---}]
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+::apply {{} {
+    variable encList
+    variable encAliasList
+    variable reversemap
+    foreach {enc mimeType} $encList {
+        if {$mimeType eq {}} continue
+	    set reversemap([string tolower $mimeType]) $enc
+    }
+    foreach {enc mimeType} $encAliasList {
+        set reversemap([string tolower $mimeType]) $enc
+    }
+    # Drop the helper variables
+    unset encList encAliasList
+
+} ::punk::encmime}
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# Secondary API namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+namespace eval punk::encmime::lib {
+    namespace export *
+    namespace path [namespace parent]
+    #*** !doctools
+    #[subsection {Namespace punk::encmime::lib}]
+    #[para] Secondary functions that are part of the API 
+    #[list_begin definitions]
+
+    #proc utility1 {p1 args} {
+    #    #*** !doctools
+    #    #[call lib::[fun utility1] [arg p1] [opt {?option value...?}]]
+    #    #[para]Description of utility1 
+    #    return 1 
+    #}
+
+
+
+    #*** !doctools
+    #[list_end] [comment {--- end definitions namespace punk::encmime::lib ---}]
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[section Internal]
+namespace eval punk::encmime::system {
+    #*** !doctools
+    #[subsection {Namespace punk::encmime::system}]
+    #[para] Internal functions that are not part of the API 
+
+
+
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Ready   
+package provide punk::encmime [namespace eval punk::encmime {
+    variable pkg punk::encmime
+    variable version
+    set version 999999.0a1.0 
+}]
+return
+
+#*** !doctools
+#[manpage_end]
+
diff --git a/src/modules/punk/encmime-buildversion.txt b/src/modules/punk/encmime-buildversion.txt
new file mode 100644
index 00000000..f47d01c8
--- /dev/null
+++ b/src/modules/punk/encmime-buildversion.txt
@@ -0,0 +1,3 @@
+0.1.0
+#First line must be a semantic version number
+#all other lines are ignored.
diff --git a/src/modules/punk/fileline-999999.0a1.0.tm b/src/modules/punk/fileline-999999.0a1.0.tm
index fc0abd11..cb928c0c 100644
--- a/src/modules/punk/fileline-999999.0a1.0.tm
+++ b/src/modules/punk/fileline-999999.0a1.0.tm
@@ -1,4 +1,4 @@
-# -*- tcl -*-
+# -*- tcl -*-
 # Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
@@ -22,7 +22,7 @@
 #[titledesc {file line-handling utilities}]  [comment {-- Name section and table of contents description --}]
 #[moddesc {punk fileline}]             [comment {-- Description at end of page heading --}] 
 #[require punk::fileline]
-#[keywords module text parse file]
+#[keywords module text parse file encoding BOM]
 #[description]
 #[para] -
 
@@ -33,7 +33,9 @@
 #[para]Utilities for in-memory analysis of text file data as both line data and byte/char-counted data whilst preserving the line-endings (even if mixed)
 #[para]This is important for certain text files where examining the number of chars/bytes is important
 #[para]For example - windows .cmd/.bat files need some byte counting to determine if labels lie on chunk boundaries and need to be moved.
-#[para]Despite including the word 'file', the library doesn't deal with reading/writing to the filesystem. It is for operating on text-file like data.
+#[para]This chunk-size counting will depend on the character encoding. 
+#[para]Despite including the word 'file', the library doesn't necessarily deal with reading/writing to the filesystem -
+#[para]The raw data can be supplied as a string, or loaded from a file using punk::fileline::get_textinfo -file <filename>
 #[subsection Concepts]
 #[para]A chunk of textfile data (possibly representing a whole file - but usually at least a complete set of lines) is loaded into a punk::fileline::class::textinfo instance at object creation.
 #[example_begin]
@@ -142,6 +144,14 @@ namespace eval punk::fileline::class {
                 variable o_LF_C 
                 variable o_CRLF_C
 
+
+                variable o_bom_id
+                variable o_bom
+                variable o_bom_map
+
+                #review - for now we expect datachunk to be data without BOM and already encoded appropriately
+                #fileline::get_textinfo has support for interpreting BOM - but we currently have no way to do that for data not coming from a file
+                #refactor to allow that code to be called from here?
                 constructor {datachunk args} {
                     #*** !doctools
                     #[call class::textinfo [method constructor] [arg datachunk] [opt {option value...}]]
@@ -164,6 +174,22 @@ namespace eval punk::fileline::class {
                         namespace path $nspath
                     }
 
+                    set o_bom_map [list\
+                        utf-8 \u00ef\u00bb\u00bf\
+                        utf-16be \u00fe\u00ff\
+                        utf-16le \u00ff\u00fe\
+                        utf-32be \u0000\u0000\u00fe\u00ff\
+                        utf-32le \u00ff\u00fe\u0000\u0000\
+                        utf-7    \u002b\u002f\u0076\
+                        utf-1    \u00f7\u0064\u004c\
+                        utf-ebcdic \u00dd\u0073\u0066\u0073\
+                        utf-scsu \u0003\u00fe\u00ff\
+                        utf-bocu-1 \u00fb\u00ee\u0028\
+                        utf-gb18030 \u0084\u0031\u0095\u0033\
+                    ]
+                    set o_bom_id ""
+                    set o_bom "" ;#review
+
                     set o_chunk $datachunk
                     set o_line_epoch [list] 
                     set o_chunk_epoch [list "fromchunkchange-at-[clock micros]"]
@@ -216,6 +242,20 @@ namespace eval punk::fileline::class {
 
                 }
 
+                method set_bomid {bomid} {
+                    if {$bomid ni [dict keys $o_bom_map]} {
+                        error "Unrecognised bom-id $bomid. Known values: [dict keys $o_bom_map]"
+                    }
+                    set o_bom_id $bomid
+                    set o_bom [dict get $o_bom_map $bomid]
+                }
+                method get_bomid {} {
+                    return $o_bom_id
+                }
+                method get_bom {} {
+                    return $o_bom
+                }
+
                 method chunk {chunkstart chunkend} {
                     #*** !doctools
                     #[call class::textinfo [method chunk] [arg chunkstart] [arg chunkend]]
@@ -1200,31 +1240,223 @@ namespace eval punk::fileline {
     #[list_begin definitions]
 
     proc get_textinfo {args} {
+        #*** !doctools
+        #[call get_textinfo [opt {option value...}] [opt datachunk]]
+        #[para]Returns textinfo object instance representing data in string datachunk or if -file filename supplied - data loaded from a file
+        #[para]The encoding used is as specified in the -encoding option - or from the Byte Order Mark (bom) at the beginning of the data
+        #[para]For Tcl 8.6 - encodings such as utf-16le may not be available - so the bytes are swapped appropriately depending on the platform byteOrder and encoding 'unicode' is used.
+        #[para]encoding defaults to utf-8 if no -encoding specified and no BOM was found
+        #[para]Specify -encoding binary to perform no encoding conversion
+        #[para]Whether  -encoding was specified or not - by default the BOM characters are not retained in the line-data
+        #[para]If -includebom 1 is specified - the bom will be retained in the stored chunk and the data for line 1, but will undergo the same encoding transformation as the rest of the data
+        #[para]The get_bomid method of the returned object will contain an identifier for any BOM encountered.
+        #[para] e.g utf-8,utf-16be, utf-16le, utf-32be, utf32-le, SCSU, BOCU-1,GB18030, UTF-EBCDIC, utf-1, utf-7
+        #[para]If the encoding specified in the BOM isn't recognised by Tcl - the resulting data is likely to remain as the raw bytes (binary translation) 
+        #[para]Currently only utf-8, utf-16* and utf-32* are properly supported even though the other BOMs are detected, reported via get_bomid, and stripped from the data.
+        #[para]GB18030 falls back to cp936/gbk (unless a gb18030 encoding has been installed). Use -encoding binary if this isn't suitable and you need to do your own processing of the raw data.
+
         set defaults { 
             -file -default {} -type existingfile
             -translation -default binary
+            -encoding -default "\uFFFF"
+            -includebom -default 0
         } 
         lassign [dict values [punk::args::opts_values $defaults $args -minvalues 0 -maxvalues 1]] opts values
         # -- --- --- ---
         set opt_file    [dict get $opts -file]
         set opt_translation [dict get $opts -translation]
+        set opt_encoding    [dict get $opts -encoding]
+        set opt_includebom  [dict get $opts -includebom]
         # -- --- --- ---
 
         if {$opt_file ne ""} {
             set filename $opt_file 
             set fd [open $filename r] 
-            fconfigure $fd -translation $opt_translation 
-            set datachunk [read $fd]
+            fconfigure $fd -translation binary -encoding $opt_translation;#should use translation binary to get actual line-endings - but we allow caller to override
+            #Always read encoding in binary - check for bom below and/or apply chosen opt_encoding 
+            set rawchunk [read $fd]
             close $fd
             if {[llength $values]} {
                 puts stderr "Ignoring trailing argument [string length [lindex $values 0]] bytes. Not used when -file is specified"
             }
         } else {
-            set datachunk [lindex $values 0]
+            set rawchunk [lindex $values 0]
+        }
+        set rawlen [string length $rawchunk]
+        #examine first 4 bytes for possible BOM
+        #big-endian BOMs
+        # -----------------------------------
+        #EFBBBF    - utf-8         reliabletxt
+        #FEFF      - utf-16be      reliabletxt
+        #FFFE      - utf-16le      reliabletxt
+        #0000FEFF  - utf-32be      reliabletxt
+        #FFFE0000  - utf-32le
+        #0000FFFE  - utf-32be(2143)  non-standard!   (not supported)
+        #FEFF0000  - utf-32le(3412)  non-standard!   (not supported - will detect as utf-16be)
+        #2B2F76    - utf-7          (not supported)
+        #F7644C    - utf-1          (not supported)
+        #DD736673  - UTF-EBCDIC     (not supported)
+        #0EFEFF    - SCSU           (not supported)
+        #FBEE28    - BOCU-1     Binary Ordered Compression for Unicode (mime-compatible) - (not supported - fall back to utf-8)
+        #84319533  - GB18030    -  Chinese gov standard (fall back to cp936 with warning if no encoding name)
+        # -----------------------------------
+
+        set first32 [string range $rawchunk 0 3]
+        #scan using capital H for big-endian order
+        set first32_be [binary scan $first32 H* maybe_bom] ;#we use H* instead of H8 for 8 nibbles (4 bytes) - because our first32 may contain less than 4 bytes - in which case we won't match
+        set bomid ""
+        set bomenc ""
+        set is_reliabletxt 0 ;#see http://reliabletxt.com - only utf-8 with bom, utf-16be, utf-16le, utf-32be supported as at 2024
+        set startdata 0
+        if {[string match "efbbbf*" $maybe_bom]} {
+            set bomid utf-8
+            set bomenc utf-8
+            set is_reliabletxt 1
+            set startdata 3
+        } elseif {$maybe_bom eq "0000feff"} {
+            set bomid utf-32be
+            set bomenc utf-32be
+            set is_reliabletxt 1
+            set startdata 4
+        } elseif {$maybe_bom eq "fffe0000"} {
+            #Technically ambiguous - could be utf-16le bom followed by utf-16 null character (2 byte null) 
+            puts stderr "WARNING - ambiguous BOM fffe0000 found. Treating as utf-32le - but could be utf-16le - consider manually setting -encoding or converting data to another encoding."
+            set bomid utf-32le
+            set bomenc utf-32le
+            set startdata 4
+        } elseif {[string match "feff*" $maybe_bom]} {
+            set bomid utf-16be
+            set bomenc utf-16be
+            set is_reliabletxt 1
+            set startdata 2
+        } elseif {[string match "fffe*" $maybe_bom]} {
+            set bomid utf-16le
+            set bomenc utf-16le
+            set is_reliabletxt 1
+            set startdata 2
+        } elseif {$maybe_bom eq "0efeff"} {
+            set bomid scsu
+            set bomenc "binary"
+            set startdata 3
+        } elseif {$maybe_bom eq "fbee28"} {
+            set bomid bocu-1
+            puts stderr "WARNING - bocu-1 BOM FBEE28 found. Not supported - back to binary"
+            set bomenc "binary" ;# utf-8???
+            set startdata 3
+        } elseif {$maybe_bom eq "84319533"} {
+            if {![dict exists [punk::char::page_names_dict gb18030]]} {
+                puts stderr "WARNING - no direct support for GB18030 (chinese) - falling back to cp936/gbk"
+                set bomenc cp936
+            } else {
+                set bomenc [dict get [punk::char::page_names_dict gb18030]] ;#review - this may never exist in Tcl or may be named differently - create a handler?
+            }
+            set bomid gb18030
+            set startdata 4
+        } elseif {$maybe_bom eq "f7644c"} {
+            puts stderr "WARNING utf-1 BOM F7644C found - not supported. Falling back to binary"
+            set bomid utf-1
+            set bomenc binary
+            set startdata 3
+        } elseif {[string match "2b2f76*" $maybe_bom]} {
+            puts stderr "WARNING utf-7 BOM 2b2f76 found - not supported. Falling back to binary and leaving BOM in data!"  
+            #review - work out how to strip bom - last 2 bits of 4th byte belong to following character
+            set bomid utf-7
+            set bomenc binary
+            set startdata 0
         }
+
+        #todo - check xml encoding attribute / html content-type
+        #todo - a separate chardet (https://chardet.readthedocs.io/ ) or mozilla like mechanism that can be manually called to autodetect character encoding
+        #This should be an explicit operation - not automatially done here unless we provide a flag for it.
+
+
+        if {$opt_includebom} {
+            set startdata 0
+        }
+
+        if {$opt_encoding eq "\uFFFF"} {
+            if {$bomenc ne "" && $bomenc ne "binary"} {
+                if {[package vcompare [package provide Tcl] 8.7] < 0} {
+                    #tcl 8.6 has unicode encoding but not utf-16le etc
+                    if {$bomenc ni [encoding names]} {
+                        if {$bomenc eq "utf-16le"} {
+                            if {$::tcl_platform(byteOrder) eq "littleEndian"} {
+                                set datachunk [encoding convertfrom unicode [string range $rawchunk $startdata end]]
+                                set encoding_selected unicode
+                            } else {
+                                set datachunk [encoding convertfrom unicode [system::wordswap16 [string range $rawchunk $startdata end]]]
+                                set encoding_selected "unicode (wordswapped 16)"
+                            }
+                        } elseif {$bomenc eq "utf-16be"} {
+                            if {$::tcl_platform(byteOrder) eq "littleEndian"} {
+                                set datachunk [encoding convertfrom unicode [system::wordswap16 [string range $rawchunk $startdata end]]]
+                                set encoding_selected "unicode (wordswapped 16)"
+                            } else {
+                                set datachunk [encoding convertfrom unicode [string range $rawchunk $startdata end]]
+                                set encoding_selected unicode
+                            }
+                        } elseif {$bomenc eq "utf-32le"} {
+                            if {$::tcl_platform(byteOrder) eq "littleEndian"} {
+                                set datachunk [encoding convertfrom unicode [string range $rawchunk $startdata end]]
+                                set encoding_selected unicode
+                            } else {
+                                set datachunk [encoding convertfrom unicode [system::wordswap32 [string range $rawchunk $startdata end]]]
+                                set encoding_selected "unicode (wordswapped 32)"
+                            }
+                        } elseif {$bomenc eq "utf-32be"} {
+                            if {$::tcl_platform(byteOrder) eq "littleEndian"} {
+                                set datachunk [encoding convertfrom unicode [system::wordswap32 [string range $rawchunk $startdata end]]]
+                                set encoding_selected "unicode (wordswapped 32)"
+                            } else {
+                                set datachunk [encoding convertfrom unicode [string range $rawchunk $startdata end]]
+                                set encoding_selected unicode
+                            }
+                        } else {
+                            error "Encoding $bomenc unavailable in this version of Tcl"
+                        }
+                    }  else {
+                        set datachunk [encoding convertfrom $bomenc [string range $rawchunk $startdata end]]
+                        set encoding_selected $bomenc
+                    }                               
+                } else {
+                    #tcl 8.7 plus has utf-16le etc
+                    set datachunk [encoding convertfrom $bomenc [string range $rawchunk $startdata end]]
+                    set encoding_selected $bomenc
+                }
+            } else {
+                if {$bomenc eq "binary"} {
+                    set datachunk [string range $rawchunk $startdata end]
+                    set encoding_selected binary 
+                } else {
+                    set datachunk [encoding convertfrom utf-8 [string range $rawchunk $startdata end]]
+                    set encoding_selected utf-8
+                }
+            }
+        } else {
+            #manually specified encoding overrides bom - but still remove bom-chars REVIEW
+            #e.g we still want bom info - but specify binary encoding
+
+            if {$opt_encoding eq "binary"} {
+                set datachunk [string range $rawchunk $startdata end]
+            } else {
+                set datachunk [encoding convertfrom $opt_encoding [string range $rawchunk $startdata end]]
+            }
+            set encoding_selected $opt_encoding
+        }
+
         set textobj [class::textinfo new $datachunk]
+        if {$bomid ne ""} {
+            $textobj set_bomid $bomid
+        }
+
+
+
+
         set summary ""
-        append summary "Bytes loaded           :  [$textobj chunklen]" \n
+        append summary "Bytes loaded           :  $rawlen" \n
+        append summary "BOM ID                 :  $bomid" \n
+        append summary "Encoding selected      :  $encoding_selected" \n
+        append summary "Characters             :  [$textobj chunklen]" \n
         append summary "Lines recognised       :  [$textobj linecount]" \n
         set leinfo [$textobj chunk_le_counts 0 end]
         append summary "crlf endings (windows) :  [dict get $leinfo crlf]" \n
@@ -1265,7 +1497,6 @@ namespace eval punk::fileline::lib {
     #[list_begin definitions]
 
 
-
     proc range_spans_chunk_boundaries {start end chunksize args} {
         #*** !doctools
         #[call [fun lib::range_spans_chunk_boundaries] [arg start] [arg end] [arg chunksize]]
@@ -1330,6 +1561,23 @@ namespace eval punk::fileline::system {
     #[subsection {Namespace punk::fileline::system}]
     #[para] Internal functions that are not part of the API 
 
+    proc wordswap16 {data} {
+        #scan in one endianness - format in the other. Whether we scan le/be first doesn't matter as long as we format using the opposite endianness
+        binary scan $data s* elements ;#scan little endian
+        return [binary format S* $elements] ;#format big endian 
+    }
+    proc wordswap32 {data} {
+        binary scan $data i* elements
+        return [binary format I* $elements]
+    }
+
+    proc scan32bit_be {i32} {
+        if {[binary scan $i32 I x]} {
+            return $x
+        } else {
+            error "couldn't scan $i32"
+        }
+    }
 
     #for 8.7+ using lseq
     #much faster when resultant boundary size is large (at least when offset 0)
diff --git a/src/modules/punk/flib-999999.0a1.0.tm b/src/modules/punk/flib-999999.0a1.0.tm
index 5bea55bc..71ca97b1 100644
--- a/src/modules/punk/flib-999999.0a1.0.tm
+++ b/src/modules/punk/flib-999999.0a1.0.tm
@@ -9,7 +9,7 @@
 # @@ Meta Begin
 # Application punk::flib 999999.0a1.0
 # Meta platform     tcl
-# Meta license      <unspecified>
+# Meta license      BSD 
 # @@ Meta End
 
 
@@ -19,12 +19,12 @@
 #*** !doctools
 #[manpage_begin punkshell_module_punk::flib 0 999999.0a1.0]
 #[copyright "2024"]
-#[titledesc {Module API}]  [comment {-- Name section and table of contents description --}]
-#[moddesc {-}]             [comment {-- Description at end of page heading --}] 
+#[titledesc {flib experimental}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {experimental pattern library}]             [comment {-- Description at end of page heading --}] 
 #[require punk::flib]
-#[keywords module]
+#[keywords module experimental]
 #[description]
-#[para] -
+#[para] Experimental 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 
@@ -32,7 +32,7 @@
 #[section Overview]
 #[para] overview of punk::flib
 #[subsection Concepts]
-#[para] -
+#[para] Experiments in functional program related features and integration with the pattern library 
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
@@ -45,8 +45,10 @@
 #[list_begin itemized]
 
 package require Tcl 8.6
+package require pattern
 #*** !doctools
 #[item] [package {Tcl 8.6}]
+#[item] [package {pattern 1.2.4}]
 
 # #package require frobz
 # #*** !doctools
diff --git a/src/modules/punk/lib-0.1.tm b/src/modules/punk/lib-0.1.tm
deleted file mode 100644
index 89e446fd..00000000
--- a/src/modules/punk/lib-0.1.tm
+++ /dev/null
@@ -1,10 +0,0 @@
-package provide punk::lib [namespace eval punk::lib {
-	variable version
-	set version 0.1
-}]
-
-namespace eval punk::lib {
-  
-
-}
-
diff --git a/src/modules/punk/lib-999999.0a1.0.tm b/src/modules/punk/lib-999999.0a1.0.tm
new file mode 100644
index 00000000..a747e7fb
--- /dev/null
+++ b/src/modules/punk/lib-999999.0a1.0.tm
@@ -0,0 +1,619 @@
+# -*- tcl -*-
+# Maintenance Instruction: leave the 999999.xxx.x as is and use punkshell 'pmix make' or bin/punkmake  to update from <pkg>-buildversion.txt
+# module template: punkshell/src/decktemplates/vendor/punk/modules/template_module-0.0.2.tm
+#
+# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
+# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# (C) 2024
+#
+# @@ Meta Begin
+# Application punk::lib 999999.0a1.0
+# Meta platform     tcl
+# Meta license      BSD 
+# @@ Meta End
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin punkshell_module_punk::lib 0 999999.0a1.0]
+#[copyright "2024"]
+#[titledesc {punk general utility functions}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {punk library}]             [comment {-- Description at end of page heading --}] 
+#[require punk::lib]
+#[keywords module utility lib]
+#[description]
+#[para]This is a set of utility functions that are commonly used across punk modules or are just considered to be general-purpose functions. 
+#[para]The base set includes string and math functions but has no specific theme
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of punk::lib
+#[subsection Concepts]
+#[para]The punk::lib modules should have no strong dependencies other than Tcl 
+#[para]Dependendencies that only affect display or additional functionality may be included - but should fail gracefully if not present, and only when a function is called that uses one of these soft dependencies.
+#[para]This requirement for no strong dependencies, means that many utility functions that might otherwise seem worthy of inclusion here are not present.
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Requirements
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by punk::lib
+#[list_begin itemized]
+
+package require Tcl 8.6
+#*** !doctools
+#[item] [package {Tcl 8.6}]
+
+# #package require frobz
+# #*** !doctools
+# #[item] [package {frobz}]
+
+#*** !doctools
+#[list_end]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section API]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# oo::class namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+namespace eval punk::lib::class {
+    #*** !doctools
+    #[subsection {Namespace punk::lib::class}]
+    #[para] class definitions
+    if {[info commands [namespace current]::interface_sample1] eq ""} {
+        #*** !doctools
+        #[list_begin enumerated]
+
+        # oo::class create interface_sample1 {
+        #     #*** !doctools
+        #     #[enum] CLASS [class interface_sample1]
+        #     #[list_begin definitions]
+
+        #     method test {arg1} {
+        #         #*** !doctools
+        #         #[call class::interface_sample1    [method test] [arg arg1]]
+        #         #[para] test method
+        #         puts "test: $arg1"
+        #     }
+
+        #     #*** !doctools
+        #     #[list_end] [comment {-- end definitions interface_sample1}]
+        # }
+
+        #*** !doctools
+        #[list_end] [comment {--- end class enumeration ---}]
+    }
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# Base namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+namespace eval punk::lib {
+    namespace export *
+    #variable xyz
+
+    #*** !doctools
+    #[subsection {Namespace punk::lib}]
+    #[para] Core API functions for punk::lib 
+    #[list_begin definitions]
+
+
+
+    #proc sample1 {p1 n args} {
+    #    #*** !doctools
+    #    #[call [fun sample1] [arg p1] [arg n] [opt {option value...}]]
+    #    #[para]Description of sample1 
+    #    #[para] Arguments:
+    #    #   [list_begin arguments]
+    #    #   [arg_def tring p1]       A description of string argument p1.
+    #    #   [arg_def integer n]      A description of integer argument n.
+    #    #   [list_end]
+    #    return "ok" 
+    #}
+
+    proc K {x y} {return $x}
+    #*** !doctools
+    #[call [fun K] [arg x] [arg y]]
+    #[para]The K-combinator function - returns the first argument, x and discards y 
+    #[para]see [uri https://wiki.tcl-lang.org/page/K]
+    #[para]It is used in cases where command-substitution at the calling-point performs some desired effect. 
+
+    proc hex2dec {args} {
+        #*** !doctools
+        #[call [fun hex2dec] [opt {option value...}] [arg list_largeHex]]
+        #[para]Convert a list of (possibly large) unprefixed hex strings to their decimal values
+        #[para]hex2dec accepts and ignores internal underscores in the same manner as Tcl 8.7+ numbers e.g  hex2dec FF_FF returns 65535
+        #[para]Leading and trailing underscores are ignored as a matter of implementation convenience - but this shouldn't be relied upon.
+        #[para]Leading or trailing whitespace in each list member is allowed e.g hex2dec " F" returns 15
+        #[para]Internal whitespace e.g "F F" is not permitted - but a completely empty element "" is allowed and will return 0
+
+        set list_largeHex [lindex $args end]
+        set argopts [lrange $args 0 end-1]
+        if {[llength $argopts]%2 !=0} {
+            error "[namespace current]::hex2dec arguments prior to list_largeHex must be option/value pairs - received '$argopts'"
+        }
+        set defaults [dict create\
+            -validate 1\
+            -empty_as_hex "INVALID set -empty_as_hex to a hex string e.g FF if empty values should be replaced"\
+        ]
+        set known_opts [dict keys $defaults]
+        set fullopts [dict create]
+        dict for {k v} $argopts {
+            dict set fullopts [tcl::prefix match -message "options for hex2dec. Unexpected option" $known_opts $k] $v
+        }
+        set opts [dict merge $defaults $fullopts]
+        # -- --- --- --- 
+        set opt_validate [dict get $opts -validate]
+        set opt_empty [dict get $opts -empty_as_hex]
+        # -- --- --- --- 
+
+        set list_largeHex [lmap h $list_largeHex[unset list_largeHex] {string map [list _ ""] [string trim $h]}]
+        if {$opt_validate} {
+            #Note appended F so that we accept list of empty strings as per the documentation
+            if {![string is xdigit -strict [join $list_largeHex ""]F ]} {
+                error "[namespace current]::hex2dec error: non-hex digits encountered after stripping underscores and leading/trailing whitespace for each element\n $list_largeHex"
+            }
+        }
+        if {![string is xdigit -strict [string map [list _ ""] $opt_empty]]} {
+            #mapping empty string to a value destroys any advantage of -scanonly
+            #todo - document that -scanonly has 2 restrictions - each element must be valid hex and less than 7 chars long
+            #set list_largeHex [lmap v $list_largeHex[set list_largeHex {}] {expr {$v eq ""} ? {0} : {[set v]}}]
+            if {[lsearch $list_largeHex ""] >=0} {
+                error "[namespace current]::hex2dec error: empty values in list cannot be mapped to non-hex $opt_empty"
+            }
+        } else {
+            set opt_empty [string trim [string map [list _ ""] $opt_empty]]
+            if {[set first_empty [lsearch $list_largeHex ""]] >= 0} {
+                #set list_largeHex [lmap v $list_largeHex[set list_largeHex {}] {expr {$v eq ""} ? {$opt_empty} : {$v}}]
+                set nonempty_head [lrange $list_largeHex 0 $first_empty-1]
+                set list_largeHex [concat $nonempty_head [lmap v [lrange $list_largeHex $first_empty end] {expr {$v eq ""} ? {$opt_empty} : {$v}}]] 
+            }
+        }
+        return [scan $list_largeHex [string repeat %llx [llength $list_largeHex]]]
+    }
+
+    proc dec2hex {args} {
+        #*** !doctools
+        #[call [fun dex2hex] [opt {option value...}] [arg list_decimals]]
+        #[para]Convert a list of decimal integers to a list of hex values
+        #[para] -width <int> can be used to make each hex value at least int characters wide, with leading zeroes.
+        #[para] -case upper|lower determines the case of the hex letters in the output
+        set list_decimals [lindex $args end]
+        set argopts [lrange $args 0 end-1]
+        if {[llength $argopts]%2 !=0} {
+            error "[namespace current]::dec2hex arguments prior to list_decimals must be option/value pairs - received '$argopts'"
+        }
+        set defaults [dict create\
+            -width 1\
+            -case upper\
+            -empty_as_decimal "INVALID set -empty_as_decimal to a number if empty values should be replaced"\
+        ]
+        set known_opts [dict keys $defaults]
+        set fullopts [dict create]
+        dict for {k v} $argopts {
+            dict set fullopts [tcl::prefix match -message "options for [namespace current]::dec2hex. Unexpected option" $known_opts $k] $v
+        }
+        set opts [dict merge $defaults $fullopts]
+        # -- --- --- ---
+        set opt_width       [dict get $opts -width]
+        set opt_case        [dict get $opts -case]
+        set opt_empty       [dict get $opts -empty_as_decimal]
+        # -- --- --- ---
+        
+
+        set resultlist [list]
+        if {[string tolower $opt_case] eq "upper"} {
+            set spec X
+        } elseif {[string tolower $opt_case] eq "lower"} {
+            set spec x
+        } else {
+            error "[namespace current]::dec2hex unknown value '$opt_case' for -case expected upper|lower"
+        }
+        set fmt "%${opt_width}.${opt_width}ll${spec}"
+
+        set list_decimals [lmap d $list_decimals[unset list_decimals] {string map [list _ ""] [string trim $d]}]
+        if {![string is digit -strict [string map [list _ ""] $opt_empty]]} {
+            if {[lsearch $list_decimals ""] >=0} {
+                error "[namespace current]::dec2hex error: empty values in list cannot be mapped to non-decimal $opt_empty"
+            }
+        } else {
+            set opt_empty [string map [list _ ""] $opt_empty]
+            if {[set first_empty [lsearch $list_decimals ""]] >= 0} {
+                set nonempty_head [lrange $list_decimals 0 $first_empty-1]
+                set list_decimals [concat $nonempty_head [lmap v [lrange $list_decimals $first_empty end] {expr {$v eq ""} ? {$opt_empty} : {$v}}]]
+            }
+        }
+        return [format [lrepeat [llength $list_decimals] $fmt] {*}$list_decimals]
+    }
+
+    proc log2 x "expr {log(\$x)/[expr log(2)]}"
+        #*** !doctools
+        #[call [fun log2] [arg x]]
+        #[para]log base2 of x
+        #[para]This uses a 'live' proc body - the divisor for the change of base is computed once at definition time
+        #[para](courtesy of RS [uri https://wiki.tcl-lang.org/page/Additional+math+functions])
+
+    proc logbase {b x} {
+        #*** !doctools
+        #[call [fun logbase] [arg b] [arg x]]
+        #[para]log base b of x
+        #[para]This function uses expr's natural log and the change of base division.
+        #[para]This means for example that we can get results like: logbase 10 1000 = 2.9999999999999996
+        #[para]Use expr's log10() function or tcl::mathfunc::log10 for base 10 
+        expr {log($x)/log($b)}
+    }
+    proc factors {x} {
+        #*** !doctools
+        #[call [fun factors] [arg x]]
+        #[para]Return a sorted list of the positive factors of x where x > 0
+        #[para]For x = 0 we return only 0 and 1 as technically any number divides zero and there are an infinite number of factors. (including zero itself in this context)*
+        #[para]This is a simple brute-force implementation that iterates all numbers below the square root of x to check the factors
+        #[para]Because the implementation is so simple - the performance is very reasonable for numbers below at least a few 10's of millions 
+        #[para]See tcllib math::numtheory::factors for a more complex implementation - which seems to be slower for 'small' numbers 
+        #[para]Comparisons were done with some numbers below 17 digits long
+        #[para]For seriously big numbers - this simple algorithm would no doubt be outperformed by more complex algorithms. 
+        #[para]The numtheory library stores some data about primes etc with each call - so may become faster when being used on more numbers
+        #but has the disadvantage of being slower for 'small' numbers and using more memory.  
+        #[para]If the largest factor below x is needed - the greatestOddFactorBelow and GreatestFactorBelow functions are a faster way to get there than computing the whole list, even for small values of x
+        #[para]* Taking x=0; Notion of x being divisible by integer y being: There exists an integer p such that x = py   
+        #[para]  In other mathematical contexts zero may be considered not to divide anything.
+        set factors [list 1]
+        set j 2
+        set max [expr {sqrt($x)}]
+        while {$j <= $max} {
+            if {($x % $j) == 0} {
+                lappend factors $j [expr {$x / $j}]
+            }
+            incr j
+        }
+        lappend factors $x
+        return [lsort -unique -integer $factors]
+    }
+    proc oddFactors {x} {
+        #*** !doctools
+        #[call [fun oddFactors] [arg x]]
+        #[para]Return a list of odd integer factors of x, sorted in ascending order 
+        set j 2
+        set max [expr {sqrt($x)}]
+        set factors [list 1]
+        while {$j <= $max} {
+            if {$x % $j == 0} {
+                set other [expr {$x / $j}]
+                if {$other % 2 != 0} {
+                    if {$other ni $factors} {
+                        lappend factors $other
+                    }
+                }
+                if {$j % 2 != 0} {
+                    if {$j ni $factors} {
+                        lappend factors $j
+                    }
+                }
+            }
+            incr j
+        }
+        return [lsort -integer -increasing $factors]
+    }
+    proc greatestFactorBelow {x} {
+        #*** !doctools
+        #[call [fun greatestFactorBelow] [arg x]]
+        #[para]Return the largest factor of x excluding itself
+        #[para]factor functions can be useful for console layout calculations
+        #[para]See Tcllib math::numtheory for more extensive implementations
+        if {$x % 2 == 0 || $x == 0} {
+            return [expr {$x / 2}]
+        }
+        set j 3
+        set max [expr {sqrt($x)}]
+        while {$j <= $max} {
+            if {$x % $j == 0} {
+                return [expr {$x / $j}] 
+            }
+            incr j 2
+        }
+        return 1
+    }
+    proc greatestOddFactorBelow {x} {
+        #*** !doctools
+        #[call [fun greatestOddFactorBelow] [arg x]]
+        #[para]Return the largest odd integer factor of x excluding x itself
+        if {$x %2 == 0} {
+            return [greatestOddFactor $x]
+        }
+        set j 3
+        #dumb brute force - time taken to compute is wildly variable on big numbers
+        #todo - use a (memoized?) generator of primes to reduce the search space
+        #tcllib math::numtheory has suitable functions - but do we want that dependency here? Testing shows brute-force often faster for small numbers.
+        set god 1
+        set max [expr {sqrt($x)}]
+        while { $j <= $max} {
+            if {$x % $j == 0} {
+                set other [expr {$x / $j}]
+                if {$other % 2 == 0} {
+                    set god $j
+                } else {
+                    set god [expr {$x / $j}] 
+                    #lowest j - so other side must be highest
+                    break
+                }
+            }
+            incr j 2
+        }
+        return $god 
+    }
+    proc greatestOddFactor {x} {
+        #*** !doctools
+        #[call [fun greatestOddFactor] [arg x]]
+        #[para]Return the largest odd integer factor of x
+        #[para]For an odd value of x - this will always return x
+        if {$x % 2 != 0 || $x == 0} {
+            return $x
+        }
+        set r [expr {$x / 2}]
+        while {$r % 2 == 0} {
+            set r [expr {$r / 2}]
+        }
+        return $r
+    }
+    proc gcd {n m} {
+        #*** !doctools
+        #[call [fun gcd] [arg n] [arg m]]
+        #[para]Return the greatest common divisor of m and n
+        #[para]Straight from Lars Hellström's math::numtheory library  in Tcllib
+        #[para]Graphical use:
+        #[para]An a by b rectangle can be covered with square tiles of side-length c,
+        #[para]only if c is a common divisor of a and b
+
+        #
+        # Apply Euclid's good old algorithm
+        #
+        if { $n > $m } {
+            set t $n
+            set n $m
+            set m $t
+        }
+
+        while { $n > 0 } {
+            set r [expr {$m % $n}]
+            set m $n
+            set n $r
+        }
+
+        return $m
+    }
+    proc lcm {n m} {
+        #*** !doctools
+        #[call [fun gcd] [arg n] [arg m]]
+        #[para]Return the lowest common multiple of m and n
+        #[para]Straight from Lars Hellström's math::numtheory library  in Tcllib
+        #[para]
+        set gcd [gcd $n $m]
+        return [expr {$n*$m/$gcd}]
+    }
+    proc commonDivisors {x y} {
+        #*** !doctools
+        #[call [fun commonDivisors] [arg x] [arg y]]
+        #[para]Return a list of all the common factors of x and y
+        #[para](equivalent to factors of their gcd)
+        return [factors [gcd $x $y]] 
+    }
+
+    #experimental only - there are better/faster ways
+    proc sieve n {
+        set primes [list]
+        if {$n < 2} {return $primes}
+        set nums [dict create]
+        for {set i 2} {$i <= $n} {incr i} {
+            dict set nums $i ""
+        }
+        set next 2
+        set limit [expr {sqrt($n)}]
+        while {$next <= $limit} {
+            for {set i $next} {$i <= $n} {incr i $next} {dict unset nums $i}
+            lappend primes $next
+            dict for {next -} $nums break
+        }
+        return [concat $primes [dict keys $nums]]
+    }
+    proc sieve2 n {
+        set primes [list]
+        if {$n < 2} {return $primes}
+        set nums [dict create]
+        for {set i 2} {$i <= $n} {incr i} {
+            dict set nums $i ""
+        }
+        set next 2
+        set limit [expr {sqrt($n)}]
+        while {$next <= $limit} {
+            for {set i $next} {$i <= $n} {incr i $next} {dict unset nums $i}
+            lappend primes $next
+            #dict for {next -} $nums break
+            set next [lindex $nums 0]
+        }
+        return [concat $primes [dict keys $nums]]
+    }
+
+    proc hasglobs {str} {
+        #*** !doctools
+        #[call [fun hasglobs] [arg str]]
+        #[para]Return a boolean indicating whether str contains any of the glob characters: * ? [lb] [rb] 
+        #[para]hasglobs uses append to preserve Tcls internal representation for str - so it should help avoid shimmering in the few cases where this may matter. 
+        regexp {[*?\[\]]} [append obj2 $str {}] ;# int-rep preserving
+    }
+
+    proc trimzero {number} {
+        #*** !doctools
+        #[call [fun trimzero] [arg number]]
+        #[para]Return number with left-hand-side zeros trimmed off - unless all zero
+        #[para]If number is all zero - a single 0 is returned
+        set trimmed [string trimleft $number 0]
+        if {[string length $trimmed] == 0} {
+            set trimmed 0
+        }
+        return $trimmed
+    }
+    proc substring_count {str substring} {
+        #*** !doctools
+        #[call [fun substring_count] [arg str] [arg substring]]
+        #[para]Search str and return number of occurrences of substring 
+
+        #faster than lsearch on split for str of a few K
+        if {$substring eq ""} {return 0}
+        set occurrences [expr {[string length $str]-[string length [string map [list $substring {}] $str]]}]
+        return [expr {$occurrences / [string length $substring]}]
+    }
+
+    proc dict_merge_ordered {defaults main} {
+        #*** !doctools
+        #[call [fun dict_merge_ordered] [arg defaults] [arg main]]
+        #[para]The standard dict merge accepts multiple dicts with values from dicts to the right (2nd argument) taking precedence.
+        #[para]When merging with a dict of default values - this means that any default key/vals that weren't in the main dict appear in the output before the main data.
+        #[para]This function merges the two dicts whilst maintaining the key order of main followed by defaults.
+
+        #1st merge (inner merge) with wrong values taking precedence - but right key-order  - then (outer merge) restore values
+        return [dict merge [dict merge $main $defaults] $main] 
+    }
+
+    proc askuser {question} {
+        #*** !doctools
+        #[call [fun askuser] [arg question]]
+        #[para]A very basic utility to read an answer from stdin
+        #[para]The prompt is written to the terminal and then it waits for a user to type something
+        #[para]stdin is temporarily configured to blocking and then put back in its original state in case it wasn't already so. 
+        #[para]The user must hit enter to submit the response
+        #[para]The return value is the string if any that was typed prior to hitting enter.
+        #[para]The question argument can be manually colourised using the various punk::ansi funcitons
+        #[example_begin]
+        #   set answer [lb]punk::lib::askuser "[lb]a+ green bold[rb]Do you want to proceed? (Y|N)[lb]a[rb]"[rb]
+        #   if {[lb]string match y* [lb]string tolower $answer[rb][rb]} {
+        #       puts "Proceeding"
+        #   } else {
+        #       puts "Cancelled by user" 
+        #   }
+        #[example_end]
+        puts stdout $question
+        flush stdout
+        set stdin_state [fconfigure stdin]
+        try {
+            fconfigure stdin -blocking 1
+            set answer [gets stdin]
+        } finally {
+            fconfigure stdin -blocking [dict get $stdin_state -blocking]
+        }
+        return $answer
+    }
+
+    #*** !doctools
+    #[list_end] [comment {--- end definitions namespace punk::lib ---}]
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+
+
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#todo - way to generate 'internal' docs separately?
+#*** !doctools
+#[section Internal]
+namespace eval punk::lib::system {
+    #*** !doctools 
+    #[subsection {Namespace punk::lib::system}]
+    #[para] Internal functions that are not part of the API 
+    #[list_begin definitions]
+
+    proc mostFactorsBelow {n} {
+        ##*** !doctools
+        #[call [fun mostFactorsBelow] [arg n]]
+        #[para]Find the number below $n which has the greatest number of factors
+        #[para]This will get slow quickly as n increases (100K = 1s+ 2024) 
+        set most 0
+        set mostcount 0
+        for {set i 1} {$i < $n} {incr i} {
+            set fc [llength [punk::lib::factors $i]]
+            if {$fc > $mostcount} {
+                set most $i
+                set mostcount $fc
+            }
+        }
+        return [list number $most numfactors $mostcount]
+    }
+    proc factorCountBelow_punk {n} {
+        ##*** !doctools 
+        #[call [fun factorCountBelow] [arg n]]
+        #[para]For numbers 1 to n - keep a tally of the total count of factors 
+        #[para]This is not useful other than a quick and dirty check that different algorithms return *probably* the same result
+        #[para]and as a rudimentary performance comparison
+        #[para]gets slow quickly!
+        set tally 0
+        for {set i 1} {$i <= $n} {incr i} {
+            incr tally [llength [punk::lib::factors $i]]
+        }
+        return $tally
+    }
+    proc factorCountBelow_numtheory {n} {
+        ##*** !doctools 
+        #[call [fun factorCountBelow] [arg n]]
+        #[para]For numbers 1 to n - keep a tally of the total count of factors 
+        #[para]This is not useful other than a quick and dirty check that different algorithms return *probably* the same result
+        #[para]and as a rudimentary performance comparison
+        #[para]gets slow quickly! (significantly slower than factorCountBelow_punk)
+        package require math::numtheory
+        set tally 0
+        for {set i 1} {$i <= $n} {incr i} {
+            incr tally [llength [math::numtheory::factors $i]]
+        }
+        return $tally
+    }
+
+    proc factors2 {x} {
+        ##*** !doctools
+        #[call [fun factors2] [arg x]]
+        #[para]Return a sorted list of factors of x
+        #[para]A similar brute-force mechanism to factors - but keeps result ordering as we go.
+        set smallfactors [list 1]
+        set j 2
+        set max [expr {sqrt($x)}]
+        while {$j < $max} {
+            if {($x % $j) == 0} {
+                lappend smallfactors $j
+                lappend largefactors [expr {$x / $j}]
+            }
+            incr j
+        }
+        #handle sqrt outside loop so we don't have to sort/dedup or check list membership in main loop
+        if {($x % $j) == 0} {
+            if {$j == ($x / $j)} {
+                lappend smallfactors $j
+            }
+        }
+        return [concat $smallfactors [lreverse $largefactors] $x]
+    }
+
+
+    #*** !doctools
+    #[list_end] [comment {--- end definitions namespace punk::lib::system ---}]
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Ready   
+package provide punk::lib [namespace eval punk::lib {
+    variable pkg punk::lib
+    variable version
+    set version 999999.0a1.0 
+}]
+return
+
+#*** !doctools
+#[manpage_end]
+
diff --git a/src/modules/punk/lib-buildversion.txt b/src/modules/punk/lib-buildversion.txt
new file mode 100644
index 00000000..f47d01c8
--- /dev/null
+++ b/src/modules/punk/lib-buildversion.txt
@@ -0,0 +1,3 @@
+0.1.0
+#First line must be a semantic version number
+#all other lines are ignored.
diff --git a/src/modules/punk/mix-0.2.tm b/src/modules/punk/mix-0.2.tm
index 482c79a4..f24deb65 100644
--- a/src/modules/punk/mix-0.2.tm
+++ b/src/modules/punk/mix-0.2.tm
@@ -5,7 +5,12 @@ package require punk::cap::handlers::templates ;#handler for templates cap
 punk::cap::register_capabilityname punk.templates ::punk::cap::handlers::templates 
 
 package require punk::mix::templates ;#registers as provider pkg for 'punk.templates' capability with punk::cap
-punk::mix::templates::provider register *
+if {[catch {punk::mix::templates::provider register *} errM]} {
+    puts stderr "punk::mix failure during punk::mix::templates::provider register *"
+    puts stderr $errM
+    puts stderr "-----"
+    puts stderr $::errorInfo
+}
 
 package require punk::mix::base
 package require punk::mix::cli
diff --git a/src/modules/punk/mix/base-0.1.tm b/src/modules/punk/mix/base-0.1.tm
index 42cdbac0..e9977bec 100644
--- a/src/modules/punk/mix/base-0.1.tm
+++ b/src/modules/punk/mix/base-0.1.tm
@@ -371,67 +371,24 @@ namespace eval punk::mix::base {
         }
 
         #get_template_basefolders
-        #   scriptpath - file or folder
-        #   It represents the base point from which to search for mixtemplates folders either directly related to the scriptpath (../) or in the containing project if any
+        #   startpath - file or folder
+        #   It represents the base point from which to search for templates folders either directly related to the scriptpath (../) or in the containing project if any
         #   The cwd will also be searched for project root - but with lower precedence in the resultset (later in list)
-        proc get_template_basefolders {{scriptpath ""}} {
-            #1 lowest precedence - templates from packages (ordered by order in which packages registered with punk::cap)
-            set folderdict [dict create]
+        proc get_template_basefolders {{startpath ""}} {
+            # templates from punk.templates provider packages (ordered by order in which packages registered with punk::cap)
+            if {[file isfile $startpath]} {
+                set startpath [file dirname $startpath]
+            }
 
             package require punk::cap
             if {[punk::cap::capability_has_handler punk.templates]} {
-                set template_folder_dict [punk::cap::call_handler punk.templates folders]
-                dict for {dir folderinfo} $template_folder_dict {
-                    #
-                    dict set folderdict $dir $folderinfo
-                }
+                set template_folder_dict [punk::cap::call_handler punk.templates folders -startdir $startpath]
             } else {
                 put stderr "get_template_basefolders WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
             }
 
-            #2 ADHOC templates folder relative to cwd.  higher precedence 
-            set searchbase [pwd] 
-            set fld [file join $searchbase templates]
-            if {[file isdirectory $fld]} {
-                if {![dict exists $folderdict $fld]} {
-                    dict set folderdict $fld [list source $searchbase sourcetype cwd pathtype adhoc vendor _project]
-                }
-            }
-
-
-            if 0 {
-                set pathinfo    [punk::repo::find_repos $searchbase]
-                set pwd_projectroot [dict get $pathinfo closest]
-                if {$pwd_projectroot ne ""} {
-                    set fld [file join $pwd_projectroot src/mixtemplates]
-                    if {![dict exists $folderdict $fld]} {
-                        dict set folderdict $fld [list source $pwd_projectroot sourcetype project]
-                    }
-                }
-
-                #3 highest precedence - mixtemplates relative to scriptpath argument
-                if {$scriptpath ne ""} {
-                    if {[file type $scriptpath] eq "file"} {
-                        set searchbase [file dirname $scriptpath]
-                    } else {
-                        set searchbase $scriptpath
-                    }
-                    if {[file isdirectory [file join $searchbase mixtemplates]]} {
-                        dict set folderdict [file join $searchbase mixtemplates] [list source $searchbase sourcetype pathsearch]
-                    }
-                    set pathinfo    [punk::repo::find_repos $searchbase]
-                    set scriptpath_projectroot [dict get $pathinfo closest]
-                    if {$scriptpath_projectroot ne ""} {
-                        set fld [file join $scriptpath_projectroot src/mixtemplates]
-                        if {[file isdirectory $fld]} {
-                            dict set folderdict $fld [list source $scriptpath_projectroot sourcetype project]
-                        }
-                    }
-                }
-            }
-
             #don't sort - order in which encountered defines the precedence - with later overriding earlier
-            return $folderdict
+            return $template_folder_dict
         }
 
         proc module_subpath {modulename} {
diff --git a/src/modules/punk/mix/cli-0.3.tm b/src/modules/punk/mix/cli-0.3.tm
index bb2292ea..13d75d78 100644
--- a/src/modules/punk/mix/cli-0.3.tm
+++ b/src/modules/punk/mix/cli-0.3.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
@@ -128,7 +128,7 @@ namespace eval punk::mix::cli {
 
         #review - why can't we be anywhere in the project? 
         if {([file tail $sourcefolder] ne "src") || (![file exists $sourcefolder/make.tcl])} {
-            puts stderr "pmix make must be run from src folder containing make.tcl - unable to proceed (cwd: [pwd])"
+            puts stderr "deck make must be run from src folder containing make.tcl - unable to proceed (cwd: [pwd])"
             if {[string length $project_base]} {
                 if {[file exists $project_base/src] && [string tolower [pwd]] ne [string tolower $project_base/src]} {
                     puts stderr "Try cd to $project_base/src"
@@ -364,7 +364,7 @@ namespace eval punk::mix::cli {
                     if {"project" in $repotypes} {
                         #punk project
                         if {![catch {package require textblock; package require patternpunk}]} {
-                           set result [textblock::join [textblock::join [>punk . logo] "  "] $result]
+                           set result [textblock::join [>punk . logo] "  " $result] 
                            append result \n
                         } 
                     }  
@@ -727,8 +727,8 @@ namespace eval punk::mix::cli {
         proc kettle_reinit {} {
             variable kettle_reset_bodies
             variable kettle_reset_args
-            foreach p [dict keys $kettle_reset_bodies] {
-                set b [dict get $kettle_reset_bodies $p]
+            dict for {p b} $kettle_reset_bodies {
+                #set b [dict get $kettle_reset_bodies $p]
                 set argl [dict get $kettle_reset_args $p]
                 uplevel 1 [list ::proc $p $argl $b]
             }
@@ -751,7 +751,7 @@ namespace eval punk::mix::cli {
                 gui\
             ]
             #set ::kettle::recipe::recipe [dict create]
-            foreach r [dict keys $::kettle::recipe::recipe] {
+            dict for {r -} $::kettle::recipe::recipe {
                 if {$r ni $standard_recipes} {
                     dict unset ::kettle::recipe::recipe $r
                 }
@@ -760,14 +760,14 @@ namespace eval punk::mix::cli {
         proc kettle_call {calltype args} {
             variable kettle_reset_bodies
             if {$calltype ni [list lib shell]} {
-                error "pmix kettle_call 1st argument must be one of: 'lib' for direct use of kettle module or 'shell' to call as separate process"
+                error "deck kettle_call 1st argument must be one of: 'lib' for direct use of kettle module or 'shell' to call as separate process"
             }
             if {$calltype eq "shell"} {
                 set kettleappfile [file dirname [info nameofexecutable]]/kettle
                 set kettlebatfile [file dirname [info nameofexecutable]]/kettle.bat
 
                 if {(![file exists $kettleappfile]) && (![file exists $kettlebatfile])} {
-                    error "pmix kettle_call unable to find installed kettle application file '$kettleappfile' (or '$kettlebatfile' if on windows)"
+                    error "deck kettle_call unable to find installed kettle application file '$kettleappfile' (or '$kettlebatfile' if on windows)"
                 }
                 if {[file exists $kettleappfile]} {
                     set kettlescript $kettleappfile
@@ -780,7 +780,7 @@ namespace eval punk::mix::cli {
             }
             set startdir [pwd]
             if {![file exists $startdir/build.tcl]} {
-                error "pmix kettle must be run from a folder containing build.tcl (cwd: [pwd])"
+                error "deck kettle must be run from a folder containing build.tcl (cwd: [pwd])"
             }
             if {[package provide kettle] eq ""} {
                 puts stdout "Loading kettle package - may be delay on first load ..."
@@ -797,7 +797,7 @@ namespace eval punk::mix::cli {
             }
             set first [lindex $args 0] 
             if {[string match @* $first]} {
-                error "pmix kettle doesn't support special operations - try calling tclsh kettle directly"
+                error "deck kettle doesn't support special operations - try calling tclsh kettle directly"
             }
             if {$first eq "-f"} {
                 set args [lassign $args __ path]
@@ -839,7 +839,7 @@ namespace eval punk::mix::cli {
                     --* {
                         #instead of using: kettle option known
                         if {$o ni $knownopts} {
-                            error "Unable to process unknown option $o." {} [list KETTLE (pmix)]
+                            error "Unable to process unknown option $o." {} [list KETTLE (deck)]
                         }
                         lappend opts $o [lindex $args 1]
                         #::kettle::option set $o [lindex $args 1]
diff --git a/src/modules/punk/mix/commandset/doc-999999.0a1.0.tm b/src/modules/punk/mix/commandset/doc-999999.0a1.0.tm
index aca86bf8..5d39d600 100644
--- a/src/modules/punk/mix/commandset/doc-999999.0a1.0.tm
+++ b/src/modules/punk/mix/commandset/doc-999999.0a1.0.tm
@@ -216,7 +216,7 @@ namespace eval punk::mix::commandset::doc {
             }
             file mkdir $output_base
 
-            set matched_paths [punk::path::treefilenames -dir $codesource_path -antiglob_paths {**/mix/templates/** **/mixtemplates/**} *.tm]
+            set matched_paths [punk::path::treefilenames -dir $codesource_path -antiglob_paths {**/mix/templates/** **/project_layouts/** **/decktemplates/**} *.tm]
             set count 0
             set newdocs [list] 
             set docgen_header_comments ""
diff --git a/src/modules/punk/mix/commandset/layout-999999.0a1.0.tm b/src/modules/punk/mix/commandset/layout-999999.0a1.0.tm
index c001a203..a7324179 100644
--- a/src/modules/punk/mix/commandset/layout-999999.0a1.0.tm
+++ b/src/modules/punk/mix/commandset/layout-999999.0a1.0.tm
@@ -18,6 +18,7 @@
 ##  Requirements
 ##e.g package require frobz
 
+package require punk::args
 #sort of a circular dependency when commandset loaded by punk::mix::cli - that's ok, but this could theoretically be loaded by another cli and with another base
 package require punk::mix
 package require punk::mix::base
@@ -28,6 +29,7 @@ package require punk::mix::base
 namespace eval punk::mix::commandset::layout {
     namespace export *
 
+
     #per layout functions
     proc files {layout} {
         set allfiles [lib::layout_all_files $layout]
@@ -38,25 +40,17 @@ namespace eval punk::mix::commandset::layout {
         return [join $templatefiles \n]
     }
     proc templatefiles.relative {layout} {
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
 
-        set bases_containing_layout [list]
-        dict for {tbase folderinfo} $template_base_dict {
-           if {[file exists $tbase/layouts/$layout]} {
-                lappend bases_containing_layout $tbase
-           } 
-        }
-        if {![llength $bases_containing_layout]} {
-            puts stderr "Unable to locate folder for layout '$layout'"
-            puts stderr "searched [dict size $template_base_dict] template folders"
+        set layoutdict [lib::layouts_dict]
+        if {![dict exists $layoutdict $layout]} {
+            puts stderr "layout '$layout' not found."
             return
         }
-        set tpldir [lindex $bases_containing_layout end]
+        set layoutinfo [dict get $layoutdict $layout]
+        set layoutfolder [dict get $layoutinfo path]
 
-        set layout_base $tpldir/layouts
-        set layout_dir [file join $layout_base $layout]
 
-        set stripprefix [file normalize $layout_dir]
+        set stripprefix [file normalize $layoutfolder]
         set templatefiles [lib::layout_scan_for_template_files $layout]
         set tails [list]
         foreach templatefullpath $templatefiles {
@@ -68,46 +62,150 @@ namespace eval punk::mix::commandset::layout {
     #layout collection functions - to be imported with punk::overlay::import_commandset separately
     namespace eval collection {
         namespace export *
-        proc _default {{glob {}}} {
+        proc _defaultx {{glob {}}} {
             if {![string length $glob]} {
                 set glob *
             }
             set layouts [list]
-            #set tplfolderdict [punk::cap::call_handler punk.templates folders]
-            set tplfolderdict [punk::mix::base::lib::get_template_basefolders]
-            dict for {tdir folderinfo} $tplfolderdict {
-                set layout_base $tdir/layouts
-                #collect all layouts and use lsearch glob rather than the filesystem glob (avoid issues with dotted folder names)
-                set all_layouts [lsort [glob -nocomplain -dir $layout_base -type d -tail *]]
-                foreach match [lsearch -all -inline $all_layouts $glob] {
-                   lappend layouts [list $match $folderinfo] 
-                }
+            set layoutdict [punk::cap::call_handler punk.templates get_itemdict_projectlayouts]
+            #set tplfolderdict [punk::mix::base::lib::get_template_basefolders]
+            dict for {layoutname layoutinfo} $layoutdict {
+                lappend layouts [list $layoutname $layoutinfo]
+            }
+            #return [join [lsort -index 0 $layouts] \n]
+            return [join $layouts \n]
+        }
+
+        proc _default {args} {
+            set tdict_low_to_high [as_dict {*}$args]
+            #convert to screen order - with higher priority at the top
+            set tdict [dict create]
+            foreach k [lreverse [dict keys $tdict_low_to_high]] {
+                dict set tdict $k [dict get $tdict_low_to_high $k]
+            }
+
+            package require overtype
+            package require textblock
+            #set pathinfolist [dict values $tdict]
+            #set paths [lsearch -all -inline -index 1 -subindices $pathinfolist *] ;#relies on first key of templates_dict being path
+
+            set names [dict keys $tdict]
+            set paths [list]
+            set pathtypes [list]
+            dict for {nm tinfo} $tdict {
+                lappend paths [dict get $tinfo path]
+                lappend pathtypes [dict get $tinfo sourceinfo pathtype]
+            }
+
+            set title(path) "Path"
+            set widest(path) [tcl::mathfunc::max {*}[lmap v [concat [list $title(path)] $paths] {punk::strlen $v}]]
+            set col(path) [string repeat " " $widest(path)] 
+
+            set title(pathtype) "[a+ green]Path Type[a]"
+            set widest(pathtype) [tcl::mathfunc::max {*}[lmap v [concat [list $title(pathtype)] $pathtypes] {punk::strlen $v}]]
+            set col(pathtype)    [string repeat " " $widest(pathtype)]
+
+            set title(name) "Layout Name"
+            set widest(name) [tcl::mathfunc::max {*}[lmap v [concat [list $title(name)] $names] {punk::strlen $v}]]
+            set col(name) [string repeat " " $widest(name)]
+
+            set vsep " | "
+            set vsep_w [string length $vsep] ;#unicode?
+            set tablewidth [expr {$widest(name) + $vsep_w + $widest(pathtype) + $vsep_w + $widest(path)}]
+            set table ""
+            append table [string repeat - $tablewidth] \n
+            append table "[textblock::join [overtype::left $col(name) $title(name)] $vsep [overtype::left $col(pathtype) $title(pathtype)] $vsep [overtype::left $col(path) $title(path)]]" \n
+            append table [string repeat - $tablewidth] \n
+
+            foreach n $names pt $pathtypes p $paths {
+            append table "[textblock::join [overtype::left $col(name) $n] $vsep [overtype::left $col(pathtype) $pt] $vsep [overtype::left $col(path) $p]]" \n 
+            }
+
+            return $table
+        }
+        proc references {args} {
+            set tdict_low_to_high [references_as_dict {*}$args]
+            #convert to screen order - with higher priority at the top
+            set tdict [dict create]
+            foreach k [lreverse [dict keys $tdict_low_to_high]] {
+                dict set tdict $k [dict get $tdict_low_to_high $k]
             }
-            return [join [lsort -index 0 $layouts] \n]
+
+            package require overtype
+            package require textblock
+            #set pathinfolist [dict values $tdict]
+            #set paths [lsearch -all -inline -index 1 -subindices $pathinfolist *] ;#relies on first key of templates_dict being path
+
+            set names [dict keys $tdict]
+            set paths [list]
+            set pathtypes [list]
+            dict for {nm tinfo} $tdict {
+                lappend paths [dict get $tinfo path]
+                lappend pathtypes [dict get $tinfo sourceinfo pathtype]
+            }
+
+            set title(path) "Path"
+            set widest(path) [tcl::mathfunc::max {*}[lmap v [concat [list $title(path)] $paths] {punk::strlen $v}]]
+            set col(path) [string repeat " " $widest(path)] 
+
+            set title(pathtype) "[a+ green]Path Type[a]"
+            set widest(pathtype) [tcl::mathfunc::max {*}[lmap v [concat [list $title(pathtype)] $pathtypes] {punk::strlen $v}]]
+            set col(pathtype)    [string repeat " " $widest(pathtype)]
+
+            set title(name) "Layout Name"
+            set widest(name) [tcl::mathfunc::max {*}[lmap v [concat [list $title(name)] $names] {punk::strlen $v}]]
+            set col(name) [string repeat " " $widest(name)]
+
+            set vsep " | "
+            set vsep_w [string length $vsep] ;#unicode?
+            set tablewidth [expr {$widest(name) + $vsep_w + $widest(pathtype) + $vsep_w + $widest(path)}]
+            set table ""
+            append table [string repeat - $tablewidth] \n
+            append table "[textblock::join [overtype::left $col(name) $title(name)] $vsep [overtype::left $col(pathtype) $title(pathtype)] $vsep [overtype::left $col(path) $title(path)]]" \n
+            append table [string repeat - $tablewidth] \n
+
+            foreach n $names pt $pathtypes p $paths {
+                append table "[textblock::join [overtype::left $col(name) $n] $vsep [overtype::left $col(pathtype) $pt] $vsep [overtype::left $col(path) $p]]" \n 
+            }
+
+            return $table
         }
 
+        proc as_dict {args} {
+            tailcall punk::mix::commandset::layout::lib::layouts_dict {*}$args
+        }
+        proc references_as_dict {args} {
+            package require punk::cap
+            if {[punk::cap::capability_has_handler punk.templates]} {
+                set ref_dict [punk::cap::call_handler punk.templates get_itemdict_projectlayoutrefs {*}$args]
+            } else {
+                put stderr "commandset::layout::lib::layouts_dict WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
+            }
+            return $ref_dict
+        }        
     }
     namespace eval lib {
+        proc layouts_dict {args} {
+            package require punk::cap
+            if {[punk::cap::capability_has_handler punk.templates]} {
+                set layout_dict [punk::cap::call_handler punk.templates get_itemdict_projectlayouts {*}$args]
+            } else {
+                put stderr "commandset::layout::lib::layouts_dict WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
+            }
+            return $layout_dict
+        }        
+        
         proc layout_all_files {layout} {
-            set tplbasedict [punk::mix::base::lib::get_template_basefolders]
-            set layouts_found [list]
-            dict for {tplbase folderinfo} $tplbasedict {
-                if {[file isdirectory $tplbase/layouts/$layout]} {
-                    lappend layouts_found $tplbase/layouts/$layout
-                }
-            } 
-            if {![llength $layouts_found]} {
+            #todo - allow versionless layout name to pick highest version found
+            set layoutdict [layouts_dict]
+            if {![dict exists $layoutdict $layout]} {
                 puts stderr "layout '$layout' not found."
-                puts stderr "searched [dict size $tplbasedict] template folders"
-                dict for {tplbase pkg} $tplbasedict {
-                    puts stderr " - $tplbase $pkg"
-                }
                 return
             }
-            set layoutfolder [lindex $layouts_found end]
-
+            set layoutinfo [dict get $layoutdict $layout]
+            set layoutfolder [dict get $layoutinfo path]
             if {![file isdirectory $layoutfolder]} {
-                puts stderr "layout '$layout' not found in /layouts within one of template_folders. (get_template_folder returned: $tplbasedict)"
+                puts stderr "layout '$layout' points to path $layoutfolder - but it doesn't seem to exist"
             }
             set file_list [list] 
             util::foreach-file $layoutfolder path {
@@ -118,25 +216,15 @@ namespace eval punk::mix::commandset::layout {
         }
 
         # 
-        #todo - allow specifying which package the layout is from:  e.g "punk::mix::templates project" ??
         proc layout_scan_for_template_files {layout {tags {}}} {
-            #equivalent for projects? punk::mix::commandset::module::lib::templates_dict  -scriptpath "" 
-            set tplbasedict [punk::mix::base::lib::get_template_basefolders]
-            set layouts_found [list]
-            dict for {tpldir pkg} $tplbasedict {
-                if {[file isdirectory $tpldir/layouts/$layout]} {
-                    lappend layouts_found $tpldir/layouts/$layout
-                }
-            } 
-            if {![llength $layouts_found]} {
+            #todo JMN
+            set layoutdict [layouts_dict]
+            if {![dict exists $layoutdict $layout]} {
                 puts stderr "layout '$layout' not found."
-                puts stderr "searched [dict size $tplbasedict] template folders"
-                dict for {tpldir pkg} $tplbasedict {
-                    puts stderr " - $tpldir $pkg"
-                }
                 return
             }
-            set layoutfolder [lindex $layouts_found end]
+            set layoutinfo [dict get $layoutdict $layout]
+            set layoutfolder [dict get $layoutinfo path]
 
             #use last matching layout found.  review silent if multiple?
             if {![llength $tags]} {
diff --git a/src/modules/punk/mix/commandset/module-999999.0a1.0.tm b/src/modules/punk/mix/commandset/module-999999.0a1.0.tm
index 3910abd7..4f9655d8 100644
--- a/src/modules/punk/mix/commandset/module-999999.0a1.0.tm
+++ b/src/modules/punk/mix/commandset/module-999999.0a1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
@@ -83,35 +83,52 @@ namespace eval punk::mix::commandset::module {
             dict set tdict $k [dict get $tdict_low_to_high $k]
         }
 
-        package require overtype       
-        set pathinfolist [dict values $tdict]
-        set paths [lsearch -all -inline -index 1 -subindices $pathinfolist *] ;#relies on first key of templates_dict being path
+        package require overtype
+        package require textblock
+        #set pathinfolist [dict values $tdict]
+        #set paths [lsearch -all -inline -index 1 -subindices $pathinfolist *] ;#relies on first key of templates_dict being path
+
         set names [dict keys $tdict]
+        set paths [list]
+        set pathtypes [list]
+        dict for {nm tinfo} $tdict {
+            lappend paths [dict get $tinfo path]
+            lappend pathtypes [dict get $tinfo sourceinfo pathtype]
+        }
+
+        set title(path) "Path"
+        set widest(path) [tcl::mathfunc::max {*}[lmap v [concat [list $title(path)] $paths] {punk::strlen $v}]]
+        set col(path) [string repeat " " $widest(path)] 
 
-        set title1 "Path"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $paths] {punk::strlen $v}]]
-        set col1 [string repeat " " $widest1] 
+        set title(pathtype) "[a+ green]Path Type[a]"
+        set widest(pathtype) [tcl::mathfunc::max {*}[lmap v [concat [list $title(pathtype)] $pathtypes] {string length $v}]]
+        set col(pathtype)    [string repeat " " $widest(pathtype)]
 
-        set title2 "Template Name"
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $names] {punk::strlen $v}]]
-        set col2 [string repeat " " $widest2]
+        set title(name) "Template Name"
+        set widest(name) [tcl::mathfunc::max {*}[lmap v [concat [list $title(name)] $names] {string length $v}]]
+        set col(name) [string repeat " " $widest(name)]
 
-        set tablewidth [expr {$widest1 + 1 + $widest2}]
+        set tablewidth [expr {$widest(name) + 1 + $widest(pathtype) + 1 + $widest(name)}]
         set table ""
         append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col1 $title1] [overtype::left $col2 $title2]" \n
+        append table "[textblock::join [overtype::left $col(name) $title(name)] " " [overtype::left $col(pathtype) $title(pathtype)] " " [overtype::left $col(path) $title(path)]]" \n
         append table [string repeat - $tablewidth] \n
 
-        foreach p $paths n $names {
-           append table "[overtype::left $col1 $p] [overtype::left $col2 $n]" \n 
+        foreach n $names pt $pathtypes p $paths {
+           append table "[overtype::left $col(name) $n] [overtype::left $col(pathtype) $pt] [overtype::left $col(path) $p]" \n 
         }
 
         return $table
     }
     #return all module templates with repeated ones suffixed with .2 .3 etc
     proc templates_dict {args} {
-        tailcall lib::templates_dict {*}$args
-    }
+        package require punk::cap
+        if {[punk::cap::capability_has_handler punk.templates]} {
+            set template_folder_dict [punk::cap::call_handler punk.templates get_itemdict_moduletemplates {*}$args]
+        } else {
+            put stderr "get_template_basefolders WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
+        }
+    }        
     proc new {module args} {
         set year [clock format [clock seconds] -format %Y]
         set defaults [list\
@@ -140,7 +157,7 @@ namespace eval punk::mix::commandset::module {
         } else {
             set opt_version $opt_version_supplied
             if {![util::is_valid_tm_version $opt_version]} {
-                error "pmix module.new error - supplied -version $opt_version doesn't appear to be a valid Tcl module version"
+                error "deck module.new error - supplied -version $opt_version doesn't appear to be a valid Tcl module version"
             }
         }
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
@@ -151,7 +168,7 @@ namespace eval punk::mix::commandset::module {
             #if it has a dash then version is required to be valid
             lassign [punk::mix::cli::lib::split_modulename_version $module] modulename mversion
             if {![util::is_valid_tm_version $mversion]} {
-                error "pmix module.new error - unable to determine modulename-version from supplied value '$module'"
+                error "deck module.new error - unable to determine modulename-version from supplied value '$module'"
             }
             set mversion_supplied $mversion ;#record as may need to compare to version from templatefile name
             set vcompare_is_mversion_bigger [package vcompare $mversion $opt_version]
@@ -174,11 +191,11 @@ namespace eval punk::mix::commandset::module {
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
         #options
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_project                             [dict get $opts -project]
+        set opt_project                            [dict get $opts -project]
         set testdir [pwd]
         if {![string length [set projectdir [punk::repo::find_project $testdir]]]} {
             if {![string length [set projectdir [punk::repo::find_candidate $testdir]]]} {
-                set msg [punkc::repo::is_candidate_root_requirements_msg]
+                set msg [punk::repo::is_candidate_root_requirements_msg]
                 error "module.new unable to create module in projectdir:$projectdir - directory doesn't appear to meet basic standards $msg"
             }
         }
@@ -198,25 +215,20 @@ namespace eval punk::mix::commandset::module {
             error "module.new -template does not support glob chars. Use an exact full name including version (and optionally .tm) - or use just the name without version or .tm, and the latest version will be selected"
         }
 
-        set templates_dict [templates_dict] ;#keys are possibly prefixed with <vendor>. and/or suffixed with .2 .3 etc if there are collisions - the remaining unsuffixed .tm being the one with highest preference
-        #todo - allow versionless name - pick latest which isn't suffixed with .2 etc
+        set templates_dict [templates_dict] ;#keys are possibly prefixed with <vendor>. and/or suffixed with #2 #3 etc if there are collisions - the remaining unsuffixed being the one with highest preference
+        #todo - allow versionless name - pick latest which isn't suffixed with #2 etc
         #if the user wants to exactly match an unversioned template, in the presence of versioned ones - they may need to include the trailing .tm
         if {[dict exists $templates_dict $opt_template]} {
-            #exact long name including version and .tm found
+            #exact long name (possibly including version) 
+            #Note - an unversioned .tm template will be matched here - even though versioned templates of the same name may exist.
             set templatefile        [dict get $templates_dict $opt_template path]
             set templatefile_info   [dict get $templates_dict $opt_template sourceinfo]
-        } elseif {[dict exists $templates_dict $opt_template.tm]} {
-            #Note - an unversioned .tm template will be matched here - even though versioned templates of the same name may exist.
-            #It's reasonable to consider an unversioned file to be lower than any versioned one
-            # so this may be very surprising given that if all templates are versioned - the highest one is normally selected - REVIEW
-            set templatefile        [dict get $templates_dict $opt_template.tm path]
-            set templatefile_info   [dict get $templates_dict $opt_template.tm sourceinfo]
         } else {
-            #if it wasn't an exact match for opt_template or opt_template.tm - then opt_template now shouldn't contain a version or end in .tm (we have also ruled out glob chars * & ? above)
+            #if it wasn't an exact match for opt_template - then opt_template now shouldn't contain a version  (we have also ruled out glob chars * & ? above)
             #(if it does - then we just won't find anything - which is fine)
             #module file name could contain dots - but only one dash - if it is versioned
 
-            set matches [lsearch -all -inline [dict keys $templates_dict] $opt_template-*]  ;#the key is of form vendor.modulename-version.tm(.suffix)  (version optional, suffix if lower precedence with same name was found)
+            set matches [lsearch -all -inline [dict keys $templates_dict] $opt_template-*]  ;#the key is of form vendor.modulename-version(#suffix)  (version optional, suffix if lower precedence with same name was found)
             #only .tm (or .TM .Tm .tM) files make it into the templates_dict - they are allowed to be unversioned though.
             set key_version_list [list]
             foreach m $matches {
@@ -341,7 +353,14 @@ namespace eval punk::mix::commandset::module {
         #This path info may be undesired in the template output (%moduletemplate%)
         #it is nevertheless useful information - and not the only way developer-machine/build-machine paths can leak
         #for now the user has the option to override any templates and remove %moduletemplate% if it is a security/privacy concern
-        set template_filedata [string map [list %moduletemplate% $moduletemplate %project% $projectname %pkg% $modulename %year% $year %license% $opt_license %version% $infile_version] $template_filedata]
+        
+        #Don't put litera %x% in the code for the commandset::module itself - to stop them being seen by layout scanner as replacable tokens 
+        set tagnames [list moduletemplate $moduletemplate project $projectname pkg $modulename year $year license $opt_license version $infile_version]
+        set strmap [list]
+        dict for {tag val} $tagnames {
+            lappend strmap %$tag% $val
+        }
+        set template_filedata [string map $strmap $template_filedata]
 
         set modulefile $modulefolder/${moduletail}-$infile_version.tm
         if {[file exists $modulefile]} {
@@ -417,108 +436,8 @@ namespace eval punk::mix::commandset::module {
     }
 
     namespace eval lib {
-        proc get_moduletemplate_folders {args} {
-
-        }
-
-        proc templates_dict {args} {
-            set globsearch [lindex $args 0]; #note that in this case our globsearch won't reduce the machine's effort in scannning the filesystem - as we need to search on the renamed results
-            if {$globsearch eq ""} {
-                set globsearch *
-            }
-            set args [lrange $args 1 end] 
-
-            set opts [dict get [punk::get_leading_opts_and_values { 
-                 -scriptpath ""
-            } $args -maxvalues 0] opts] 
-            # -- --- --- --- --- --- --- --- ---
-            set opt_scriptpath [dict get $opts -scriptpath]
-            # -- --- --- --- --- --- --- --- ---
-
-            set module_template_bases [list]
-            set tbasedict [punk::mix::base::lib::get_template_basefolders $opt_scriptpath]
-            dict for {tbase folderinfo} $tbasedict {
-                lappend module_template_bases [list modulefolder [file join $tbase modules] sourceinfo $folderinfo]
-            }
-
-            set template_files [list]
-            #don't apply our globsearch until after we have assigned vendor prefix and dup-suffixes
-            
-            #Flip the priority order of the module bases to  high-priority earliest in the list
-            #we want a sensible display order for files within the module bases - and for the files to be encountered in the order high prio to low when setting the trailing .<int> dup/overridden indicator
-            foreach baseinfo [lreverse $module_template_bases] {
-                set basefld [dict get $baseinfo modulefolder]
-                #set matched_files [glob -nocomplain -dir $basefld -type f template_*.tm] ;#glob is case insensitive on windows  
-                set matched_files [punk::path::treefilenames -dir $basefld template_*.tm]
-                foreach tf $matched_files {
-                    if {[string match ignore* $tf]} {
-                        continue
-                    }
-                    set ext [file extension $tf]
-                    if {[string tolower $ext] in [list ".tm"]} {
-                        #we will ignore any .tm files that don't have versions that tcl understands - but warn
-                        #this reduces the cases we have to test later
-                        set fname [file tail $tf]
-                        lassign [split [punk::mix::cli::lib::split_modulename_version $fname]] mname ver
-                        if {[catch {punk::mix::cli::lib::validate_modulename $mname} errM]} {
-                            puts stderr "Invalid module name/version $tf - please rename with standard Tcl .tm module name and version (or leave out version)"
-                            if {[string match *-* $mname]} {
-                                puts stderr "Tcl module name cannot contain dash character - except between name and version"
-                            }
-                        } else {
-                            lappend template_files [list file $tf baseinfo $baseinfo]
-                        }
-                    }
-                }
-            }
-
-            set tdict [dict create]
-            set seen_dict [dict create]
-            foreach fileinfo $template_files {
-                set fullpath [dict get $fileinfo file]
-                set vendor       [dict get $fileinfo baseinfo sourceinfo vendor]
-                set modulefolder [dict get $fileinfo baseinfo modulefolder]
-                #if template is in a hierarchy below modulefolder - we join the segments with :: - same as the way Tcl does for determining module names
-                set relativepath [punk::path::relative $modulefolder $fullpath] 
-                set dirs [file dirname $relativepath]
-                if {$dirs eq "."} {
-                    set dirs ""
-                }
-                set moduleprefix [join $dirs ::]
 
-                set ftail [file tail $fullpath]
-                set tname [string range $ftail [string length template_] end]
-                if {$moduleprefix ne ""} {
-                    set tname ${moduleprefix}::$tname
-                }
-                if {$vendor ne "_project"} {
-                    set tname ${vendor}.$tname
-                } 
-                 
-                if {![dict exists $seen_dict $tname]} {
-                    dict set seen_dict $tname 1 
-                    dict set tdict $tname [list path $fullpath {*}[dict get $fileinfo baseinfo]] ; #first seen of filename gets no number
-                } else {
-                    set n [dict get $seen_dict $tname]
-                    incr n
-                    dict incr seen_dict $tname
-                    dict set tdict ${tname}.$n [list path $fullpath {*}[dict get $fileinfo baseinfo]]
-                }
-            }
-            #assert path is first key of tdict (callers of templates_dict are allowed to rely on it being first)
-            #assert tdict has keys path,modulefolder,sourceinfo
-
-            set result [dict create]
-            set keys [lreverse [dict keys $tdict]] ;#return in priority order low to high (which is generally reverse of how we'd like to see it on screen)
-            #set keys [dict keys $tdict]
-            foreach k $keys {
-                if {[string match $globsearch $k]} {
-                    dict set result $k [dict get $tdict $k]
-                }
-            }
 
-            return $result
-        }
     }
 
 
diff --git a/src/modules/punk/mix/commandset/project-999999.0a1.0.tm b/src/modules/punk/mix/commandset/project-999999.0a1.0.tm
index 2ab101f7..0e9beee5 100644
--- a/src/modules/punk/mix/commandset/project-999999.0a1.0.tm
+++ b/src/modules/punk/mix/commandset/project-999999.0a1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
@@ -19,8 +19,8 @@
 #*** !doctools
 #[manpage_begin punkshell_module_punk::mix::commandset::project 0 999999.0a1.0]
 #[copyright "2023"]
-#[titledesc {pmix commandset - project}]  [comment {-- Name section and table of contents description --}]
-#[moddesc {pmix CLI commandset - project}]             [comment {-- Description at end of page heading --}] 
+#[titledesc {dec commandset - project}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {deck CLI commandset - project}]             [comment {-- Description at end of page heading --}] 
 #[require punk::mix::commandset::project]
 #[description]
 
@@ -139,7 +139,7 @@ namespace eval punk::mix::commandset::project {
             -update 0\
             -confirm 1\
             -modules \uFFFF\
-            -layout project
+            -layout punk.project
         ] ;#todo
         set known_opts [dict keys $defaults]
         foreach {k v} $args {
@@ -151,7 +151,7 @@ namespace eval punk::mix::commandset::project {
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
         set opt_type                                [dict get $opts -type]
         if {$opt_type ni [punk::mix::cli::lib::module_types]} {
-            error "pmix new error - unknown type '$opt_type' known types: [punk::mix::cli::lib::module_types]"
+            error "deck new error - unknown type '$opt_type' known types: [punk::mix::cli::lib::module_types]"
         }
         # -- --- --- --- --- --- --- --- --- --- --- --- ---
         set opt_force                               [dict get $opts -force]
@@ -170,10 +170,10 @@ namespace eval punk::mix::commandset::project {
 
         set fossil_prog [auto_execok fossil]
         if {![string length $fossil_prog]} {
-            puts stderr "The fossil program was not found. A fossil executable is required to use most pmix features."
+            puts stderr "The fossil program was not found. A fossil executable is required to use most deck features."
             if {[string length [set scoop_prog [auto_execok scoop]]]} {
                 #restrict to windows?
-                set answer [util::askuser "scoop detected. Would you like pmix to install fossil now using scoop? Y|N"]
+                set answer [util::askuser "scoop detected. Would you like deck to install fossil now using scoop? Y|N"]
                 if {[string tolower $answer] ne "y"} {
                     puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
                     return
@@ -216,23 +216,31 @@ namespace eval punk::mix::commandset::project {
             puts stdout "This project will be searched for templates"
             puts stdout "-------------------------------------------"
         }
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-        set template_bases_containing_layout [list]
-        dict for {tbase folderinfo} $template_base_dict {
-           if {[file exists $tbase/layouts/$opt_layout]} {
-                lappend template_bases_containing_layout $tbase
-           } 
+
+
+        package require punk::cap
+        if {[punk::cap::capability_has_handler punk.templates]} {
+            set layout_dict [punk::cap::call_handler punk.templates get_itemdict_projectlayouts]
+        } else {
+            put stderr "commandset::project::new WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide layout locations"
+            return
         }
-        if {![llength $template_bases_containing_layout]} {
-            puts stderr "layout '$opt_layout' was not found in template dirs"
-            puts stderr "searched [dict size $template_base_dict] template folders"
-            dict for  {tbase folderinfo} $template_base_dict {
-                puts stderr " - $tbase $folderinfo"
-            }
+        if {[dict exists $layout_dict $opt_layout]} {
+            set layout_name $opt_layout
+            set layout_info [dict get $layout_dict $layout_name]
+            set layout_path [dict get $layout_info path]
+            set layout_sourceinfo [dict get $layout_info sourceinfo]
+        } else {
+            puts stderr "commandset::project::new - no exact match for specified layout-name $opt_layout found"
+            puts stderr "layout names found: [dict keys $layout_dict]"
             return
+
+            #todo - pick highest version layout that matches opt_layout if version not specified but multiple exist
+
+            #set layout_name ...
+            #set layout_info ..
+            #set layout_path ...
         }
-        #review: silently use last entry which had the layout (?)
-        set templatebase [lindex $template_bases_containing_layout end]
 
 
 
@@ -275,7 +283,7 @@ namespace eval punk::mix::commandset::project {
             puts stderr "Unable to create new project at $projectdir - file/folder already exists use -update 1 to fill in missing items from template use -force 1 to overwrite from template"
             return
         } elseif {$project_dir_exists && $opt_force} {
-            puts stderr "mix new WARNING: -force 1 was supplied. Will copy layout $templatebase/layouts/$opt_layout using -force option to overwrite from template"
+            puts stderr "mix new WARNING: -force 1 was supplied. Will copy layout $layout_path using -force option to overwrite from template"
             if {$opt_confirm ni [list 0 no false]} {
                 set answer [util::askuser "Do you want to proceed to possibly overwrite existing files in $projectdir? Y|N"]
                 if {[string tolower $answer] ne "y"} {
@@ -284,7 +292,7 @@ namespace eval punk::mix::commandset::project {
                 }
             }
         } elseif {$project_dir_exists && $opt_update} {
-            puts stderr "mix new WARNING: -update 1 was supplied. Will copy layout $templatebase/layouts/$opt_layout using -update option to add missing items"
+            puts stderr "mix new WARNING: -update 1 was supplied. Will copy layout $layout_path using -update option to add missing items"
         }
 
         set fossil_repo_file "" 
@@ -325,29 +333,38 @@ namespace eval punk::mix::commandset::project {
             }
         }
 
+        #
+
+
+
         file mkdir $projectdir
 
-        set layout_dir $templatebase/layouts/$opt_layout
-        puts stdout ">>> about to call punkcheck::install $layout_dir $projectdir" 
+        puts stdout ">>> about to call punkcheck::install $layout_path $projectdir" 
         set resultdict [dict create]
         set antipaths [list\
             src/doc/*\
             src/doc/include/*\
+            src/PROJECT_LAYOUTS_*\
+        ]
+
+        #set antiglob_dir [list\
+        #    _ignore_*\
+        #]
+        set antiglob_dir [list\
         ]
 
         #default antiglob_dir_core will stop .fossil* from being updated - which is generally desirable as these are likely to be customized
         if {$opt_force} {
             puts stdout "copying layout files - with force applied - overwrite all-targets" 
-            set resultdict [punkcheck::install $layout_dir $projectdir -installer project.new  -overwrite ALL-TARGETS -antiglob_paths $antipaths]
-            #file copy -force $layout_dir $projectdir
+            set resultdict [punkcheck::install $layout_path $projectdir -installer project.new  -overwrite ALL-TARGETS -antiglob_paths $antipaths -antiglob_dir $antiglob_dir]
         } else {
             puts stdout "copying layout files - (if source file changed)" 
-            set resultdict [punkcheck::install $layout_dir $projectdir -installer project.new -overwrite installedsourcechanged-targets -antiglob_paths $antipaths]
+            set resultdict [punkcheck::install $layout_path $projectdir -installer project.new -overwrite installedsourcechanged-targets -antiglob_paths $antipaths -antiglob_dir $antiglob_dir]
         }
         puts stdout [punkcheck::summarize_install_resultdict $resultdict]
 
         puts stdout "copying layout src/doc files (if target missing)"
-        set resultdict [punkcheck::install $layout_dir/src/doc $projectdir/src/doc -punkcheck_folder $projectdir -installer project.new  -overwrite SYNCED-TARGETS]
+        set resultdict [punkcheck::install $layout_path/src/doc $projectdir/src/doc -punkcheck_folder $projectdir -installer project.new  -overwrite SYNCED-TARGETS]
         puts stdout [punkcheck::summarize_install_resultdict $resultdict]
 
         #target folders .fossil-custom and .fossil-settings may not exist. use -createdir 1 to ensure existence. 
@@ -355,33 +372,33 @@ namespace eval punk::mix::commandset::project {
         ## default_antiglob_dir_core  [list "#*" "_aside" ".git" ".fossil*"]
         set override_antiglob_dir_core [list #* _aside .git] 
         puts stdout "copying layout src/.fossil-custom files (if target missing or uncustomised)"
-        set resultdict [punkcheck::install $layout_dir/.fossil-custom $projectdir/.fossil-custom -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
+        set resultdict [punkcheck::install $layout_path/.fossil-custom $projectdir/.fossil-custom -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
         puts stdout [punkcheck::summarize_install_resultdict $resultdict]
 
         puts stdout "copying layout src/.fossil-settings files (if target missing or uncustomised)"
-        set resultdict [punkcheck::install $layout_dir/.fossil-settings $projectdir/.fossil-settings -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
+        set resultdict [punkcheck::install $layout_path/.fossil-settings $projectdir/.fossil-settings -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
         puts stdout [punkcheck::summarize_install_resultdict $resultdict]
 
-
-
-
-        #lappend substfiles $projectdir/README.md
-        #lappend substfiles $projectdir/src/README.md
-        #lappend substfiles $projectdir/src/doc/main.man
-        #expect this in all templates? - todo make these substitutions independent of specific paths and filenames?
         #scan all files in template 
         #
-        #TODO - pmix command to substitute templates? 
+        #TODO - deck command to substitute templates? 
         set templatefiles [punk::mix::commandset::layout::lib::layout_scan_for_template_files $opt_layout]
-        set stripprefix [file normalize $layout_dir]
+        set stripprefix [file normalize $layout_path]
 
+        set tagmap [list [lib::template_tag project] $projectname]
+        if {[llength $templatefiles]} {
+            puts stdout "Filling template file placeholders with the following tag map:"
+            dict for {placeholder value} $tagmap {
+                puts stdout "  $placeholder -> $value" 
+            }
+        }
         foreach templatefullpath $templatefiles {
             set templatetail [punk::repo::path_strip_alreadynormalized_prefixdepth $templatefullpath $stripprefix]
 
             set fpath [file join $projectdir $templatetail]
             if {[file exists $fpath]} {
                 set fd [open $fpath r]; fconfigure $fd -translation binary; set data [read $fd]; close $fd
-                set data2 [string map [list [lib::template_tag project] $projectname] $data]
+                set data2 [string map $tagmap $data]
                 if {$data2 ne $data} {
                     puts stdout "updated template file: $fpath"
                     set fdout [open $fpath w]; fconfigure $fdout -translation binary; puts -nonewline $fdout $data2; close $fdout 
@@ -392,12 +409,12 @@ namespace eval punk::mix::commandset::project {
         }
         #todo - tag substitutions in src/doc tree
 
-
         ::cd $projectdir
 
         if {[file exists $projectdir/src/modules]} {
             foreach m $opt_modules {
                 if {![file exists $projectdir/src/modules/$m-[punk::mix::util::magic_tm_version].tm]} {
+                    #todo - option for -module_template - and check existence at top? or change opt_modules to be a list of dicts with configuration info -template -type etc
                     punk::mix::commandset::module::new $m -project $projectname -type $opt_type 
                 } else {
                     if {$opt_force} {
@@ -531,7 +548,7 @@ namespace eval punk::mix::commandset::project {
             set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
             set col2 [string repeat " " $widest2]
             set title3 "Checkouts"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {punk::strlen $v}]]
+            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {string length $v}]]
             set col3 [string repeat " " $widest3]
             set tablewidth [expr {$widest1 + 1 + $widest2 + 1 + $widest3}]
             
@@ -617,19 +634,19 @@ namespace eval punk::mix::commandset::project {
             set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
             set col2 [string repeat " " $widest2]
             set title3 "Checkouts"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {punk::strlen $v}]]
+            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {string length $v}]]
             set col3 [string repeat " " $widest3]
             set title4 "Project Name"
-            set widest4 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col4_pnames] {punk::strlen $v}]]
+            set widest4 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col4_pnames] {string length $v}]]
             set col4 [string repeat " " $widest4]
             set title5 "Project Code"
-            set widest5 [tcl::mathfunc::max {*}[lmap v [concat [list $title5] $col5_pcodes] {punk::strlen $v}]]
+            set widest5 [tcl::mathfunc::max {*}[lmap v [concat [list $title5] $col5_pcodes] {string length $v}]]
             set col5 [string repeat " " $widest5]
             set title6 "Dup"
-            set widest6 [tcl::mathfunc::max {*}[lmap v [concat [list $title6] $col6_dupids] {punk::strlen $v}]]
+            set widest6 [tcl::mathfunc::max {*}[lmap v [concat [list $title6] $col6_dupids] {string length $v}]]
             set col6 [string repeat " " $widest6]
             set title7 "Description"
-            #set widest7 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col7_pdescs] {punk::strlen $v}]]
+            #set widest7 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col7_pdescs] {string length $v}]]
             set widest7 35
             set col7 [string repeat " " $widest7]
             
@@ -766,7 +783,12 @@ namespace eval punk::mix::commandset::project {
                 puts stderr "Result is from a single repo db [dict keys $fosdb_cache]"
             }
             if {$opt_detail} {
-                puts stderr "Gathering file state for [llength $workdirs] checkout folder(s). Use -detail 0 to omit file state"
+                if {!$opt_detail_explicit_zero} {
+                    set detailmsg "Use -detail 0 to omit file state"
+                } else {
+                    set detailmsg ""
+                }
+                puts stderr "Gathering file state for [llength $workdirs] checkout folder(s). $detailmsg"
                 set c_rev [list]
                 set c_rev_iso [list]
                 set c_unchanged [list]
@@ -881,7 +903,7 @@ namespace eval punk::mix::commandset::project {
                         set index [expr {$answer - 1}]
                         set workingdir [lindex $workdirs $index]
                         ::cd $workingdir
-                        puts stdout [pmix stat]
+                        puts stdout [deck stat]
                         return $workingdir
                     }
                 }
@@ -907,23 +929,8 @@ namespace eval punk::mix::commandset::project {
             }
             set fossil_prog [auto_execok fossil]
 
-            set fossilinfo [exec {*}$fossil_prog info] ;#will give us the necessary config-db info whether in a project folder or not
-            set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
-            if {[llength $matching_lines] != 1} {
-                puts stderr "Unable to find config-db info from fossil. Check your fossil installation."
-                puts stderr "Fossil output was:"
-                puts stderr "-------------" 
-                puts stderr "$fossilinfo"
-                puts stderr "-------------"
-                puts stderr "config-db info:"
-                puts stderr "$matching_lines"
-                return
-            }
-            set ln [lindex $matching_lines 0]
-            set configdb [string trim [string range $ln [string length "config-db: "] end]]
-            if {![file exists $configdb]} {
-                error "config-db not found at path $configdb"
-            }
+            set configdb [punk::repo::fossil_get_configdb]
+
             package require sqlite3
             ::sqlite3 fosconf $configdb
             #set testresult [fosconf eval {select name,value from global_config;}]
diff --git a/src/modules/punk/mix/commandset/repo-999999.0a1.0.tm b/src/modules/punk/mix/commandset/repo-999999.0a1.0.tm
index 4f2515d7..5dab9e46 100644
--- a/src/modules/punk/mix/commandset/repo-999999.0a1.0.tm
+++ b/src/modules/punk/mix/commandset/repo-999999.0a1.0.tm
@@ -68,6 +68,334 @@ namespace eval punk::mix::commandset::repo {
         }
         return $result
     }
+    proc fossil-move-repository {{path ""}} {
+        set searchbase [pwd]
+        set projectinfo    [punk::repo::find_repos $searchbase]
+        set projectbase [dict get $projectinfo closest]
+        set is_fossil [expr {"fossil" in [dict get $projectinfo closest_types]}]
+        if {[catch {
+            package require sqlite3
+        } errM]} {
+            puts stderr "sqlite3 package failed to load"
+            puts stderr "Try using 'fossil test-move-repository <targetpath>' from within an open checkout folder, or ensure that the Tcl sqlite3 package is available."
+            return
+        }
+        set ansiprompt [a+ green bold]
+        set ansiwarn   [a+ red bold]
+        set ansihighlight [a+ cyan bold]
+        set ansireset  [a]
+
+        set in_checkout 0
+        set is_checkout_relink 0; #whether we are attempting to link a checkout that has lost its repo
+        #we may also encounter a different kind of relink candidate - other checkouts of the same repo that we examine and find don't point back.
+        if {$projectbase eq "" || !$is_fossil} {
+            set repodbs [glob -dir $searchbase -type f -tail *.fossil]
+            if {![llength $repodbs]} {
+                puts stderr "Current directory does not seem to be directly below a fossil checkout, and no .fossil files found"
+                puts stderr "Please move to a folder containing the .fossil repository database to move, or to a folder directly within a fossil checkout (and with no intermediate git/fossil repos)"
+                return
+            }
+            set choice_files [list]
+            set i 1
+            set menu_message ""
+            append menu_message "${ansiprompt}Select the number of the fossil repo db to potentially move (confirmation will be requested before any action is taken)${ansireset}" \n
+            foreach db $repodbs {
+                sqlite3 dbinfo [file join $searchbase $db]
+                set ckouts [dbinfo eval {select name from config where name like 'ckout:%'}]
+                dbinfo close
+                lappend choice_files [list index $i repofile $db checkouts [llength $ckouts]]
+                append menu_message "$i  $db checkouts: [llength $ckouts]" \n
+                incr i
+            }
+            puts stdout $menu_message
+            set max [llength $choice_files] 
+            if {$max == 1} {
+                set rangemsg "the number 1"
+            } else {
+                set rangemsg "a number from 1 to $max" 
+            }
+            set answer [punk::repo::askuser "${ansiprompt}Enter $rangemsg to select a .fossil repository database to show details and potentially move. (or N to abort)${ansireset}"]
+            if {![string is integer -strict $answer]} {
+                puts stderr "Aborting"
+                return
+            }
+
+            set index [expr {int($answer) -1}]
+            if {$index >= 0 && $index <= $max-1} {
+                set repo_file_choice [lindex $choice_files $index]
+                set repo_file [dict get $repo_file_choice repofile]
+                set repo_file [file join $searchbase $repo_file]
+                puts stdout "Selected fossil repo database file: $repo_file" 
+            } else {
+                puts stderr " No menu number matched - aborting."
+                return
+            }
+        } else {
+            if {[file exists $projectbase/_FOSSIL_]} {
+                set cdbfile [file join $projectbase/_FOSSIL_]
+            } elseif {[file exists $projectbase/.fslckout]} {
+                set cdbfile [file join $projectbase/.fslckout]
+            } else {
+                puts stderr "No checkout database (_FOSSIL_ or .fslckout) found in nearest repository folder $projectbase (looked upwards from $searchbase)"
+                puts stderr "Unable to locate repository databases for potential move. Please move to a checkout folder or a folder containing .fossil repositories"
+                puts stderr "If run from a location where repositories are found, fossil-move-repository will give you the option to select a repository or cancel the operation"
+                return
+            }
+            set in_checkout 1
+            sqlite3 cdb $cdbfile
+            set repo_file [cdb eval {select value from vvar where name='repository'}]
+            cdb close
+            if {[string length [string trim $repo_file]] && [file pathtype $repo_file] eq "relative"} {
+                set  repo_file [file join $projectbase $repo_file]
+            }
+            if {![string length [string trim $repo_file]] || ![file exists $repo_file]} {
+                puts stderr "${ansiwarn}Checkout at $projectbase points to repository '$repo_file' - but it doesn't seem to exist${ansireset}"
+                set answer [punk::repo::askuser "${ansiprompt}Do you want to link this to an existing repository file? (Y|N)${ansireset}"]
+                if {[string match y* [string tolower $answer]]} {
+                    set is_checkout_relink 1
+                } else {
+                    puts stderr "Aborting - Unable to link this checkout dir to a repository database file"
+                    return
+                }
+            }
+        }
+
+        set pname [file rootname [file tail $repo_file]]
+        set full_path_repo_file [file join $searchbase $repo_file]
+        if {[file isfile $full_path_repo_file]} {
+            sqlite3 dbinfo [file join $searchbase $repo_file]
+            set ckouts [dbinfo eval {select name from config where name like 'ckout:%'}]
+            dbinfo close
+            if {![llength $ckouts]} {
+                puts stdout "Repository db at [file join $searchbase $repo_file] appears to have no open checkouts"
+            } else {
+                puts stdout "Repository db at [file join $searchbase $repo_file] appears to have [llength $ckouts] open checkouts:"
+                foreach ck $ckouts {
+                    puts stdout [string range $ck 6 end]
+                }
+            }
+        } else {
+            puts stderr "${ansiwarn}Missing repository db at $full_path_repo_file${ansireset}"
+        }
+        puts stdout "${ansihighlight}Report for all projects with repository file name $pname${ansireset}"
+        puts stdout [punk::mix::commandset::project::collection::detail $pname]
+        puts stdout [punk::mix::commandset::project::collection::work $pname -detail 1]
+
+        #todo
+        #ask user if they want to select a different pname
+        set wantrenameprompt "${ansiprompt}Would you like to rename the .fossil file? (Y|N)${ansireset}"
+        append wantrenameprompt \n "${ansiprompt}.eg change $pname.fossil to something else such as ${pname}_new.fossil${ansireset}"
+        set answer [punk::repo::askuser $wantrenameprompt]
+        set pname2 $pname
+        if {[string match y* [string tolower $answer]]} {
+            set dorenameprompt "${ansiprompt}Enter the new name and hit enter. (Just an alphanumeric name (possibly with dots/dashes/underscores) without .fossil and without any path)${ansireset}"
+            set namechoice [punk::repo::askuser $dorenameprompt]
+            if {[string length $namechoice]} {
+                set permittedmap [list . "" - "" _ ""]
+                if {[string is alnum -strict [string map $permittedmap $namechoice]]} {
+                    set pname2 $namechoice
+                } else {
+                    puts stderr "Entered name was invalid. Must be numbers,letters,underscore,dot,dash"
+                }
+            }
+            puts stdout "Continuing with name $pname2 - cancel at next prompt if this is incorrect"
+        }
+
+        set target_repodb_folder [punk::repo::fossil_get_repository_folder_for_project $pname2 -parentfolder $searchbase -askpath 1]
+        #target_repodb_folder might be same as source folder - check for same file if name wasn't changed?
+        if {![string length $target_repodb_folder]} {
+            puts stderr "No usable repository database folder selected for $pname2.fossil file"
+            return
+        }
+
+        set existing_target_repofile 0
+        if {[file exists $target_repodb_folder/$pname2.fossil]} {
+            set existing_target_repofile 1
+            puts stdout "${ansiwarn}NOTICE: $target_repodb_folder/$pname2.fossil already exists${ansireset}"
+            if {!$is_checkout_relink} {
+                set finalquestion "${ansiprompt}Are you sure you want to switch the repository $repo_file for the open checkout(s) to the existing file $target_repodb_folder/$pname2.fossil? (Y|N)${ansireset}"
+            } else {
+                set finalquestion "${ansiprompt}Are you sure you want to attempt to linke the repository (previously linked with '$repo_file') for the open checkout(s) to the existing file $target_repodb_folder/$pname2.fossil? (Y|N)${ansireset}"
+            }
+        } else {
+            if {!$is_checkout_relink} { 
+                set finalquestion "${ansiprompt}Proceed to move repository $repo_file to the new file $target_repodb_folder/$pname2.fossil? Y|N${ansireset}"
+            } else {
+                set finalquestion "${ansiprompt}Proceed to attempt link for missing repo db $repo_file to the new file $target_repodb_folder/$pname2.fossil? Y|N${ansireset}"
+            }
+        }
+        set line "${ansiwarn}[string repeat - [string length $finalquestion]]${ansireset}"
+        set finalprompt $line\n
+        append finalprompt $finalquestion \n
+        append finalprompt $line \n
+
+        set answer [punk::repo::askuser $finalprompt]
+        if {[string match y* [string tolower $answer]]} {
+            if {!$existing_target_repofile && !$is_checkout_relink} {
+                if {[catch {
+                    file copy $repo_file $target_repodb_folder/$pname2.fossil
+                } errM]} {
+                    puts stderr "${ansiwarn}FAILED to copy $repo_file to $target_repodb_folder/$pname2.fossil - aborting${ansireset}"
+                    puts stderr "Error message was:\n $errM"
+                    return
+                }
+                if {$in_checkout} {
+                    #in_checkout means we can assume projectbase var exists
+                    #there may be other checkouts on the old repo  
+                    #if so, we will remind the user of their existence
+                    if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} errM]} {
+                        puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                        puts stderr "$errM"
+                    } else {
+
+                        sqlite3 oldrepo $repo_file 
+                        set ckouts [oldrepo eval {select name from config where name like 'ckout:%'}]
+                        set pcode [oldrepo eval {select value from config where name = 'project-code'}]
+                        oldrepo close
+                        if {[string length $pcode] < 20} {
+                            puts stderr "WARNING: Failed to get project-code from repo db $repo_file"
+                        }
+                        set other_checkouts [list]
+                        set norm_projectbase [file normalize $projectbase]
+                        foreach ck $ckouts {
+                            set ckfolder [string trim [string range $ck 6 end]]
+                            if {![file isdirectory $ckfolder]} {
+                                #as the process was launched within a checkout - we won't bother user with reports of non-existant other checkouts
+                                continue
+                            }
+                            if {[file normalize $ckfolder] ne $norm_projectbase} {
+                                lappend other_checkouts $ckfolder
+                            }
+                        }
+                        if {[llength $other_checkouts]} { 
+                            puts stderr "${ansiwarn}Other checkouts of $repo_file that may need consideration${ansireset}"
+                            foreach other $other_checkouts {
+                                puts stdout $other
+                            }
+                        }
+                    }
+                } else {
+                    #we aren't in a checkout - moving a repo to a new db location and/or name so there's no reason to prefer one checkout over another.. presumably the user either wants to move them all - or be asked..
+                    sqlite3 oldrepo $repo_file
+                    set ckouts [oldrepo eval {select name from config where name like 'ckout:%'}]
+                    oldrepo close
+                    if {[llength $ckouts] > 1} {
+                        puts stdout "There are [llength $ckouts] checkouts for the repository you are moving" 
+                        puts stdout "You will be asked for each checkout if you want to adjust it to point to $target_repodb_folder/$pname2.folder"
+                    }
+                    set original_cwd [pwd]
+                    foreach ck $ckouts {
+                        set ckfolder [string trim [string range $ck 6 end]]
+                        if {![file isdirectory $ckfolder]} {
+                            puts stderr "old repo shows a checkout at $ckfolder - but it doesn't seem to exist. Ignoring"
+                            continue
+                        }
+                        cd $ckfolder
+                        puts stdout [exec fossil info]
+                        puts stdout [state]
+                        set answer  [punk::repo::askuser "${ansiprompt}Do you want to point this checkout to $target_repodb_folder/$pname2.folder? (Y|N) Q to stop processing checkouts${ansireset}"]
+                        if {[string match q* [string tolower $answer]]} {
+                            puts stderr "User aborting loop"
+                            break
+                        }
+                        if {[string match y* [string tolower $answer]]} {
+                            if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} moveresult]} {
+                                puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                                puts stderr "$moveresult"
+                            } else {
+                                puts stdout "OK - move performed with result:" 
+                                puts stdout $moveresult
+                            }
+                        }
+                    } 
+                    cd $original_cwd
+
+                }
+            } else {
+                if {$is_checkout_relink} {
+                    #relinking a lost checkout to an existing repo.. we should probably check it's other checkouts and see if they point back
+                    if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} errM]} {
+                        puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                        puts stderr "$errM"
+                    }
+                } else {
+                    if {$in_checkout} {
+                        if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} errM]} {
+                            puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                            puts stderr "$errM"
+                        }
+                    } else {
+                        #not in checkout - we're wanting what pointed to one repo to point to a different existing one - presumably for all checkouts
+                        sqlite3 newrepo $target_repodb_folder/$pname2.fossil
+                        set newpname [newrepo eval {select value from config where name = 'project-name'}]
+                        set newpcode [newrepo eval {select value from config where name = 'project-code'}]
+                        set newckouts [newrepo eval {select name from config where name like 'ckout:%'}]
+                        newrepo close
+
+                        sqlite3 oldrepo $repo_file 
+                        set oldpname [oldrepo eval {select value from config where name = 'project-name'}]
+                        set oldpcode [oldrepo eval {select value from config where name = 'project-code'}]
+                        set oldckouts [oldrepo eval {select name from config where name like 'ckout:%'}]
+                        oldrepo close
+                        if {$newpname eq $oldpname} {
+                            set ansi_newpname [a+ green bold]$newpname[a]
+                            set ansi_oldpname [a+ green bold]$oldpname[a]
+                        } else {
+                            set ansi_newpname [a+ cyan bold]$newpname[a]
+                            set ansi_oldpname [a+ red bold]$oldpname[a]
+                        }
+                        if {$newpcode eq $oldpcode} {
+                            set ansi_newpcode [a+ green bold]$newpcode[a]
+                            set ansi_oldpcode [a+ green bold]$oldpcode[a]
+                        } else {
+                            set ansi_newpcode [a+ cyan bold]$newpcode[a]
+                            set ansi_oldpcode [a+ red bold]$oldpcode[a]
+                        }
+                        puts stdout "Target repository $target_repodb_folder/$pname2.fossil has project-name: $ansi_newpname and [llength $newckouts] existing checkouts"
+                        puts stdout "Target project code: $ansi_newpcode"
+                        puts stdout "Source repository $repo_file has project-name: $ansi_oldpname and [llength $oldckouts] existing checkouts"
+                        puts stdout "Source project code: $ansi_oldpcode"
+                        if {[llength $oldckouts] > 1} {
+                            puts stdout "You will be asked for each checkout if you want to adjust it to point to $target_repodb_folder/$pname2.folder"
+                        }
+                        set original_cwd [pwd]
+                        foreach ck $oldckouts {
+                            set ckfolder [string trim [string range $ck 6 end]]
+                            if {![file isdirectory $ckfolder]} {
+                                puts stderr "old repo shows a checkout at $ckfolder - but it doesn't seem to exist. Ignoring"
+                                continue
+                            }
+                            cd $ckfolder
+                            puts stdout [exec fossil info]
+                            puts stdout [state]
+                            set answer  [punk::repo::askuser "${ansiprompt}Do you want to point this checkout to $target_repodb_folder/$pname2.folder? (Y|N) Q to stop processing checkouts${ansireset}"]
+                            if {[string match q* [string tolower $answer]]} {
+                                puts stderr "User aborting loop"
+                                break
+                            }
+                            if {[string match y* [string tolower $answer]]} {
+                                if {[catch {exec fossil test-move-repository $target_repodb_folder/$pname2.fossil} moveresult]} {
+                                    puts stderr "${ansiwarn}The fossil test-move-repository command appears to have failed${ansireset}"
+                                    puts stderr "$moveresult"
+                                } else {
+                                    puts stdout "OK - move performed with result:" 
+                                    puts stdout $moveresult
+                                }
+                            }
+                        } 
+                        cd $original_cwd
+
+                    }
+                }
+            }
+
+
+            puts stdout "-done-"
+        } else {
+            puts stdout "-cancelled by user-"
+        }
+
+    }
 }
 
 
diff --git a/src/modules/punk/mix/commandset/scriptwrap-999999.0a1.0.tm b/src/modules/punk/mix/commandset/scriptwrap-999999.0a1.0.tm
index e042ac1c..e91d0ae8 100644
--- a/src/modules/punk/mix/commandset/scriptwrap-999999.0a1.0.tm
+++ b/src/modules/punk/mix/commandset/scriptwrap-999999.0a1.0.tm
@@ -59,7 +59,7 @@ namespace eval punk::mix::commandset::scriptwrap {
         set widest(name) [tcl::mathfunc::max {*}[lmap v [concat [list $title(name)] $names] {string length $v}]]
         set col(name) [string repeat " " $widest(name)]
 
-        set title(pathtype) "[a+ green]Path\n Type[a]"
+        set title(pathtype) "[a+ green]Path\nType[a]"
         set widest(pathtype) [tcl::mathfunc::max {*}[lmap v [concat [list $title(pathtype)] $pathtypes] {textblock::width $v}]]
         set col(pathtype) [string repeat " " $widest(pathtype)]
 
@@ -73,7 +73,7 @@ namespace eval punk::mix::commandset::scriptwrap {
         set tablewidth [expr {$widest(name) + 1 + $widest(pathtype) + $widest(path)}]
         set table ""
         append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col(name) $title(name)] [overtype::left $col(pathtype) $title(pathtype)] [overtype::left $col(path) $title(path)]" \n
+        append table [textblock::join [overtype::left $col(name) $title(name)] " " [overtype::left $col(pathtype) $title(pathtype)] " " [overtype::left $col(path) $title(path)]] \n
         append table [string repeat - $tablewidth] \n
 
         foreach n $names pt $pathtypes p $paths {
@@ -84,8 +84,14 @@ namespace eval punk::mix::commandset::scriptwrap {
         return $table
     }
     proc templates_dict {args} {
-        tailcall lib::templates_dict {*}$args
-    }
+        package require punk::cap
+        if {[punk::cap::capability_has_handler punk.templates]} {
+            return [punk::cap::call_handler punk.templates get_itemdict_scriptappwrappers {*}$args]
+        } else {
+            put stderr "commandset::scriptwrap::templates_dict WARNING - no handler available for the 'punk.templates' capability - template providers will be unable to provide template locations"
+        }
+        return
+    }        
    
     
     #A batch file with unix line-endings is sensitive to label positioning. 
@@ -695,17 +701,16 @@ namespace eval punk::mix::commandset::scriptwrap {
         if {[dict size $possible_target_labels_found] > 0} {
             #puts stdout "Possibly bogus target-labels: [dict keys $possible_target_labels_found]"
             set bogus_summary [list] 
-            foreach pb [dict keys $possible_target_labels_found] {
+            dict for {pb pbrecords} $possible_target_labels_found {
                 if {$pb in [dict keys $call_labels_found]} {
-                    puts stdout "[a+ yellow bold]Warning - target for label $pb was found with a record as being possibly bogus. record: [dict get $possible_target_labels_found $pb][a]"
+                    puts stdout "[a+ yellow bold]Warning - target for label $pb was found with a record as being possibly bogus. record: $pbrecords [a]"
                     puts stdout "[a+ yellow bold]Consider moving this target-label and re-checking[a]"
                     puts stdout "[a+ yellow bold]It may be a call label line that was found by boundary scanning - which shouldn't really happen[a]"
                     puts stdout "Call record [dict get $call_labels_found $pb]"
-                    lappend warning_labels [list label $pb warning possibly_bogus_target list_of_target_hits [dict get $possible_target_labels_found $pb]]
+                    lappend warning_labels [list label $pb warning possibly_bogus_target list_of_target_hits $pbrecords]
                 }
-                set records [dict get $possible_target_labels_found $pb]
                 set blines [list] 
-                foreach rec $records {
+                foreach rec $pbrecords {
                     lappend blines [dict get $rec line]
                 }
                 lappend bogus_summary [list label $pb found_on_lines $blines]
@@ -1168,139 +1173,7 @@ namespace eval punk::mix::commandset::scriptwrap {
         }
 
 
-        #get_wrapper_folders
-        #   scriptpath - file or folder
-        #   It represents the base point from which to search for /wrapper folders either directly above the scriptpath or in the containing project if any
-        #   The cwd will also be searched for /wrapper folder and project - but with lower precedence in the resultset (later in list)
-        proc get_wrapper_folders1 {{scriptpath ""}} {
-            set wrapper_folders [list]
-            if {$scriptpath ne ""} {
-                if {[file type $scriptpath] eq "file"} {
-                    set searchbase [file dirname $scriptpath]
-                } else {
-                    set searchbase $scriptpath
-                }
-                if {[file isdirectory [file join $searchbase wrappers]]} {
-                    lappend wrapper_folders [file join $searchbase wrappers]
-                }
-                set pathinfo    [punk::repo::find_repos $searchbase]
-                set scriptpath_projectroot [dict get $pathinfo closest]
-                if {$scriptpath_projectroot ne ""} {
-                    set fld [file join $scriptpath_projectroot src/scriptapps/wrappers]
-                    if {[file isdirectory $fld]} {
-                        if {$fld ni $wrapper_folders} {
-                            lappend wrapper_folders $fld
-                        }
-                    }
-                }
-            }
-            set searchbase [pwd] 
-            set fld [file join $searchbase wrappers]
-            if {[file isdirectory $fld]} {
-                if {$fld ni $wrapper_folders} {
-                    lappend wrapper_folders $fld
-                }
-            }
-            set pathinfo    [punk::repo::find_repos $searchbase]
-            set pwd_projectroot [dict get $pathinfo closest]
-            if {$pwd_projectroot ne ""} {
-                set fld [file join $pwd_projectroot src/scriptapps/wrappers]
-                if {[file isdirectory $fld]} {
-                    if {$fld ni $wrapper_folders} {
-                        lappend wrapper_folders $fld
-                    }
-                }
-            }
-
-            set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-            set tpldirs [list]
-            dict for {tdir tsourceinfo} $template_base_dict {
-                if {[file exists $tdir/utility/scriptappwrappers]} {
-                        lappend tpldirs $tdir
-                } 
-            }
-            foreach tpldir $tpldirs {
-                set fld [file join $tpldir utility scriptappwrappers]
-                if {[file isdirectory $fld]} {
-                    if {$fld ni $wrapper_folders} {
-                        lappend wrapper_folders $fld
-                    }
-                }
-            }
-            return $wrapper_folders
-        }
         
-        #scriptpath allows templates command to use same custom template set as when multishell pointed to a filepath
-        #it may or may not be within a project
-        #by using the same folder or path, the same project root will be discovered. REVIEW.
-        proc templates_dict {args} {
-            set globsearch [lindex $args 0]
-            if {$globsearch eq ""} {
-                set globsearch *
-            }
-            set args [lrange $args 1 end] 
-
-            set opts [dict get [punk::get_leading_opts_and_values { 
-                    -scriptpath ""
-            } $args -maxvalues 0] opts] 
-            # -- --- --- --- --- --- --- --- ---
-            set opt_scriptpath [dict get $opts -scriptpath]
-            # -- --- --- --- --- --- --- --- ---
-
-            set wrapper_folders [lib::get_wrapper_folders -scriptpath $opt_scriptpath]
-
-            set wrapper_files [list]
-            #flip the priority order to high-priority earliest in the list (display order - and processing order of found files)
-            foreach baseinfo [lreverse $wrapper_folders] {
-                set basefld [dict get $baseinfo basefolder]
-                #set matched_files [glob -nocomplain -dir $basefld -type f *]
-                set matched_files [punk::path::treefilenames  -dir $basefld *]
-
-                foreach tf $matched_files {
-                    if {[string match ignore* $tf]} {
-                        continue
-                    }
-                    set ext [file extension $tf]
-                    if {[string tolower $ext] in [list "" ".bat" ".cmd" ".sh" ".bash" ".pl" ".ps1" ".tcl"]} {
-                        lappend wrapper_files [list file $tf baseinfo $baseinfo]
-                    }
-                }
-            }
-
-            set tdict [dict create]
-            set seen_dict [dict create]
-            foreach fileinfo $wrapper_files {
-                set fullpath [dict get $fileinfo file]
-                set vendor   [dict get $fileinfo baseinfo sourceinfo vendor]
-                set basefolder [dict get $fileinfo baseinfo basefolder]
-                set relativepath [punk::path::relative $basefolder $fullpath]
-                set ftail [file tail $fullpath]
-                set tname $relativepath
-                if {$vendor ne "_project"} {
-                    set tname ${vendor}.$tname
-                }
-                if {![dict exists $seen_dict $tname]} {
-                    dict set seen_dict $tname 1 
-                    dict set tdict $tname [list path $fullpath {*}[dict get $fileinfo baseinfo]] ; #first seen of filename gets no number
-                } else {
-                    set n [dict get $seen_dict $tname]
-                    incr n
-                    dict incr seen_dict $tname
-                    dict set tdict ${tname}.$n [list path $fullpath {*}[dict get $fileinfo baseinfo]]
-                }
-            }
-
-            #return in priority order low to high
-            set result [dict create]
-            set keys [lreverse [dict keys $tdict]]
-            foreach k $keys {
-                if {[string match $globsearch $k]} {
-                    dict set result $k [dict get $tdict $k]
-                }
-            }
-            return $result
-        }
-
         proc _scriptapp_tag_from_line {line} {
             set result [list istag 0 raw ""] ;#default assumption. All 
             #----
diff --git a/src/modules/punk/mix/templates-999999.0a1.0.tm b/src/modules/punk/mix/templates-999999.0a1.0.tm
index fd2a7097..e109469e 100644
--- a/src/modules/punk/mix/templates-999999.0a1.0.tm
+++ b/src/modules/punk/mix/templates-999999.0a1.0.tm
@@ -32,6 +32,8 @@ namespace eval punk::mix::templates {
             oo::objdefine capprovider.registration {
                 method get_declarations {} {
                     set decls [list]
+                    lappend decls [list punk.templates {path templates pathtype adhoc vendor _project}] ;#todo - split out to a different provider package?
+
                     lappend decls [list punk.templates {path templates pathtype module vendor punk}]
                     #only punk::templates is allowed to register a _multivendor path - review
                     #other punk.template providers should use module, absolute, currentproject and shellproject pathtypes only
diff --git a/src/modules/punk/mix/templates/layout_refs/project@vendor+punk+project-0.1.ref b/src/modules/punk/mix/templates/layout_refs/project@vendor+punk+project-0.1.ref
new file mode 100644
index 00000000..e69de29b
diff --git a/src/modules/punk/mix/templates/layouts/minimal/.fossil-custom/mainmenu b/src/modules/punk/mix/templates/layouts/minimal/.fossil-custom/mainmenu
deleted file mode 100644
index bb38af37..00000000
--- a/src/modules/punk/mix/templates/layouts/minimal/.fossil-custom/mainmenu
+++ /dev/null
@@ -1,14 +0,0 @@
-Home      /home        *              {}
-Timeline  /timeline    {o r j}        {}
-Files     /dir?ci=tip  oh             desktoponly
-Branches  /brlist      o              wideonly
-Tags      /taglist     o              wideonly
-Forum     /forum       {@2 3 4 5 6}   wideonly
-Chat      /chat        C              wideonly
-Tickets   /ticket      r              wideonly
-Wiki      /wiki        j              wideonly
-Doc       /doc/tip/src/embedded/md/toc.md   *   {}
-Download  /download    *              {}
-Admin     /setup       {a s}          desktoponly
-Logout    /logout      L              wideonly
-Login     /login       !L             wideonly
diff --git a/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/crlf-glob b/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/crlf-glob
deleted file mode 100644
index eaa1c665..00000000
--- a/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/crlf-glob
+++ /dev/null
@@ -1 +0,0 @@
-src/embedded/*
diff --git a/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/empty-dirs b/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/empty-dirs
deleted file mode 100644
index f8f80ad7..00000000
--- a/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/empty-dirs
+++ /dev/null
@@ -1,7 +0,0 @@
-src
-src/vendorlib
-src/vendormodules
-src/modules
-src/lib
-lib
-modules
diff --git a/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/ignore-glob b/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/ignore-glob
deleted file mode 100644
index 3c2ac851..00000000
--- a/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/ignore-glob
+++ /dev/null
@@ -1,39 +0,0 @@
-.git
-bin
-lib
-#The directory for compiled/built Tcl modules
-modules
-#The buildsuites output folder
-builds
-
-#Temporary files e.g from tests
-tmp
-
-logs
-_aside
-_build
-
-#Built documentation
-html
-man
-md
-doc
-
-test*
-
-#Built tclkits (if any)
-punk*.exe
-tcl*.exe
-
-#miscellaneous editor files etc
-*.swp
-
-todo.txt
-
-zig-cache
-zig-out
-release
-debug
-build
-build-*
-docgen_tmp
diff --git a/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/manifest b/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/manifest
deleted file mode 100644
index 50cc10db..00000000
--- a/src/modules/punk/mix/templates/layouts/minimal/.fossil-settings/manifest
+++ /dev/null
@@ -1 +0,0 @@
-rut
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/minimal/.gitignore b/src/modules/punk/mix/templates/layouts/minimal/.gitignore
deleted file mode 100644
index deddaf71..00000000
--- a/src/modules/punk/mix/templates/layouts/minimal/.gitignore
+++ /dev/null
@@ -1,39 +0,0 @@
-
-/bin/
-/lib/
-#The directory for compiled/built Tcl modules
-/modules/
-/vendorbuilds/
-
-#Temporary files e.g from tests
-/tmp/
-
-/logs/
-**/_aside/
-**/_build/
-scratch*
-
-#Built documentation
-/html/
-/man/
-/md/
-/doc/
-
-/test*
-
-
-#Built tclkits (if any)
-punk*.exe
-tcl*.exe
-
-#ignore fossil database files (but keep .fossil-settings and .fossil-custom in repository even if fossil not being used at your site)
-_FOSSIL_
-.fos
-.fslckout
-*.fossil
-
-#miscellaneous editor files etc 
-*.swp
-
-
-todo.txt
diff --git a/src/modules/punk/mix/templates/layouts/minimal/README.md b/src/modules/punk/mix/templates/layouts/minimal/README.md
deleted file mode 100644
index 841c3dd3..00000000
--- a/src/modules/punk/mix/templates/layouts/minimal/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-%project%
-==============================
-
-+ 
-+ 
-
-
-About
-------------------------------
-
-+
-+
-+
diff --git a/src/modules/punk/mix/templates/layouts/minimal/src/modules/README.md b/src/modules/punk/mix/templates/layouts/minimal/src/modules/README.md
deleted file mode 100644
index 1c037091..00000000
--- a/src/modules/punk/mix/templates/layouts/minimal/src/modules/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
-Tcl Module Source files for the project.
-Consider using the punkshell pmix facility to create and manage these.
-
-pmix::newmodule <name> will create a basic .tm module template and assist in versioning.
-
-Tcl modules can be namespaced.
-For example 
-> pmix::newmodule mymodule::utils
-will create the new module under src/modules/mymodule/utils 
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/.fossil-custom/mainmenu b/src/modules/punk/mix/templates/layouts/project/.fossil-custom/mainmenu
deleted file mode 100644
index bb38af37..00000000
--- a/src/modules/punk/mix/templates/layouts/project/.fossil-custom/mainmenu
+++ /dev/null
@@ -1,14 +0,0 @@
-Home      /home        *              {}
-Timeline  /timeline    {o r j}        {}
-Files     /dir?ci=tip  oh             desktoponly
-Branches  /brlist      o              wideonly
-Tags      /taglist     o              wideonly
-Forum     /forum       {@2 3 4 5 6}   wideonly
-Chat      /chat        C              wideonly
-Tickets   /ticket      r              wideonly
-Wiki      /wiki        j              wideonly
-Doc       /doc/tip/src/embedded/md/toc.md   *   {}
-Download  /download    *              {}
-Admin     /setup       {a s}          desktoponly
-Logout    /logout      L              wideonly
-Login     /login       !L             wideonly
diff --git a/src/modules/punk/mix/templates/layouts/project/.fossil-settings/crlf-glob b/src/modules/punk/mix/templates/layouts/project/.fossil-settings/crlf-glob
deleted file mode 100644
index eaa1c665..00000000
--- a/src/modules/punk/mix/templates/layouts/project/.fossil-settings/crlf-glob
+++ /dev/null
@@ -1 +0,0 @@
-src/embedded/*
diff --git a/src/modules/punk/mix/templates/layouts/project/.fossil-settings/empty-dirs b/src/modules/punk/mix/templates/layouts/project/.fossil-settings/empty-dirs
deleted file mode 100644
index f8f80ad7..00000000
--- a/src/modules/punk/mix/templates/layouts/project/.fossil-settings/empty-dirs
+++ /dev/null
@@ -1,7 +0,0 @@
-src
-src/vendorlib
-src/vendormodules
-src/modules
-src/lib
-lib
-modules
diff --git a/src/modules/punk/mix/templates/layouts/project/.fossil-settings/ignore-glob b/src/modules/punk/mix/templates/layouts/project/.fossil-settings/ignore-glob
deleted file mode 100644
index 7df6f13c..00000000
--- a/src/modules/punk/mix/templates/layouts/project/.fossil-settings/ignore-glob
+++ /dev/null
@@ -1,45 +0,0 @@
-.git
-CVS
-bin
-lib
-#The directory for compiled/built Tcl modules
-modules
-#The buildsuites output folder
-builds
-
-#Temporary files e.g from tests
-tmp
-
-logs
-_aside
-
-#working directories
-_build
-src/docgen
-
-#Built documentation
-html
-man
-md
-doc
-
-test*
-
-#Built tclkits (if any)
-punk*.exe
-tcl*.exe
-
-#miscellaneous editor files etc
-*.swp
-
-.punkcheck
-
-todo.txt
-
-zig-cache
-zig-out
-release
-debug
-build
-build-*
-docgen_tmp
diff --git a/src/modules/punk/mix/templates/layouts/project/.fossil-settings/manifest b/src/modules/punk/mix/templates/layouts/project/.fossil-settings/manifest
deleted file mode 100644
index 50cc10db..00000000
--- a/src/modules/punk/mix/templates/layouts/project/.fossil-settings/manifest
+++ /dev/null
@@ -1 +0,0 @@
-rut
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/project/.gitignore b/src/modules/punk/mix/templates/layouts/project/.gitignore
deleted file mode 100644
index 3aaba3c7..00000000
--- a/src/modules/punk/mix/templates/layouts/project/.gitignore
+++ /dev/null
@@ -1,48 +0,0 @@
-
-/bin/
-/lib/
-#The directory for compiled/built Tcl modules
-/modules/
-/vendorbuilds/
-
-#Temporary files e.g from tests
-/tmp/
-
-/logs/
-**/_aside/
-**/_build/
-scratch*
-
-#Built documentation
-/html/
-/man/
-/md/
-/doc/
-
-/test*
-
-
-#Built tclkits (if any)
-punk*.exe
-tcl*.exe
-
-#ignore fossil database files (but keep .fossil-settings and .fossil-custom in repository even if fossil not being used at your site)
-_FOSSIL_
-.fos
-.fslckout
-*.fossil
-
-#miscellaneous editor files etc 
-*.swp
-
-.punkcheck
-
-todo.txt
-
-zig-cache/
-zig-out/
-/release/
-/debug/
-/build/
-/build-*/
-/docgen_tmp/
diff --git a/src/modules/punk/mix/templates/layouts/project/README.md b/src/modules/punk/mix/templates/layouts/project/README.md
deleted file mode 100644
index 841c3dd3..00000000
--- a/src/modules/punk/mix/templates/layouts/project/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-%project%
-==============================
-
-+ 
-+ 
-
-
-About
-------------------------------
-
-+
-+
-+
diff --git a/src/modules/punk/mix/templates/layouts/project/src/README.md b/src/modules/punk/mix/templates/layouts/project/src/README.md
deleted file mode 100644
index 972fd1ab..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-%project%
-==============================
-
-Build Instructions
-------------------------------
-
-+ Use  tclsh|punk make.tcl to build .tm modules and rebuild the executable (if applicable)
-
-+ Use tclsh|punk build.tcl to run the 'kettle' system to build docs and/or standard tcl libraries with pkgIndex.tcl files,   
-or - use the `pmix KettleShell` command from within the punk shell to perform kettle operations.
-
-(The name 'build.tcl' is the standard name used by the [Kettle](https://chiselapp.com/user/andreas_kupries/repository/Kettle/home) system)
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/include_modules.config b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/include_modules.config
deleted file mode 100644
index d8eb8c9a..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/include_modules.config
+++ /dev/null
@@ -1,6 +0,0 @@
-## e.g
-#set bootsupport_modules [list\
-#    src/vendormodules cksum\
-#    modules punkcheck\
-#]
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/README.md b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/README.md
deleted file mode 100644
index 7646295d..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/README.md
+++ /dev/null
@@ -1,24 +0,0 @@
-This is primarily for tcl .tm modules required for your bootstrapping/make/build process.
-It could include other files necessary for this process.
-
-The .tm modules here may be required for your build script if it intended the installation operator uses an existing tclsh or other shell as opposed to a tclkit you may have for distribution which is more likely to include necessary libraries.
-
-The modules here are loaded by your initialisation scripts and so can be a snapshot of different versions than those in your project src.
-The modules can be your own, or 3rd party such as individual items from tcllib.
-
-You can copy modules from a running punk shell to this location using the pmix command.
-
-e.g
->pmix visible_lib_copy_to_modulefolder some::module::lib bootsupport
-
-The pmix command will help you pick the latest version, and will create any necessary file structure matching the namespace of the package.
-
-e.g the result might be a file such as
-<projectname>/src/bootsupport/some/module/lib-0.1.tm 
-
-The originating library may not yet be in .tm form.
-You can copy a pkgIndex.tcl based library that is composed of a single .tcl file the same way using the above process and it will automatically name and file it appropriately but you need to check that the library doesn't require/load additional files - and that it is Tcl script only. 
-
-Always verify that the library is copyable in this manner and test in a shell with tcl::tm::path pointed to ./bootsupport  that it works.
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/cksum-1.1.4.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/cksum-1.1.4.tm
deleted file mode 100644
index 0fb17981..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/cksum-1.1.4.tm
+++ /dev/null
@@ -1,200 +0,0 @@
-# cksum.tcl - Copyright (C) 2002 Pat Thoyts <patthoyts@users.sourceforge.net>
-#
-# Provides a Tcl only implementation of the unix cksum(1) command. This is
-# similar to the sum(1) command but the algorithm is better defined and
-# standardized across multiple platforms by POSIX 1003.2/D11.2
-#
-# This command has been verified against the cksum command from the GNU
-# textutils package version 2.0
-#
-# -------------------------------------------------------------------------
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-# -------------------------------------------------------------------------
-
-package require Tcl 8.5-;                # tcl minimum version
-
-namespace eval ::crc {
-    namespace export cksum
-
-    variable cksum_tbl [list 0x0 \
-           0x04C11DB7 0x09823B6E 0x0D4326D9 0x130476DC 0x17C56B6B \
-           0x1A864DB2 0x1E475005 0x2608EDB8 0x22C9F00F 0x2F8AD6D6 \
-           0x2B4BCB61 0x350C9B64 0x31CD86D3 0x3C8EA00A 0x384FBDBD \
-           0x4C11DB70 0x48D0C6C7 0x4593E01E 0x4152FDA9 0x5F15ADAC \
-           0x5BD4B01B 0x569796C2 0x52568B75 0x6A1936C8 0x6ED82B7F \
-           0x639B0DA6 0x675A1011 0x791D4014 0x7DDC5DA3 0x709F7B7A \
-           0x745E66CD 0x9823B6E0 0x9CE2AB57 0x91A18D8E 0x95609039 \
-           0x8B27C03C 0x8FE6DD8B 0x82A5FB52 0x8664E6E5 0xBE2B5B58 \
-           0xBAEA46EF 0xB7A96036 0xB3687D81 0xAD2F2D84 0xA9EE3033 \
-           0xA4AD16EA 0xA06C0B5D 0xD4326D90 0xD0F37027 0xDDB056FE \
-           0xD9714B49 0xC7361B4C 0xC3F706FB 0xCEB42022 0xCA753D95 \
-           0xF23A8028 0xF6FB9D9F 0xFBB8BB46 0xFF79A6F1 0xE13EF6F4 \
-           0xE5FFEB43 0xE8BCCD9A 0xEC7DD02D 0x34867077 0x30476DC0 \
-           0x3D044B19 0x39C556AE 0x278206AB 0x23431B1C 0x2E003DC5 \
-           0x2AC12072 0x128E9DCF 0x164F8078 0x1B0CA6A1 0x1FCDBB16 \
-           0x018AEB13 0x054BF6A4 0x0808D07D 0x0CC9CDCA 0x7897AB07 \
-           0x7C56B6B0 0x71159069 0x75D48DDE 0x6B93DDDB 0x6F52C06C \
-           0x6211E6B5 0x66D0FB02 0x5E9F46BF 0x5A5E5B08 0x571D7DD1 \
-           0x53DC6066 0x4D9B3063 0x495A2DD4 0x44190B0D 0x40D816BA \
-           0xACA5C697 0xA864DB20 0xA527FDF9 0xA1E6E04E 0xBFA1B04B \
-           0xBB60ADFC 0xB6238B25 0xB2E29692 0x8AAD2B2F 0x8E6C3698 \
-           0x832F1041 0x87EE0DF6 0x99A95DF3 0x9D684044 0x902B669D \
-           0x94EA7B2A 0xE0B41DE7 0xE4750050 0xE9362689 0xEDF73B3E \
-           0xF3B06B3B 0xF771768C 0xFA325055 0xFEF34DE2 0xC6BCF05F \
-           0xC27DEDE8 0xCF3ECB31 0xCBFFD686 0xD5B88683 0xD1799B34 \
-           0xDC3ABDED 0xD8FBA05A 0x690CE0EE 0x6DCDFD59 0x608EDB80 \
-           0x644FC637 0x7A089632 0x7EC98B85 0x738AAD5C 0x774BB0EB \
-           0x4F040D56 0x4BC510E1 0x46863638 0x42472B8F 0x5C007B8A \
-           0x58C1663D 0x558240E4 0x51435D53 0x251D3B9E 0x21DC2629 \
-           0x2C9F00F0 0x285E1D47 0x36194D42 0x32D850F5 0x3F9B762C \
-           0x3B5A6B9B 0x0315D626 0x07D4CB91 0x0A97ED48 0x0E56F0FF \
-           0x1011A0FA 0x14D0BD4D 0x19939B94 0x1D528623 0xF12F560E \
-           0xF5EE4BB9 0xF8AD6D60 0xFC6C70D7 0xE22B20D2 0xE6EA3D65 \
-           0xEBA91BBC 0xEF68060B 0xD727BBB6 0xD3E6A601 0xDEA580D8 \
-           0xDA649D6F 0xC423CD6A 0xC0E2D0DD 0xCDA1F604 0xC960EBB3 \
-           0xBD3E8D7E 0xB9FF90C9 0xB4BCB610 0xB07DABA7 0xAE3AFBA2 \
-           0xAAFBE615 0xA7B8C0CC 0xA379DD7B 0x9B3660C6 0x9FF77D71 \
-           0x92B45BA8 0x9675461F 0x8832161A 0x8CF30BAD 0x81B02D74 \
-           0x857130C3 0x5D8A9099 0x594B8D2E 0x5408ABF7 0x50C9B640 \
-           0x4E8EE645 0x4A4FFBF2 0x470CDD2B 0x43CDC09C 0x7B827D21 \
-           0x7F436096 0x7200464F 0x76C15BF8 0x68860BFD 0x6C47164A \
-           0x61043093 0x65C52D24 0x119B4BE9 0x155A565E 0x18197087 \
-           0x1CD86D30 0x029F3D35 0x065E2082 0x0B1D065B 0x0FDC1BEC \
-           0x3793A651 0x3352BBE6 0x3E119D3F 0x3AD08088 0x2497D08D \
-           0x2056CD3A 0x2D15EBE3 0x29D4F654 0xC5A92679 0xC1683BCE \
-           0xCC2B1D17 0xC8EA00A0 0xD6AD50A5 0xD26C4D12 0xDF2F6BCB \
-           0xDBEE767C 0xE3A1CBC1 0xE760D676 0xEA23F0AF 0xEEE2ED18 \
-           0xF0A5BD1D 0xF464A0AA 0xF9278673 0xFDE69BC4 0x89B8FD09 \
-           0x8D79E0BE 0x803AC667 0x84FBDBD0 0x9ABC8BD5 0x9E7D9662 \
-           0x933EB0BB 0x97FFAD0C 0xAFB010B1 0xAB710D06 0xA6322BDF \
-           0xA2F33668 0xBCB4666D 0xB8757BDA 0xB5365D03 0xB1F740B4 ]
-
-    variable uid
-    if {![info exists uid]} {set uid 0}
-}
-
-# crc::CksumInit -- 
-#
-#	Create and initialize a cksum context. This is cleaned up when we
-#	call CksumFinal to obtain the result.
-#
-proc ::crc::CksumInit {} {
-    variable uid
-    set token [namespace current]::[incr uid]
-    upvar #0 $token state
-    array set state {t 0 l 0}
-    return $token
-}
-
-proc ::crc::CksumUpdate {token data} {
-    variable cksum_tbl
-    upvar #0 $token state
-    set t $state(t)
-    binary scan $data c* r
-    foreach {n} $r {
-        set index [expr { (($t >> 24) ^ ($n & 0xFF)) & 0xFF }]
-        # Since the introduction of built-in bigInt support with Tcl
-        # 8.5, bit-shifting $t to the left no longer overflows,
-        # keeping it 32 bits long.  The value grows bigger and bigger
-        # instead - a severe hit on performance.  For this reason we
-        # do a bitwise AND against 0xFFFFFFFF at each step to keep the
-        # value within limits.
-        set t [expr {0xFFFFFFFF & (($t << 8) ^ [lindex $cksum_tbl $index])}]
-        incr state(l)
-    }
-    set state(t) $t
-    return
-}
-
-proc ::crc::CksumFinal {token} {
-    variable cksum_tbl
-    upvar #0 $token state
-    set t $state(t)
-    for {set i $state(l)} {$i > 0} {set i [expr {$i>>8}]} {
-        set index [expr {(($t >> 24) ^ $i) & 0xFF}]
-        set t [expr {0xFFFFFFFF & (($t << 8) ^ [lindex $cksum_tbl $index])}]
-    }
-    unset state
-    return [expr {~$t & 0xFFFFFFFF}]
-}
-
-# crc::Pop --
-#
-#	Pop the nth element off a list. Used in options processing.
-#
-proc ::crc::Pop {varname {nth 0}} {
-    upvar $varname args
-    set r [lindex $args $nth]
-    set args [lreplace $args $nth $nth]
-    return $r
-}
-
-# Description:
-#  Provide a Tcl equivalent of the unix cksum(1) command.
-# Options:
-#  -filename name  - return a checksum for the specified file.
-#  -format string  - return the checksum using this format string.
-#  -chunksize size - set the chunking read size
-#
-proc ::crc::cksum {args} {
-    array set opts [list -filename {} -channel {} -chunksize 4096 \
-                        -format %u -command {}]
-    while {[string match -* [set option [lindex $args 0]]]} {
-        switch -glob -- $option {
-            -file*   { set opts(-filename) [Pop args 1] }
-            -chan*   { set opts(-channel) [Pop args 1] }
-            -chunk*  { set opts(-chunksize) [Pop args 1] }
-            -for*    { set opts(-format)   [Pop args 1] }
-            -command { set opts(-command)  [Pop args 1] }
-            default {
-                if {[llength $args] == 1} { break }
-                if {[string compare $option "--"] == 0} { Pop args ; break }
-                set err [join [lsort [array names opts -*]] ", "]
-                return -code error "bad option \"option\": must be $err"
-            }
-        }
-        Pop args
-    }
-
-    if {$opts(-filename) != {}} {
-        set opts(-channel) [open $opts(-filename) r]
-        fconfigure $opts(-channel) -translation binary
-    }
-
-    if {$opts(-channel) == {}} {
-
-        if {[llength $args] != 1} {
-            return -code error "wrong # args: should be\
-                cksum ?-format string?\
-                -channel chan | -filename file | string"
-        }
-        set tok [CksumInit]
-        CksumUpdate $tok [lindex $args 0]
-        set r [CksumFinal $tok]
-    
-    } else {
-
-        set tok [CksumInit]
-        while {![eof $opts(-channel)]} {
-            CksumUpdate $tok [read $opts(-channel) $opts(-chunksize)]
-        }
-        set r [CksumFinal $tok]
-
-        if {$opts(-filename) != {}} {
-            close $opts(-channel)
-        }
-    }
-
-    return [format $opts(-format) $r]
-}
-
-# -------------------------------------------------------------------------
-
-package provide cksum 1.1.4
-
-# -------------------------------------------------------------------------
-# Local variables:
-#   mode: tcl
-#   indent-tabs-mode: nil
-# End:
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/cmdline-1.5.2.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/cmdline-1.5.2.tm
deleted file mode 100644
index 4e5e1df9..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/cmdline-1.5.2.tm
+++ /dev/null
@@ -1,933 +0,0 @@
-# cmdline.tcl --
-#
-#	This package provides a utility for parsing command line
-#	arguments that are processed by our various applications.
-#	It also includes a utility routine to determine the
-#	application name for use in command line errors.
-#
-# Copyright (c) 1998-2000 by Ajuba Solutions.
-# Copyright (c) 2001-2015 by Andreas Kupries <andreas_kupries@users.sf.net>.
-# Copyright (c) 2003      by David N. Welton  <davidw@dedasys.com>
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-
-package require Tcl 8.5-
-package provide cmdline 1.5.2
-
-namespace eval ::cmdline {
-    namespace export getArgv0 getopt getKnownOpt getfiles getoptions \
-	    getKnownOptions usage
-}
-
-# ::cmdline::getopt --
-#
-#	The cmdline::getopt works in a fashion like the standard
-#	C based getopt function.  Given an option string and a
-#	pointer to an array or args this command will process the
-#	first argument and return info on how to proceed.
-#
-# Arguments:
-#	argvVar		Name of the argv list that you
-#			want to process.  If options are found the
-#			arg list is modified and the processed arguments
-#			are removed from the start of the list.
-#	optstring	A list of command options that the application
-#			will accept.  If the option ends in ".arg" the
-#			getopt routine will use the next argument as
-#			an argument to the option.  Otherwise the option
-#			is a boolean that is set to 1 if present.
-#	optVar		The variable pointed to by optVar
-#			contains the option that was found (without the
-#			leading '-' and without the .arg extension).
-#	valVar		Upon success, the variable pointed to by valVar
-#			contains the value for the specified option.
-#			This value comes from the command line for .arg
-#			options, otherwise the value is 1.
-#			If getopt fails, the valVar is filled with an
-#			error message.
-#
-# Results:
-# 	The getopt function returns 1 if an option was found, 0 if no more
-# 	options were found, and -1 if an error occurred.
-
-proc ::cmdline::getopt {argvVar optstring optVar valVar} {
-    upvar 1 $argvVar argsList
-    upvar 1 $optVar option
-    upvar 1 $valVar value
-
-    set result [getKnownOpt argsList $optstring option value]
-
-    if {$result < 0} {
-        # Collapse unknown-option error into any-other-error result.
-        set result -1
-    }
-    return $result
-}
-
-# ::cmdline::getKnownOpt --
-#
-#	The cmdline::getKnownOpt works in a fashion like the standard
-#	C based getopt function.  Given an option string and a
-#	pointer to an array or args this command will process the
-#	first argument and return info on how to proceed.
-#
-# Arguments:
-#	argvVar		Name of the argv list that you
-#			want to process.  If options are found the
-#			arg list is modified and the processed arguments
-#			are removed from the start of the list.  Note that
-#			unknown options and the args that follow them are
-#			left in this list.
-#	optstring	A list of command options that the application
-#			will accept.  If the option ends in ".arg" the
-#			getopt routine will use the next argument as
-#			an argument to the option.  Otherwise the option
-#			is a boolean that is set to 1 if present.
-#	optVar		The variable pointed to by optVar
-#			contains the option that was found (without the
-#			leading '-' and without the .arg extension).
-#	valVar		Upon success, the variable pointed to by valVar
-#			contains the value for the specified option.
-#			This value comes from the command line for .arg
-#			options, otherwise the value is 1.
-#			If getopt fails, the valVar is filled with an
-#			error message.
-#
-# Results:
-# 	The getKnownOpt function returns 1 if an option was found,
-#	0 if no more options were found, -1 if an unknown option was
-#	encountered, and -2 if any other error occurred.
-
-proc ::cmdline::getKnownOpt {argvVar optstring optVar valVar} {
-    upvar 1 $argvVar argsList
-    upvar 1 $optVar  option
-    upvar 1 $valVar  value
-
-    # default settings for a normal return
-    set value ""
-    set option ""
-    set result 0
-
-    # check if we're past the end of the args list
-    if {[llength $argsList] != 0} {
-
-	# if we got -- or an option that doesn't begin with -, return (skipping
-	# the --).  otherwise process the option arg.
-	switch -glob -- [set arg [lindex $argsList 0]] {
-	    "--" {
-		set argsList [lrange $argsList 1 end]
-	    }
-	    "--*" -
-	    "-*" {
-		set option [string range $arg 1 end]
-		if {[string equal [string range $option 0 0] "-"]} {
-		    set option [string range $arg 2 end]
-		}
-
-		# support for format: [-]-option=value
-		set idx [string first "=" $option 1]
-		if {$idx != -1} {
-		    set _val   [string range $option [expr {$idx+1}] end]
-		    set option [string range $option 0   [expr {$idx-1}]]
-		}
-
-		if {[lsearch -exact $optstring $option] != -1} {
-		    # Booleans are set to 1 when present
-		    set value 1
-		    set result 1
-		    set argsList [lrange $argsList 1 end]
-		} elseif {[lsearch -exact $optstring "$option.arg"] != -1} {
-		    set result 1
-		    set argsList [lrange $argsList 1 end]
-
-		    if {[info exists _val]} {
-			set value $_val
-		    } elseif {[llength $argsList]} {
-			set value [lindex $argsList 0]
-			set argsList [lrange $argsList 1 end]
-		    } else {
-			set value "Option \"$option\" requires an argument"
-			set result -2
-		    }
-		} else {
-		    # Unknown option.
-		    set value "Illegal option \"-$option\""
-		    set result -1
-		}
-	    }
-	    default {
-		# Skip ahead
-	    }
-	}
-    }
-
-    return $result
-}
-
-# ::cmdline::getoptions --
-#
-#	Process a set of command line options, filling in defaults
-#	for those not specified.  This also generates an error message
-#	that lists the allowed flags if an incorrect flag is specified.
-#
-# Arguments:
-#	argvVar		The name of the argument list, typically argv.
-#			We remove all known options and their args from it.
-#                       In other words, after the call to this command the
-#                       referenced variable contains only the non-options,
-#                       and unknown options.
-#	optlist		A list-of-lists where each element specifies an option
-#			in the form:
-#				(where flag takes no argument)
-#					flag comment
-#
-#				(or where flag takes an argument)
-#					flag default comment
-#
-#			If flag ends in ".arg" then the value is taken from the
-#			command line. Otherwise it is a boolean and appears in
-#			the result if present on the command line. If flag ends
-#			in ".secret", it will not be displayed in the usage.
-#	usage		Text to include in the usage display. Defaults to
-#			"options:"
-#
-# Results
-#	Name value pairs suitable for using with array set.
-#       A modified `argvVar`.
-
-proc ::cmdline::getoptions {argvVar optlist {usage options:}} {
-    upvar 1 $argvVar argv
-
-    set opts [GetOptionDefaults $optlist result]
-
-    set argc [llength $argv]
-    while {[set err [getopt argv $opts opt arg]]} {
-	if {$err < 0} {
-            set result(?) ""
-            break
-	}
-	set result($opt) $arg
-    }
-    if {[info exist result(?)] || [info exists result(help)]} {
-	Error [usage $optlist $usage] USAGE
-    }
-    return [array get result]
-}
-
-# ::cmdline::getKnownOptions --
-#
-#	Process a set of command line options, filling in defaults
-#	for those not specified.  This ignores unknown flags, but generates
-#	an error message that lists the correct usage if a known option
-#	is used incorrectly.
-#
-# Arguments:
-#	argvVar		The name of the argument list, typically argv.  This
-#			We remove all known options and their args from it.
-#                       In other words, after the call to this command the
-#                       referenced variable contains only the non-options,
-#                       and unknown options.
-#	optlist		A list-of-lists where each element specifies an option
-#			in the form:
-#				flag default comment
-#			If flag ends in ".arg" then the value is taken from the
-#			command line. Otherwise it is a boolean and appears in
-#			the result if present on the command line. If flag ends
-#			in ".secret", it will not be displayed in the usage.
-#	usage		Text to include in the usage display. Defaults to
-#			"options:"
-#
-# Results
-#	Name value pairs suitable for using with array set.
-#       A modified `argvVar`.
-
-proc ::cmdline::getKnownOptions {argvVar optlist {usage options:}} {
-    upvar 1 $argvVar argv
-
-    set opts [GetOptionDefaults $optlist result]
-
-    # As we encounter them, keep the unknown options and their
-    # arguments in this list.  Before we return from this procedure,
-    # we'll prepend these args to the argList so that the application
-    # doesn't lose them.
-
-    set unknownOptions [list]
-
-    set argc [llength $argv]
-    while {[set err [getKnownOpt argv $opts opt arg]]} {
-	if {$err == -1} {
-            # Unknown option.
-
-            # Skip over any non-option items that follow it.
-            # For now, add them to the list of unknownOptions.
-            lappend unknownOptions [lindex $argv 0]
-            set argv [lrange $argv 1 end]
-            while {([llength $argv] != 0) \
-                    && ![string match "-*" [lindex $argv 0]]} {
-                lappend unknownOptions [lindex $argv 0]
-                set argv [lrange $argv 1 end]
-            }
-	} elseif {$err == -2} {
-            set result(?) ""
-            break
-        } else {
-            set result($opt) $arg
-        }
-    }
-
-    # Before returning, prepend the any unknown args back onto the
-    # argList so that the application doesn't lose them.
-    set argv [concat $unknownOptions $argv]
-
-    if {[info exist result(?)] || [info exists result(help)]} {
-	Error [usage $optlist $usage] USAGE
-    }
-    return [array get result]
-}
-
-# ::cmdline::GetOptionDefaults --
-#
-#	This internal procedure processes the option list (that was passed to
-#	the getopt or getKnownOpt procedure).  The defaultArray gets an index
-#	for each option in the option list, the value of which is the option's
-#	default value.
-#
-# Arguments:
-#	optlist		A list-of-lists where each element specifies an option
-#			in the form:
-#				flag default comment
-#			If flag ends in ".arg" then the value is taken from the
-#			command line. Otherwise it is a boolean and appears in
-#			the result if present on the command line. If flag ends
-#			in ".secret", it will not be displayed in the usage.
-#	defaultArrayVar	The name of the array in which to put argument defaults.
-#
-# Results
-#	Name value pairs suitable for using with array set.
-
-proc ::cmdline::GetOptionDefaults {optlist defaultArrayVar} {
-    upvar 1 $defaultArrayVar result
-
-    set opts {? help}
-    foreach opt $optlist {
-	set name [lindex $opt 0]
-	if {[regsub -- {\.secret$} $name {} name] == 1} {
-	    # Need to hide this from the usage display and getopt
-	}
-	lappend opts $name
-	if {[regsub -- {\.arg$} $name {} name] == 1} {
-
-	    # Set defaults for those that take values.
-
-	    set default [lindex $opt 1]
-	    set result($name) $default
-	} else {
-	    # The default for booleans is false
-	    set result($name) 0
-	}
-    }
-    return $opts
-}
-
-# ::cmdline::usage --
-#
-#	Generate an error message that lists the allowed flags.
-#
-# Arguments:
-#	optlist		As for cmdline::getoptions
-#	usage		Text to include in the usage display. Defaults to
-#			"options:"
-#
-# Results
-#	A formatted usage message
-
-proc ::cmdline::usage {optlist {usage {options:}}} {
-    set str "[getArgv0] $usage\n"
-    set longest 20
-    set lines {}
-    foreach opt [concat $optlist \
-	     {{- "Forcibly stop option processing"} {help "Print this message"} {? "Print this message"}}] {
-	set name "-[lindex $opt 0]"
-	if {[regsub -- {\.secret$} $name {} name] == 1} {
-	    # Hidden option
-	    continue
-	}
-	if {[regsub -- {\.arg$} $name {} name] == 1} {
-	    append name " value"
-	    set desc "[lindex $opt 2] <[lindex $opt 1]>"
-	} else {
-	    set desc "[lindex $opt 1]"
-	}
-	set n [string length $name]
-	if {$n > $longest} { set longest $n }
-	# max not available before 8.5 - set longest [expr {max($longest, )}]
-	lappend lines $name $desc
-    }
-    foreach {name desc} $lines {
-	append str "[string trimright [format " %-*s %s" $longest $name $desc]]\n"
-    }
-
-    return $str
-}
-
-# ::cmdline::getfiles --
-#
-#	Given a list of file arguments from the command line, compute
-#	the set of valid files.  On windows, file globbing is performed
-#	on each argument.  On Unix, only file existence is tested.  If
-#	a file argument produces no valid files, a warning is optionally
-#	generated.
-#
-#	This code also uses the full path for each file.  If not
-#	given it prepends [pwd] to the filename.  This ensures that
-#	these files will never conflict with files in our zip file.
-#
-# Arguments:
-#	patterns	The file patterns specified by the user.
-#	quiet		If this flag is set, no warnings will be generated.
-#
-# Results:
-#	Returns the list of files that match the input patterns.
-
-proc ::cmdline::getfiles {patterns quiet} {
-    set result {}
-    if {$::tcl_platform(platform) == "windows"} {
-	foreach pattern $patterns {
-	    set pat [file join $pattern]
-	    set files [glob -nocomplain -- $pat]
-	    if {$files == {}} {
-		if {! $quiet} {
-		    puts stdout "warning: no files match \"$pattern\""
-		}
-	    } else {
-		foreach file $files {
-		    lappend result $file
-		}
-	    }
-	}
-    } else {
-	set result $patterns
-    }
-    set files {}
-    foreach file $result {
-	# Make file an absolute path so that we will never conflict
-	# with files that might be contained in our zip file.
-	set fullPath [file join [pwd] $file]
-
-	if {[file isfile $fullPath]} {
-	    lappend files $fullPath
-	} elseif {! $quiet} {
-	    puts stdout "warning: no files match \"$file\""
-	}
-    }
-    return $files
-}
-
-# ::cmdline::getArgv0 --
-#
-#	This command returns the "sanitized" version of argv0.  It will strip
-#	off the leading path and remove the ".bin" extensions that our apps
-#	use because they must be wrapped by a shell script.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	The application name that can be used in error messages.
-
-proc ::cmdline::getArgv0 {} {
-    global argv0
-
-    set name [file tail $argv0]
-    return [file rootname $name]
-}
-
-##
-# ### ### ### ######### ######### #########
-##
-# Now the typed versions of the above commands.
-##
-# ### ### ### ######### ######### #########
-##
-
-# typedCmdline.tcl --
-#
-#    This package provides a utility for parsing typed command
-#    line arguments that may be processed by various applications.
-#
-# Copyright (c) 2000 by Ross Palmer Mohn.
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: cmdline.tcl,v 1.28 2011/02/23 17:41:52 andreas_kupries Exp $
-
-namespace eval ::cmdline {
-    namespace export typedGetopt typedGetoptions typedUsage
-
-    # variable cmdline::charclasses --
-    #
-    #    Create regexp list of allowable character classes
-    #    from "string is" error message.
-    #
-    # Results:
-    #    String of character class names separated by "|" characters.
-
-    variable charclasses
-    #checker exclude badKey
-    catch {string is . .} charclasses
-    variable dummy
-    regexp      -- {must be (.+)$} $charclasses dummy charclasses
-    regsub -all -- {, (or )?}      $charclasses {|}   charclasses
-    unset dummy
-}
-
-# ::cmdline::typedGetopt --
-#
-#	The cmdline::typedGetopt works in a fashion like the standard
-#	C based getopt function.  Given an option string and a
-#	pointer to a list of args this command will process the
-#	first argument and return info on how to proceed. In addition,
-#	you may specify a type for the argument to each option.
-#
-# Arguments:
-#	argvVar		Name of the argv list that you want to process.
-#			If options are found, the arg list is modified
-#			and the processed arguments are removed from the
-#			start of the list.
-#
-#	optstring	A list of command options that the application
-#			will accept.  If the option ends in ".xxx", where
-#			xxx is any valid character class to the tcl
-#			command "string is", then typedGetopt routine will
-#			use the next argument as a typed argument to the
-#			option. The argument must match the specified
-#			character classes (e.g. integer, double, boolean,
-#			xdigit, etc.). Alternatively, you may specify
-#			".arg" for an untyped argument.
-#
-#	optVar		Upon success, the variable pointed to by optVar
-#			contains the option that was found (without the
-#			leading '-' and without the .xxx extension).  If
-#			typedGetopt fails the variable is set to the empty
-#			string. SOMETIMES! Different for each -value!
-#
-#	argVar		Upon success, the variable pointed to by argVar
-#			contains the argument for the specified option.
-#			If typedGetopt fails, the variable is filled with
-#			an error message.
-#
-# Argument type syntax:
-#	Option that takes no argument.
-#		foo
-#
-#	Option that takes a typeless argument.
-#		foo.arg
-#
-#	Option that takes a typed argument. Allowable types are all
-#	valid character classes to the tcl command "string is".
-#	Currently must be one of alnum, alpha, ascii, control,
-#	boolean, digit, double, false, graph, integer, lower, print,
-#	punct, space, true, upper, wordchar, or xdigit.
-#		foo.double
-#
-#	Option that takes an argument from a list.
-#		foo.(bar|blat)
-#
-# Argument quantifier syntax:
-#	Option that takes an optional argument.
-#		foo.arg?
-#
-#	Option that takes a list of arguments terminated by "--".
-#		foo.arg+
-#
-#	Option that takes an optional list of arguments terminated by "--".
-#		foo.arg*
-#
-#	Argument quantifiers work on all argument types, so, for
-#	example, the following is a valid option specification.
-#		foo.(bar|blat|blah)?
-#
-# Argument syntax miscellany:
-#	Options may be specified on the command line using a unique,
-#	shortened version of the option name. Given that program foo
-#	has an option list of {bar.alpha blah.arg blat.double},
-#	"foo -b fob" returns an error, but "foo -ba fob"
-#	successfully returns {bar fob}
-#
-# Results:
-#	The typedGetopt function returns one of the following:
-#	 1	a valid option was found
-#	 0	no more options found to process
-#	-1	invalid option
-#	-2	missing argument to a valid option
-#	-3	argument to a valid option does not match type
-#
-# Known Bugs:
-#	When using options which include special glob characters,
-#	you must use the exact option. Abbreviating it can cause
-#	an error in the "cmdline::prefixSearch" procedure.
-
-proc ::cmdline::typedGetopt {argvVar optstring optVar argVar} {
-    variable charclasses
-
-    upvar $argvVar argsList
-
-    upvar $optVar retvar
-    upvar $argVar optarg
-
-    # default settings for a normal return
-    set optarg ""
-    set retvar ""
-    set retval 0
-
-    # check if we're past the end of the args list
-    if {[llength $argsList] != 0} {
-
-        # if we got -- or an option that doesn't begin with -, return (skipping
-        # the --).  otherwise process the option arg.
-        switch -glob -- [set arg [lindex $argsList 0]] {
-            "--" {
-                set argsList [lrange $argsList 1 end]
-            }
-
-            "-*" {
-                # Create list of options without their argument extensions
-
-                set optstr ""
-                foreach str $optstring {
-                    lappend optstr [file rootname $str]
-                }
-
-                set _opt [string range $arg 1 end]
-
-                set i [prefixSearch $optstr [file rootname $_opt]]
-                if {$i != -1} {
-                    set opt [lindex $optstring $i]
-
-                    set quantifier "none"
-                    if {[regexp -- {\.[^.]+([?+*])$} $opt dummy quantifier]} {
-                        set opt [string range $opt 0 end-1]
-                    }
-
-                    if {[string first . $opt] == -1} {
-                        set retval 1
-                        set retvar $opt
-                        set argsList [lrange $argsList 1 end]
-
-                    } elseif {[regexp -- "\\.(arg|$charclasses)\$" $opt dummy charclass]
-                            || [regexp -- {\.\(([^)]+)\)} $opt dummy charclass]} {
-				if {[string equal arg $charclass]} {
-                            set type arg
-			} elseif {[regexp -- "^($charclasses)\$" $charclass]} {
-                            set type class
-                        } else {
-                            set type oneof
-                        }
-
-                        set argsList [lrange $argsList 1 end]
-                        set opt [file rootname $opt]
-
-                        while {1} {
-                            if {[llength $argsList] == 0
-                                    || [string equal "--" [lindex $argsList 0]]} {
-                                if {[string equal "--" [lindex $argsList 0]]} {
-                                    set argsList [lrange $argsList 1 end]
-                                }
-
-                                set oneof ""
-                                if {$type == "arg"} {
-                                    set charclass an
-                                } elseif {$type == "oneof"} {
-                                    set oneof ", one of $charclass"
-                                    set charclass an
-                                }
-
-                                if {$quantifier == "?"} {
-                                    set retval 1
-                                    set retvar $opt
-                                    set optarg ""
-                                } elseif {$quantifier == "+"} {
-                                    set retvar $opt
-                                    if {[llength $optarg] < 1} {
-                                        set retval -2
-                                        set optarg "Option requires at least one $charclass argument$oneof -- $opt"
-                                    } else {
-                                        set retval 1
-                                    }
-                                } elseif {$quantifier == "*"} {
-                                    set retval 1
-                                    set retvar $opt
-                                } else {
-                                    set optarg "Option requires $charclass argument$oneof -- $opt"
-                                    set retvar $opt
-                                    set retval -2
-                                }
-                                set quantifier ""
-                            } elseif {($type == "arg")
-                                    || (($type == "oneof")
-                                    && [string first "|[lindex $argsList 0]|" "|$charclass|"] != -1)
-                                    || (($type == "class")
-                                    && [string is $charclass [lindex $argsList 0]])} {
-                                set retval 1
-                                set retvar $opt
-                                lappend optarg [lindex $argsList 0]
-                                set argsList [lrange $argsList 1 end]
-                            } else {
-                                set oneof ""
-                                if {$type == "arg"} {
-                                    set charclass an
-                                } elseif {$type == "oneof"} {
-                                    set oneof ", one of $charclass"
-                                    set charclass an
-                                }
-                                set optarg "Option requires $charclass argument$oneof -- $opt"
-                                set retvar $opt
-                                set retval -3
-
-                                if {$quantifier == "?"} {
-                                    set retval 1
-                                    set optarg ""
-                                }
-                                set quantifier ""
-                            }
-                             if {![regexp -- {[+*]} $quantifier]} {
-                                break;
-                            }
-                        }
-                    } else {
-                        Error \
-			    "Illegal option type specification: must be one of $charclasses" \
-			    BAD OPTION TYPE
-                    }
-                } else {
-                    set optarg "Illegal option -- $_opt"
-                    set retvar $_opt
-                    set retval -1
-                }
-            }
-	    default {
-		# Skip ahead
-	    }
-        }
-    }
-
-    return $retval
-}
-
-# ::cmdline::typedGetoptions --
-#
-#	Process a set of command line options, filling in defaults
-#	for those not specified. This also generates an error message
-#	that lists the allowed options if an incorrect option is
-#	specified.
-#
-# Arguments:
-#	argvVar		The name of the argument list, typically argv
-#	optlist		A list-of-lists where each element specifies an option
-#			in the form:
-#
-#				option default comment
-#
-#			Options formatting is as described for the optstring
-#			argument of typedGetopt. Default is for optionally
-#			specifying a default value. Comment is for optionally
-#			specifying a comment for the usage display. The
-#			options "--", "-help", and "-?" are automatically included
-#			in optlist.
-#
-# Argument syntax miscellany:
-#	Options formatting and syntax is as described in typedGetopt.
-#	There are two additional suffixes that may be applied when
-#	passing options to typedGetoptions.
-#
-#	You may add ".multi" as a suffix to any option. For options
-#	that take an argument, this means that the option may be used
-#	more than once on the command line and that each additional
-#	argument will be appended to a list, which is then returned
-#	to the application.
-#		foo.double.multi
-#
-#	If a non-argument option is specified as ".multi", it is
-#	toggled on and off for each time it is used on the command
-#	line.
-#		foo.multi
-#
-#	If an option specification does not contain the ".multi"
-#	suffix, it is not an error to use an option more than once.
-#	In this case, the behavior for options with arguments is that
-#	the last argument is the one that will be returned. For
-#	options that do not take arguments, using them more than once
-#	has no additional effect.
-#
-#	Options may also be hidden from the usage display by
-#	appending the suffix ".secret" to any option specification.
-#	Please note that the ".secret" suffix must be the last suffix,
-#	after any argument type specification and ".multi" suffix.
-#		foo.xdigit.multi.secret
-#
-# Results
-#	Name value pairs suitable for using with array set.
-
-proc ::cmdline::typedGetoptions {argvVar optlist {usage options:}} {
-    variable charclasses
-
-    upvar 1 $argvVar argv
-
-    set opts {? help}
-    foreach opt $optlist {
-        set name [lindex $opt 0]
-        if {[regsub -- {\.secret$} $name {} name] == 1} {
-            # Remove this extension before passing to typedGetopt.
-        }
-        if {[regsub -- {\.multi$} $name {} name] == 1} {
-            # Remove this extension before passing to typedGetopt.
-
-            regsub -- {\..*$} $name {} temp
-            set multi($temp) 1
-        }
-        lappend opts $name
-        if {[regsub -- "\\.(arg|$charclasses|\\(.+).?\$" $name {} name] == 1} {
-            # Set defaults for those that take values.
-            # Booleans are set just by being present, or not
-
-            set dflt [lindex $opt 1]
-            if {$dflt != {}} {
-                set defaults($name) $dflt
-            }
-        }
-    }
-    set argc [llength $argv]
-    while {[set err [typedGetopt argv $opts opt arg]]} {
-        if {$err == 1} {
-            if {[info exists result($opt)]
-                    && [info exists multi($opt)]} {
-                # Toggle boolean options or append new arguments
-
-                if {$arg == ""} {
-                    unset result($opt)
-                } else {
-                    set result($opt) "$result($opt) $arg"
-                }
-            } else {
-                set result($opt) "$arg"
-            }
-        } elseif {($err == -1) || ($err == -3)} {
-            Error [typedUsage $optlist $usage] USAGE
-        } elseif {$err == -2 && ![info exists defaults($opt)]} {
-            Error [typedUsage $optlist $usage] USAGE
-        }
-    }
-    if {[info exists result(?)] || [info exists result(help)]} {
-        Error [typedUsage $optlist $usage] USAGE
-    }
-    foreach {opt dflt} [array get defaults] {
-        if {![info exists result($opt)]} {
-            set result($opt) $dflt
-        }
-    }
-    return [array get result]
-}
-
-# ::cmdline::typedUsage --
-#
-#	Generate an error message that lists the allowed flags,
-#	type of argument taken (if any), default value (if any),
-#	and an optional description.
-#
-# Arguments:
-#	optlist		As for cmdline::typedGetoptions
-#
-# Results
-#	A formatted usage message
-
-proc ::cmdline::typedUsage {optlist {usage {options:}}} {
-    variable charclasses
-
-    set str "[getArgv0] $usage\n"
-    set longest 20
-    set lines {}
-    foreach opt [concat $optlist \
-            {{help "Print this message"} {? "Print this message"}}] {
-        set name "-[lindex $opt 0]"
-        if {[regsub -- {\.secret$} $name {} name] == 1} {
-            # Hidden option
-	    continue
-	}
-
-	if {[regsub -- {\.multi$} $name {} name] == 1} {
-	    # Display something about multiple options
-	}
-
-	if {[regexp -- "\\.(arg|$charclasses)\$" $name dummy charclass] ||
-	    [regexp -- {\.\(([^)]+)\)} $opt dummy charclass]
-	} {
-	    regsub -- "\\..+\$" $name {} name
-	    append name " $charclass"
-	    set desc [lindex $opt 2]
-	    set default [lindex $opt 1]
-	    if {$default != ""} {
-		append desc " <$default>"
-	    }
-	} else {
-	    set desc [lindex $opt 1]
-	}
-	lappend accum $name $desc
-	set n [string length $name]
-	if {$n > $longest} { set longest $n }
-	# max not available before 8.5 - set longest [expr {max($longest, [string length $name])}]
-    }
-    foreach {name desc} $accum {
-	append str "[string trimright [format " %-*s %s" $longest $name $desc]]\n"
-    }
-    return $str
-}
-
-# ::cmdline::prefixSearch --
-#
-#	Search a Tcl list for a pattern; searches first for an exact match,
-#	and if that fails, for a unique prefix that matches the pattern
-#	(i.e, first "lsearch -exact", then "lsearch -glob $pattern*"
-#
-# Arguments:
-#	list		list of words
-#	pattern		word to search for
-#
-# Results:
-#	Index of found word is returned. If no exact match or
-#	unique short version is found then -1 is returned.
-
-proc ::cmdline::prefixSearch {list pattern} {
-    # Check for an exact match
-
-    if {[set pos [::lsearch -exact $list $pattern]] > -1} {
-        return $pos
-    }
-
-    # Check for a unique short version
-
-    set slist [lsort $list]
-    if {[set pos [::lsearch -glob $slist $pattern*]] > -1} {
-        # What if there is nothing for the check variable?
-
-        set check [lindex $slist [expr {$pos + 1}]]
-        if {[string first $pattern $check] != 0} {
-            return [::lsearch -exact $list [lindex $slist $pos]]
-        }
-    }
-    return -1
-}
-# ::cmdline::Error --
-#
-#	Internal helper to throw errors with a proper error-code attached.
-#
-# Arguments:
-#	message		text of the error message to throw.
-#	args		additional parts of the error code to use,
-#                       with CMDLINE as basic prefix added by this command.
-#
-# Results:
-#	An error is thrown, always.
-
-proc ::cmdline::Error {message args} {
-    return -code error -errorcode [linsert $args 0 CMDLINE] $message
-}
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/fileutil-1.16.1.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/fileutil-1.16.1.tm
deleted file mode 100644
index 6d5c737e..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/fileutil-1.16.1.tm
+++ /dev/null
@@ -1,2311 +0,0 @@
-# fileutil.tcl --
-#
-#	Tcl implementations of standard UNIX utilities.
-#
-# Copyright (c) 1998-2000 by Ajuba Solutions.
-# Copyright (c) 2002      by Phil Ehrens <phil@slug.org> (fileType)
-# Copyright (c) 2005-2013 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-
-package require Tcl 8.5-
-package require cmdline
-package provide fileutil 1.16.1
-
-namespace eval ::fileutil {
-    namespace export \
-	    grep find findByPattern cat touch foreachLine \
-	    jail stripPwd stripN stripPath tempdir tempfile \
-	    install fileType writeFile appendToFile \
-	    insertIntoFile removeFromFile replaceInFile \
-	    updateInPlace test tempdirReset maketempdir
-}
-
-# ::fileutil::grep --
-#
-#	Implementation of grep.  Adapted from the Tcler's Wiki.
-#
-# Arguments:
-#	pattern		pattern to search for.
-#	files		list of files to search; if NULL, uses stdin.
-#
-# Results:
-#	results		list of matches
-
-proc ::fileutil::grep {pattern {files {}}} {
-    set result [list]
-    if {[llength $files] == 0} {
-	# read from stdin
-	set lnum 0
-	while {[gets stdin line] >= 0} {
-	    incr lnum
-	    if {[regexp -- $pattern $line]} {
-		lappend result "${lnum}:${line}"
-	    }
-	}
-    } else {
-	foreach filename $files {
-	    set file [open $filename r]
-	    set lnum 0
-	    while {[gets $file line] >= 0} {
-		incr lnum
-		if {[regexp -- $pattern $line]} {
-		    lappend result "${filename}:${lnum}:${line}"
-		}
-	    }
-	    close $file
-	}
-    }
-    return $result
-}
-
-# ::fileutil::find ==
-
-# Below is the core command, which is portable across Tcl versions and
-# platforms. Functionality which is common or platform and/or Tcl
-# version dependent, has been factored out/ encapsulated into separate
-# (small) commands. Only these commands may have multiple variant
-# implementations per the available features of the Tcl core /
-# platform.
-#
-# These commands are
-#
-# FADD   - Add path result, performs filtering. Portable!
-# GLOBF  - Return files in a directory.         Tcl version/platform dependent.
-# GLOBD  - Return dirs  in a directory.         Tcl version/platform dependent.
-# ACCESS - Check directory for accessibility.   Tcl version/platform dependent.
-
-proc ::fileutil::find {{basedir .} {filtercmd {}}} {
-    set result {}
-    set filt   [string length $filtercmd]
-
-    if {[file isfile $basedir]} {
-	# The base is a file, and therefore only possible result,
-	# modulo filtering.
-
-	FADD $basedir
-
-    } elseif {[file isdirectory $basedir]} {
-	# For a directory as base we do an iterative recursion through
-	# the directory hierarchy starting at the base. We use a queue
-	# (Tcl list) of directories we have to check. We access it by
-	# index, and stop when we have reached beyond the end of the
-	# list. This is faster than removing elements from the be-
-	# ginning of the list, as that entails copying down a possibly
-	# large list of directories, making it O(n*n). The index is
-	# faster, O(n), at the expense of memory. Nothing is deleted
-	# from the list until we have processed all directories in the
-	# hierarchy.
-	#
-	# We scan each directory at least twice. First for files, then
-	# for directories. The scans may internally make several
-	# passes (normal vs hidden files).
-	#
-	# Looped directory structures due to symbolic links are
-	# handled by _fully_ normalizing directory paths and checking
-	# if we encountered the normalized form before. The array
-	# 'known' is our cache where we record the known normalized
-	# paths.
-
-	set pending [list $basedir]
-	set at      0
-	array set   parent {}
-	array set   norm   {}
-	Enter {} $basedir
-
-	while {$at < [llength $pending]} {
-	    # Get next directory not yet processed.
-	    set current [lindex $pending $at]
-	    incr at
-
-	    # Is the directory accessible? Continue if not.
-	    ACCESS $current
-
-	    # Files first, then the sub-directories ...
-
-	    foreach f [GLOBF $current] { FADD $f }
-
-	    foreach f [GLOBD $current] {
-		# Ignore current and parent directory, this needs
-		# explicit filtering outside of the filter command.
-		if {
-		    [string equal [file tail $f]  "."] ||
-		    [string equal [file tail $f] ".."]
-		} continue
-
-		# Extend result, modulo filtering.
-		FADD $f
-
-		# Detection of symlink loops via a portable path
-		# normalization computing a canonical form of the path
-		# followed by a check if that canonical form was
-		# encountered before. If ok, record directory for
-		# expansion in future iterations.
-
-		Enter $current $f
-		if {[Cycle $f]} continue
-
-		lappend pending $f
-	    }
-	}
-    } else {
-	return -code error "$basedir does not exist"
-    }
-
-    return $result
-}
-
-proc  ::fileutil::Enter {parent path} {
-    upvar 1 parent _parent norm _norm
-    set _parent($path) $parent
-    set _norm($path)   [fullnormalize $path]
-    return
-}
-
-proc  ::fileutil::Cycle {path} {
-    upvar 1 parent _parent norm _norm
-    set nform $_norm($path)
-    set paren $_parent($path)
-    while {$paren ne {}} {
-	if {$_norm($paren) eq $nform} { return yes }
-	set paren $_parent($paren)
-    }
-    return no
-}
-
-# Helper command for fileutil::find. Performs the filtering of the
-# result per a filter command for the candidates found by the
-# traversal core, see above. This is portable.
-
-proc ::fileutil::FADD {filename} {
-    upvar 1 result result filt filt filtercmd filtercmd
-    if {!$filt} {
-	lappend result $filename
-	return
-    }
-
-    set here [pwd]
-    cd [file dirname $filename]
-
-    if {[uplevel 2 [linsert $filtercmd end [file tail $filename]]]} {
-	lappend result $filename
-    }
-
-    cd $here
-    return
-}
-
-# The next three helper commands for fileutil::find depend strongly on
-# the version of Tcl, and partially on the platform.
-
-# 1. The -directory and -types switches were added to glob in Tcl
-#    8.3. This means that we have to emulate them for Tcl 8.2.
-#
-# 2. In Tcl 8.3 using -types f will return only true files, but not
-#    links to files. This changed in 8.4+ where links to files are
-#    returned as well. So for 8.3 we have to handle the links
-#    separately (-types l) and also filter on our own.
-#    Note that Windows file links are hard links which are reported by
-#    -types f, but not -types l, so we can optimize that for the two
-#    platforms.
-#
-#    Note further that we have to handle broken links on our own. They
-#    are not returned by glob yet we want them in the output.
-#
-# 3. In Tcl 8.3 we also have a crashing bug in glob (SIGABRT, "stat on
-#    a known file") when trying to perform 'glob -types {hidden f}' on
-#    a directory without e'x'ecute permissions. We code around by
-#    testing if we can cd into the directory (stat might return enough
-#    information too (mode), but possibly also not portable).
-#
-#    For Tcl 8.2 and 8.4+ glob simply delivers an empty result
-#    (-nocomplain), without crashing. For them this command is defined
-#    so that the bytecode compiler removes it from the bytecode.
-#
-#    This bug made the ACCESS helper necessary.
-#    We code around the problem by testing if we can cd into the
-#    directory (stat might return enough information too (mode), but
-#    possibly also not portable).
-
-if {[package vsatisfies [package present Tcl] 8.5]} {
-    # Tcl 8.5+.
-    # We have to check readability of "current" on our own, glob
-    # changed to error out instead of returning nothing.
-
-    proc ::fileutil::ACCESS {args} {}
-
-    proc ::fileutil::GLOBF {current} {
-	if {![file readable $current] ||
-	    [BadLink $current]} {
-	    return {}
-	}
-
-	set res [lsort -unique [concat \
-		     [glob -nocomplain -directory $current -types f          -- *] \
-		     [glob -nocomplain -directory $current -types {hidden f} -- *]]]
-
-	# Look for broken links (They are reported as neither file nor directory).
-	foreach l [lsort -unique [concat \
-		       [glob -nocomplain -directory $current -types l          -- *] \
-		       [glob -nocomplain -directory $current -types {hidden l} -- *]]] {
-	    if {[file isfile      $l]} continue
-	    if {[file isdirectory $l]} continue
-	    lappend res $l
-	}
-	return [lsort -unique $res]
-    }
-
-    proc ::fileutil::GLOBD {current} {
-	if {![file readable $current] ||
-	    [BadLink $current]} {
-	    return {}
-	}
-
-	lsort -unique [concat \
-	   [glob -nocomplain -directory $current -types d          -- *] \
-	   [glob -nocomplain -directory $current -types {hidden d} -- *]]
-    }
-
-    proc ::fileutil::BadLink {current} {
-	if {[file type $current] ne "link"} { return no }
-
-	set dst [file join [file dirname $current] [file readlink $current]]
-
-	if {![file exists   $dst] ||
-	    ![file readable $dst]} {
-	    return yes
-	}
-
-	return no
-    }
-} elseif {[package vsatisfies [package present Tcl] 8.4]} {
-    # Tcl 8.4+.
-    # (Ad 1) We have -directory, and -types,
-    # (Ad 2) Links are returned for -types f/d if they refer to files/dirs.
-    # (Ad 3) No bug to code around
-
-    proc ::fileutil::ACCESS {args} {}
-
-    proc ::fileutil::GLOBF {current} {
-	set res [lsort -unique [concat \
-		    [glob -nocomplain -directory $current -types f          -- *] \
-		    [glob -nocomplain -directory $current -types {hidden f} -- *]]]
-
-	# Look for broken links (They are reported as neither file nor directory).
-	foreach l [lsort -unique [concat \
-		       [glob -nocomplain -directory $current -types l          -- *] \
-		       [glob -nocomplain -directory $current -types {hidden l} -- *]]] {
-	    if {[file isfile      $l]} continue
-	    if {[file isdirectory $l]} continue
-	    lappend res $l
-	}
-	return [lsort -unique $res]
-    }
-
-    proc ::fileutil::GLOBD {current} {
-	lsort -unique [concat \
-	    [glob -nocomplain -directory $current -types d          -- *] \
-	    [glob -nocomplain -directory $current -types {hidden d} -- *]]
-    }
-
-} elseif {[package vsatisfies [package present Tcl] 8.3]} {
-    # 8.3.
-    # (Ad 1) We have -directory, and -types,
-    # (Ad 2) Links are NOT returned for -types f/d, collect separately.
-    #        No symbolic file links on Windows.
-    # (Ad 3) Bug to code around.
-
-    proc ::fileutil::ACCESS {current} {
-	if {[catch {
-	    set h [pwd] ; cd $current ; cd $h
-	}]} {return -code continue}
-	return
-    }
-
-    if {[string equal $::tcl_platform(platform) windows]} {
-	proc ::fileutil::GLOBF {current} {
-	    concat \
-		[glob -nocomplain -directory $current -types f          -- *] \
-		[glob -nocomplain -directory $current -types {hidden f} -- *]]
-	}
-    } else {
-	proc ::fileutil::GLOBF {current} {
-	    set l [concat \
-		       [glob -nocomplain -directory $current -types f          -- *] \
-		       [glob -nocomplain -directory $current -types {hidden f} -- *]]
-
-	    foreach x [concat \
-			   [glob -nocomplain -directory $current -types l          -- *] \
-			   [glob -nocomplain -directory $current -types {hidden l} -- *]] {
-		if {[file isdirectory $x]} continue
-		# We have now accepted files, links to files, and broken links.
-		lappend l $x
-	    }
-
-	    return $l
-	}
-    }
-
-    proc ::fileutil::GLOBD {current} {
-	set l [concat \
-		   [glob -nocomplain -directory $current -types d          -- *] \
-		   [glob -nocomplain -directory $current -types {hidden d} -- *]]
-
-	foreach x [concat \
-		       [glob -nocomplain -directory $current -types l          -- *] \
-		       [glob -nocomplain -directory $current -types {hidden l} -- *]] {
-	    if {![file isdirectory $x]} continue
-	    lappend l $x
-	}
-
-	return $l
-    }
-} else {
-    # 8.2.
-    # (Ad 1,2,3) We do not have -directory, nor -types. Full emulation required.
-
-    proc ::fileutil::ACCESS {args} {}
-
-    if {[string equal $::tcl_platform(platform) windows]} {
-	# Hidden files cannot be handled by Tcl 8.2 in glob. We have
-	# to punt.
-
-	proc ::fileutil::GLOBF {current} {
-	    set current \\[join [split $current {}] \\]
-	    set res {}
-	    foreach x [glob -nocomplain -- [file join $current *]] {
-		if {[file isdirectory $x]} continue
-		if {[catch {file type $x}]} continue
-		# We have now accepted files, links to files, and
-		# broken links. We may also have accepted a directory
-		# as well, if the current path was inaccessible. This
-		# however will cause 'file type' to throw an error,
-		# hence the second check.
-		lappend res $x
-	    }
-	    return $res
-	}
-
-	proc ::fileutil::GLOBD {current} {
-	    set current \\[join [split $current {}] \\]
-	    set res {}
-	    foreach x [glob -nocomplain -- [file join $current *]] {
-		if {![file isdirectory $x]} continue
-		lappend res $x
-	    }
-	    return $res
-	}
-    } else {
-	# Hidden files on Unix are dot-files. We emulate the switch
-	# '-types hidden' by using an explicit pattern.
-
-	proc ::fileutil::GLOBF {current} {
-	    set current \\[join [split $current {}] \\]
-	    set res {}
-	    foreach x [glob -nocomplain -- [file join $current *] [file join $current .*]] {
-		if {[file isdirectory $x]} continue
-		if {[catch {file type $x}]} continue
-		# We have now accepted files, links to files, and
-		# broken links. We may also have accepted a directory
-		# as well, if the current path was inaccessible. This
-		# however will cause 'file type' to throw an error,
-		# hence the second check.
-
-		lappend res $x
-	    }
-	    return $res
-	}
-
-	proc ::fileutil::GLOBD {current} {
-	    set current \\[join [split $current {}] \\]
-	    set res {}
-	    foreach x [glob -nocomplain -- $current/* [file join $current .*]] {
-		if {![file isdirectory $x]} continue
-		lappend res $x
-	    }
-	    return $res
-	}
-    }
-}
-
-# ::fileutil::findByPattern --
-#
-#	Specialization of find. Finds files based on their names,
-#	which have to match the specified patterns. Options are used
-#	to specify which type of patterns (regexp-, glob-style) is
-#	used.
-#
-# Arguments:
-#	basedir		Directory to start searching from.
-#	args		Options (-glob, -regexp, --) followed by a
-#			list of patterns to search for.
-#
-# Results:
-#	files		a list of interesting files.
-
-proc ::fileutil::findByPattern {basedir args} {
-    set pos 0
-    set cmd ::fileutil::FindGlob
-    foreach a $args {
-	incr pos
-	switch -glob -- $a {
-	    --      {break}
-	    -regexp {set cmd ::fileutil::FindRegexp}
-	    -glob   {set cmd ::fileutil::FindGlob}
-	    -*      {return -code error "Unknown option $a"}
-	    default {incr pos -1 ; break}
-	}
-    }
-
-    set args [lrange $args $pos end]
-
-    if {[llength $args] != 1} {
-	set pname [lindex [info level 0] 0]
-	return -code error \
-		"wrong#args for \"$pname\", should be\
-		\"$pname basedir ?-regexp|-glob? ?--? patterns\""
-    }
-
-    set patterns [lindex $args 0]
-    return [find $basedir [list $cmd $patterns]]
-}
-
-
-# ::fileutil::FindRegexp --
-#
-#	Internal helper. Filter command used by 'findByPattern'
-#	to match files based on regular expressions.
-#
-# Arguments:
-#	patterns	List of regular expressions to match against.
-#	filename	Name of the file to match against the patterns.
-# Results:
-#	interesting	A boolean flag. Set to true if the file
-#			matches at least one of the patterns.
-
-proc ::fileutil::FindRegexp {patterns filename} {
-    foreach p $patterns {
-	if {[regexp -- $p $filename]} {
-	    return 1
-	}
-    }
-    return 0
-}
-
-# ::fileutil::FindGlob --
-#
-#	Internal helper. Filter command used by 'findByPattern'
-#	to match files based on glob expressions.
-#
-# Arguments:
-#	patterns	List of glob expressions to match against.
-#	filename	Name of the file to match against the patterns.
-# Results:
-#	interesting	A boolean flag. Set to true if the file
-#			matches at least one of the patterns.
-
-proc ::fileutil::FindGlob {patterns filename} {
-    foreach p $patterns {
-	if {[string match $p $filename]} {
-	    return 1
-	}
-    }
-    return 0
-}
-
-# ::fileutil::stripPwd --
-#
-#	If the specified path references is a path in [pwd] (or [pwd] itself) it
-#	is made relative to [pwd]. Otherwise it is left unchanged.
-#	In the case of [pwd] itself the result is the string '.'.
-#
-# Arguments:
-#	path		path to modify
-#
-# Results:
-#	path		The (possibly) modified path.
-
-proc ::fileutil::stripPwd {path} {
-
-    # [file split] is used to generate a canonical form for both
-    # paths, for easy comparison, and also one which is easy to modify
-    # using list commands.
-
-    set pwd [pwd]
-    if {[string equal $pwd $path]} {
-	return "."
-    }
-
-    set pwd   [file split $pwd]
-    set npath [file split $path]
-
-    if {[string match ${pwd}* $npath]} {
-	set path [eval [linsert [lrange $npath [llength $pwd] end] 0 file join ]]
-    }
-    return $path
-}
-
-# ::fileutil::stripN --
-#
-#	Removes N elements from the beginning of the path.
-#
-# Arguments:
-#	path		path to modify
-#	n		number of elements to strip
-#
-# Results:
-#	path		The modified path
-
-proc ::fileutil::stripN {path n} {
-    set path [file split $path]
-    if {$n >= [llength $path]} {
-	return {}
-    } else {
-	return [eval [linsert [lrange $path $n end] 0 file join]]
-    }
-}
-
-# ::fileutil::stripPath --
-#
-#	If the specified path references/is a path in prefix (or prefix itself) it
-#	is made relative to prefix. Otherwise it is left unchanged.
-#	In the case of it being prefix itself the result is the string '.'.
-#
-# Arguments:
-#	prefix		prefix to strip from the path.
-#	path		path to modify
-#
-# Results:
-#	path		The (possibly) modified path.
-
-if {[string equal $tcl_platform(platform) windows]} {
-
-    # Windows. While paths are stored with letter-case preserved al
-    # comparisons have to be done case-insensitive. For reference see
-    # SF Tcllib Bug 2499641.
-
-    proc ::fileutil::stripPath {prefix path} {
-	# [file split] is used to generate a canonical form for both
-	# paths, for easy comparison, and also one which is easy to modify
-	# using list commands.
-
-	set prefix [file split $prefix]
-	set npath  [file split $path]
-
-	if {[string equal -nocase $prefix $npath]} {
-	    return "."
-	}
-
-	if {[string match -nocase "${prefix} *" $npath]} {
-	    set path [eval [linsert [lrange $npath [llength $prefix] end] 0 file join ]]
-	}
-	return $path
-    }
-} else {
-    proc ::fileutil::stripPath {prefix path} {
-	# [file split] is used to generate a canonical form for both
-	# paths, for easy comparison, and also one which is easy to modify
-	# using list commands.
-
-	set prefix [file split $prefix]
-	set npath  [file split $path]
-
-	if {[string equal $prefix $npath]} {
-	    return "."
-	}
-
-	if {[string match "${prefix} *" $npath]} {
-	    set path [eval [linsert [lrange $npath [llength $prefix] end] 0 file join ]]
-	}
-	return $path
-    }
-}
-
-# ::fileutil::jail --
-#
-#	Ensures that the input path 'filename' stays within the
-#	directory 'jail'. In this way it prevents user-supplied paths
-#	from escaping the jail.
-#
-# Arguments:
-#	jail		The path to the directory the other must
-#			not escape from.
-#	filename	The path to prevent from escaping.
-#
-# Results:
-#	path		The (possibly) modified path surely within
-#			the confines of the jail.
-
-proc fileutil::jail {jail filename} {
-    if {![string equal [file pathtype $filename]  "relative"]} {
-	# Although the path to check is absolute (or volumerelative on
-	# windows) we cannot perform a simple prefix check to see if
-	# the path is inside the jail or not. We have to normalize
-	# both path and jail and then we can check. If the path is
-	# outside we make the original path relative and prefix it
-	# with the original jail. We do make the jail pseudo-absolute
-	# by prefixing it with the current working directory for that.
-
-	# Normalized jail. Fully resolved sym links, if any. Our main
-	# complication is that normalize does not resolve symlinks in the
-	# last component of the path given to it, so we add a bogus
-	# component, resolve, and then strip it off again. That is why the
-	# code is so large and long.
-
-	set njail [eval [list file join] [lrange [file split \
-		[Normalize [file join $jail __dummy__]]] 0 end-1]]
-
-	# Normalize filename. Fully resolved sym links, if
-	# any. S.a. for an explanation of the complication.
-
-	set nfile [eval [list file join] [lrange [file split \
-		[Normalize [file join $filename __dummy__]]] 0 end-1]]
-
-	if {[string match ${njail}* $nfile]} {
-	    return $filename
-	}
-
-	# Outside the jail, put it inside. ... We normalize the input
-	# path lexically for this, to prevent escapes still lurking in
-	# the original path. (We cannot use the normalized path,
-	# symlinks may have bent it out of shape in unrecognizable ways.
-
-	return [eval [linsert [lrange [file split \
-		[lexnormalize $filename]] 1 end] 0 file join [pwd] $jail]]
-    } else {
-	# The path is relative, consider it as outside
-	# implicitly. Normalize it lexically! to prevent escapes, then
-	# put the jail in front, use PWD to ensure absoluteness.
-
-	return [eval [linsert [file split [lexnormalize $filename]] 0 \
-		file join [pwd] $jail]]
-    }
-}
-
-
-# ::fileutil::test --
-#
-#	Simple API to testing various properties of
-#	a path (read, write, file/dir, existence)
-#
-# Arguments:
-#	path	path to test
-#	codes	names of the properties to test
-#	msgvar	Name of variable to leave an error
-#		message in. Optional.
-#	label	Label for error message, optional
-#
-# Results:
-#	ok	boolean flag, set if the path passes
-#		all tests.
-
-namespace eval ::fileutil {
-    variable  test
-    array set test {
-	read   {readable    {Read access is denied}}
-	write  {writable    {Write access is denied}}
-	exec   {executable  {Is not executable}}
-	exists {exists      {Does not exist}}
-	file   {isfile      {Is not a file}}
-	dir    {isdirectory {Is not a directory}}
-    }
-}
-
-proc ::fileutil::test {path codes {msgvar {}} {label {}}} {
-    variable test
-
-    if {[string equal $msgvar ""]} {
-	set msg ""
-    } else {
-	upvar 1 $msgvar msg
-    }
-
-    if {![string equal $label ""]} {append label { }}
-
-    if {![regexp {^(read|write|exec|exists|file|dir)} $codes]} {
-	# Translate single characters into proper codes
-	set codes [string map {
-	    r read w write e exists x exec f file d dir
-	} [split $codes {}]]
-    }
-
-    foreach c $codes {
-	foreach {cmd text} $test($c) break
-	if {![file $cmd $path]} {
-	    set msg "$label\"$path\": $text"
-	    return 0
-	}
-    }
-
-    return 1
-}
-
-# ::fileutil::cat --
-#
-#	Tcl implementation of the UNIX "cat" command.  Returns the contents
-#	of the specified files.
-#
-# Arguments:
-#	args	names of the files to read, interspersed with options
-#		to set encodings, translations, or eofchar.
-#
-# Results:
-#	data	data read from the file.
-
-proc ::fileutil::cat {args} {
-    # Syntax: (?options? file)+
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    if {![llength $args]} {
-	# Argument processing stopped with arguments missing.
-	return -code error \
-		"wrong#args: should be\
-		[lindex [info level 0] 0] ?-eofchar|-translation|-encoding arg?+ file ..."
-    }
-
-    # We go through the arguments using foreach and keeping track of
-    # the index we are at. We do not shift the arguments out to the
-    # left. That is inherently quadratic, copying everything down.
-
-    set opts {}
-    set mode maybeopt
-    set channels {}
-
-    foreach a $args {
-	if {[string equal $mode optarg]} {
-	    lappend opts $a
-	    set mode maybeopt
-	    continue
-	} elseif {[string equal $mode maybeopt]} {
-	    if {[string match -* $a]} {
-		switch -exact -- $a {
-		    -encoding -
-		    -translation -
-		    -eofchar {
-			lappend opts $a
-			set mode optarg
-			continue
-		    }
-		    -- {
-			set mode file
-			continue
-		    }
-		    default {
-			return -code error \
-				"Bad option \"$a\",\
-				expected one of\
-				-encoding, -eofchar,\
-				or -translation"
-		    }
-		}
-	    }
-	    # Not an option, but a file. Change mode and fall through.
-	    set mode file
-	}
-	# Process file arguments
-
-	if {[string equal $a -]} {
-	    # Stdin reference is special.
-
-	    # Test that the current options are all ok.
-	    # For stdin we have to avoid closing it.
-
-	    set old [fconfigure stdin]
-	    set fail [catch {
-		SetOptions stdin $opts
-	    } msg] ; # {}
-	    SetOptions stdin $old
-
-	    if {$fail} {
-		return -code error $msg
-	    }
-
-	    lappend channels [list $a $opts 0]
-	} else {
-	    if {![file exists $a]} {
-		return -code error "Cannot read file \"$a\", does not exist"
-	    } elseif {![file isfile $a]} {
-		return -code error "Cannot read file \"$a\", is not a file"
-	    } elseif {![file readable $a]} {
-		return -code error "Cannot read file \"$a\", read access is denied"
-	    }
-
-	    # Test that the current options are all ok.
-	    set c [open $a r]
-	    set fail [catch {
-		SetOptions $c $opts
-	    } msg] ; # {}
-	    close $c
-	    if {$fail} {
-		return -code error $msg
-	    }
-
-	    lappend channels [list $a $opts [file size $a]]
-	}
-
-	# We may have more options and files coming after.
-	set mode maybeopt
-    }
-
-    if {![string equal $mode maybeopt]} {
-	# Argument processing stopped with arguments missing.
-	return -code error \
-		"wrong#args: should be\
-		[lindex [info level 0] 0] ?-eofchar|-translation|-encoding arg?+ file ..."
-    }
-
-    set data ""
-    foreach c $channels {
-	foreach {fname opts size} $c break
-
-	if {[string equal $fname -]} {
-	    set old [fconfigure stdin]
-	    SetOptions stdin $opts
-	    append data [read stdin]
-	    SetOptions stdin $old
-	    continue
-	}
-
-	set c [open $fname r]
-	SetOptions $c $opts
-
-	if {$size > 0} {
-	    # Used the [file size] command to get the size, which
-	    # preallocates memory, rather than trying to grow it as
-	    # the read progresses.
-	    append data [read $c $size]
-	} else {
-	    # if the file has zero bytes it is either empty, or
-	    # something where [file size] reports 0 but the file
-	    # actually has data (like the files in the /proc
-	    # filesystem on Linux).
-	    append data [read $c]
-	}
-	close $c
-    }
-
-    return $data
-}
-
-# ::fileutil::writeFile --
-#
-#	Write the specified data into the named file,
-#	creating it if necessary.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to write.
-#	data		The data to write into the file
-#
-# Results:
-#	None.
-
-proc ::fileutil::writeFile {args} {
-    # Syntax: ?options? file data
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec Writable $args opts fname data
-
-    # Now perform the requested operation.
-
-    file mkdir [file dirname $fname]
-    set              c [open $fname w]
-    SetOptions      $c $opts
-    puts -nonewline $c $data
-    close           $c
-    return
-}
-
-# ::fileutil::appendToFile --
-#
-#	Append the specified data at the end of the named file,
-#	creating it if necessary.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	data		The data to extend the file with.
-#
-# Results:
-#	None.
-
-proc ::fileutil::appendToFile {args} {
-    # Syntax: ?options? file data
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec Writable $args opts fname data
-
-    # Now perform the requested operation.
-
-    file mkdir [file dirname $fname]
-    set              c [open $fname a]
-    SetOptions      $c $opts
-    set at    [tell $c]
-    puts -nonewline $c $data
-    close           $c
-    return $at
-}
-
-# ::fileutil::insertIntoFile --
-#
-#	Insert the specified data into the named file,
-#	creating it if necessary, at the given locaton.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	data		The data to extend the file with.
-#
-# Results:
-#	None.
-
-proc ::fileutil::insertIntoFile {args} {
-
-    # Syntax: ?options? file at data
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec ReadWritable $args opts fname at data
-
-    set max [file size $fname]
-    CheckLocation $at $max insertion
-
-    if {[string length $data] == 0} {
-	# Another degenerate case, inserting nothing.
-	# Leave the file well enough alone.
-	return
-    }
-
-    foreach {c o t} [Open2 $fname $opts] break
-
-    # The degenerate cases of both appending and insertion at the
-    # beginning of the file allow more optimized implementations of
-    # the operation.
-
-    if {$at == 0} {
-	puts -nonewline    $o $data
-	fcopy           $c $o
-    } elseif {$at == $max} {
-	fcopy           $c $o
-	puts -nonewline    $o $data
-    } else {
-	fcopy           $c $o -size $at
-	puts -nonewline    $o $data
-	fcopy           $c $o
-    }
-
-    Close2 $fname $t $c $o
-    return
-}
-
-# ::fileutil::removeFromFile --
-#
-#	Remove n characters from the named file,
-#	starting at the given locaton.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	at		Location to start the removal from.
-#	n		Number of characters to remove.
-#
-# Results:
-#	None.
-
-proc ::fileutil::removeFromFile {args} {
-
-    # Syntax: ?options? file at n
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec ReadWritable $args opts fname at n
-
-    set max [file size $fname]
-    CheckLocation    $at $max removal
-    CheckLength   $n $at $max removal
-
-    if {$n == 0} {
-	# Another degenerate case, removing nothing.
-	# Leave the file well enough alone.
-	return
-    }
-
-    foreach {c o t} [Open2 $fname $opts] break
-
-    # The degenerate cases of both removal from the beginning or end
-    # of the file allow more optimized implementations of the
-    # operation.
-
-    if {$at == 0} {
-	seek  $c    $n current
-	fcopy $c $o
-    } elseif {($at + $n) == $max} {
-	fcopy $c $o -size $at
-	# Nothing further to copy.
-    } else {
-	fcopy $c $o -size $at
-	seek  $c    $n current
-	fcopy $c $o
-    }
-
-    Close2 $fname $t $c $o
-    return
-}
-
-# ::fileutil::replaceInFile --
-#
-#	Remove n characters from the named file,
-#	starting at the given locaton, and replace
-#	it with the given data.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	at		Location to start the removal from.
-#	n		Number of characters to remove.
-#	data		The replacement data.
-#
-# Results:
-#	None.
-
-proc ::fileutil::replaceInFile {args} {
-
-    # Syntax: ?options? file at n data
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec ReadWritable $args opts fname at n data
-
-    set max [file size $fname]
-    CheckLocation    $at $max replacement
-    CheckLength   $n $at $max replacement
-
-    if {
-	($n == 0) &&
-	([string length $data] == 0)
-    } {
-	# Another degenerate case, replacing nothing with
-	# nothing. Leave the file well enough alone.
-	return
-    }
-
-    foreach {c o t} [Open2 $fname $opts] break
-
-    # Check for degenerate cases and handle them separately,
-    # i.e. strip the no-op parts out of the general implementation.
-
-    if {$at == 0} {
-	if {$n == 0} {
-	    # Insertion instead of replacement.
-
-	    puts -nonewline    $o $data
-	    fcopy           $c $o
-
-	} elseif {[string length $data] == 0} {
-	    # Removal instead of replacement.
-
-	    seek  $c    $n current
-	    fcopy $c $o
-
-	} else {
-	    # General replacement at front.
-
-	    seek         $c    $n current
-	    puts -nonewline $o $data
-	    fcopy        $c $o
-	}
-    } elseif {($at + $n) == $max} {
-	if {$n == 0} {
-	    # Appending instead of replacement
-
-	    fcopy           $c $o
-	    puts -nonewline    $o $data
-
-	} elseif {[string length $data] == 0} {
-	    # Truncating instead of replacement
-
-	    fcopy $c $o -size $at
-	    # Nothing further to copy.
-
-	} else {
-	    # General replacement at end
-
-	    fcopy        $c $o -size $at
-	    puts -nonewline $o $data
-	}
-    } else {
-	if {$n == 0} {
-	    # General insertion.
-
-	    fcopy           $c $o -size $at
-	    puts -nonewline    $o $data
-	    fcopy           $c $o
-
-	} elseif {[string length $data] == 0} {
-	    # General removal.
-
-	    fcopy $c $o -size $at
-	    seek  $c    $n current
-	    fcopy $c $o
-
-	} else {
-	    # General replacement.
-
-	    fcopy        $c $o -size $at
-	    seek         $c    $n current
-	    puts -nonewline $o $data
-	    fcopy        $c $o
-	}
-    }
-
-    Close2 $fname $t $c $o
-    return
-}
-
-# ::fileutil::updateInPlace --
-#
-#	Run command prefix on the contents of the
-#	file and replace them with the result of
-#	the command.
-#
-# Arguments:
-#	options...	Options and arguments.
-#	filename	Path to the file to extend.
-#	cmd		Command prefix to run.
-#
-# Results:
-#	None.
-
-proc ::fileutil::updateInPlace {args} {
-    # Syntax: ?options? file cmd
-    # options = -encoding    ENC
-    #         | -translation TRA
-    #         | -eofchar     ECH
-    #         | --
-
-    Spec ReadWritable $args opts fname cmd
-
-    # readFile/cat inlined ...
-
-    set             c [open $fname r]
-    SetOptions     $c $opts
-    set data [read $c]
-    close          $c
-
-    # Transformation. Abort and do not modify the target file if an
-    # error was raised during this step.
-
-    lappend cmd $data
-    set code [catch {uplevel 1 $cmd} res]
-    if {$code} {
-	return -code $code $res
-    }
-
-    # writeFile inlined, with careful preservation of old contents
-    # until we are sure that the write was ok.
-
-    if {[catch {
-	file rename -force $fname ${fname}.bak
-
-	set              o [open $fname w]
-	SetOptions      $o $opts
-	puts -nonewline $o $res
-	close           $o
-
-	file delete -force ${fname}.bak
-    } msg]} {
-	if {[file exists ${fname}.bak]} {
-	    catch {
-		file rename -force ${fname}.bak $fname
-	    }
-	    return -code error $msg
-	}
-    }
-    return
-}
-
-proc ::fileutil::Writable {fname mv} {
-    upvar 1 $mv msg
-    if {[file exists $fname]} {
-	if {![file isfile $fname]} {
-	    set msg "Cannot use file \"$fname\", is not a file"
-	    return 0
-	} elseif {![file writable $fname]} {
-	    set msg "Cannot use file \"$fname\", write access is denied"
-	    return 0
-	}
-    }
-    return 1
-}
-
-proc ::fileutil::ReadWritable {fname mv} {
-    upvar 1 $mv msg
-    if {![file exists $fname]} {
-	set msg "Cannot use file \"$fname\", does not exist"
-	return 0
-    } elseif {![file isfile $fname]} {
-	set msg "Cannot use file \"$fname\", is not a file"
-	return 0
-    } elseif {![file writable $fname]} {
-	set msg "Cannot use file \"$fname\", write access is denied"
-	return 0
-    } elseif {![file readable $fname]} {
-	set msg "Cannot use file \"$fname\", read access is denied"
-	return 0
-    }
-    return 1
-}
-
-proc ::fileutil::Spec {check alist ov fv args} {
-    upvar 1 $ov opts $fv fname
-
-    set  n [llength $args] ; # Num more args
-    incr n                 ; # Count path as well
-
-    set opts {}
-    set mode maybeopt
-
-    set at 0
-    foreach a $alist {
-	if {[string equal $mode optarg]} {
-	    lappend opts $a
-	    set mode maybeopt
-	    incr at
-	    continue
-	} elseif {[string equal $mode maybeopt]} {
-	    if {[string match -* $a]} {
-		switch -exact -- $a {
-		    -encoding -
-		    -translation -
-		    -eofchar {
-			lappend opts $a
-			set mode optarg
-			incr at
-			continue
-		    }
-		    -- {
-			# Stop processing.
-			incr at
-			break
-		    }
-		    default {
-			return -code error \
-				"Bad option \"$a\",\
-				expected one of\
-				-encoding, -eofchar,\
-				or -translation"
-		    }
-		}
-	    }
-	    # Not an option, but a file.
-	    # Stop processing.
-	    break
-	}
-    }
-
-    if {([llength $alist] - $at) != $n} {
-	# Argument processing stopped with arguments missing, or too
-	# many
-	return -code error \
-		"wrong#args: should be\
-		[lindex [info level 1] 0] ?-eofchar|-translation|-encoding arg? file $args"
-    }
-
-    set fname [lindex $alist $at]
-    incr at
-    foreach \
-	    var $args \
-	    val [lrange $alist $at end] {
-	upvar 1 $var A
-	set A $val
-    }
-
-    # Check given path ...
-
-    if {![eval [linsert $check end $a msg]]} {
-	return -code error $msg
-    }
-
-    return
-}
-
-proc ::fileutil::Open2 {fname opts} {
-    set c [open $fname r]
-    set t [tempfile]
-    set o [open $t     w]
-
-    SetOptions $c $opts
-    SetOptions $o $opts
-
-    return [list $c $o $t]
-}
-
-proc ::fileutil::Close2 {f temp in out} {
-    close $in
-    close $out
-
-    file copy   -force $f ${f}.bak
-    file rename -force $temp $f
-    file delete -force ${f}.bak
-    return
-}
-
-proc ::fileutil::SetOptions {c opts} {
-    if {![llength $opts]} return
-    eval [linsert $opts 0 fconfigure $c]
-    return
-}
-
-proc ::fileutil::CheckLocation {at max label} {
-    if {![string is integer -strict $at]} {
-	return -code error \
-		"Expected integer but got \"$at\""
-    } elseif {$at < 0} {
-	return -code error \
-		"Bad $label point $at, before start of data"
-    } elseif {$at > $max} {
-	return -code error \
-		"Bad $label point $at, behind end of data"
-    }
-}
-
-proc ::fileutil::CheckLength {n at max label} {
-    if {![string is integer -strict $n]} {
-	return -code error \
-		"Expected integer but got \"$n\""
-    } elseif {$n < 0} {
-	return -code error \
-		"Bad $label size $n"
-    } elseif {($at + $n) > $max} {
-	return -code error \
-		"Bad $label size $n, going behind end of data"
-    }
-}
-
-# ::fileutil::foreachLine --
-#
-#	Executes a script for every line in a file.
-#
-# Arguments:
-#	var		name of the variable to contain the lines
-#	filename	name of the file to read.
-#	cmd		The script to execute.
-#
-# Results:
-#	None.
-
-proc ::fileutil::foreachLine {var filename cmd} {
-    upvar 1 $var line
-    set fp [open $filename r]
-
-    # -future- Use try/eval from tcllib/control
-    catch {
-	set code 0
-	set result {}
-	set return 0
-	while {[gets $fp line] >= 0} {
-	    set code [catch {uplevel 1 $cmd} result options]
-	    if {$code == 2} {
-		set return 1
-		set code [dict get $options -code]
-		break
-	    } elseif {$code != 0 && $code != 4} {
-		break
-	    }
-	}
-    }
-    close $fp
-
-    if {$return || $code == 1 || $code > 4} {
-	return -options $options $result
-    }
-    return $result
-}
-
-# ::fileutil::touch --
-#
-#	Tcl implementation of the UNIX "touch" command.
-#
-#	touch [-a] [-m] [-c] [-r ref_file] [-t time] filename ...
-#
-# Arguments:
-#	-a		change the access time only, unless -m also specified
-#	-m		change the modification time only, unless -a also specified
-#	-c		silently prevent creating a file if it did not previously exist
-#	-r ref_file	use the ref_file's time instead of the current time
-#	-t time		use the specified time instead of the current time
-#			("time" is an integer clock value, like [clock seconds])
-#	filename ...	the files to modify
-#
-# Results
-#	None.
-#
-# Errors:
-#	Both of "-r" and "-t" cannot be specified.
-
-if {[package vsatisfies [package provide Tcl] 8.3]} {
-    namespace eval ::fileutil {
-	namespace export touch
-    }
-
-    proc ::fileutil::touch {args} {
-        # Don't bother catching errors, just let them propagate up
-
-        set options {
-            {a          "set the atime only"}
-            {m          "set the mtime only"}
-            {c          "do not create non-existant files"}
-            {r.arg  ""  "use time from ref_file"}
-            {t.arg  -1  "use specified time"}
-        }
-        set usage ": [lindex [info level 0] 0]\
-                      \[options] filename ...\noptions:"
-        array set params [::cmdline::getoptions args $options $usage]
-
-        # process -a and -m options
-        set set_atime [set set_mtime "true"]
-        if {  $params(a) && ! $params(m)} {set set_mtime "false"}
-        if {! $params(a) &&   $params(m)} {set set_atime "false"}
-
-        # process -r and -t
-        set has_t [expr {$params(t) != -1}]
-        set has_r [expr {[string length $params(r)] > 0}]
-        if {$has_t && $has_r} {
-            return -code error "Cannot specify both -r and -t"
-        } elseif {$has_t} {
-            set atime [set mtime $params(t)]
-        } elseif {$has_r} {
-            file stat $params(r) stat
-            set atime $stat(atime)
-            set mtime $stat(mtime)
-        } else {
-            set atime [set mtime [clock seconds]]
-        }
-
-        # do it
-        foreach filename $args {
-            if {! [file exists $filename]} {
-                if {$params(c)} {continue}
-                close [open $filename w]
-            }
-            if {$set_atime} {file atime $filename $atime}
-            if {$set_mtime} {file mtime $filename $mtime}
-        }
-        return
-    }
-}
-
-# ::fileutil::fileType --
-#
-#	Do some simple heuristics to determine file type.
-#
-#
-# Arguments:
-#	filename        Name of the file to test.
-#
-# Results
-#	type            Type of the file.  May be a list if multiple tests
-#                       are positive (eg, a file could be both a directory
-#                       and a link).  In general, the list proceeds from most
-#                       general (eg, binary) to most specific (eg, gif), so
-#                       the full type for a GIF file would be
-#                       "binary graphic gif"
-#
-#                       At present, the following types can be detected:
-#
-#                       directory
-#                       empty
-#                       binary
-#                       text
-#                       script <interpreter>
-#                       executable [elf, dos, ne, pe]
-#                       binary graphic [gif, jpeg, png, tiff, bitmap, icns]
-#                       ps, eps, pdf
-#                       html
-#                       xml <doctype>
-#                       message pgp
-#                       compressed [bzip, gzip, zip, tar]
-#                       audio [mpeg, wave]
-#                       gravity_wave_data_frame
-#                       link
-#			doctools, doctoc, and docidx documentation files.
-#
-
-proc ::fileutil::fileType {filename} {
-    ;## existence test
-    if { ! [ file exists $filename ] } {
-        set err "file not found: '$filename'"
-        return -code error $err
-    }
-    ;## directory test
-    if { [ file isdirectory $filename ] } {
-        set type directory
-        if { ! [ catch {file readlink $filename} ] } {
-            lappend type link
-        }
-        return $type
-    }
-    ;## empty file test
-    if { ! [ file size $filename ] } {
-        set type empty
-        if { ! [ catch {file readlink $filename} ] } {
-            lappend type link
-        }
-        return $type
-    }
-    set bin_rx {[\x00-\x08\x0b\x0e-\x1f]}
-
-    if { [ catch {
-        set fid [ open $filename r ]
-        fconfigure $fid -translation binary
-        fconfigure $fid -buffersize 1024
-        fconfigure $fid -buffering full
-        set test [ read $fid 1024 ]
-        ::close $fid
-    } err ] } {
-        catch { ::close $fid }
-        return -code error "::fileutil::fileType: $err"
-    }
-
-    if { [ regexp $bin_rx $test ] } {
-        set type binary
-        set binary 1
-    } else {
-        set type text
-        set binary 0
-    }
-
-    # SF Tcllib bug [795585]. Allowing whitespace between #!
-    # and path of script interpreter
-
-    set metakit 0
-
-    if { [ regexp {^\#\!\s*(\S+)} $test -> terp ] } {
-        lappend type script $terp
-    } elseif {([regexp "\\\[manpage_begin " $test] &&
-	       !([regexp -- {--- !doctools ---} $test] || [regexp -- "!tcl\.tk//DSL doctools//EN//" $test])) ||
-                ([regexp -- {--- doctools ---} $test]  || [regexp -- "tcl\.tk//DSL doctools//EN//" $test])} {
-	lappend type doctools
-    } elseif {([regexp "\\\[toc_begin " $test] &&
-	       !([regexp -- {--- !doctoc ---} $test] || [regexp -- "!tcl\.tk//DSL doctoc//EN//" $test])) ||
-                ([regexp -- {--- doctoc ---} $test]  || [regexp -- "tcl\.tk//DSL doctoc//EN//" $test])} {
-	lappend type doctoc
-    } elseif {([regexp "\\\[index_begin " $test] &&
-	       !([regexp -- {--- !docidx ---} $test] || [regexp -- "!tcl\.tk//DSL docidx//EN//" $test])) ||
-              ([regexp -- {--- docidx ---} $test] || [regexp -- "tcl\.tk//DSL docidx//EN//" $test])} {
-	lappend type docidx
-    } elseif {[regexp -- "tcl\\.tk//DSL diagram//EN//" $test]} {
-	lappend type tkdiagram
-    } elseif { $binary && [ regexp {^[\x7F]ELF} $test ] } {
-        lappend type executable elf
-    } elseif { $binary && [string match "MZ*" $test] } {
-        if { [scan [string index $test 24] %c] < 64 } {
-            lappend type executable dos
-        } else {
-            binary scan [string range $test 60 61] s next
-            set sig [string range $test $next [expr {$next + 1}]]
-            if { $sig == "NE" || $sig == "PE" } {
-                lappend type executable [string tolower $sig]
-            } else {
-                lappend type executable dos
-            }
-        }
-    } elseif { $binary && [string match "SQLite format 3\x00*" $test] } {
-	lappend type sqlite3
-
-	# Check for various sqlite-based application file formats.
-	set appid [string range $test 68 71]
-	if {$appid eq "\x0f\x05\x51\x12"} {
-	    lappend type fossil-checkout
-	} elseif {$appid eq "\x0f\x05\x51\x13"} {
-	    lappend type fossil-global-config
-	} elseif {$appid eq "\x0f\x05\x51\x11"} {
-	    lappend type fossil-repository
-	} else {
-	    # encode the appid as hex and append that.
-	    binary scan $appid H8 aid
-	    lappend type A$aid
-	}
-
-    } elseif { $binary && [string match "BZh91AY\&SY*" $test] } {
-        lappend type compressed bzip
-    } elseif { $binary && [string match "\x1f\x8b*" $test] } {
-        lappend type compressed gzip
-    } elseif { $binary && [string range $test 257 262] == "ustar\x00" } {
-        lappend type compressed tar
-    } elseif { $binary && [string match "\x50\x4b\x03\x04*" $test] } {
-        lappend type compressed zip
-    } elseif { $binary && [string match "GIF*" $test] } {
-        lappend type graphic gif
-    } elseif { $binary && [string match "icns*" $test] } {
-        lappend type graphic icns bigendian
-    } elseif { $binary && [string match "snci*" $test] } {
-        lappend type graphic icns smallendian
-    } elseif { $binary && [string match "\x89PNG*" $test] } {
-        lappend type graphic png
-    } elseif { $binary && [string match "\xFF\xD8\xFF*" $test] } {
-        binary scan $test x3H2x2a5 marker txt
-        if { $marker == "e0" && $txt == "JFIF\x00" } {
-            lappend type graphic jpeg jfif
-        } elseif { $marker == "e1" && $txt == "Exif\x00" } {
-            lappend type graphic jpeg exif
-        }
-    } elseif { $binary && [string match "MM\x00\**" $test] } {
-        lappend type graphic tiff
-    } elseif { $binary && [string match "BM*" $test] && [string range $test 6 9] == "\x00\x00\x00\x00" } {
-        lappend type graphic bitmap
-    } elseif { ! $binary && [string match -nocase "*\<html\>*" $test] } {
-        lappend type html
-    } elseif {[string match "\%PDF\-*" $test] } {
-        lappend type pdf
-    } elseif { [string match "\%\!PS\-*" $test] } {
-       lappend type ps
-       if { [string match "* EPSF\-*" $test] } {
-           lappend type eps
-       }
-    } elseif { [string match -nocase "*\<\?xml*" $test] } {
-        lappend type xml
-        if { [ regexp -nocase {\<\!DOCTYPE\s+(\S+)} $test -> doctype ] } {
-            lappend type $doctype
-        }
-    } elseif { [string match {*BEGIN PGP MESSAGE*} $test] } {
-        lappend type message pgp
-    } elseif { $binary && [string match {IGWD*} $test] } {
-        lappend type gravity_wave_data_frame
-    } elseif {[string match "JL\x1a\x00*" $test] && ([file size $filename] >= 27)} {
-	lappend type metakit smallendian
-	set metakit 1
-    } elseif {[string match "LJ\x1a\x00*" $test] && ([file size $filename] >= 27)} {
-	lappend type metakit bigendian
-	set metakit 1
-    } elseif { $binary && [string match "RIFF*" $test] && [string range $test 8 11] == "WAVE" } {
-        lappend type audio wave
-    } elseif { $binary && [string match "ID3*" $test] } {
-        lappend type audio mpeg
-    } elseif { $binary && [binary scan $test S tmp] && [expr {$tmp & 0xFFE0}] == 65504 } {
-        lappend type audio mpeg
-    }
-
-    # Additional checks of file contents at the end of the file,
-    # possibly pointing into the middle too (attached metakit,
-    # attached zip).
-
-    ## Metakit File format: http://www.equi4.com/metakit/metakit-ff.html
-    ## Metakit database attached ? ##
-
-    if {!$metakit && ([file size $filename] >= 27)} {
-	# The offsets in the footer are in always bigendian format
-
-	if { [ catch {
-	    set fid [ open $filename r ]
-	    fconfigure $fid -translation binary
-	    fconfigure $fid -buffersize 1024
-	    fconfigure $fid -buffering full
-	    seek $fid -16 end
-	    set test [ read $fid 16 ]
-	    ::close $fid
-	} err ] } {
-	    catch { ::close $fid }
-	    return -code error "::fileutil::fileType: $err"
-	}
-
-	binary scan $test IIII __ hdroffset __ __
-	set hdroffset [expr {[file size $filename] - 16 - $hdroffset}]
-
-	# Further checks iff the offset is actually inside the file.
-
-	if {($hdroffset >= 0) && ($hdroffset < [file size $filename])} {
-	    # Seek to the specified location and try to match a metakit header
-	    # at this location.
-
-	    if { [ catch {
-		set         fid [ open $filename r ]
-		fconfigure $fid -translation binary
-		fconfigure $fid -buffersize 1024
-		fconfigure $fid -buffering full
-		seek       $fid $hdroffset start
-		set test [ read $fid 16 ]
-		::close $fid
-	    } err ] } {
-		catch { ::close $fid }
-		return -code error "::fileutil::fileType: $err"
-	    }
-
-	    if {[string match "JL\x1a\x00*" $test]} {
-		lappend type attached metakit smallendian
-		set metakit 1
-	    } elseif {[string match "LJ\x1a\x00*" $test]} {
-		lappend type attached metakit bigendian
-		set metakit 1
-	    }
-	}
-    }
-
-    ## Zip File Format: http://zziplib.sourceforge.net/zzip-parse.html
-    ## http://www.pkware.com/products/enterprise/white_papers/appnote.html
-
-
-    ;## lastly, is it a link?
-    if { ! [ catch {file readlink $filename} ] } {
-        lappend type link
-    }
-    return $type
-}
-
-# ::fileutil::tempdir --
-#
-#	Return the correct directory to use for temporary files.
-#	Python attempts this sequence, which seems logical:
-#
-#       1. The directory named by the `TMPDIR' environment variable.
-#
-#       2. The directory named by the `TEMP' environment variable.
-#
-#       3. The directory named by the `TMP' environment variable.
-#
-#       4. A platform-specific location:
-#            * On Macintosh, the `Temporary Items' folder.
-#
-#            * On Windows, the directories `C:\\TEMP', `C:\\TMP',
-#              `\\TEMP', and `\\TMP', in that order.
-#
-#            * On all other platforms, the directories `/tmp',
-#              `/var/tmp', and `/usr/tmp', in that order.
-#
-#       5. As a last resort, the current working directory.
-#
-#	The code here also does
-#
-#	0. The directory set by invoking tempdir with an argument.
-#	   If this is present it is used exclusively.
-#
-# Arguments:
-#	None.
-#
-# Side Effects:
-#	None.
-#
-# Results:
-#	The directory for temporary files.
-
-proc ::fileutil::tempdir {args} {
-    if {[llength $args] > 1} {
-	return -code error {wrong#args: should be "::fileutil::tempdir ?path?"}
-    } elseif {[llength $args] == 1} {
-	variable tempdir    [lindex $args 0]
-	variable tempdirSet 1
-	return
-    }
-    return [Normalize [TempDir]]
-}
-
-proc ::fileutil::tempdirReset {} {
-    variable tempdir    {}
-    variable tempdirSet 0
-    return
-}
-
-proc ::fileutil::TempDir {} {
-    global tcl_platform env
-    variable tempdir
-    variable tempdirSet
-
-    set attempdirs [list]
-    set problems   {}
-
-    if {$tempdirSet} {
-	lappend attempdirs $tempdir
-	lappend problems {User/Application specified tempdir}
-    } else {
-	foreach tmp {TMPDIR TEMP TMP} {
-	    if { [info exists env($tmp)] } {
-		lappend attempdirs $env($tmp)
-	    } else {
-		lappend problems "No environment variable $tmp"
-	    }
-	}
-
-	switch $tcl_platform(platform) {
-	    windows {
-		lappend attempdirs "C:\\TEMP" "C:\\TMP" "\\TEMP" "\\TMP"
-	    }
-	    macintosh {
-		lappend attempdirs $env(TRASH_FOLDER)  ;# a better place?
-	    }
-	    default {
-		lappend attempdirs \
-		    [file join / tmp] \
-		    [file join / var tmp] \
-		    [file join / usr tmp]
-	    }
-	}
-
-	lappend attempdirs [pwd]
-    }
-
-    foreach tmp $attempdirs {
-	if { [file isdirectory $tmp] && [file writable $tmp] } {
-	    return $tmp
-	} elseif { ![file isdirectory $tmp] } {
-	    lappend problems "Not a directory: $tmp"
-	} else {
-	    lappend problems "Not writable: $tmp"
-	}
-    }
-
-    # Fail if nothing worked.
-    return -code error "Unable to determine a proper directory for temporary files\n[join $problems \n]"
-}
-
-namespace eval ::fileutil {
-    variable tempdir    {}
-    variable tempdirSet 0
-}
-
-# ::fileutil::maketempdir --
-
-proc ::fileutil::maketempdir {args} {
-    return [Normalize [MakeTempDir $args]]
-}
-
-proc ::fileutil::MakeTempDir {config} {
-    # Setup of default configuration.
-    array set options {}
-    set options(-suffix) ""
-    set options(-prefix) "tmp"
-    set options(-dir)    [tempdir]
-
-    # TODO: Check for and reject options not in -suffix, -prefix, -dir
-    # Merge user configuration, overwrite defaults.
-    array set options $config
-
-    # See also "tempfile" below. Could be shareable internal configuration.
-    set chars       abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
-    set nrand_chars 10
-    set maxtries    10
-
-    for {set i 0} {$i < $maxtries} {incr i} {
-	# Build up the candidate name. See also "tempfile".
-	set directory_name $options(-prefix)
-	for {set j 0} {$j < $nrand_chars} {incr j} {
-	    append directory_name \
-		[string index $chars [expr {int(rand() * 62)}]]
-	}
-	append directory_name $options(-suffix)
-	set path [file join $options(-dir) $directory_name]
-
-	# Try to create. Try again if already exists, or trouble
-	# with creation and setting of perms.
-	#
-	# Note: The last looks as if it is able to leave partial
-	# directories behind (created, trouble with perms). But
-	# deleting ... Might pull the rug out from somebody else.
-
-	if {[file exists $path]} continue
-	if {[catch {
-	    file mkdir $path
-	    if {$::tcl_platform(platform) eq "unix"} {
-		file attributes $path -permissions 0700
-	    }
-	}]} continue
-
-	return $path
-    }
-    return -code error "Failed to find an unused temporary directory name"
-}
-
-# ::fileutil::tempfile --
-#
-#   generate a temporary file name suitable for writing to
-#   the file name will be unique, writable and will be in the
-#   appropriate system specific temp directory
-#   Code taken from http://mini.net/tcl/772 attributed to
-#    Igor Volobouev and anon.
-#
-# Arguments:
-#   prefix     - a prefix for the filename, p
-# Results:
-#   returns a file name
-#
-
-proc ::fileutil::tempfile {{prefix {}}} {
-    return [Normalize [TempFile $prefix]]
-}
-
-proc ::fileutil::TempFile {prefix} {
-    set tmpdir [tempdir]
-
-    set chars       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-    set nrand_chars 10
-    set maxtries    10
-    set access      [list RDWR CREAT EXCL]
-    set permission  0600
-    set channel ""
-    set checked_dir_writable 0
-
-    for {set i 0} {$i < $maxtries} {incr i} {
- 	set newname $prefix
- 	for {set j 0} {$j < $nrand_chars} {incr j} {
- 	    append newname [string index $chars \
-		    [expr {int(rand()*62)}]]
- 	}
-	set newname [file join $tmpdir $newname]
-
-	if {[catch {open $newname $access $permission} channel]} {
-	    if {!$checked_dir_writable} {
-		set dirname [file dirname $newname]
-		if {![file writable $dirname]} {
-		    return -code error "Directory $dirname is not writable"
-		}
-		set checked_dir_writable 1
-	    }
-	} else {
-	    # Success
-	    close $channel
-	    return $newname
-	}
-
-    }
-    if {[string compare $channel ""]} {
- 	return -code error "Failed to open a temporary file: $channel"
-    } else {
- 	return -code error "Failed to find an unused temporary file name"
-    }
-}
-
-# ::fileutil::install --
-#
-#	Tcl version of the 'install' command, which copies files from
-#	one places to another and also optionally sets some attributes
-#	such as group, owner, and permissions.
-#
-# Arguments:
-#	-m		Change the file permissions to the specified
-#                       value.  Valid arguments are those accepted by
-#			file attributes -permissions
-#
-# Results:
-#	None.
-
-# TODO - add options for group/owner manipulation.
-
-proc ::fileutil::install {args} {
-    set options {
-	{m.arg "" "Set permission mode"}
-    }
-    set usage ": [lindex [info level 0] 0]\
-\[options] source destination \noptions:"
-    array set params [::cmdline::getoptions args $options $usage]
-    # Args should now just be the source and destination.
-    if { [llength $args] < 2 } {
-	return -code error $usage
-    }
-    set src [lindex $args 0]
-    set dst [lindex $args 1]
-    file copy -force $src $dst
-    if { $params(m) != "" } {
-	set targets [::fileutil::find $dst]
-	foreach fl $targets {
-	    file attributes $fl -permissions $params(m)
-	}
-    }
-}
-
-# ### ### ### ######### ######### #########
-
-proc ::fileutil::lexnormalize {sp} {
-    set spx [file split $sp]
-
-    # Resolution of embedded relative modifiers (., and ..).
-
-    if {
-	([lsearch -exact $spx . ] < 0) &&
-	([lsearch -exact $spx ..] < 0)
-    } {
-	# Quick path out if there are no relative modifiers
-	return $sp
-    }
-
-    set absolute [expr {![string equal [file pathtype $sp] relative]}]
-    # A volumerelative path counts as absolute for our purposes.
-
-    set sp $spx
-    set np {}
-    set noskip 1
-
-    while {[llength $sp]} {
-	set ele    [lindex $sp 0]
-	set sp     [lrange $sp 1 end]
-	set islast [expr {[llength $sp] == 0}]
-
-	if {[string equal $ele ".."]} {
-	    if {
-		($absolute  && ([llength $np] >  1)) ||
-		(!$absolute && ([llength $np] >= 1))
-	    } {
-		# .. : Remove the previous element added to the
-		# new path, if there actually is enough to remove.
-		set np [lrange $np 0 end-1]
-	    }
-	} elseif {[string equal $ele "."]} {
-	    # Ignore .'s, they stay at the current location
-	    continue
-	} else {
-	    # A regular element.
-	    lappend np $ele
-	}
-    }
-    if {[llength $np] > 0} {
-	return [eval [linsert $np 0 file join]]
-	# 8.5: return [file join {*}$np]
-    }
-    return {}
-}
-
-# ### ### ### ######### ######### #########
-## Forward compatibility. Some routines require path normalization,
-## something we have supported by the builtin 'file' only since Tcl
-## 8.4. For versions of Tcl before that, to be supported by the
-## module, we implement a normalizer in Tcl itself. Slow, but working.
-
-if {[package vcompare [package provide Tcl] 8.4] < 0} {
-    # Pre 8.4. We do not have 'file normalize'. We create an
-    # approximation for it based on earlier commands.
-
-    # ... Hm. This is lexical normalization. It does not resolve
-    # symlinks in the path to their origin.
-
-    proc ::fileutil::Normalize {sp} {
-	set sp [file split $sp]
-
-	# Conversion of the incoming path to absolute.
-	if {[string equal [file pathtype [lindex $sp 0]] "relative"]} {
-	    set sp [file split [eval [list file join [pwd]] $sp]]
-	}
-
-	# Resolution of symlink components, and embedded relative
-	# modifiers (., and ..).
-
-	set np {}
-	set noskip 1
-	while {[llength $sp]} {
-	    set ele    [lindex $sp 0]
-	    set sp     [lrange $sp 1 end]
-	    set islast [expr {[llength $sp] == 0}]
-
-	    if {[string equal $ele ".."]} {
-		if {[llength $np] > 1} {
-		    # .. : Remove the previous element added to the
-		    # new path, if there actually is enough to remove.
-		    set np [lrange $np 0 end-1]
-		}
-	    } elseif {[string equal $ele "."]} {
-		# Ignore .'s, they stay at the current location
-		continue
-	    } else {
-		# A regular element. If it is not the last component
-		# then check if the combination is a symlink, and if
-		# yes, resolve it.
-
-		lappend np $ele
-
-		if {!$islast && $noskip} {
-		    # The flag 'noskip' is technically not required,
-		    # just 'file exists'. However if a path P does not
-		    # exist, then all longer paths starting with P can
-		    # not exist either, and using the flag to store
-		    # this knowledge then saves us a number of
-		    # unnecessary stat calls. IOW this a performance
-		    # optimization.
-
-		    set p [eval file join $np]
-		    set noskip [file exists $p]
-		    if {$noskip} {
-			if {[string equal link [file type $p]]} {
-			    set dst [file readlink $p]
-
-			    # We always push the destination in front of
-			    # the source path (in expanded form). So that
-			    # we handle .., .'s, and symlinks inside of
-			    # this path as well. An absolute path clears
-			    # the result, a relative one just removes the
-			    # last, now resolved component.
-
-			    set sp [eval [linsert [file split $dst] 0 linsert $sp 0]]
-
-			    if {![string equal relative [file pathtype $dst]]} {
-				# Absolute|volrelative destination, clear
-				# result, we have to start over.
-				set np {}
-			    } else {
-				# Relative link, just remove the resolved
-				# component again.
-				set np [lrange $np 0 end-1]
-			    }
-			}
-		    }
-		}
-	    }
-	}
-	if {[llength $np] > 0} {
-	    return [eval file join $np]
-	}
-	return {}
-    }
-} else {
-    proc ::fileutil::Normalize {sp} {
-	file normalize $sp
-    }
-}
-
-# ::fileutil::relative --
-#
-#	Taking two _directory_ paths, a base and a destination, computes the path
-#	of the destination relative to the base.
-#
-# Arguments:
-#	base	The path to make the destination relative to.
-#	dst	The destination path
-#
-# Results:
-#	The path of the destination, relative to the base.
-
-proc ::fileutil::relative {base dst} {
-    # Ensure that the link to directory 'dst' is properly done relative to
-    # the directory 'base'.
-
-    if {![string equal [file pathtype $base] [file pathtype $dst]]} {
-	return -code error "Unable to compute relation for paths of different pathtypes: [file pathtype $base] vs. [file pathtype $dst], ($base vs. $dst)"
-    }
-
-    set base [lexnormalize [file join [pwd] $base]]
-    set dst  [lexnormalize [file join [pwd] $dst]]
-
-    set save $dst
-    set base [file split $base]
-    set dst  [file split $dst]
-
-    while {[string equal [lindex $dst 0] [lindex $base 0]]} {
-	set dst  [lrange $dst  1 end]
-	set base [lrange $base 1 end]
-	if {![llength $dst]} {break}
-    }
-
-    set dstlen  [llength $dst]
-    set baselen [llength $base]
-
-    if {($dstlen == 0) && ($baselen == 0)} {
-	# Cases:
-	# (a) base == dst
-
-	set dst .
-    } else {
-	# Cases:
-	# (b) base is: base/sub = sub
-	#     dst  is: base     = {}
-
-	# (c) base is: base     = {}
-	#     dst  is: base/sub = sub
-
-	while {$baselen > 0} {
-	    set dst [linsert $dst 0 ..]
-	    incr baselen -1
-	}
-	# 8.5: set dst [file join {*}$dst]
-	set dst [eval [linsert $dst 0 file join]]
-    }
-
-    return $dst
-}
-
-# ::fileutil::relativeUrl --
-#
-#	Taking two _file_ paths, a base and a destination, computes the path
-#	of the destination relative to the base, from the inside of the base.
-#
-#	This is how a browser resolves relative links in a file, hence the
-#	url in the command name.
-#
-# Arguments:
-#	base	The file path to make the destination relative to.
-#	dst	The destination file path
-#
-# Results:
-#	The path of the destination file, relative to the base file.
-
-proc ::fileutil::relativeUrl {base dst} {
-    # Like 'relative', but for links from _inside_ a file to a
-    # different file.
-
-    if {![string equal [file pathtype $base] [file pathtype $dst]]} {
-	return -code error "Unable to compute relation for paths of different pathtypes: [file pathtype $base] vs. [file pathtype $dst], ($base vs. $dst)"
-    }
-
-    set base [lexnormalize [file join [pwd] $base]]
-    set dst  [lexnormalize [file join [pwd] $dst]]
-
-    set basedir [file dirname $base]
-    set dstdir  [file dirname $dst]
-
-    set dstdir  [relative $basedir $dstdir]
-
-    # dstdir == '.' on input => dstdir output has trailing './'. Strip
-    # this superfluous segment off.
-
-    if {[string equal $dstdir "."]} {
-	return [file tail $dst]
-    } elseif {[string equal [file tail $dstdir] "."]} {
-	return [file join [file dirname $dstdir] [file tail $dst]]
-    } else {
-	return [file join $dstdir [file tail $dst]]
-    }
-}
-
-# ::fileutil::fullnormalize --
-#
-#	Normalizes a path completely. I.e. a symlink in the last
-#	element is resolved as well, not only symlinks in the higher
-#	elements.
-#
-# Arguments:
-#	path	The path to normalize
-#
-# Results:
-#	The input path with all symlinks resolved.
-
-proc ::fileutil::fullnormalize {path} {
-    # When encountering symlinks in a file copy operation Tcl copies
-    # the link, not the contents of the file it references. There are
-    # situations there this is not acceptable. For these this command
-    # resolves all symbolic links in the path, including in the last
-    # element of the path. A "file copy" using the return value of
-    # this command copies an actual file, it will not encounter
-    # symlinks.
-
-    # BUG / WORKAROUND. Using the / instead of the join seems to work
-    # around a bug in the path handling on windows which can break the
-    # core 'file normalize' for symbolic links. This was exposed by
-    # the find testsuite which could not reproduced outside. I believe
-    # that there is some deep path bug in the core triggered under
-    # special circumstances. Use of / likely forces a refresh through
-    # the string rep and so avoids the problem with the path intrep.
-
-    return [file dirname [Normalize $path/__dummy__]]
-    #return [file dirname [Normalize [file join $path __dummy__]]]
-}
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/http-2.10b1.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/http-2.10b1.tm
deleted file mode 100644
index 6c3c068c..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/http-2.10b1.tm
+++ /dev/null
@@ -1,5457 +0,0 @@
-# http.tcl --
-#
-#	Client-side HTTP for GET, POST, and HEAD commands. These routines can
-#	be used in untrusted code that uses the Safesock security policy.
-#	These procedures use a callback interface to avoid using vwait, which
-#	is not defined in the safe base.
-#
-# See the file "license.terms" for information on usage and redistribution of
-# this file, and for a DISCLAIMER OF ALL WARRANTIES.
-
-package require Tcl 8.6-
-# Keep this in sync with pkgIndex.tcl and with the install directories in
-# Makefiles
-package provide http 2.10b1
-
-namespace eval http {
-    # Allow resourcing to not clobber existing data
-
-    variable http
-    if {![info exists http]} {
-	array set http {
-	    -accept */*
-	    -cookiejar {}
-	    -pipeline 1
-	    -postfresh 0
-	    -proxyhost {}
-	    -proxyport {}
-	    -proxyfilter http::ProxyRequired
-	    -proxynot {}
-	    -proxyauth {}
-	    -repost 0
-	    -threadlevel 0
-	    -urlencoding utf-8
-	    -zip 1
-	}
-	# We need a useragent string of this style or various servers will
-	# refuse to send us compressed content even when we ask for it. This
-	# follows the de-facto layout of user-agent strings in current browsers.
-	# Safe interpreters do not have ::tcl_platform(os) or
-	# ::tcl_platform(osVersion).
-	if {[interp issafe]} {
-	    set http(-useragent) "Mozilla/5.0\
-		(Windows; U;\
-		Windows NT 10.0)\
-		http/[package provide http] Tcl/[package provide Tcl]"
-	} else {
-	    set http(-useragent) "Mozilla/5.0\
-		([string totitle $::tcl_platform(platform)]; U;\
-		$::tcl_platform(os) $::tcl_platform(osVersion))\
-		http/[package provide http] Tcl/[package provide Tcl]"
-	}
-    }
-
-    proc init {} {
-	# Set up the map for quoting chars. RFC3986 Section 2.3 say percent
-	# encode all except: "... percent-encoded octets in the ranges of
-	# ALPHA (%41-%5A and %61-%7A), DIGIT (%30-%39), hyphen (%2D), period
-	# (%2E), underscore (%5F), or tilde (%7E) should not be created by URI
-	# producers ..."
-	for {set i 0} {$i <= 256} {incr i} {
-	    set c [format %c $i]
-	    if {![string match {[-._~a-zA-Z0-9]} $c]} {
-		set map($c) %[format %.2X $i]
-	    }
-	}
-	# These are handled specially
-	set map(\n) %0D%0A
-	variable formMap [array get map]
-
-	# Create a map for HTTP/1.1 open sockets
-	variable socketMapping
-	variable socketRdState
-	variable socketWrState
-	variable socketRdQueue
-	variable socketWrQueue
-	variable socketPhQueue
-	variable socketClosing
-	variable socketPlayCmd
-	variable socketCoEvent
-	variable socketProxyId
-	if {[info exists socketMapping]} {
-	    # Close open sockets on re-init.  Do not permit retries.
-	    foreach {url sock} [array get socketMapping] {
-		unset -nocomplain socketClosing($url)
-		unset -nocomplain socketPlayCmd($url)
-		CloseSocket $sock
-	    }
-	}
-
-	# CloseSocket should have unset the socket* arrays, one element at
-	# a time.  Now unset anything that was overlooked.
-	# Traces on "unset socketRdState(*)" will call CancelReadPipeline and
-	# cancel any queued responses.
-	# Traces on "unset socketWrState(*)" will call CancelWritePipeline and
-	# cancel any queued requests.
-	array unset socketMapping
-	array unset socketRdState
-	array unset socketWrState
-	array unset socketRdQueue
-	array unset socketWrQueue
-	array unset socketPhQueue
-	array unset socketClosing
-	array unset socketPlayCmd
-	array unset socketCoEvent
-	array unset socketProxyId
-	array set socketMapping {}
-	array set socketRdState {}
-	array set socketWrState {}
-	array set socketRdQueue {}
-	array set socketWrQueue {}
-	array set socketPhQueue {}
-	array set socketClosing {}
-	array set socketPlayCmd {}
-	array set socketCoEvent {}
-	array set socketProxyId {}
-	return
-    }
-    init
-
-    variable urlTypes
-    if {![info exists urlTypes]} {
-	set urlTypes(http) [list 80 ::http::socket]
-    }
-
-    variable encodings [string tolower [encoding names]]
-    # This can be changed, but iso8859-1 is the RFC standard.
-    variable defaultCharset
-    if {![info exists defaultCharset]} {
-	set defaultCharset "iso8859-1"
-    }
-
-    # Force RFC 3986 strictness in geturl url verification?
-    variable strict
-    if {![info exists strict]} {
-	set strict 1
-    }
-
-    # Let user control default keepalive for compatibility
-    variable defaultKeepalive
-    if {![info exists defaultKeepalive]} {
-	set defaultKeepalive 0
-    }
-
-    # Regular expression used to parse cookies
-    variable CookieRE {(?x)                            # EXPANDED SYNTAX
-	\s*                                            # Ignore leading spaces
-	([^][\u0000- ()<>@,;:\\""/?={}\u007f-\uffff]+) # Match the name
-	=                                              # LITERAL: Equal sign
-	([!\u0023-+\u002D-:<-\u005B\u005D-~]*)         # Match the value
-	(?:
-	 \s* ; \s*                                     # LITERAL: semicolon
-	 ([^\u0000]+)                                  # Match the options
-	)?
-    }
-
-    variable TmpSockCounter 0
-    variable ThreadCounter  0
-
-    variable reasonDict [dict create {*}{
-        100 Continue
-        101 {Switching Protocols}
-        102 Processing
-        103 {Early Hints}
-        200 OK
-        201 Created
-        202 Accepted
-        203 {Non-Authoritative Information}
-        204 {No Content}
-        205 {Reset Content}
-        206 {Partial Content}
-        207 Multi-Status
-        208 {Already Reported}
-        226 {IM Used}
-        300 {Multiple Choices}
-        301 {Moved Permanently}
-        302 Found
-        303 {See Other}
-        304 {Not Modified}
-        305 {Use Proxy}
-        306 (Unused)
-        307 {Temporary Redirect}
-        308 {Permanent Redirect}
-        400 {Bad Request}
-        401 Unauthorized
-        402 {Payment Required}
-        403 Forbidden
-        404 {Not Found}
-        405 {Method Not Allowed}
-        406 {Not Acceptable}
-        407 {Proxy Authentication Required}
-        408 {Request Timeout}
-        409 Conflict
-        410 Gone
-        411 {Length Required}
-        412 {Precondition Failed}
-        413 {Content Too Large}
-        414 {URI Too Long}
-        415 {Unsupported Media Type}
-        416 {Range Not Satisfiable}
-        417 {Expectation Failed}
-        418 (Unused)
-        421 {Misdirected Request}
-        422 {Unprocessable Content}
-        423 Locked
-        424 {Failed Dependency}
-        425 {Too Early}
-        426 {Upgrade Required}
-        428 {Precondition Required}
-        429 {Too Many Requests}
-        431 {Request Header Fields Too Large}
-        451 {Unavailable For Legal Reasons}
-        500 {Internal Server Error}
-        501 {Not Implemented}
-        502 {Bad Gateway}
-        503 {Service Unavailable}
-        504 {Gateway Timeout}
-        505 {HTTP Version Not Supported}
-        506 {Variant Also Negotiates}
-        507 {Insufficient Storage}
-        508 {Loop Detected}
-        510 {Not Extended (OBSOLETED)}
-        511 {Network Authentication Required}
-    }]
-
-    variable failedProxyValues {
-	binary
-	body
-	charset
-	coding
-	connection
-	connectionRespFlag
-	currentsize
-	host
-	http
-	httpResponse
-	meta
-	method
-	querylength
-	queryoffset
-	reasonPhrase
-	requestHeaders
-	requestLine
-	responseCode
-	state
-	status
-	tid
-	totalsize
-	transfer
-	type
-    }
-
-    namespace export geturl config reset wait formatQuery postError quoteString
-    namespace export register unregister registerError
-    namespace export requestLine requestHeaders requestHeaderValue
-    namespace export responseLine responseHeaders responseHeaderValue
-    namespace export responseCode responseBody responseInfo reasonPhrase
-    # - Legacy aliases, were never exported:
-    #     data, code, mapReply, meta, ncode
-    # - Callable from outside (e.g. from TLS) by fully-qualified name, but
-    #   not exported:
-    #     socket
-    # - Useful, but never exported (and likely to have naming collisions):
-    #     size, status, cleanup, error, init
-    #   Comments suggest that "init" can be used for re-initialisation,
-    #   although the command is undocumented.
-    # - Never exported, renamed from lower-case names:
-    #   GetTextLine, MakeTransformationChunked.
-}
-
-# http::Log --
-#
-#	Debugging output -- define this to observe HTTP/1.1 socket usage.
-#	Should echo any args received.
-#
-# Arguments:
-#     msg	Message to output
-#
-if {[info command http::Log] eq {}} {proc http::Log {args} {}}
-
-# http::register --
-#
-#     See documentation for details.
-#
-# Arguments:
-#     proto	URL protocol prefix, e.g. https
-#     port	Default port for protocol
-#     command	Command to use to create socket
-# Results:
-#     list of port and command that was registered.
-
-proc http::register {proto port command} {
-    variable urlTypes
-    set urlTypes([string tolower $proto]) [list $port $command]
-}
-
-# http::unregister --
-#
-#     Unregisters URL protocol handler
-#
-# Arguments:
-#     proto	URL protocol prefix, e.g. https
-# Results:
-#     list of port and command that was unregistered.
-
-proc http::unregister {proto} {
-    variable urlTypes
-    set lower [string tolower $proto]
-    if {![info exists urlTypes($lower)]} {
-	return -code error "unsupported url type \"$proto\""
-    }
-    set old $urlTypes($lower)
-    unset urlTypes($lower)
-    return $old
-}
-
-# http::config --
-#
-#	See documentation for details.
-#
-# Arguments:
-#	args		Options parsed by the procedure.
-# Results:
-#        TODO
-
-proc http::config {args} {
-    variable http
-    set options [lsort [array names http -*]]
-    set usage [join $options ", "]
-    if {[llength $args] == 0} {
-	set result {}
-	foreach name $options {
-	    lappend result $name $http($name)
-	}
-	return $result
-    }
-    set options [string map {- ""} $options]
-    set pat ^-(?:[join $options |])$
-    if {[llength $args] == 1} {
-	set flag [lindex $args 0]
-	if {![regexp -- $pat $flag]} {
-	    return -code error "Unknown option $flag, must be: $usage"
-	}
-	return $http($flag)
-    } elseif {[llength $args] % 2} {
-	return -code error "If more than one argument is supplied, the\
-		number of arguments must be even"
-    } else {
-	foreach {flag value} $args {
-	    if {![regexp -- $pat $flag]} {
-		return -code error "Unknown option $flag, must be: $usage"
-	    }
-	    if {($flag eq {-threadlevel}) && ($value ni {0 1 2})} {
-		return -code error {Option -threadlevel must be 0, 1 or 2}
-	    }
-	    set http($flag) $value
-	}
-	return
-    }
-}
-
-# ------------------------------------------------------------------------------
-#  Proc http::reasonPhrase
-# ------------------------------------------------------------------------------
-# Command to return the IANA-recommended "reason phrase" for a HTTP Status Code.
-# Information obtained from:
-# https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-#
-# Arguments:
-# code        - A valid HTTP Status Code (integer from 100 to 599)
-#
-# Return Value: the reason phrase
-# ------------------------------------------------------------------------------
-
-proc http::reasonPhrase {code} {
-    variable reasonDict
-    if {![regexp -- {^[1-5][0-9][0-9]$} $code]} {
-        set msg {argument must be a three-digit integer from 100 to 599}
-        return -code error $msg
-    }
-    if {[dict exists $reasonDict $code]} {
-        set reason [dict get $reasonDict $code]
-    } else {
-        set reason Unassigned
-    }
-    return $reason
-}
-
-# http::Finish --
-#
-#	Clean up the socket and eval close time callbacks
-#
-# Arguments:
-#	token	    Connection token.
-#	errormsg    (optional) If set, forces status to error.
-#	skipCB      (optional) If set, don't call the -command callback. This
-#		    is useful when geturl wants to throw an exception instead
-#		    of calling the callback. That way, the same error isn't
-#		    reported to two places.
-#
-# Side Effects:
-#        May close the socket.
-
-proc http::Finish {token {errormsg ""} {skipCB 0}} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    global errorInfo errorCode
-    set closeQueue 0
-    if {$errormsg ne ""} {
-	set state(error) [list $errormsg $errorInfo $errorCode]
-	set state(status) "error"
-    }
-    if {[info commands ${token}--EventCoroutine] ne {}} {
-	rename ${token}--EventCoroutine {}
-    }
-    if {[info commands ${token}--SocketCoroutine] ne {}} {
-	rename ${token}--SocketCoroutine {}
-    }
-    if {[info exists state(socketcoro)]} {
-        Log $token Cancel socket after-idle event (Finish)
-        after cancel $state(socketcoro)
-        unset state(socketcoro)
-    }
-
-    # Is this an upgrade request/response?
-    set upgradeResponse \
-	[expr {    [info exists state(upgradeRequest)]
-		&& $state(upgradeRequest)
-		&& [info exists state(http)]
-		&& ([ncode $token] eq {101})
-		&& [info exists state(connection)]
-		&& ("upgrade" in $state(connection))
-		&& [info exists state(upgrade)]
-		&& ("" ne $state(upgrade))
-	}]
-
-    if {  ($state(status) eq "timeout")
-       || ($state(status) eq "error")
-       || ($state(status) eq "eof")
-    } {
-	set closeQueue 1
-	set connId $state(socketinfo)
-	if {[info exists state(sock)]} {
-	    set sock $state(sock)
-	    CloseSocket $state(sock) $token
-	} else {
-            # When opening the socket and calling http::reset
-            # immediately, the socket may not yet exist.
-            # Test http-4.11 may come here.
-	}
-	if {$state(tid) ne {}} {
-            # When opening the socket in a thread, and calling http::reset
-            # immediately, the thread may still exist.
-            # Test http-4.11 may come here.
-	    thread::release $state(tid)
-	    set state(tid) {}
-	} else {
-	}
-    } elseif {$upgradeResponse} {
-	# Special handling for an upgrade request/response.
-	# - geturl ensures that this is not a "persistent" socket used for
-	#   multiple HTTP requests, so a call to KeepSocket is not needed.
-	# - Leave socket open, so a call to CloseSocket is not needed either.
-	# - Remove fileevent bindings.  The caller will set its own bindings.
-	# - THE CALLER MUST PROCESS THE UPGRADED SOCKET IN THE CALLBACK COMMAND
-	#   PASSED TO http::geturl AS -command callback.
-	catch {fileevent $state(sock) readable {}}
-	catch {fileevent $state(sock) writable {}}
-    } elseif {
-          ([info exists state(-keepalive)] && !$state(-keepalive))
-       || ([info exists state(connection)] && ("close" in $state(connection)))
-    } {
-	set closeQueue 1
-	set connId $state(socketinfo)
-	if {[info exists state(sock)]} {
-	    set sock $state(sock)
-	    CloseSocket $state(sock) $token
-	} else {
-            # When opening the socket and calling http::reset
-            # immediately, the socket may not yet exist.
-            # Test http-4.11 may come here.
-	}
-    } elseif {
-	  ([info exists state(-keepalive)] && $state(-keepalive))
-       && ([info exists state(connection)] && ("close" ni $state(connection)))
-    } {
-	KeepSocket $token
-    }
-    if {[info exists state(after)]} {
-	after cancel $state(after)
-	unset state(after)
-    }
-    if {[info exists state(-command)] && (!$skipCB)
-	    && (![info exists state(done-command-cb)])} {
-	set state(done-command-cb) yes
-	if {    [catch {namespace eval :: $state(-command) $token} err]
-	     && ($errormsg eq "")
-	} {
-	    set state(error) [list $err $errorInfo $errorCode]
-	    set state(status) error
-	}
-    }
-
-    if {    $closeQueue
-	 && [info exists socketMapping($connId)]
-	 && ($socketMapping($connId) eq $sock)
-    } {
-	http::CloseQueuedQueries $connId $token
-	# This calls Unset.  Other cases do not need the call.
-    }
-    return
-}
-
-# http::KeepSocket -
-#
-#	Keep a socket in the persistent sockets table and connect it to its next
-#	queued task if possible.  Otherwise leave it idle and ready for its next
-#	use.
-#
-#	If $socketClosing(*), then ("close" in $state(connection)) and therefore
-#	this command will not be called by Finish.
-#
-# Arguments:
-#	token	    Connection token.
-
-proc http::KeepSocket {token} {
-    variable http
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    # Keep this socket open for another request ("Keep-Alive").
-    # React if the server half-closes the socket.
-    # Discussion is in http::geturl.
-    catch {fileevent $state(sock) readable [list http::CheckEof $state(sock)]}
-
-    # The line below should not be changed in production code.
-    # It is edited by the test suite.
-    set TEST_EOF 0
-    if {$TEST_EOF} {
-	# ONLY for testing reaction to server eof.
-	# No server timeouts will be caught.
-	catch {fileevent $state(sock) readable {}}
-    }
-
-    if {    [info exists state(socketinfo)]
-	 && [info exists socketMapping($state(socketinfo))]
-    } {
-	set connId $state(socketinfo)
-	# The value "Rready" is set only here.
-	set socketRdState($connId) Rready
-
-	if {    $state(-pipeline)
-	     && [info exists socketRdQueue($connId)]
-	     && [llength $socketRdQueue($connId)]
-	} {
-	    # The usual case for pipelined responses - if another response is
-	    # queued, arrange to read it.
-	    set token3 [lindex $socketRdQueue($connId) 0]
-	    set socketRdQueue($connId) [lrange $socketRdQueue($connId) 1 end]
-
-	    #Log pipelined, GRANT read access to $token3 in KeepSocket
-	    set socketRdState($connId) $token3
-	    ReceiveResponse $token3
-
-	    # Other pipelined cases.
-	    # - The test above ensures that, for the pipelined cases in the two
-	    #   tests below, the read queue is empty.
-	    # - In those two tests, check whether the next write will be
-	    #   nonpipeline.
-	} elseif {
-		$state(-pipeline)
-	     && [info exists socketWrState($connId)]
-	     && ($socketWrState($connId) eq "peNding")
-
-	     && [info exists socketWrQueue($connId)]
-	     && [llength $socketWrQueue($connId)]
-	     && (![set token3 [lindex $socketWrQueue($connId) 0]
-		   set ${token3}(-pipeline)
-		  ]
-		)
-	} {
-	    # This case:
-	    # - Now it the time to run the "pending" request.
-	    # - The next token in the write queue is nonpipeline, and
-	    #   socketWrState has been marked "pending" (in
-	    #   http::NextPipelinedWrite or http::geturl) so a new pipelined
-	    #   request cannot jump the queue.
-	    #
-	    # Tests:
-	    # - In this case the read queue (tested above) is empty and this
-	    #   "pending" write token is in front of the rest of the write
-	    #   queue.
-	    # - The write state is not Wready and therefore appears to be busy,
-	    #   but because it is "pending" we know that it is reserved for the
-	    #   first item in the write queue, a non-pipelined request that is
-	    #   waiting for the read queue to empty.  That has now happened: so
-	    #   give that request read and write access.
-	    set conn [set ${token3}(connArgs)]
-	    #Log nonpipeline, GRANT r/w access to $token3 in KeepSocket
-	    set socketRdState($connId) $token3
-	    set socketWrState($connId) $token3
-	    set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	    # Connect does its own fconfigure.
-	    fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
-	    #Log ---- $state(sock) << conn to $token3 for HTTP request (c)
-
-	} elseif {
-		$state(-pipeline)
-	     && [info exists socketWrState($connId)]
-	     && ($socketWrState($connId) eq "peNding")
-
-	} {
-	    # Should not come here.  The second block in the previous "elseif"
-	    # test should be tautologous (but was needed in an earlier
-	    # implementation) and will be removed after testing.
-	    # If we get here, the value "pending" was assigned in error.
-	    # This error would block the queue for ever.
-	    Log ^X$tk <<<<< Error in queueing of requests >>>>> - token $token
-
-	} elseif {
-		$state(-pipeline)
-	     && [info exists socketWrState($connId)]
-	     && ($socketWrState($connId) eq "Wready")
-
-	     && [info exists socketWrQueue($connId)]
-	     && [llength $socketWrQueue($connId)]
-	     && (![set token3 [lindex $socketWrQueue($connId) 0]
-		   set ${token3}(-pipeline)
-		  ]
-		)
-	} {
-	    # This case:
-	    # - The next token in the write queue is nonpipeline, and
-	    #   socketWrState is Wready.  Get the next event from socketWrQueue.
-	    # Tests:
-	    # - In this case the read state (tested above) is Rready and the
-	    #   write state (tested here) is Wready - there is no "pending"
-	    #   request.
-	    # Code:
-	    # - The code is the same as the code below for the nonpipelined
-	    #   case with a queued request.
-	    set conn [set ${token3}(connArgs)]
-	    #Log nonpipeline, GRANT r/w access to $token3 in KeepSocket
-	    set socketRdState($connId) $token3
-	    set socketWrState($connId) $token3
-	    set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	    # Connect does its own fconfigure.
-	    fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
-	    #Log ---- $state(sock) << conn to $token3 for HTTP request (c)
-
-	} elseif {
-		(!$state(-pipeline))
-	     && [info exists socketWrQueue($connId)]
-	     && [llength $socketWrQueue($connId)]
-	     && ("close" ni $state(connection))
-	} {
-	    # If not pipelined, (socketRdState eq Rready) tells us that we are
-	    # ready for the next write - there is no need to check
-	    # socketWrState. Write the next request, if one is waiting.
-	    # If the next request is pipelined, it receives premature read
-	    # access to the socket. This is not a problem.
-	    set token3 [lindex $socketWrQueue($connId) 0]
-	    set conn [set ${token3}(connArgs)]
-	    #Log nonpipeline, GRANT r/w access to $token3 in KeepSocket
-	    set socketRdState($connId) $token3
-	    set socketWrState($connId) $token3
-	    set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	    # Connect does its own fconfigure.
-	    fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
-	    #Log ---- $state(sock) << conn to $token3 for HTTP request (d)
-
-	} elseif {(!$state(-pipeline))} {
-	    set socketWrState($connId) Wready
-	    # Rready and Wready and idle: nothing to do.
-	}
-
-    } else {
-	CloseSocket $state(sock) $token
-	# There is no socketMapping($state(socketinfo)), so it does not matter
-	# that CloseQueuedQueries is not called.
-    }
-    return
-}
-
-# http::CheckEof -
-#
-#	Read from a socket and close it if eof.
-#	The command is bound to "fileevent readable" on an idle socket, and
-#	"eof" is the only event that should trigger the binding, occurring when
-#	the server times out and half-closes the socket.
-#
-#	A read is necessary so that [eof] gives a meaningful result.
-#	Any bytes sent are junk (or a bug).
-
-proc http::CheckEof {sock} {
-    set junk [read $sock]
-    set n [string length $junk]
-    if {$n} {
-	Log "WARNING: $n bytes received but no HTTP request sent"
-    }
-
-    if {[catch {eof $sock} res] || $res} {
-	# The server has half-closed the socket.
-	# If a new write has started, its transaction will fail and
-	# will then be error-handled.
-	CloseSocket $sock
-    }
-    return
-}
-
-# http::CloseSocket -
-#
-#	Close a socket and remove it from the persistent sockets table.  If
-#	possible an http token is included here but when we are called from a
-#	fileevent on remote closure we need to find the correct entry - hence
-#	the "else" block of the first "if" command.
-
-proc http::CloseSocket {s {token {}}} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set tk [namespace tail $token]
-
-    catch {fileevent $s readable {}}
-    set connId {}
-    if {$token ne ""} {
-	variable $token
-	upvar 0 $token state
-	if {[info exists state(socketinfo)]} {
-	    set connId $state(socketinfo)
-	}
-    } else {
-	set map [array get socketMapping]
-	set ndx [lsearch -exact $map $s]
-	if {$ndx >= 0} {
-	    incr ndx -1
-	    set connId [lindex $map $ndx]
-	}
-    }
-    if {    ($connId ne {})
-	 && [info exists socketMapping($connId)]
-	 && ($socketMapping($connId) eq $s)
-    } {
-	Log "Closing connection $connId (sock $socketMapping($connId))"
-	if {[catch {close $socketMapping($connId)} err]} {
-	    Log "Error closing connection: $err"
-	} else {
-	}
-	if {$token eq {}} {
-	    # Cases with a non-empty token are handled by Finish, so the tokens
-	    # are finished in connection order.
-	    http::CloseQueuedQueries $connId
-	} else {
-	}
-    } else {
-	Log "Closing socket $s (no connection info)"
-	if {[catch {close $s} err]} {
-	    Log "Error closing socket: $err"
-	} else {
-	}
-    }
-    return
-}
-
-# http::CloseQueuedQueries
-#
-#	connId  - identifier "domain:port" for the connection
-#	token   - (optional) used only for logging
-#
-# Called from http::CloseSocket and http::Finish, after a connection is closed,
-# to clear the read and write queues if this has not already been done.
-
-proc http::CloseQueuedQueries {connId {token {}}} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    ##Log CloseQueuedQueries $connId $token
-    if {![info exists socketMapping($connId)]} {
-	# Command has already been called.
-	# Don't come here again - especially recursively.
-	return
-    }
-
-    # Used only for logging.
-    if {$token eq {}} {
-	set tk {}
-    } else {
-	set tk [namespace tail $token]
-    }
-
-    if {    [info exists socketPlayCmd($connId)]
-	 && ($socketPlayCmd($connId) ne {ReplayIfClose Wready {} {}})
-    } {
-	# Before unsetting, there is some unfinished business.
-	# - If the server sent "Connection: close", we have stored the command
-	#   for retrying any queued requests in socketPlayCmd, so copy that
-	#   value for execution below.  socketClosing(*) was also set.
-	# - Also clear the queues to prevent calls to Finish that would set the
-	#   state for the requests that will be retried to "finished with error
-	#   status".
-	# - At this stage socketPhQueue is empty.
-	set unfinished $socketPlayCmd($connId)
-	set socketRdQueue($connId) {}
-	set socketWrQueue($connId) {}
-    } else {
-	set unfinished {}
-    }
-
-    Unset $connId
-
-    if {$unfinished ne {}} {
-	Log ^R$tk Any unfinished transactions (excluding $token) failed \
-		- token $token - unfinished $unfinished
-	{*}$unfinished
-	# Calls ReplayIfClose.
-    }
-    return
-}
-
-# http::Unset
-#
-#	The trace on "unset socketRdState(*)" will call CancelReadPipeline
-#	and cancel any queued responses.
-#	The trace on "unset socketWrState(*)" will call CancelWritePipeline
-#	and cancel any queued requests.
-
-proc http::Unset {connId} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    unset socketMapping($connId)
-    unset socketRdState($connId)
-    unset socketWrState($connId)
-    unset -nocomplain socketRdQueue($connId)
-    unset -nocomplain socketWrQueue($connId)
-    unset -nocomplain socketClosing($connId)
-    unset -nocomplain socketPlayCmd($connId)
-    unset -nocomplain socketProxyId($connId)
-    return
-}
-
-# http::reset --
-#
-#	See documentation for details.
-#
-# Arguments:
-#	token	Connection token.
-#	why	Status info.
-#
-# Side Effects:
-#        See Finish
-
-proc http::reset {token {why reset}} {
-    variable $token
-    upvar 0 $token state
-    set state(status) $why
-    catch {fileevent $state(sock) readable {}}
-    catch {fileevent $state(sock) writable {}}
-    Finish $token
-    if {[info exists state(error)]} {
-	set errorlist $state(error)
-	unset state
-	eval ::error $errorlist
-	# i.e. error msg errorInfo errorCode
-    }
-    return
-}
-
-# http::geturl --
-#
-#	Establishes a connection to a remote url via http.
-#
-# Arguments:
-#	url		The http URL to goget.
-#	args		Option value pairs. Valid options include:
-#				-blocksize, -validate, -headers, -timeout
-# Results:
-#	Returns a token for this connection. This token is the name of an
-#	array that the caller should unset to garbage collect the state.
-
-proc http::geturl {url args} {
-    variable urlTypes
-
-    # - If ::tls::socketCmd has its default value "::socket", change it to the
-    #   new value ::http::socketForTls.
-    # - If the old value is different, then it has been modified either by the
-    #   script or by the Tcl installation, and replaced by a new command.  The
-    #   script or installation that modified ::tls::socketCmd is also
-    #   responsible for integrating ::http::socketForTls into its own "new"
-    #   command, if it wishes to do so.
-    # - Commands that open a socket:
-    #   - ::socket             - basic
-    #   - ::http::socket       - can use a thread to avoid blockage by slow DNS
-    #                            lookup.  See http::config option -threadlevel.
-    #   - ::http::socketForTls - as ::http::socket, but can also open a socket
-    #                            for HTTPS/TLS through a proxy.
-
-    if {[info exists ::tls::socketCmd] && ($::tls::socketCmd eq {::socket})} {
-        set ::tls::socketCmd ::http::socketForTls
-    }
-
-    set token [CreateToken $url {*}$args]
-    variable $token
-    upvar 0 $token state
-
-    AsyncTransaction $token
-
-    # --------------------------------------------------------------------------
-    # Synchronous Call to http::geturl
-    # --------------------------------------------------------------------------
-    # - If the call to http::geturl is asynchronous, it is now complete (apart
-    #   from delivering the return value).
-    # - If the call to http::geturl is synchronous, the command must now wait
-    #   for the HTTP transaction to be completed.  The call to http::wait uses
-    #   vwait, which may be inappropriate if the caller makes other HTTP
-    #   requests in the background.
-    # --------------------------------------------------------------------------
-
-    if {![info exists state(-command)]} {
-	# geturl does EVERYTHING asynchronously, so if the user
-	# calls it synchronously, we just do a wait here.
-	http::wait $token
-
-	if {![info exists state]} {
-	    # If we timed out then Finish has been called and the users
-	    # command callback may have cleaned up the token. If so we end up
-	    # here with nothing left to do.
-	    return $token
-	} elseif {$state(status) eq "error"} {
-	    # Something went wrong while trying to establish the connection.
-	    # Clean up after events and such, but DON'T call the command
-	    # callback (if available) because we're going to throw an
-	    # exception from here instead.
-	    set err [lindex $state(error) 0]
-	    cleanup $token
-	    return -code error $err
-	}
-    }
-
-    return $token
-}
-
-# ------------------------------------------------------------------------------
-#  Proc http::CreateToken
-# ------------------------------------------------------------------------------
-# Command to convert arguments into an initialised request token.
-# The return value is the variable name of the token.
-#
-# Other effects:
-# - Sets ::http::http(usingThread) if not already done
-# - Sets ::http::http(uid) if not already done
-# - Increments ::http::http(uid)
-# - May increment ::http::TmpSockCounter
-# - Alters ::http::socketPlayCmd, ::http::socketWrQueue if a -keepalive 1
-#   request is appended to the queue of a persistent socket that is already
-#   scheduled to close.
-#   This also sets state(alreadyQueued) to 1.
-# - Alters ::http::socketPhQueue if a -keepalive 1 request is appended to the
-#   queue of a persistent socket that has not yet been created (and is therefore
-#   represented by a placeholder).
-#   This also sets state(ReusingPlaceholder) to 1.
-# ------------------------------------------------------------------------------
-
-proc http::CreateToken {url args} {
-    variable http
-    variable urlTypes
-    variable defaultCharset
-    variable defaultKeepalive
-    variable strict
-    variable TmpSockCounter
-
-    # Initialize the state variable, an array. We'll return the name of this
-    # array as the token for the transaction.
-
-    if {![info exists http(usingThread)]} {
-	set http(usingThread) 0
-    }
-    if {![info exists http(uid)]} {
-	set http(uid) 0
-    }
-    set token [namespace current]::[incr http(uid)]
-    ##Log Starting http::geturl - token $token
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    reset $token
-    Log ^A$tk URL $url - token $token
-
-    # Process command options.
-
-    array set state {
-	-binary		false
-	-blocksize	8192
-	-queryblocksize 8192
-	-validate	0
-	-headers	{}
-	-timeout	0
-	-type		application/x-www-form-urlencoded
-	-queryprogress	{}
-	-protocol	1.1
-	-guesstype      0
-	binary		0
-	state		created
-	meta		{}
-	method		{}
-	coding		{}
-	currentsize	0
-	totalsize	0
-	querylength	0
-	queryoffset	0
-	type		application/octet-stream
-	body		{}
-	status		""
-	http		""
-	httpResponse    {}
-	responseCode    {}
-	reasonPhrase    {}
-	connection	keep-alive
-	tid             {}
-	requestHeaders  {}
-	requestLine     {}
-	transfer        {}
-	proxyUsed       none
-    }
-    set state(-keepalive) $defaultKeepalive
-    set state(-strict) $strict
-    # These flags have their types verified [Bug 811170]
-    array set type {
-	-binary		boolean
-	-blocksize	integer
-	-guesstype      boolean
-	-queryblocksize integer
-	-strict		boolean
-	-timeout	integer
-	-validate	boolean
-	-headers	list
-    }
-    set state(charset)	$defaultCharset
-    set options {
-	-binary -blocksize -channel -command -guesstype -handler -headers -keepalive
-	-method -myaddr -progress -protocol -query -queryblocksize
-	-querychannel -queryprogress -strict -timeout -type -validate
-    }
-    set usage [join [lsort $options] ", "]
-    set options [string map {- ""} $options]
-    set pat ^-(?:[join $options |])$
-    foreach {flag value} $args {
-	if {[regexp -- $pat $flag]} {
-	    # Validate numbers
-	    if {    [info exists type($flag)]
-	        && (![string is $type($flag) -strict $value])
-	    } {
-		unset $token
-		return -code error \
-		    "Bad value for $flag ($value), must be $type($flag)"
-	    }
-	    if {($flag eq "-headers") && ([llength $value] % 2 != 0)} {
-		unset $token
-		return -code error "Bad value for $flag ($value), number\
-			of list elements must be even"
-	    }
-	    set state($flag) $value
-	} else {
-	    unset $token
-	    return -code error "Unknown option $flag, can be: $usage"
-	}
-    }
-
-    # Make sure -query and -querychannel aren't both specified
-
-    set isQueryChannel [info exists state(-querychannel)]
-    set isQuery [info exists state(-query)]
-    if {$isQuery && $isQueryChannel} {
-	unset $token
-	return -code error "Can't combine -query and -querychannel options!"
-    }
-
-    # Validate URL, determine the server host and port, and check proxy case
-    # Recognize user:pass@host URLs also, although we do not do anything with
-    # that info yet.
-
-    # URLs have basically four parts.
-    # First, before the colon, is the protocol scheme (e.g. http)
-    # Second, for HTTP-like protocols, is the authority
-    #	The authority is preceded by // and lasts up to (but not including)
-    #	the following / or ? and it identifies up to four parts, of which
-    #	only one, the host, is required (if an authority is present at all).
-    #	All other parts of the authority (user name, password, port number)
-    #	are optional.
-    # Third is the resource name, which is split into two parts at a ?
-    #	The first part (from the single "/" up to "?") is the path, and the
-    #	second part (from that "?" up to "#") is the query. *HOWEVER*, we do
-    #	not need to separate them; we send the whole lot to the server.
-    #	Both, path and query are allowed to be missing, including their
-    #	delimiting character.
-    # Fourth is the fragment identifier, which is everything after the first
-    #	"#" in the URL. The fragment identifier MUST NOT be sent to the server
-    #	and indeed, we don't bother to validate it (it could be an error to
-    #	pass it in here, but it's cheap to strip).
-    #
-    # An example of a URL that has all the parts:
-    #
-    #     http://jschmoe:xyzzy@www.bogus.net:8000/foo/bar.tml?q=foo#changes
-    #
-    # The "http" is the protocol, the user is "jschmoe", the password is
-    # "xyzzy", the host is "www.bogus.net", the port is "8000", the path is
-    # "/foo/bar.tml", the query is "q=foo", and the fragment is "changes".
-    #
-    # Note that the RE actually combines the user and password parts, as
-    # recommended in RFC 3986. Indeed, that RFC states that putting passwords
-    # in URLs is a Really Bad Idea, something with which I would agree utterly.
-    # RFC 9110 Sec 4.2.4 goes further than this, and deprecates the format
-    # "user:password@".  It is retained here for backward compatibility,
-    # but its use is not recommended.
-    #
-    # From a validation perspective, we need to ensure that the parts of the
-    # URL that are going to the server are correctly encoded.  This is only
-    # done if $state(-strict) is true (inherited from $::http::strict).
-
-    set URLmatcher {(?x)		# this is _expanded_ syntax
-	^
-	(?: (\w+) : ) ?			# <protocol scheme>
-	(?: //
-	    (?:
-		(
-		    [^@/\#?]+		# <userinfo part of authority>
-		) @
-	    )?
-	    (				# <host part of authority>
-		[^/:\#?]+ |		# host name or IPv4 address
-		\[ [^/\#?]+ \]		# IPv6 address in square brackets
-	    )
-	    (?: : (\d+) )?		# <port part of authority>
-	)?
-	( [/\?] [^\#]*)?		# <path> (including query)
-	(?: \# (.*) )?			# <fragment>
-	$
-    }
-
-    # Phase one: parse
-    if {![regexp -- $URLmatcher $url -> proto user host port srvurl]} {
-	unset $token
-	return -code error "Unsupported URL: $url"
-    }
-    # Phase two: validate
-    set host [string trim $host {[]}]; # strip square brackets from IPv6 address
-    if {$host eq ""} {
-	# Caller has to provide a host name; we do not have a "default host"
-	# that would enable us to handle relative URLs.
-	unset $token
-	return -code error "Missing host part: $url"
-	# Note that we don't check the hostname for validity here; if it's
-	# invalid, we'll simply fail to resolve it later on.
-    }
-    if {$port ne "" && $port > 65535} {
-	unset $token
-	return -code error "Invalid port number: $port"
-    }
-    # The user identification and resource identification parts of the URL can
-    # have encoded characters in them; take care!
-    if {$user ne ""} {
-	# Check for validity according to RFC 3986, Appendix A
-	set validityRE {(?xi)
-	    ^
-	    (?: [-\w.~!$&'()*+,;=:] | %[0-9a-f][0-9a-f] )+
-	    $
-	}
-	if {$state(-strict) && ![regexp -- $validityRE $user]} {
-	    unset $token
-	    # Provide a better error message in this error case
-	    if {[regexp {(?i)%(?![0-9a-f][0-9a-f]).?.?} $user bad]} {
-		return -code error \
-			"Illegal encoding character usage \"$bad\" in URL user"
-	    }
-	    return -code error "Illegal characters in URL user"
-	}
-    }
-    if {$srvurl ne ""} {
-	# RFC 3986 allows empty paths (not even a /), but servers
-	# return 400 if the path in the HTTP request doesn't start
-	# with / , so add it here if needed.
-	if {[string index $srvurl 0] ne "/"} {
-	    set srvurl /$srvurl
-	}
-	# Check for validity according to RFC 3986, Appendix A
-	set validityRE {(?xi)
-	    ^
-	    # Path part (already must start with / character)
-	    (?:	      [-\w.~!$&'()*+,;=:@/]  | %[0-9a-f][0-9a-f] )*
-	    # Query part (optional, permits ? characters)
-	    (?: \? (?: [-\w.~!$&'()*+,;=:@/?] | %[0-9a-f][0-9a-f] )* )?
-	    $
-	}
-	if {$state(-strict) && ![regexp -- $validityRE $srvurl]} {
-	    unset $token
-	    # Provide a better error message in this error case
-	    if {[regexp {(?i)%(?![0-9a-f][0-9a-f])..} $srvurl bad]} {
-		return -code error \
-		    "Illegal encoding character usage \"$bad\" in URL path"
-	    }
-	    return -code error "Illegal characters in URL path"
-	}
-	if {![regexp {^[^?#]+} $srvurl state(path)]} {
-	    set state(path) /
-	}
-    } else {
-	set srvurl /
-	set state(path) /
-    }
-    if {$proto eq ""} {
-	set proto http
-    }
-    set lower [string tolower $proto]
-    if {![info exists urlTypes($lower)]} {
-	unset $token
-	return -code error "Unsupported URL type \"$proto\""
-    }
-    set defport [lindex $urlTypes($lower) 0]
-    set defcmd [lindex $urlTypes($lower) 1]
-
-    if {$port eq ""} {
-	set port $defport
-    }
-    if {![catch {$http(-proxyfilter) $host} proxy]} {
-	set phost [lindex $proxy 0]
-	set pport [lindex $proxy 1]
-    } else {
-	set phost {}
-	set pport {}
-    }
-
-    # OK, now reassemble into a full URL
-    set url ${proto}://
-    if {$user ne ""} {
-	append url $user
-	append url @
-    }
-    append url $host
-    if {$port != $defport} {
-	append url : $port
-    }
-    append url $srvurl
-    # Don't append the fragment! RFC 7230 Sec 5.1
-    set state(url) $url
-
-    # Proxy connections aren't shared among different hosts.
-    set state(socketinfo) $host:$port
-
-    # Save the accept types at this point to prevent a race condition. [Bug
-    # c11a51c482]
-    set state(accept-types) $http(-accept)
-
-    # Check whether this is an Upgrade request.
-    set connectionValues [SplitCommaSeparatedFieldValue \
-			      [GetFieldValue $state(-headers) Connection]]
-    set connectionValues [string tolower $connectionValues]
-    set upgradeValues [SplitCommaSeparatedFieldValue \
-			   [GetFieldValue $state(-headers) Upgrade]]
-    set state(upgradeRequest) [expr {    "upgrade" in $connectionValues
-				      && [llength $upgradeValues] >= 1}]
-    set state(connectionValues) $connectionValues
-
-    if {$isQuery || $isQueryChannel} {
-	# It's a POST.
-	# A client wishing to send a non-idempotent request SHOULD wait to send
-	# that request until it has received the response status for the
-	# previous request.
-	if {$http(-postfresh)} {
-	    # Override -keepalive for a POST.  Use a new connection, and thus
-	    # avoid the small risk of a race against server timeout.
-	    set state(-keepalive) 0
-	} else {
-	    # Allow -keepalive but do not -pipeline - wait for the previous
-	    # transaction to finish.
-	    # There is a small risk of a race against server timeout.
-	    set state(-pipeline) 0
-	}
-    } elseif {$state(upgradeRequest)} {
-	# It's an upgrade request.  Method must be GET (untested).
-	# Force -keepalive to 0 so the connection is not made over a persistent
-	# socket, i.e. one used for multiple HTTP requests.
-	set state(-keepalive) 0
-    } else {
-	# It's a non-upgrade GET or HEAD.
-	set state(-pipeline) $http(-pipeline)
-    }
-
-    # We cannot handle chunked encodings with -handler, so force HTTP/1.0
-    # until we can manage this.
-    if {[info exists state(-handler)]} {
-	set state(-protocol) 1.0
-    }
-
-    # RFC 7320 A.1 - HTTP/1.0 Keep-Alive is problematic. We do not support it.
-    if {$state(-protocol) eq "1.0"} {
-	set state(connection) close
-	set state(-keepalive) 0
-    }
-
-    # Handle proxy requests here for http:// but not for https://
-    # The proxying for https is done in the ::http::socketForTls command.
-    # A proxy request for http:// needs the full URL in the HTTP request line,
-    # including the server name.
-    # The *tls* test below attempts to describe protocols in addition to
-    # "https on port 443" that use HTTP over TLS.
-    if {($phost ne "") && (![string match -nocase *tls* $defcmd])} {
-	set srvurl $url
-	set targetAddr [list $phost $pport]
-	set state(proxyUsed) HttpProxy
-	# The value of state(proxyUsed) none|HttpProxy depends only on the
-	# all-transactions http::config settings and on the target URL.
-	# Even if this is a persistent socket there is no need to change the
-	# value of state(proxyUsed) for other transactions that use the socket:
-	# they have the same value already.
-    } else {
-	set targetAddr [list $host $port]
-    }
-
-    set sockopts [list -async]
-
-    # Pass -myaddr directly to the socket command
-    if {[info exists state(-myaddr)]} {
-	lappend sockopts -myaddr $state(-myaddr)
-    }
-
-    set state(connArgs) [list $proto $phost $srvurl]
-    set state(openCmd) [list {*}$defcmd {*}$sockopts -type $token {*}$targetAddr]
-
-    # See if we are supposed to use a previously opened channel.
-    # - In principle, ANY call to http::geturl could use a previously opened
-    #   channel if it is available - the "Connection: keep-alive" header is a
-    #   request to leave the channel open AFTER completion of this call.
-    # - In fact, we try to use an existing channel only if -keepalive 1 -- this
-    #   means that at most one channel is left open for each value of
-    #   $state(socketinfo). This property simplifies the mapping of open
-    #   channels.
-    set reusing 0
-    set state(alreadyQueued) 0
-    set state(ReusingPlaceholder) 0
-    if {$state(-keepalive)} {
-	variable socketMapping
-	variable socketRdState
-	variable socketWrState
-	variable socketRdQueue
-	variable socketWrQueue
-	variable socketPhQueue
-	variable socketClosing
-	variable socketPlayCmd
-	variable socketCoEvent
-	variable socketProxyId
-
-	if {[info exists socketMapping($state(socketinfo))]} {
-	    # - If the connection is idle, it has a "fileevent readable" binding
-	    #   to http::CheckEof, in case the server times out and half-closes
-	    #   the socket (http::CheckEof closes the other half).
-	    # - We leave this binding in place until just before the last
-	    #   puts+flush in http::Connected (GET/HEAD) or http::Write (POST),
-	    #   after which the HTTP response might be generated.
-
-	    if {    [info exists socketClosing($state(socketinfo))]
-		       && $socketClosing($state(socketinfo))
-	    } {
-		# socketClosing(*) is set because the server has sent a
-		# "Connection: close" header.
-		# Do not use the persistent socket again.
-		# Since we have only one persistent socket per server, and the
-		# old socket is not yet dead, add the request to the write queue
-		# of the dying socket, which will be replayed by ReplayIfClose.
-		# Also add it to socketWrQueue(*) which is used only if an error
-		# causes a call to Finish.
-		set reusing 1
-		set sock $socketMapping($state(socketinfo))
-		set state(proxyUsed) $socketProxyId($state(socketinfo))
-		Log "reusing closing socket $sock for $state(socketinfo) - token $token"
-
-		set state(alreadyQueued) 1
-		lassign $socketPlayCmd($state(socketinfo)) com0 com1 com2 com3
-		lappend com3 $token
-		set socketPlayCmd($state(socketinfo)) [list $com0 $com1 $com2 $com3]
-		lappend socketWrQueue($state(socketinfo)) $token
-		##Log socketPlayCmd($state(socketinfo)) is $socketPlayCmd($state(socketinfo))
-		##Log socketWrQueue($state(socketinfo)) is $socketWrQueue($state(socketinfo))
-	    } elseif {
-		   [catch {fconfigure $socketMapping($state(socketinfo))}]
-		&& (![SockIsPlaceHolder $socketMapping($state(socketinfo))])
-	    } {
-		###Log "Socket $socketMapping($state(socketinfo)) for $state(socketinfo)"
-		# FIXME Is it still possible for this code to be executed? If
-		#       so, this could be another place to call TestForReplay,
-		#       rather than discarding the queued transactions.
-		Log "WARNING: socket for $state(socketinfo) was closed\
-			- token $token"
-		Log "WARNING - if testing, pay special attention to this\
-			case (GH) which is seldom executed - token $token"
-
-		# This will call CancelReadPipeline, CancelWritePipeline, and
-		# cancel any queued requests, responses.
-		Unset $state(socketinfo)
-	    } else {
-		# Use the persistent socket.
-		# - The socket may not be ready to write: an earlier request might
-		#   still be still writing (in the pipelined case) or
-		#   writing/reading (in the nonpipeline case). This possibility
-		#   is handled by socketWrQueue later in this command.
-		# - The socket may not yet exist, and be defined with a placeholder.
-		set reusing 1
-		set sock $socketMapping($state(socketinfo))
-		set state(proxyUsed) $socketProxyId($state(socketinfo))
-		if {[SockIsPlaceHolder $sock]} {
-		    set state(ReusingPlaceholder) 1
-		    lappend socketPhQueue($sock) $token
-		} else {
-		}
-		Log "reusing open socket $sock for $state(socketinfo) - token $token"
-	    }
-	    # Do not automatically close the connection socket.
-	    set state(connection) keep-alive
-	}
-    }
-
-    set state(reusing) $reusing
-    unset reusing
-
-    if {![info exists sock]} {
-        # N.B. At this point ([info exists sock] == $state(reusing)).
-        # This will no longer be true after we set a value of sock here.
-	# Give the socket a placeholder name.
-	set sock HTTP_PLACEHOLDER_[incr TmpSockCounter]
-    }
-    set state(sock) $sock
-
-    if {$state(reusing)} {
-	# Define these for use (only) by http::ReplayIfDead if the persistent
-	# connection has died.
-	set state(tmpConnArgs) $state(connArgs)
-	set state(tmpState) [array get state]
-	set state(tmpOpenCmd) $state(openCmd)
-    }
-    return $token
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc ::http::SockIsPlaceHolder
-# ------------------------------------------------------------------------------
-# Command to return 0 if the argument is a genuine socket handle, or 1 if is a
-# placeholder value generated by geturl or ReplayCore before the real socket is
-# created.
-#
-# Arguments:
-# sock        - either a valid socket handle or a placeholder value
-#
-# Return Value: 0 or 1
-# ------------------------------------------------------------------------------
-
-proc http::SockIsPlaceHolder {sock} {
-    expr {[string range $sock 0 16] eq {HTTP_PLACEHOLDER_}}
-}
-
-
-# ------------------------------------------------------------------------------
-# state(reusing)
-# ------------------------------------------------------------------------------
-# - state(reusing) is set by geturl, ReplayCore
-# - state(reusing) is used by geturl, AsyncTransaction, OpenSocket,
-#   ConfigureNewSocket, and ScheduleRequest when creating and configuring the
-#   connection.
-# - state(reusing) is used by Connect, Connected, Event x 2 when deciding
-#   whether to call TestForReplay.
-# - Other places where state(reusing) is used:
-#   - Connected   - if reusing and not pipelined, start the state(-timeout)
-#                   timeout (when writing).
-#   - DoneRequest - if reusing and pipelined, send the next pipelined write
-#   - Event       - if reusing and pipelined, start the state(-timeout)
-#                   timeout (when reading).
-#   - Event       - if (not reusing) and pipelined, send the next pipelined
-#                   write.
-# ------------------------------------------------------------------------------
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::AsyncTransaction
-# ------------------------------------------------------------------------------
-# This command is called by geturl and ReplayCore to prepare the HTTP
-# transaction prescribed by a suitably prepared token.
-#
-# Arguments:
-# token         - connection token (name of an array)
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::AsyncTransaction {token} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set sock $state(sock)
-
-    # See comments above re the start of this timeout in other cases.
-    if {(!$state(reusing)) && ($state(-timeout) > 0)} {
-	set state(after) [after $state(-timeout) \
-		[list http::reset $token timeout]]
-    }
-
-    if {    $state(-keepalive)
-	 && (![info exists socketMapping($state(socketinfo))])
-    } {
-	# This code is executed only for the first -keepalive request on a
-	# socket.  It makes the socket persistent.
-	##Log "  PreparePersistentConnection" $token -- $sock -- DO
-        set DoLater [PreparePersistentConnection $token]
-    } else {
-        ##Log "  PreparePersistentConnection" $token -- $sock -- SKIP
-        set DoLater {-traceread 0 -tracewrite 0}
-    }
-
-    if {$state(ReusingPlaceholder)} {
-        # - This request was added to the socketPhQueue of a persistent
-        #   connection.
-        # - But the connection has not yet been created and is a placeholder;
-        # - And the placeholder was created by an earlier request.
-        # - When that earlier request calls OpenSocket, its placeholder is
-        #   replaced with a true socket, and it then executes the equivalent of
-        #   OpenSocket for any subsequent requests that have
-        #   $state(ReusingPlaceholder).
-        Log >J$tk after idle coro NO - ReusingPlaceholder
-    } elseif {$state(alreadyQueued)} {
-        # - This request was added to the socketWrQueue and socketPlayCmd
-        #   of a persistent connection that will close at the end of its current
-        #   read operation.
-        Log >J$tk after idle coro NO - alreadyQueued
-    } else {
-        Log >J$tk after idle coro YES
-        set CoroName ${token}--SocketCoroutine
-        set cancel [after idle [list coroutine $CoroName ::http::OpenSocket \
-                $token $DoLater]]
-        dict set socketCoEvent($state(socketinfo)) $token $cancel
-        set state(socketcoro) $cancel
-    }
-
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::PreparePersistentConnection
-# ------------------------------------------------------------------------------
-# This command is called by AsyncTransaction to initialise a "persistent
-# connection" based upon a socket placeholder.  It is called the first time the
-# socket is associated with a "-keepalive" request.
-#
-# Arguments:
-# token         - connection token (name of an array)
-#
-# Return Value: - DoLater, a dictionary of boolean values listing unfinished
-#                 tasks; to be passed to ConfigureNewSocket via OpenSocket.
-# ------------------------------------------------------------------------------
-
-proc http::PreparePersistentConnection {token} {
-    variable $token
-    upvar 0 $token state
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set DoLater {-traceread 0 -tracewrite 0}
-    set socketMapping($state(socketinfo)) $state(sock)
-    set socketProxyId($state(socketinfo)) $state(proxyUsed)
-    # - The value of state(proxyUsed) was set in http::CreateToken to either
-    #   "none" or "HttpProxy".
-    # - $token is the first transaction to use this placeholder, so there are
-    #   no other tokens whose (proxyUsed) must be modified.
-
-    if {![info exists socketRdState($state(socketinfo))]} {
-        set socketRdState($state(socketinfo)) {}
-        # set varName ::http::socketRdState($state(socketinfo))
-        # trace add variable $varName unset ::http::CancelReadPipeline
-        dict set DoLater -traceread 1
-    }
-    if {![info exists socketWrState($state(socketinfo))]} {
-        set socketWrState($state(socketinfo)) {}
-        # set varName ::http::socketWrState($state(socketinfo))
-        # trace add variable $varName unset ::http::CancelWritePipeline
-        dict set DoLater -tracewrite 1
-    }
-
-    if {$state(-pipeline)} {
-        #Log new, init for pipelined, GRANT write access to $token in geturl
-        # Also grant premature read access to the socket. This is OK.
-        set socketRdState($state(socketinfo)) $token
-        set socketWrState($state(socketinfo)) $token
-    } else {
-        # socketWrState is not used by this non-pipelined transaction.
-        # We cannot leave it as "Wready" because the next call to
-        # http::geturl with a pipelined transaction would conclude that the
-        # socket is available for writing.
-        #Log new, init for nonpipeline, GRANT r/w access to $token in geturl
-        set socketRdState($state(socketinfo)) $token
-        set socketWrState($state(socketinfo)) $token
-    }
-
-    # Value of socketPhQueue() may have already been set by ReplayCore.
-    if {![info exists socketPhQueue($state(sock))]} {
-        set socketPhQueue($state(sock))   {}
-    }
-    set socketRdQueue($state(socketinfo)) {}
-    set socketWrQueue($state(socketinfo)) {}
-    set socketClosing($state(socketinfo)) 0
-    set socketPlayCmd($state(socketinfo)) {ReplayIfClose Wready {} {}}
-    set socketCoEvent($state(socketinfo)) {}
-    set socketProxyId($state(socketinfo)) {}
-
-    return $DoLater
-}
-
-# ------------------------------------------------------------------------------
-#  Proc ::http::OpenSocket
-# ------------------------------------------------------------------------------
-# This command is called as a coroutine idletask to start the asynchronous HTTP
-# transaction in most cases.  For the exceptions, see the calling code in
-# command AsyncTransaction.
-#
-# Arguments:
-# token       - connection token (name of an array)
-# DoLater     - dictionary of boolean values listing unfinished tasks
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::OpenSocket {token DoLater} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    Log >K$tk Start OpenSocket coroutine
-
-    if {![info exists state(-keepalive)]} {
-        # The request has already been cancelled by the calling script.
-        return
-    }
-
-    set sockOld $state(sock)
-
-    dict unset socketCoEvent($state(socketinfo)) $token
-    unset -nocomplain state(socketcoro)
-
-    if {[catch {
-        if {$state(reusing)} {
-	    # If ($state(reusing)) is true, then we do not need to create a new
-	    # socket, even if $sockOld is only a placeholder for a socket.
-            set sock $sockOld
-        } else {
-	    # set sock in the [catch] below.
-	    set pre [clock milliseconds]
-	    ##Log pre socket opened, - token $token
-	    ##Log $state(openCmd) - token $token
-	    set sock [namespace eval :: $state(openCmd)]
-	    set state(sock) $sock
-	    # Normal return from $state(openCmd) always returns a valid socket.
-	    # A TLS proxy connection with 407 or other failure from the
-	    # proxy server raises an error.
-
-	    # Initialisation of a new socket.
-	    ##Log post socket opened, - token $token
-	    ##Log socket opened, now fconfigure - token $token
-	    set delay [expr {[clock milliseconds] - $pre}]
-	    if {$delay > 3000} {
-		Log socket delay $delay - token $token
-	    }
-	    fconfigure $sock -translation {auto crlf} \
-			     -buffersize $state(-blocksize)
-	    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-		fconfigure $sock -profile tcl8
-	    }
-	    ##Log socket opened, DONE fconfigure - token $token
-        }
-
-        Log "Using $sock for $state(socketinfo) - token $token" \
-	    [expr {$state(-keepalive)?"keepalive":""}]
-
-        # Code above has set state(sock) $sock
-        ConfigureNewSocket $token $sockOld $DoLater
-        ##Log OpenSocket success $sock - token $token
-    } result errdict]} {
-	##Log OpenSocket failed $result - token $token
-	# There may be other requests in the socketPhQueue.
-	# Prepare socketPlayCmd so that Finish will replay them.
-	if {    ($state(-keepalive)) && (!$state(reusing))
-	     && [info exists socketPhQueue($sockOld)]
-	     && ($socketPhQueue($sockOld) ne {})
-	} {
-	    if {$socketMapping($state(socketinfo)) ne $sockOld} {
-		Log "WARNING: this code should not be reached.\
-			{$socketMapping($state(socketinfo)) ne $sockOld}"
-	    }
-	    set socketPlayCmd($state(socketinfo)) [list ReplayIfClose Wready {} $socketPhQueue($sockOld)]
-	    set socketPhQueue($sockOld) {}
-	}
-        if {[string range $result 0 20] eq {proxy connect failed:}} {
-	    # - The HTTPS proxy did not create a socket.  The pre-existing value
-	    #   (a "placeholder socket") is unchanged.
-	    # - The proxy returned a valid HTTP response to the failed CONNECT
-	    #   request, and http::SecureProxyConnect copied this to $token,
-	    #   and also set ${token}(connection) set to "close".
-	    # - Remove the error message $result so that Finish delivers this
-	    #   HTTP response to the caller.
-	    set result {}
-	}
-	Finish $token $result
-	# Because socket creation failed, the placeholder "socket" must be
-	# "closed" and (if persistent) removed from the persistent sockets
-	# table.  In the {proxy connect failed:} case Finish does this because
-	# the value of ${token}(connection) is "close". In the other cases here,
-	# it does so because $result is non-empty.
-    }
-    ##Log Leaving http::OpenSocket coroutine [info coroutine] - token $token
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc ::http::ConfigureNewSocket
-# ------------------------------------------------------------------------------
-# Command to initialise a newly-created socket.  Called only from OpenSocket.
-#
-# This command is called by OpenSocket whenever a genuine socket (sockNew) has
-# been opened for for use by HTTP.  It does two things:
-# (1) If $token uses a placeholder socket, this command replaces the placeholder
-#     socket with the real socket, not only in $token but in all other requests
-#     that use the same placeholder.
-# (2) It calls ScheduleRequest to schedule each request that uses the socket.
-#
-#
-# Value of sockOld/sockNew can be "sock" (genuine socket) or "ph" (placeholder).
-# sockNew is ${token}(sock)
-# sockOld   sockNew  CASES
-#  sock       sock   (if $reusing, and sockOld is sock)
-#  ph         sock   (if (not $reusing), and sockOld is ph)
-#  ph         ph     (if $reusing, and sockOld is ph) - not called in this case
-#  sock       ph     (cannot occur unless a bug)      - not called in this case
-#                    (if (not $reusing), and sockOld is sock) - illogical
-#
-# Arguments:
-# token         - connection token (name of an array)
-# sockOld       - handle or placeholder used for a socket before the call to
-#                 OpenSocket
-# DoLater       - dictionary of boolean values listing unfinished tasks
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::ConfigureNewSocket {token sockOld DoLater} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set reusing $state(reusing)
-    set sock $state(sock)
-    set proxyUsed $state(proxyUsed)
-    ##Log "  ConfigureNewSocket" $token $sockOld ... -- $reusing $sock $proxyUsed
-
-    if {(!$reusing) && ($sock ne $sockOld)} {
-        # Replace the placeholder value sockOld with sock.
-
-        if {    [info exists socketMapping($state(socketinfo))]
-             && ($socketMapping($state(socketinfo)) eq $sockOld)
-        } {
-            set socketMapping($state(socketinfo)) $sock
-            set socketProxyId($state(socketinfo)) $proxyUsed
-            # tokens that use the placeholder $sockOld are updated below.
-            ##Log set socketMapping($state(socketinfo)) $sock
-        }
-
-        # Now finish any tasks left over from PreparePersistentConnection on
-        # the connection.
-        #
-        # The "unset" traces are fired by init (clears entire arrays), and
-        # by http::Unset.
-        # Unset is called by CloseQueuedQueries and (possibly never) by geturl.
-        #
-        # CancelReadPipeline, CancelWritePipeline call http::Finish for each
-        # token.
-        #
-        # FIXME If Finish is placeholder-aware, these traces can be set earlier,
-        # in PreparePersistentConnection.
-
-        if {[dict get $DoLater -traceread]} {
-	    set varName ::http::socketRdState($state(socketinfo))
-	    trace add variable $varName unset ::http::CancelReadPipeline
-        }
-        if {[dict get $DoLater -tracewrite]} {
-	    set varName ::http::socketWrState($state(socketinfo))
-	    trace add variable $varName unset ::http::CancelWritePipeline
-        }
-    }
-
-    # Do this in all cases.
-    ScheduleRequest $token
-
-    # Now look at all other tokens that use the placeholder $sockOld.
-    if {    (!$reusing)
-         && ($sock ne $sockOld)
-         && [info exists socketPhQueue($sockOld)]
-    } {
-        ##Log "  ConfigureNewSocket" $token scheduled, now do $socketPhQueue($sockOld)
-        foreach tok $socketPhQueue($sockOld) {
-	    # 1. Amend the token's (sock).
-	    ##Log set ${tok}(sock) $sock
-	    set ${tok}(sock) $sock
-	    set ${tok}(proxyUsed) $proxyUsed
-
-	    # 2. Schedule the token's HTTP request.
-	    # Every token in socketPhQueue(*) has reusing 1 alreadyQueued 0.
-	    set ${tok}(reusing) 1
-	    set ${tok}(alreadyQueued) 0
-	    ScheduleRequest $tok
-	}
-	set socketPhQueue($sockOld) {}
-    }
-    ##Log "  ConfigureNewSocket" $token DONE
-
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-# The values of array variables socketMapping etc.
-# ------------------------------------------------------------------------------
-# connId                 "$host:$port"
-# socketMapping($connId) the handle or placeholder for the socket that is used
-#                        for "-keepalive 1" requests to $connId.
-# socketRdState($connId) the token that is currently reading from the socket.
-#                        Other values: Rready (ready for next token to read).
-# socketWrState($connId) the token that is currently writing to the socket.
-#                        Other values: Wready (ready for next token to write),
-#                        peNding (would be ready for next write, except that
-#                        the integrity of a non-pipelined transaction requires
-#                        waiting until the read(s) in progress are finished).
-# socketRdQueue($connId) List of tokens that are queued for reading later.
-# socketWrQueue($connId) List of tokens that are queued for writing later.
-# socketPhQueue($sock)   List of tokens that are queued to use a placeholder
-#                        socket, when the real socket has not yet been created.
-# socketClosing($connId) (boolean) true iff a server response header indicates
-#                        that the server will close the connection at the end of
-#                        the current response.
-# socketPlayCmd($connId) The command to execute to replay pending and
-#                        part-completed transactions if the socket closes early.
-# socketCoEvent($connId) Identifier for the "after idle" event that will launch
-#                        an OpenSocket coroutine to open or re-use a socket.
-# socketProxyId($connId) The type of proxy that this socket uses: values are
-#                        those of state(proxyUsed) i.e. none, HttpProxy,
-#                        SecureProxy, and SecureProxyFailed.
-#                        The value is not used for anything by http, its purpose
-#                        is to set the value of state() for caller information.
-# ------------------------------------------------------------------------------
-
-
-# ------------------------------------------------------------------------------
-# Using socketWrState(*), socketWrQueue(*), socketRdState(*), socketRdQueue(*)
-# ------------------------------------------------------------------------------
-# The element socketWrState($connId) has a value which is either the name of
-# the token that is permitted to write to the socket, or "Wready" if no
-# token is permitted to write.
-#
-# The code that sets the value to Wready immediately calls
-# http::NextPipelinedWrite, which examines socketWrQueue($connId) and
-# processes the next request in the queue, if there is one.  The value
-# Wready is not found when the interpreter is in the event loop unless the
-# socket is idle.
-#
-# The element socketRdState($connId) has a value which is either the name of
-# the token that is permitted to read from the socket, or "Rready" if no
-# token is permitted to read.
-#
-# The code that sets the value to Rready then examines
-# socketRdQueue($connId) and processes the next request in the queue, if
-# there is one.  The value Rready is not found when the interpreter is in
-# the event loop unless the socket is idle.
-# ------------------------------------------------------------------------------
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::ScheduleRequest
-# ------------------------------------------------------------------------------
-# Command to either begin the HTTP request, or add it to the appropriate queue.
-# Called from two places in ConfigureNewSocket.
-#
-# Arguments:
-# token         - connection token (name of an array)
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::ScheduleRequest {token} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    Log >L$tk ScheduleRequest
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    set Unfinished 0
-
-    set reusing $state(reusing)
-    set sockNew $state(sock)
-
-    # The "if" tests below: must test against the current values of
-    # socketWrState, socketRdState, and so the tests must be done here,
-    # not earlier in PreparePersistentConnection.
-
-    if {$state(alreadyQueued)} {
-	# The request has been appended to the queue of a persistent socket
-	# (that is scheduled to close and have its queue replayed).
-	#
-	# A write may or may not be in progress.  There is no need to set
-	# socketWrState to prevent another call stealing write access - all
-	# subsequent calls on this socket will come here because the socket
-	# will close after the current read, and its
-	# socketClosing($connId) is 1.
-	##Log "HTTP request for token $token is queued"
-
-    } elseif {    $reusing
-	       && $state(-pipeline)
-	       && ($socketWrState($state(socketinfo)) ne "Wready")
-    } {
-	##Log "HTTP request for token $token is queued for pipelined use"
-	lappend socketWrQueue($state(socketinfo)) $token
-
-    } elseif {    $reusing
-	       && (!$state(-pipeline))
-	       && ($socketWrState($state(socketinfo)) ne "Wready")
-    } {
-	# A write is queued or in progress.  Lappend to the write queue.
-	##Log "HTTP request for token $token is queued for nonpipeline use"
-	lappend socketWrQueue($state(socketinfo)) $token
-
-    } elseif {    $reusing
-	       && (!$state(-pipeline))
-	       && ($socketWrState($state(socketinfo)) eq "Wready")
-	       && ($socketRdState($state(socketinfo)) ne "Rready")
-    } {
-	# A read is queued or in progress, but not a write.  Cannot start the
-	# nonpipeline transaction, but must set socketWrState to prevent a
-	# pipelined request jumping the queue.
-	##Log "HTTP request for token $token is queued for nonpipeline use"
-	#Log re-use nonpipeline, GRANT delayed write access to $token in geturl
-	set socketWrState($state(socketinfo)) peNding
-	lappend socketWrQueue($state(socketinfo)) $token
-
-    } else {
-        if {$reusing && $state(-pipeline)} {
-	    #Log new, init for pipelined, GRANT write access to $token in geturl
-	    # DO NOT grant premature read access to the socket.
-            # set socketRdState($state(socketinfo)) $token
-            set socketWrState($state(socketinfo)) $token
-        } elseif {$reusing} {
-	    # socketWrState is not used by this non-pipelined transaction.
-	    # We cannot leave it as "Wready" because the next call to
-	    # http::geturl with a pipelined transaction would conclude that the
-	    # socket is available for writing.
-	    #Log new, init for nonpipeline, GRANT r/w access to $token in geturl
-            set socketRdState($state(socketinfo)) $token
-            set socketWrState($state(socketinfo)) $token
-        } else {
-        }
-
-	# Process the request now.
-	# - Command is not called unless $state(sock) is a real socket handle
-	#   and not a placeholder.
-	# - All (!$reusing) cases come here.
-	# - Some $reusing cases come here too if the connection is
-	#   marked as ready.  Those $reusing cases are:
-	#   $reusing && ($socketWrState($state(socketinfo)) eq "Wready") &&
-	#   EITHER !$pipeline && ($socketRdState($state(socketinfo)) eq "Rready")
-	#   OR      $pipeline
-	#
-	#Log ---- $state(socketinfo) << conn to $token for HTTP request (a)
-	##Log "  ScheduleRequest" $token -- fileevent $state(sock) writable for $token
-	# Connect does its own fconfigure.
-
-        lassign $state(connArgs) proto phost srvurl
-
-	if {[catch {
-		fileevent $state(sock) writable \
-			[list http::Connect $token $proto $phost $srvurl]
-	} res opts]} {
-	    # The socket no longer exists.
-	    ##Log bug -- socket gone -- $res -- $opts
-	}
-
-    }
-
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::SendHeader
-# ------------------------------------------------------------------------------
-# Command to send a request header, and keep a copy in state(requestHeaders)
-# for debugging purposes.
-#
-# Arguments:
-# token       - connection token (name of an array)
-# key         - header name
-# value       - header value
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::SendHeader {token key value} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    set sock $state(sock)
-    lappend state(requestHeaders) [string tolower $key] $value
-    puts $sock "$key: $value"
-    return
-}
-
-# http::Connected --
-#
-#	Callback used when the connection to the HTTP server is actually
-#	established.
-#
-# Arguments:
-#	token	State token.
-#	proto	What protocol (http, https, etc.) was used to connect.
-#	phost	Are we using keep-alive? Non-empty if yes.
-#	srvurl	Service-local URL that we're requesting
-# Results:
-#	None.
-
-proc http::Connected {token proto phost srvurl} {
-    variable http
-    variable urlTypes
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    if {$state(reusing) && (!$state(-pipeline)) && ($state(-timeout) > 0)} {
-	set state(after) [after $state(-timeout) \
-		[list http::reset $token timeout]]
-    }
-
-    # Set back the variables needed here.
-    set sock $state(sock)
-    set isQueryChannel [info exists state(-querychannel)]
-    set isQuery [info exists state(-query)]
-    regexp {^(.+):([^:]+)$} $state(socketinfo) {} host port
-
-    set lower [string tolower $proto]
-    set defport [lindex $urlTypes($lower) 0]
-
-    # Send data in cr-lf format, but accept any line terminators.
-    # Initialisation to {auto *} now done in geturl, KeepSocket and DoneRequest.
-    # We are concerned here with the request (write) not the response (read).
-    lassign [fconfigure $sock -translation] trRead trWrite
-    fconfigure $sock -translation [list $trRead crlf] \
-		     -buffersize $state(-blocksize)
-    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-	fconfigure $sock -profile tcl8
-    }
-
-    # The following is disallowed in safe interpreters, but the socket is
-    # already in non-blocking mode in that case.
-
-    catch {fconfigure $sock -blocking off}
-    set how GET
-    if {$isQuery} {
-	set state(querylength) [string length $state(-query)]
-	if {$state(querylength) > 0} {
-	    set how POST
-	    set contDone 0
-	} else {
-	    # There's no query data.
-	    unset state(-query)
-	    set isQuery 0
-	}
-    } elseif {$state(-validate)} {
-	set how HEAD
-    } elseif {$isQueryChannel} {
-	set how POST
-	# The query channel must be blocking for the async Write to
-	# work properly.
-	fconfigure $state(-querychannel) -blocking 1 -translation binary
-	set contDone 0
-    }
-    if {[info exists state(-method)] && ($state(-method) ne "")} {
-	set how $state(-method)
-    }
-    set accept_types_seen 0
-
-    Log ^B$tk begin sending request - token $token
-
-    if {[catch {
-	if {[info exists state(bypass)]} {
-	    set state(method) [lindex [split $state(bypass) { }] 0]
-	    set state(requestHeaders) {}
-	    set state(requestLine) $state(bypass)
-	} else {
-	    set state(method) $how
-	    set state(requestHeaders) {}
-	    set state(requestLine) "$how $srvurl HTTP/$state(-protocol)"
-	}
-	puts $sock $state(requestLine)
-	set hostValue [GetFieldValue $state(-headers) Host]
-	if {$hostValue ne {}} {
-	    # Allow Host spoofing. [Bug 928154]
-	    regexp {^[^:]+} $hostValue state(host)
-	    SendHeader $token Host $hostValue
-	} elseif {$port == $defport} {
-	    # Don't add port in this case, to handle broken servers. [Bug
-	    # #504508]
-	    set state(host) $host
-	    SendHeader $token Host $host
-	} else {
-	    set state(host) $host
-	    SendHeader $token Host "$host:$port"
-	}
-	SendHeader $token User-Agent $http(-useragent)
-	if {($state(-protocol) > 1.0) && $state(-keepalive)} {
-	    # Send this header, because a 1.1 server is not compelled to treat
-	    # this as the default.
-	    set ConnVal keep-alive
-	} elseif {($state(-protocol) > 1.0)} {
-	    # RFC2616 sec 8.1.2.1
-	    set ConnVal close
-	} else {
-	    # ($state(-protocol) <= 1.0)
-	    # RFC7230 A.1
-	    # Some server implementations of HTTP/1.0 have a faulty
-	    # implementation of RFC 2068 Keep-Alive.
-	    # Don't leave this to chance.
-	    # For HTTP/1.0 we have already "set state(connection) close"
-	    # and "state(-keepalive) 0".
-	    set ConnVal close
-	}
-        # Proxy authorisation (cf. mod by Anders Ramdahl to autoproxy by
-        # Pat Thoyts).
-        if {($http(-proxyauth) ne {}) && ($state(proxyUsed) eq {HttpProxy})} {
-	    SendHeader $token Proxy-Authorization $http(-proxyauth)
-        }
-	# RFC7230 A.1 - "clients are encouraged not to send the
-	# Proxy-Connection header field in any requests"
-	set accept_encoding_seen 0
-	set content_type_seen 0
-	set connection_seen 0
-	foreach {key value} $state(-headers) {
-	    set value [string map [list \n "" \r ""] $value]
-	    set key [string map {" " -} [string trim $key]]
-	    if {[string equal -nocase $key "host"]} {
-		continue
-	    }
-	    if {[string equal -nocase $key "accept-encoding"]} {
-		set accept_encoding_seen 1
-	    }
-	    if {[string equal -nocase $key "accept"]} {
-		set accept_types_seen 1
-	    }
-	    if {[string equal -nocase $key "content-type"]} {
-		set content_type_seen 1
-	    }
-	    if {[string equal -nocase $key "content-length"]} {
-		set contDone 1
-		set state(querylength) $value
-	    }
-	    if {    [string equal -nocase $key "connection"]
-	         && [info exists state(bypass)]
-	    } {
-		# Value supplied in -headers overrides $ConnVal.
-		set connection_seen 1
-	    } elseif {[string equal -nocase $key "connection"]} {
-		# Remove "close" or "keep-alive" and use our own value.
-		# In an upgrade request, the upgrade is not guaranteed.
-		# Value "close" or "keep-alive" tells the server what to do
-		# if it refuses the upgrade.  We send a single "Connection"
-		# header because some websocket servers, e.g. civetweb, reject
-		# multiple headers. Bug [d01de3281f] of tcllib/websocket.
-		set connection_seen 1
-		set listVal $state(connectionValues)
-		if {[set pos [lsearch $listVal close]] != -1} {
-		    set listVal [lreplace $listVal $pos $pos]
-		}
-		if {[set pos [lsearch $listVal keep-alive]] != -1} {
-		    set listVal [lreplace $listVal $pos $pos]
-		}
-		lappend listVal $ConnVal
-		set value [join $listVal {, }]
-	    }
-	    if {[string length $key]} {
-		SendHeader $token $key $value
-	    }
-	}
-	# Allow overriding the Accept header on a per-connection basis. Useful
-	# for working with REST services. [Bug c11a51c482]
-	if {!$accept_types_seen} {
-	    SendHeader $token Accept $state(accept-types)
-	}
-	if {    (!$accept_encoding_seen)
-	     && (![info exists state(-handler)])
-	     && $http(-zip)
-	} {
-	    SendHeader $token Accept-Encoding gzip,deflate
-	} elseif {!$accept_encoding_seen} {
-	    SendHeader $token Accept-Encoding identity
-	} else {
-	}
-	if {!$connection_seen} {
-	    SendHeader $token Connection $ConnVal
-	}
-	if {$isQueryChannel && ($state(querylength) == 0)} {
-	    # Try to determine size of data in channel. If we cannot seek, the
-	    # surrounding catch will trap us
-
-	    set start [tell $state(-querychannel)]
-	    seek $state(-querychannel) 0 end
-	    set state(querylength) \
-		    [expr {[tell $state(-querychannel)] - $start}]
-	    seek $state(-querychannel) $start
-	}
-
-	# Note that we don't do Cookie2; that's much nastier and not normally
-	# observed in practice either. It also doesn't fix the multitude of
-	# bugs in the basic cookie spec.
-	if {$http(-cookiejar) ne ""} {
-	    set cookies ""
-	    set separator ""
-	    foreach {key value} [{*}$http(-cookiejar) \
-		    getCookies $proto $host $state(path)] {
-		append cookies $separator $key = $value
-		set separator "; "
-	    }
-	    if {$cookies ne ""} {
-		SendHeader $token Cookie $cookies
-	    }
-	}
-
-	# Flush the request header and set up the fileevent that will either
-	# push the POST data or read the response.
-	#
-	# fileevent note:
-	#
-	# It is possible to have both the read and write fileevents active at
-	# this point. The only scenario it seems to affect is a server that
-	# closes the connection without reading the POST data. (e.g., early
-	# versions TclHttpd in various error cases). Depending on the
-	# platform, the client may or may not be able to get the response from
-	# the server because of the error it will get trying to write the post
-	# data. Having both fileevents active changes the timing and the
-	# behavior, but no two platforms (among Solaris, Linux, and NT) behave
-	# the same, and none behave all that well in any case. Servers should
-	# always read their POST data if they expect the client to read their
-	# response.
-
-	if {$isQuery || $isQueryChannel} {
-	    # POST method.
-	    if {!$content_type_seen} {
-		SendHeader $token Content-Type $state(-type)
-	    }
-	    if {!$contDone} {
-		SendHeader $token Content-Length $state(querylength)
-	    }
-	    puts $sock ""
-	    flush $sock
-	    # Flush flushes the error in the https case with a bad handshake:
-	    # else the socket never becomes writable again, and hangs until
-	    # timeout (if any).
-
-	    lassign [fconfigure $sock -translation] trRead trWrite
-	    fconfigure $sock -translation [list $trRead binary]
-	    fileevent $sock writable [list http::Write $token]
-	    # The http::Write command decides when to make the socket readable,
-	    # using the same test as the GET/HEAD case below.
-	} else {
-	    # GET or HEAD method.
-	    if {    (![catch {fileevent $sock readable} binding])
-		 && ($binding eq [list http::CheckEof $sock])
-	    } {
-		# Remove the "fileevent readable" binding of an idle persistent
-		# socket to http::CheckEof.  We can no longer treat bytes
-		# received as junk. The server might still time out and
-		# half-close the socket if it has not yet received the first
-		# "puts".
-		fileevent $sock readable {}
-	    }
-	    puts $sock ""
-	    flush $sock
-	    Log ^C$tk end sending request - token $token
-	    # End of writing (GET/HEAD methods).  The request has been sent.
-
-	    DoneRequest $token
-	}
-
-    } err]} {
-	# The socket probably was never connected, OR the connection dropped
-	# later, OR https handshake error, which may be discovered as late as
-	# the "flush" command above...
-	Log "WARNING - if testing, pay special attention to this\
-		case (GI) which is seldom executed - token $token"
-	if {[info exists state(reusing)] && $state(reusing)} {
-	    # The socket was closed at the server end, and closed at
-	    # this end by http::CheckEof.
-    	    if {[TestForReplay $token write $err a]} {
-		return
-	    } else {
-		Finish $token {failed to re-use socket}
-	    }
-
-	    # else:
-	    # This is NOT a persistent socket that has been closed since its
-	    # last use.
-	    # If any other requests are in flight or pipelined/queued, they will
-	    # be discarded.
-	} elseif {$state(status) eq ""} {
-	    # https handshake errors come here, for
-	    # Tcl 8.7 without http::SecureProxyConnect, and for Tcl 8.6.
-	    set msg [registerError $sock]
-	    registerError $sock {}
-	    if {$msg eq {}} {
-		set msg {failed to use socket}
-	    }
-	    Finish $token $msg
-	} elseif {$state(status) ne "error"} {
-	    Finish $token $err
-	}
-    }
-    return
-}
-
-# http::registerError
-#
-#	Called (for example when processing TclTLS activity) to register
-#	an error for a connection on a specific socket.  This helps
-#	http::Connected to deliver meaningful error messages, e.g. when a TLS
-#	certificate fails verification.
-#
-#	Usage: http::registerError socket ?newValue?
-#
-#	"set" semantics, except that a "get" (a call without a new value) for a
-#	non-existent socket returns {}, not an error.
-
-proc http::registerError {sock args} {
-    variable registeredErrors
-
-    if {    ([llength $args] == 0)
-	 && (![info exists registeredErrors($sock)])
-    } {
-	return
-    } elseif {    ([llength $args] == 1)
-	       && ([lindex $args 0] eq {})
-    } {
-	unset -nocomplain registeredErrors($sock)
-	return
-    }
-    set registeredErrors($sock) {*}$args
-}
-
-# http::DoneRequest --
-#
-#	Command called when a request has been sent.  It will arrange the
-#	next request and/or response as appropriate.
-#
-#	If this command is called when $socketClosing(*), the request $token
-#	that calls it must be pipelined and destined to fail.
-
-proc http::DoneRequest {token} {
-    variable http
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    set sock $state(sock)
-
-    # If pipelined, connect the next HTTP request to the socket.
-    if {$state(reusing) && $state(-pipeline)} {
-	# Enable next token (if any) to write.
-	# The value "Wready" is set only here, and
-	# in http::Event after reading the response-headers of a
-	# non-reusing transaction.
-	# Previous value is $token. It cannot be pending.
-	set socketWrState($state(socketinfo)) Wready
-
-	# Now ready to write the next pipelined request (if any).
-	http::NextPipelinedWrite $token
-    } else {
-	# If pipelined, this is the first transaction on this socket.  We wait
-	# for the response headers to discover whether the connection is
-	# persistent.  (If this is not done and the connection is not
-	# persistent, we SHOULD retry and then MUST NOT pipeline before knowing
-	# that we have a persistent connection
-	# (rfc2616 8.1.2.2)).
-    }
-
-    # Connect to receive the response, unless the socket is pipelined
-    # and another response is being sent.
-    # This code block is separate from the code below because there are
-    # cases where socketRdState already has the value $token.
-    if {    $state(-keepalive)
-	 && $state(-pipeline)
-	 && [info exists socketRdState($state(socketinfo))]
-	 && ($socketRdState($state(socketinfo)) eq "Rready")
-    } {
-	#Log pipelined, GRANT read access to $token in Connected
-	set socketRdState($state(socketinfo)) $token
-    }
-
-    if {    $state(-keepalive)
-	 && $state(-pipeline)
-	 && [info exists socketRdState($state(socketinfo))]
-	 && ($socketRdState($state(socketinfo)) ne $token)
-    } {
-	# Do not read from the socket until it is ready.
-	##Log "HTTP response for token $token is queued for pipelined use"
-	# If $socketClosing(*), then the caller will be a pipelined write and
-	# execution will come here.
-	# This token has already been recorded as "in flight" for writing.
-	# When the socket is closed, the read queue will be cleared in
-	# CloseQueuedQueries and so the "lappend" here has no effect.
-	lappend socketRdQueue($state(socketinfo)) $token
-    } else {
-	# In the pipelined case, connection for reading depends on the
-	# value of socketRdState.
-	# In the nonpipeline case, connection for reading always occurs.
-	ReceiveResponse $token
-    }
-    return
-}
-
-# http::ReceiveResponse
-#
-#	Connects token to its socket for reading.
-
-proc http::ReceiveResponse {token} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    set sock $state(sock)
-
-    #Log ---- $state(socketinfo) >> conn to $token for HTTP response
-    lassign [fconfigure $sock -translation] trRead trWrite
-    fconfigure $sock -translation [list auto $trWrite] \
-		     -buffersize $state(-blocksize)
-    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-	fconfigure $sock -profile tcl8
-    }
-    Log ^D$tk begin receiving response - token $token
-
-    coroutine ${token}--EventCoroutine http::Event $sock $token
-    if {[info exists state(-handler)] || [info exists state(-progress)]} {
-        fileevent $sock readable [list http::EventGateway $sock $token]
-    } else {
-        fileevent $sock readable ${token}--EventCoroutine
-    }
-    return
-}
-
-
-# http::EventGateway
-#
-#	Bug [c2dc1da315].
-#	- Recursive launch of the coroutine can occur if a -handler or -progress
-#	  callback is used, and the callback command enters the event loop.
-#	- To prevent this, the fileevent "binding" is disabled while the
-#	  coroutine is in flight.
-#	- If a recursive call occurs despite these precautions, it is not
-#	  trapped and discarded here, because it is better to report it as a
-#	  bug.
-#	- Although this solution is believed to be sufficiently general, it is
-#	  used only if -handler or -progress is specified.  In other cases,
-#	  the coroutine is called directly.
-
-proc http::EventGateway {sock token} {
-    variable $token
-    upvar 0 $token state
-    fileevent $sock readable {}
-    catch {${token}--EventCoroutine} res opts
-    if {[info commands ${token}--EventCoroutine] ne {}} {
-        # The coroutine can be deleted by completion (a non-yield return), by
-        # http::Finish (when there is a premature end to the transaction), by
-        # http::reset or http::cleanup, or if the caller set option -channel
-        # but not option -handler: in the last case reading from the socket is
-        # now managed by commands ::http::Copy*, http::ReceiveChunked, and
-        # http::MakeTransformationChunked.
-        #
-        # Catch in case the coroutine has closed the socket.
-        catch {fileevent $sock readable [list http::EventGateway $sock $token]}
-    }
-
-    # If there was an error, re-throw it.
-    return -options $opts $res
-}
-
-
-# http::NextPipelinedWrite
-#
-# - Connecting a socket to a token for writing is done by this command and by
-#   command KeepSocket.
-# - If another request has a pipelined write scheduled for $token's socket,
-#   and if the socket is ready to accept it, connect the write and update
-#   the queue accordingly.
-# - This command is called from http::DoneRequest and http::Event,
-#   IF $state(-pipeline) AND (the current transfer has reached the point at
-#   which the socket is ready for the next request to be written).
-# - This command is called when a token has write access and is pipelined and
-#   keep-alive, and sets socketWrState to Wready.
-# - The command need not consider the case where socketWrState is set to a token
-#   that does not yet have write access.  Such a token is waiting for Rready,
-#   and the assignment of the connection to the token will be done elsewhere (in
-#   http::KeepSocket).
-# - This command cannot be called after socketWrState has been set to a
-#   "pending" token value (that is then overwritten by the caller), because that
-#   value is set by this command when it is called by an earlier token when it
-#   relinquishes its write access, and the pending token is always the next in
-#   line to write.
-
-proc http::NextPipelinedWrite {token} {
-    variable http
-    variable socketRdState
-    variable socketWrState
-    variable socketWrQueue
-    variable socketClosing
-    variable $token
-    upvar 0 $token state
-    set connId $state(socketinfo)
-
-    if {    [info exists socketClosing($connId)]
-	 && $socketClosing($connId)
-    } {
-	# socketClosing(*) is set because the server has sent a
-	# "Connection: close" header.
-	# Behave as if the queues are empty - so do nothing.
-    } elseif {    $state(-pipeline)
-	 && [info exists socketWrState($connId)]
-	 && ($socketWrState($connId) eq "Wready")
-
-	 && [info exists socketWrQueue($connId)]
-	 && [llength $socketWrQueue($connId)]
-	 && ([set token2 [lindex $socketWrQueue($connId) 0]
-	      set ${token2}(-pipeline)
-	     ]
-	    )
-    } {
-	# - The usual case for a pipelined connection, ready for a new request.
-	#Log pipelined, GRANT write access to $token2 in NextPipelinedWrite
-	set conn [set ${token2}(connArgs)]
-	set socketWrState($connId) $token2
-	set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	# Connect does its own fconfigure.
-	fileevent $state(sock) writable [list http::Connect $token2 {*}$conn]
-	#Log ---- $connId << conn to $token2 for HTTP request (b)
-
-	# In the tests below, the next request will be nonpipeline.
-    } elseif {    $state(-pipeline)
-	       && [info exists socketWrState($connId)]
-	       && ($socketWrState($connId) eq "Wready")
-
-	       && [info exists socketWrQueue($connId)]
-	       && [llength $socketWrQueue($connId)]
-	       && (![ set token3 [lindex $socketWrQueue($connId) 0]
-		      set ${token3}(-pipeline)
-		    ]
-		  )
-
-	       && [info exists socketRdState($connId)]
-	       && ($socketRdState($connId) eq "Rready")
-    } {
-	# The case in which the next request will be non-pipelined, and the read
-	# and write queues is ready: which is the condition for a non-pipelined
-	# write.
-	set conn [set ${token3}(connArgs)]
-	#Log nonpipeline, GRANT r/w access to $token3 in NextPipelinedWrite
-	set socketRdState($connId) $token3
-	set socketWrState($connId) $token3
-	set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
-	# Connect does its own fconfigure.
-	fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
-	#Log ---- $state(sock) << conn to $token3 for HTTP request (c)
-
-    } elseif {    $state(-pipeline)
-	 && [info exists socketWrState($connId)]
-	 && ($socketWrState($connId) eq "Wready")
-
-	 && [info exists socketWrQueue($connId)]
-	 && [llength $socketWrQueue($connId)]
-	 && (![set token2 [lindex $socketWrQueue($connId) 0]
-	      set ${token2}(-pipeline)
-	     ]
-	    )
-    } {
-	# - The case in which the next request will be non-pipelined, but the
-	#   read queue is NOT ready.
-	# - A read is queued or in progress, but not a write.  Cannot start the
-	#   nonpipeline transaction, but must set socketWrState to prevent a new
-	#   pipelined request (in http::geturl) jumping the queue.
-	# - Because socketWrState($connId) is not set to Wready, the assignment
-	#   of the connection to $token2 will be done elsewhere - by command
-	#   http::KeepSocket when $socketRdState($connId) is set to "Rready".
-
-	#Log re-use nonpipeline, GRANT delayed write access to $token in NextP..
-	set socketWrState($connId) peNding
-    }
-    return
-}
-
-# http::CancelReadPipeline
-#
-#	Cancel pipelined responses on a closing "Keep-Alive" socket.
-#
-#	- Called by a variable trace on "unset socketRdState($connId)".
-#	- The variable relates to a Keep-Alive socket, which has been closed.
-#	- Cancels all pipelined responses. The requests have been sent,
-#	  the responses have not yet been received.
-#	- This is a hard cancel that ends each transaction with error status,
-#	  and closes the connection. Do not use it if you want to replay failed
-#	  transactions.
-#	- N.B. Always delete ::http::socketRdState($connId) before deleting
-#	  ::http::socketRdQueue($connId), or this command will do nothing.
-#
-# Arguments
-#	As for a trace command on a variable.
-
-proc http::CancelReadPipeline {name1 connId op} {
-    variable socketRdQueue
-    ##Log CancelReadPipeline $name1 $connId $op
-    if {[info exists socketRdQueue($connId)]} {
-	set msg {the connection was closed by CancelReadPipeline}
-	foreach token $socketRdQueue($connId) {
-	    set tk [namespace tail $token]
-	    Log ^X$tk end of response "($msg)" - token $token
-	    set ${token}(status) eof
-	    Finish $token ;#$msg
-	}
-	set socketRdQueue($connId) {}
-    }
-    return
-}
-
-# http::CancelWritePipeline
-#
-#	Cancel queued events on a closing "Keep-Alive" socket.
-#
-#	- Called by a variable trace on "unset socketWrState($connId)".
-#	- The variable relates to a Keep-Alive socket, which has been closed.
-#	- In pipelined or nonpipeline case: cancels all queued requests.  The
-#	  requests have not yet been sent, the responses are not due.
-#	- This is a hard cancel that ends each transaction with error status,
-#	  and closes the connection. Do not use it if you want to replay failed
-#	  transactions.
-#	- N.B. Always delete ::http::socketWrState($connId) before deleting
-#	  ::http::socketWrQueue($connId), or this command will do nothing.
-#
-# Arguments
-#	As for a trace command on a variable.
-
-proc http::CancelWritePipeline {name1 connId op} {
-    variable socketWrQueue
-
-    ##Log CancelWritePipeline $name1 $connId $op
-    if {[info exists socketWrQueue($connId)]} {
-	set msg {the connection was closed by CancelWritePipeline}
-	foreach token $socketWrQueue($connId) {
-	    set tk [namespace tail $token]
-	    Log ^X$tk end of response "($msg)" - token $token
-	    set ${token}(status) eof
-	    Finish $token ;#$msg
-	}
-	set socketWrQueue($connId) {}
-    }
-    return
-}
-
-# http::ReplayIfDead --
-#
-# - A query on a re-used persistent socket failed at the earliest opportunity,
-#   because the socket had been closed by the server.  Keep the token, tidy up,
-#   and try to connect on a fresh socket.
-# - The connection is monitored for eof by the command http::CheckEof.  Thus
-#   http::ReplayIfDead is needed only when a server event (half-closing an
-#   apparently idle connection), and a client event (sending a request) occur at
-#   almost the same time, and neither client nor server detects the other's
-#   action before performing its own (an "asynchronous close event").
-# - To simplify testing of http::ReplayIfDead, set TEST_EOF 1 in
-#   http::KeepSocket, and then http::ReplayIfDead will be called if http::geturl
-#   is called at any time after the server timeout.
-#
-# Arguments:
-#	token	Connection token.
-#
-# Side Effects:
-#	Use the same token, but try to open a new socket.
-
-proc http::ReplayIfDead {token doing} {
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-
-    Log running http::ReplayIfDead for $token $doing
-
-    # 1. Merge the tokens for transactions in flight, the read (response) queue,
-    #    and the write (request) queue.
-
-    set InFlightR {}
-    set InFlightW {}
-
-    # Obtain the tokens for transactions in flight.
-    if {$state(-pipeline)} {
-	# Two transactions may be in flight.  The "read" transaction was first.
-	# It is unlikely that the server would close the socket if a response
-	# was pending; however, an earlier request (as well as the present
-	# request) may have been sent and ignored if the socket was half-closed
-	# by the server.
-
-	if {    [info exists socketRdState($state(socketinfo))]
-	     && ($socketRdState($state(socketinfo)) ne "Rready")
-	} {
-	    lappend InFlightR $socketRdState($state(socketinfo))
-	} elseif {($doing eq "read")} {
-	    lappend InFlightR $token
-	}
-
-	if {    [info exists socketWrState($state(socketinfo))]
-	     && $socketWrState($state(socketinfo)) ni {Wready peNding}
-	} {
-	    lappend InFlightW $socketWrState($state(socketinfo))
-	} elseif {($doing eq "write")} {
-	    lappend InFlightW $token
-	}
-
-	# Report any inconsistency of $token with socket*state.
-	if {    ($doing eq "read")
-	     && [info exists socketRdState($state(socketinfo))]
-	     && ($token ne $socketRdState($state(socketinfo)))
-	} {
-	    Log WARNING - ReplayIfDead pipelined token $token $doing \
-		    ne socketRdState($state(socketinfo)) \
-		      $socketRdState($state(socketinfo))
-
-	} elseif {
-		($doing eq "write")
-	     && [info exists socketWrState($state(socketinfo))]
-	     && ($token ne $socketWrState($state(socketinfo)))
-	} {
-	    Log WARNING - ReplayIfDead pipelined token $token $doing \
-		    ne socketWrState($state(socketinfo)) \
-		      $socketWrState($state(socketinfo))
-	}
-    } else {
-	# One transaction should be in flight.
-	# socketRdState, socketWrQueue are used.
-	# socketRdQueue should be empty.
-
-	# Report any inconsistency of $token with socket*state.
-	if {$token ne $socketRdState($state(socketinfo))} {
-	    Log WARNING - ReplayIfDead nonpipeline token $token $doing \
-		    ne socketRdState($state(socketinfo)) \
-		      $socketRdState($state(socketinfo))
-	}
-
-	# Report the inconsistency that socketRdQueue is non-empty.
-	if {    [info exists socketRdQueue($state(socketinfo))]
-	     && ($socketRdQueue($state(socketinfo)) ne {})
-	} {
-	    Log WARNING - ReplayIfDead nonpipeline token $token $doing \
-		    has read queue socketRdQueue($state(socketinfo)) \
-		    $socketRdQueue($state(socketinfo)) ne {}
-	}
-
-	lappend InFlightW $socketRdState($state(socketinfo))
-	set socketRdQueue($state(socketinfo)) {}
-    }
-
-    set newQueue {}
-    lappend newQueue {*}$InFlightR
-    lappend newQueue {*}$socketRdQueue($state(socketinfo))
-    lappend newQueue {*}$InFlightW
-    lappend newQueue {*}$socketWrQueue($state(socketinfo))
-
-
-    # 2. Tidy up token.  This is a cut-down form of Finish/CloseSocket.
-    #    Do not change state(status).
-    #    No need to after cancel state(after) - either this is done in
-    #    ReplayCore/ReInit, or Finish is called.
-
-    catch {close $state(sock)}
-    Unset $state(socketinfo)
-
-    # 2a. Tidy the tokens in the queues - this is done in ReplayCore/ReInit.
-    # - Transactions, if any, that are awaiting responses cannot be completed.
-    #   They are listed for re-sending in newQueue.
-    # - All tokens are preserved for re-use by ReplayCore, and their variables
-    #   will be re-initialised by calls to ReInit.
-    # - The relevant element of socketMapping, socketRdState, socketWrState,
-    #   socketRdQueue, socketWrQueue, socketClosing, socketPlayCmd will be set
-    #   to new values in ReplayCore.
-
-    ReplayCore $newQueue
-    return
-}
-
-# http::ReplayIfClose --
-#
-#	A request on a socket that was previously "Connection: keep-alive" has
-#	received a "Connection: close" response header.  The server supplies
-#	that response correctly, but any later requests already queued on this
-#	connection will be lost when the socket closes.
-#
-#	This command takes arguments that represent the socketWrState,
-#	socketRdQueue and socketWrQueue for this connection.  The socketRdState
-#	is not needed because the server responds in full to the request that
-#	received the "Connection: close" response header.
-#
-#	Existing request tokens $token (::http::$n) are preserved.  The caller
-#	will be unaware that the request was processed this way.
-
-proc http::ReplayIfClose {Wstate Rqueue Wqueue} {
-    Log running http::ReplayIfClose for $Wstate $Rqueue $Wqueue
-
-    if {$Wstate in $Rqueue || $Wstate in $Wqueue} {
-	Log WARNING duplicate token in http::ReplayIfClose - token $Wstate
-	set Wstate Wready
-    }
-
-    # 1. Create newQueue
-    set InFlightW {}
-    if {$Wstate ni {Wready peNding}} {
-	lappend InFlightW $Wstate
-    }
-    ##Log $Rqueue -- $InFlightW -- $Wqueue
-    set newQueue {}
-    lappend newQueue {*}$Rqueue
-    lappend newQueue {*}$InFlightW
-    lappend newQueue {*}$Wqueue
-
-    # 2. Cleanup - none needed, done by the caller.
-
-    ReplayCore $newQueue
-    return
-}
-
-# http::ReInit --
-#
-#	Command to restore a token's state to a condition that
-#	makes it ready to replay a request.
-#
-#	Command http::geturl stores extra state in state(tmp*) so
-#	we don't need to do the argument processing again.
-#
-#	The caller must:
-#	- Set state(reusing) and state(sock) to their new values after calling
-#	  this command.
-#	- Unset state(tmpState), state(tmpOpenCmd) if future calls to ReplayCore
-#	  or ReInit are inappropriate for this token. Typically only one retry
-#	  is allowed.
-#	The caller may also unset state(tmpConnArgs) if this value (and the
-#	token) will be used immediately.  The value is needed by tokens that
-#	will be stored in a queue.
-#
-# Arguments:
-#	token	Connection token.
-#
-# Return Value: (boolean) true iff the re-initialisation was successful.
-
-proc http::ReInit {token} {
-    variable $token
-    upvar 0 $token state
-
-    if {!(
-	      [info exists state(tmpState)]
-	   && [info exists state(tmpOpenCmd)]
-	   && [info exists state(tmpConnArgs)]
-	 )
-    } {
-	Log FAILED in http::ReInit via ReplayCore - NO tmp vars for $token
-	return 0
-    }
-
-    if {[info exists state(after)]} {
-	after cancel $state(after)
-	unset state(after)
-    }
-    if {[info exists state(socketcoro)]} {
-        Log $token Cancel socket after-idle event (ReInit)
-        after cancel $state(socketcoro)
-        unset state(socketcoro)
-    }
-
-    # Don't alter state(status) - this would trigger http::wait if it is in use.
-    set tmpState    $state(tmpState)
-    set tmpOpenCmd  $state(tmpOpenCmd)
-    set tmpConnArgs $state(tmpConnArgs)
-    foreach name [array names state] {
-	if {$name ne "status"} {
-	    unset state($name)
-	}
-    }
-
-    # Don't alter state(status).
-    # Restore state(tmp*) - the caller may decide to unset them.
-    # Restore state(tmpConnArgs) which is needed for connection.
-    # state(tmpState), state(tmpOpenCmd) are needed only for retries.
-
-    dict unset tmpState status
-    array set state $tmpState
-    set state(tmpState)    $tmpState
-    set state(tmpOpenCmd)  $tmpOpenCmd
-    set state(tmpConnArgs) $tmpConnArgs
-
-    return 1
-}
-
-# http::ReplayCore --
-#
-#	Command to replay a list of requests, using existing connection tokens.
-#
-#	Abstracted from http::geturl which stores extra state in state(tmp*) so
-#	we don't need to do the argument processing again.
-#
-# Arguments:
-#	newQueue	List of connection tokens.
-#
-# Side Effects:
-#	Use existing tokens, but try to open a new socket.
-
-proc http::ReplayCore {newQueue} {
-    variable TmpSockCounter
-
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    if {[llength $newQueue] == 0} {
-	# Nothing to do.
-	return
-    }
-
-    ##Log running ReplayCore for {*}$newQueue
-    set newToken [lindex $newQueue 0]
-    set newQueue [lrange $newQueue 1 end]
-
-    # 3. Use newToken, and restore its values of state(*).  Do not restore
-    #    elements tmp* - we try again only once.
-
-    set token $newToken
-    variable $token
-    upvar 0 $token state
-
-    if {![ReInit $token]} {
-	Log FAILED in http::ReplayCore - NO tmp vars
-	Log ReplayCore reject $token
-	Finish $token {cannot send this request again}
-	return
-    }
-
-    set tmpState    $state(tmpState)
-    set tmpOpenCmd  $state(tmpOpenCmd)
-    set tmpConnArgs $state(tmpConnArgs)
-    unset state(tmpState)
-    unset state(tmpOpenCmd)
-    unset state(tmpConnArgs)
-
-    set state(reusing) 0
-    set state(ReusingPlaceholder) 0
-    set state(alreadyQueued) 0
-    Log ReplayCore replay $token
-
-    # Give the socket a placeholder name before it is created.
-    set sock HTTP_PLACEHOLDER_[incr TmpSockCounter]
-    set state(sock) $sock
-
-    # Move the $newQueue into the placeholder socket's socketPhQueue.
-    set socketPhQueue($sock) {}
-    foreach tok $newQueue {
-	if {[ReInit $tok]} {
-	    set ${tok}(reusing) 1
-	    set ${tok}(sock) $sock
-	    lappend socketPhQueue($sock) $tok
-	    Log ReplayCore replay $tok
-	} else {
-	    Log ReplayCore reject $tok
-	    set ${tok}(reusing) 1
-	    set ${tok}(sock) NONE
-	    Finish $tok {cannot send this request again}
-	}
-    }
-
-    AsyncTransaction $token
-
-    return
-}
-
-# Data access functions:
-# Data - the URL data
-# Status - the transaction status: ok, reset, eof, timeout, error
-# Code - the HTTP transaction code, e.g., 200
-# Size - the size of the URL data
-
-proc http::responseBody {token} {
-    variable $token
-    upvar 0 $token state
-    return $state(body)
-}
-proc http::status {token} {
-    if {![info exists $token]} {
-	return "error"
-    }
-    variable $token
-    upvar 0 $token state
-    return $state(status)
-}
-proc http::responseLine {token} {
-    variable $token
-    upvar 0 $token state
-    return $state(http)
-}
-proc http::requestLine {token} {
-    variable $token
-    upvar 0 $token state
-    return $state(requestLine)
-}
-proc http::responseCode {token} {
-    variable $token
-    upvar 0 $token state
-    if {[regexp {[0-9]{3}} $state(http) numeric_code]} {
-	return $numeric_code
-    } else {
-	return $state(http)
-    }
-}
-proc http::size {token} {
-    variable $token
-    upvar 0 $token state
-    return $state(currentsize)
-}
-proc http::requestHeaders {token args} {
-    set lenny  [llength $args]
-    if {$lenny > 1} {
-        return -code error {usage: ::http::requestHeaders token ?headerName?}
-    } else {
-        return [Meta $token request {*}$args]
-    }
-}
-proc http::responseHeaders {token args} {
-    set lenny  [llength $args]
-    if {$lenny > 1} {
-        return -code error {usage: ::http::responseHeaders token ?headerName?}
-    } else {
-        return [Meta $token response {*}$args]
-    }
-}
-proc http::requestHeaderValue {token header} {
-    Meta $token request $header VALUE
-}
-proc http::responseHeaderValue {token header} {
-    Meta $token response $header VALUE
-}
-proc http::Meta {token who args} {
-    variable $token
-    upvar 0 $token state
-
-    if {$who eq {request}} {
-        set whom requestHeaders
-    } elseif {$who eq {response}} {
-        set whom meta
-    } else {
-        return -code error {usage: ::http::Meta token request|response ?headerName ?VALUE??}
-    }
-
-    set header [string tolower [lindex $args 0]]
-    set how    [string tolower [lindex $args 1]]
-    set lenny  [llength $args]
-    if {$lenny == 0} {
-        return $state($whom)
-    } elseif {($lenny > 2) || (($lenny == 2) && ($how ne {value}))} {
-        return -code error {usage: ::http::Meta token request|response ?headerName ?VALUE??}
-    } else {
-        set result {}
-        set combined {}
-        foreach {key value} $state($whom) {
-            if {$key eq $header} {
-                lappend result $key $value
-                append combined $value {, }
-            }
-        }
-        if {$lenny == 1} {
-            return $result
-        } else {
-            return [string range $combined 0 end-2]
-        }
-    }
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::responseInfo
-# ------------------------------------------------------------------------------
-# Command to return a dictionary of the most useful metadata of a HTTP
-# response.
-#
-# Arguments:
-# token       - connection token (name of an array)
-#
-# Return Value: a dict. See man page http(n) for a description of each item.
-# ------------------------------------------------------------------------------
-
-proc http::responseInfo {token} {
-    variable $token
-    upvar 0 $token state
-    set result {}
-    foreach {key origin name} {
-        stage                 STATE  state
-        status                STATE  status
-        responseCode          STATE  responseCode
-        reasonPhrase          STATE  reasonPhrase
-        contentType           STATE  type
-        binary                STATE  binary
-        redirection           RESP   location
-        upgrade               STATE  upgrade
-        error                 ERROR  -
-        postError             STATE  posterror
-        method                STATE  method
-        charset               STATE  charset
-        compression           STATE  coding
-        httpRequest           STATE  -protocol
-        httpResponse          STATE  httpResponse
-        url                   STATE  url
-        connectionRequest     REQ    connection
-        connectionResponse    RESP   connection
-        connectionActual      STATE  connection
-        transferEncoding      STATE  transfer
-        totalPost             STATE  querylength
-        currentPost           STATE  queryoffset
-        totalSize             STATE  totalsize
-        currentSize           STATE  currentsize
-        proxyUsed             STATE  proxyUsed
-    } {
-        if {$origin eq {STATE}} {
-            if {[info exists state($name)]} {
-                dict set result $key $state($name)
-            } else {
-                # Should never come here
-                dict set result $key {}
-            }
-        } elseif {$origin eq {REQ}} {
-            dict set result $key [requestHeaderValue $token $name]
-        } elseif {$origin eq {RESP}} {
-            dict set result $key [responseHeaderValue $token $name]
-        } elseif {$origin eq {ERROR}} {
-            # Don't flood the dict with data.  The command ::http::error is
-            # available.
-            if {[info exists state(error)]} {
-                set msg [lindex $state(error) 0]
-            } else {
-                set msg {}
-            }
-            dict set result $key $msg
-        } else {
-            # Should never come here
-            dict set result $key {}
-        }
-    }
-    return $result
-}
-proc http::error {token} {
-    variable $token
-    upvar 0 $token state
-    if {[info exists state(error)]} {
-	return $state(error)
-    }
-    return
-}
-proc http::postError {token} {
-    variable $token
-    upvar 0 $token state
-    if {[info exists state(postErrorFull)]} {
-	return $state(postErrorFull)
-    }
-    return
-}
-
-# http::cleanup
-#
-#	Garbage collect the state associated with a transaction
-#
-# Arguments
-#	token	The token returned from http::geturl
-#
-# Side Effects
-#	Unsets the state array.
-
-proc http::cleanup {token} {
-    variable $token
-    upvar 0 $token state
-    if {[info commands ${token}--EventCoroutine] ne {}} {
-	rename ${token}--EventCoroutine {}
-    }
-    if {[info commands ${token}--SocketCoroutine] ne {}} {
-	rename ${token}--SocketCoroutine {}
-    }
-    if {[info exists state(after)]} {
-	after cancel $state(after)
-	unset state(after)
-    }
-    if {[info exists state(socketcoro)]} {
-        Log $token Cancel socket after-idle event (cleanup)
-        after cancel $state(socketcoro)
-        unset state(socketcoro)
-    }
-    if {[info exists state]} {
-	unset state
-    }
-    return
-}
-
-# http::Connect
-#
-#	This callback is made when an asynchronous connection completes.
-#
-# Arguments
-#	token	The token returned from http::geturl
-#
-# Side Effects
-#	Sets the status of the connection, which unblocks
-# 	the waiting geturl call
-
-proc http::Connect {token proto phost srvurl} {
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-
-    if {[catch {eof $state(sock)} tmp] || $tmp} {
-        set err "due to unexpected EOF"
-    } elseif {[set err [fconfigure $state(sock) -error]] ne ""} {
-        # set err is done in test
-    } else {
-        # All OK
-	set state(state) connecting
-	fileevent $state(sock) writable {}
-	::http::Connected $token $proto $phost $srvurl
-	return
-    }
-
-    # Error cases.
-	Log "WARNING - if testing, pay special attention to this\
-		case (GJ) which is seldom executed - token $token"
-	if {[info exists state(reusing)] && $state(reusing)} {
-	    # The socket was closed at the server end, and closed at
-	    # this end by http::CheckEof.
-	    if {[TestForReplay $token write $err b]} {
-		return
-	    }
-
-	    # else:
-	    # This is NOT a persistent socket that has been closed since its
-	    # last use.
-	    # If any other requests are in flight or pipelined/queued, they will
-	    # be discarded.
-	}
-	Finish $token "connect failed: $err"
-    return
-}
-
-# http::Write
-#
-#	Write POST query data to the socket
-#
-# Arguments
-#	token	The token for the connection
-#
-# Side Effects
-#	Write the socket and handle callbacks.
-
-proc http::Write {token} {
-    variable http
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    set sock $state(sock)
-
-    # Output a block.  Tcl will buffer this if the socket blocks
-    set done 0
-    if {[catch {
-	# Catch I/O errors on dead sockets
-
-	if {[info exists state(-query)]} {
-	    # Chop up large query strings so queryprogress callback can give
-	    # smooth feedback.
-	    if {    $state(queryoffset) + $state(-queryblocksize)
-		 >= $state(querylength)
-	    } {
-		# This will be the last puts for the request-body.
-		if {    (![catch {fileevent $sock readable} binding])
-		     && ($binding eq [list http::CheckEof $sock])
-		} {
-		    # Remove the "fileevent readable" binding of an idle
-		    # persistent socket to http::CheckEof.  We can no longer
-		    # treat bytes received as junk. The server might still time
-		    # out and half-close the socket if it has not yet received
-		    # the first "puts".
-		    fileevent $sock readable {}
-		}
-	    }
-	    puts -nonewline $sock \
-		[string range $state(-query) $state(queryoffset) \
-		     [expr {$state(queryoffset) + $state(-queryblocksize) - 1}]]
-	    incr state(queryoffset) $state(-queryblocksize)
-	    if {$state(queryoffset) >= $state(querylength)} {
-		set state(queryoffset) $state(querylength)
-		set done 1
-	    }
-	} else {
-	    # Copy blocks from the query channel
-
-	    set outStr [read $state(-querychannel) $state(-queryblocksize)]
-	    if {[eof $state(-querychannel)]} {
-		# This will be the last puts for the request-body.
-		if {    (![catch {fileevent $sock readable} binding])
-		     && ($binding eq [list http::CheckEof $sock])
-		} {
-		    # Remove the "fileevent readable" binding of an idle
-		    # persistent socket to http::CheckEof.  We can no longer
-		    # treat bytes received as junk. The server might still time
-		    # out and half-close the socket if it has not yet received
-		    # the first "puts".
-		    fileevent $sock readable {}
-		}
-	    }
-	    puts -nonewline $sock $outStr
-	    incr state(queryoffset) [string length $outStr]
-	    if {[eof $state(-querychannel)]} {
-		set done 1
-	    }
-	}
-    } err opts]} {
-	# Do not call Finish here, but instead let the read half of the socket
-	# process whatever server reply there is to get.
-	set state(posterror) $err
-	set info [dict get $opts -errorinfo]
-	set code [dict get $opts -code]
-	set state(postErrorFull) [list $err $info $code]
-	set done 1
-    }
-
-    if {$done} {
-	catch {flush $sock}
-	fileevent $sock writable {}
-	Log ^C$tk end sending request - token $token
-	# End of writing (POST method).  The request has been sent.
-
-	DoneRequest $token
-    }
-
-    # Callback to the client after we've completely handled everything.
-
-    if {[string length $state(-queryprogress)]} {
-	namespace eval :: $state(-queryprogress) \
-	    [list $token $state(querylength) $state(queryoffset)]
-    }
-    return
-}
-
-# http::Event
-#
-#	Handle input on the socket. This command is the core of
-#	the coroutine commands ${token}--EventCoroutine that are
-#	bound to "fileevent $sock readable" and process input.
-#
-# Arguments
-#	sock	The socket receiving input.
-#	token	The token returned from http::geturl
-#
-# Side Effects
-#	Read the socket and handle callbacks.
-
-proc http::Event {sock token} {
-    variable http
-    variable socketMapping
-    variable socketRdState
-    variable socketWrState
-    variable socketRdQueue
-    variable socketWrQueue
-    variable socketPhQueue
-    variable socketClosing
-    variable socketPlayCmd
-    variable socketCoEvent
-    variable socketProxyId
-
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    while 1 {
-	yield
-	##Log Event call - token $token
-
-	if {![info exists state]} {
-	    Log "Event $sock with invalid token '$token' - remote close?"
-	    if {!([catch {eof $sock} tmp] || $tmp)} {
-		if {[set d [read $sock]] ne ""} {
-		    Log "WARNING: additional data left on closed socket\
-			    - token $token"
-		} else {
-		}
-	    } else {
-	    }
-	    Log ^X$tk end of response (token error) - token $token
-	    CloseSocket $sock
-	    return
-	} else {
-	}
-	if {$state(state) eq "connecting"} {
-	    ##Log - connecting - token $token
-	    if {    $state(reusing)
-		 && $state(-pipeline)
-		 && ($state(-timeout) > 0)
-		 && (![info exists state(after)])
-	    } {
-		set state(after) [after $state(-timeout) \
-			[list http::reset $token timeout]]
-	    } else {
-	    }
-
-	    if {[catch {gets $sock state(http)} nsl]} {
-		Log "WARNING - if testing, pay special attention to this\
-			case (GK) which is seldom executed - token $token"
-		if {[info exists state(reusing)] && $state(reusing)} {
-		    # The socket was closed at the server end, and closed at
-		    # this end by http::CheckEof.
-
-		    if {[TestForReplay $token read $nsl c]} {
-			return
-		    } else {
-		    }
-		    # else:
-		    # This is NOT a persistent socket that has been closed since
-		    # its last use.
-		    # If any other requests are in flight or pipelined/queued,
-		    # they will be discarded.
-		} else {
-		    # https handshake errors come here, for
-		    # Tcl 8.7 with http::SecureProxyConnect.
-		    set msg [registerError $sock]
-		    registerError $sock {}
-		    if {$msg eq {}} {
-			set msg $nsl
-		    }
-		    Log ^X$tk end of response (error) - token $token
-		    Finish $token $msg
-		    return
-		}
-	    } elseif {$nsl >= 0} {
-		##Log - connecting 1 - token $token
-		set state(state) "header"
-	    } elseif {    ([catch {eof $sock} tmp] || $tmp)
-		       && [info exists state(reusing)]
-		       && $state(reusing)
-	    } {
-		# The socket was closed at the server end, and we didn't notice.
-		# This is the first read - where the closure is usually first
-		# detected.
-
-		if {[TestForReplay $token read {} d]} {
-		    return
-		} else {
-		}
-
-		# else:
-		# This is NOT a persistent socket that has been closed since its
-		# last use.
-		# If any other requests are in flight or pipelined/queued, they
-		# will be discarded.
-	    } else {
-	    }
-	} elseif {$state(state) eq "header"} {
-	    if {[catch {gets $sock line} nhl]} {
-		##Log header failed - token $token
-		Log ^X$tk end of response (error) - token $token
-		Finish $token $nhl
-		return
-	    } elseif {$nhl == 0} {
-		##Log header done - token $token
-		Log ^E$tk end of response headers - token $token
-		# We have now read all headers
-		# We ignore HTTP/1.1 100 Continue returns. RFC2616 sec 8.2.3
-		if {    ($state(http) == "")
-		     || ([regexp {^\S+\s(\d+)} $state(http) {} x] && $x == 100)
-		} {
-		    set state(state) "connecting"
-		    continue
-		    # This was a "return" in the pre-coroutine code.
-		} else {
-		}
-
-		# We have $state(http) so let's split it into its components.
-		if {[regexp {^HTTP/(\S+) ([0-9]{3}) (.*)$} $state(http) \
-			-> httpResponse responseCode reasonPhrase]
-		} {
-		    set state(httpResponse) $httpResponse
-		    set state(responseCode) $responseCode
-		    set state(reasonPhrase) $reasonPhrase
-		} else {
-		    set state(httpResponse) $state(http)
-		    set state(responseCode) $state(http)
-		    set state(reasonPhrase) $state(http)
-		}
-
-		if {    ([info exists state(connection)])
-		     && ([info exists socketMapping($state(socketinfo))])
-		     && ("keep-alive" in $state(connection))
-		     && ($state(-keepalive))
-		     && (!$state(reusing))
-		     && ($state(-pipeline))
-		} {
-		    # Response headers received for first request on a
-		    # persistent socket.  Now ready for pipelined writes (if
-		    # any).
-		    # Previous value is $token. It cannot be "pending".
-		    set socketWrState($state(socketinfo)) Wready
-		    http::NextPipelinedWrite $token
-		} else {
-		}
-
-		# Once a "close" has been signaled, the client MUST NOT send any
-		# more requests on that connection.
-		#
-		# If either the client or the server sends the "close" token in
-		# the Connection header, that request becomes the last one for
-		# the connection.
-
-		if {    ([info exists state(connection)])
-		     && ([info exists socketMapping($state(socketinfo))])
-		     && ("close" in $state(connection))
-		     && ($state(-keepalive))
-		} {
-		    # The server warns that it will close the socket after this
-		    # response.
-		    ##Log WARNING - socket will close after response for $token
-		    # Prepare data for a call to ReplayIfClose.
-		    Log $token socket will close after this transaction
-		    # 1. Cancel socket-assignment coro events that have not yet
-		    # launched, and add the tokens to the write queue.
-		    if {[info exists socketCoEvent($state(socketinfo))]} {
-			foreach {tok can} $socketCoEvent($state(socketinfo)) {
-			    lappend socketWrQueue($state(socketinfo)) $tok
-			    unset -nocomplain ${tok}(socketcoro)
-			    after cancel $can
-			    Log $tok Cancel socket after-idle event (Event)
-			    Log Move $tok from socketCoEvent to socketWrQueue and cancel its after idle coro
-			}
-			set socketCoEvent($state(socketinfo)) {}
-		    } else {
-		    }
-
-		    if {    ($socketRdQueue($state(socketinfo)) ne {})
-			 || ($socketWrQueue($state(socketinfo)) ne {})
-			 || ($socketWrState($state(socketinfo)) ni
-						[list Wready peNding $token])
-		    } {
-			set InFlightW $socketWrState($state(socketinfo))
-			if {$InFlightW in [list Wready peNding $token]} {
-			    set InFlightW Wready
-			} else {
-			    set msg "token ${InFlightW} is InFlightW"
-			    ##Log $msg - token $token
-			}
-			set socketPlayCmd($state(socketinfo)) \
-				[list ReplayIfClose $InFlightW \
-				$socketRdQueue($state(socketinfo)) \
-				$socketWrQueue($state(socketinfo))]
-
-			# - All tokens are preserved for re-use by ReplayCore.
-			# - Queues are preserved in case of Finish with error,
-			#   but are not used for anything else because
-			#   socketClosing(*) is set below.
-			# - Cancel the state(after) timeout events.
-			foreach tokenVal $socketRdQueue($state(socketinfo)) {
-			    if {[info exists ${tokenVal}(after)]} {
-				after cancel [set ${tokenVal}(after)]
-				unset ${tokenVal}(after)
-			    } else {
-			    }
-			    # Tokens in the read queue have no (socketcoro) to
-			    # cancel.
-			}
-		    } else {
-			set socketPlayCmd($state(socketinfo)) \
-				{ReplayIfClose Wready {} {}}
-		    }
-
-		    # Do not allow further connections on this socket (but
-		    # geturl can add new requests to the replay).
-		    set socketClosing($state(socketinfo)) 1
-		} else {
-		}
-
-		set state(state) body
-
-		# According to
-		# https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Connection
-		# any comma-separated "Connection:" list implies keep-alive, but I
-		# don't see this in the RFC so we'll play safe and
-		# scan any list for "close".
-		# Done here to support combining duplicate header field's values.
-		if {   [info exists state(connection)]
-		    && ("close" ni $state(connection))
-		    && ("keep-alive" ni $state(connection))
-		} {
-		    lappend state(connection) "keep-alive"
-		} else {
-		}
-
-		# If doing a HEAD, then we won't get any body
-		if {$state(-validate)} {
-		    Log ^F$tk end of response for HEAD request - token $token
-		    set state(state) complete
-		    Eot $token
-		    return
-		} elseif {
-			($state(method) eq {CONNECT})
-		     && [string is integer -strict $state(responseCode)]
-		     && ($state(responseCode) >= 200)
-		     && ($state(responseCode) < 300)
-		} {
-		    # A successful CONNECT response has no body.
-		    # (An unsuccessful CONNECT has headers and body.)
-		    # The code below is abstracted from Eot/Finish, but
-		    # keeps the socket open.
-		    catch {fileevent $state(sock) readable {}}
-		    catch {fileevent $state(sock) writable {}}
-		    set state(state) complete
-		    set state(status) ok
-		    if {[info commands ${token}--EventCoroutine] ne {}} {
-			rename ${token}--EventCoroutine {}
-		    }
-		    if {[info commands ${token}--SocketCoroutine] ne {}} {
-			rename ${token}--SocketCoroutine {}
-		    }
-		    if {[info exists state(socketcoro)]} {
-		        Log $token Cancel socket after-idle event (Finish)
-		        after cancel $state(socketcoro)
-		        unset state(socketcoro)
-		    }
-		    if {[info exists state(after)]} {
-			after cancel $state(after)
-			unset state(after)
-		    }
-		    if {    [info exists state(-command)]
-			 && (![info exists state(done-command-cb)])
-		    } {
-			set state(done-command-cb) yes
-			if {[catch {namespace eval :: $state(-command) $token} err]} {
-			    set state(error) [list $err $errorInfo $errorCode]
-			    set state(status) error
-			}
-		    }
-		    return
-		} else {
-		}
-
-		# - For non-chunked transfer we may have no body - in this case
-		#   we may get no further file event if the connection doesn't
-		#   close and no more data is sent. We can tell and must finish
-		#   up now - not later - the alternative would be to wait until
-		#   the server times out.
-		# - In this case, the server has NOT told the client it will
-		#   close the connection, AND it has NOT indicated the resource
-		#   length EITHER by setting the Content-Length (totalsize) OR
-		#   by using chunked Transfer-Encoding.
-		# - Do not worry here about the case (Connection: close) because
-		#   the server should close the connection.
-		# - IF (NOT Connection: close) AND (NOT chunked encoding) AND
-		#      (totalsize == 0).
-
-		if {    (!(    [info exists state(connection)]
-			    && ("close" in $state(connection))
-			  )
-			)
-		     && ($state(transfer) eq {})
-		     && ($state(totalsize) == 0)
-		} {
-		    set msg {body size is 0 and no events likely - complete}
-		    Log "$msg - token $token"
-		    set msg {(length unknown, set to 0)}
-		    Log ^F$tk end of response body {*}$msg - token $token
-		    set state(state) complete
-		    Eot $token
-		    return
-		} else {
-		}
-
-		# We have to use binary translation to count bytes properly.
-		lassign [fconfigure $sock -translation] trRead trWrite
-		fconfigure $sock -translation [list binary $trWrite]
-
-		if {
-		    $state(-binary) || [IsBinaryContentType $state(type)]
-		} {
-		    # Turn off conversions for non-text data.
-		    set state(binary) 1
-		} else {
-		}
-		if {[info exists state(-channel)]} {
-		    if {$state(binary) || [llength [ContentEncoding $token]]} {
-			fconfigure $state(-channel) -translation binary
-		    } else {
-		    }
-		    if {![info exists state(-handler)]} {
-			# Initiate a sequence of background fcopies.
-			fileevent $sock readable {}
-			rename ${token}--EventCoroutine {}
-			CopyStart $sock $token
-			return
-		    } else {
-		    }
-		} else {
-		}
-	    } elseif {$nhl > 0} {
-		# Process header lines.
-		##Log header - token $token - $line
-		if {[regexp -nocase {^([^:]+):(.+)$} $line x key value]} {
-		    set key [string tolower $key]
-		    switch -- $key {
-			content-type {
-			    set state(type) [string trim [string tolower $value]]
-			    # Grab the optional charset information.
-			    if {[regexp -nocase \
-				    {charset\s*=\s*\"((?:[^""]|\\\")*)\"} \
-				    $state(type) -> cs]} {
-				set state(charset) [string map {{\"} \"} $cs]
-			    } else {
-				regexp -nocase {charset\s*=\s*(\S+?);?} \
-					$state(type) -> state(charset)
-			    }
-			}
-			content-length {
-			    set state(totalsize) [string trim $value]
-			}
-			content-encoding {
-			    set state(coding) [string trim $value]
-			}
-			transfer-encoding {
-			    set state(transfer) \
-				    [string trim [string tolower $value]]
-			}
-			proxy-connection -
-			connection {
-			    # RFC 7230 Section 6.1 states that a comma-separated
-			    # list is an acceptable value.
-			    if {![info exists state(connectionRespFlag)]} {
-				# This is the first "Connection" response header.
-				# Scrub the earlier value set by iniitialisation.
-				set state(connectionRespFlag) {}
-				set state(connection) {}
-			    }
-			    foreach el [SplitCommaSeparatedFieldValue $value] {
-				lappend state(connection) [string tolower $el]
-			    }
-			}
-			upgrade {
-			    set state(upgrade) [string trim $value]
-			}
-			set-cookie {
-			    if {$http(-cookiejar) ne ""} {
-				ParseCookie $token [string trim $value]
-			    } else {
-			    }
-			}
-		    }
-		    lappend state(meta) $key [string trim $value]
-		} else {
-		}
-	    } else {
-	    }
-	} else {
-	    # Now reading body
-	    ##Log body - token $token
-	    if {[catch {
-		if {[info exists state(-handler)]} {
-		    set n [namespace eval :: $state(-handler) [list $sock $token]]
-		    ##Log handler $n - token $token
-		    # N.B. the protocol has been set to 1.0 because the -handler
-		    # logic is not expected to handle chunked encoding.
-		    # FIXME Allow -handler with 1.1 on dechunked stacked chan.
-		    if {$state(totalsize) == 0} {
-			# We know the transfer is complete only when the server
-			# closes the connection - i.e. eof is not an error.
-			set state(state) complete
-		    } else {
-		    }
-		    if {![string is integer -strict $n]} {
-			if 1 {
-			    # Do not tolerate bad -handler - fail with error
-			    # status.
-			    set msg {the -handler command for http::geturl must\
-				    return an integer (the number of bytes\
-				    read)}
-			    Log ^X$tk end of response (handler error) -\
-				    token $token
-			    Eot $token $msg
-			} else {
-			    # Tolerate the bad -handler, and continue.  The
-			    # penalty:
-			    # (a) Because the handler returns nonsense, we know
-			    #     the transfer is complete only when the server
-			    #     closes the connection - i.e. eof is not an
-			    #     error.
-			    # (b) http::size will not be accurate.
-			    # (c) The transaction is already downgraded to 1.0
-			    #     to avoid chunked transfer encoding.  It MUST
-			    #     also be forced to "Connection: close" or the
-			    #     HTTP/1.0 equivalent; or it MUST fail (as
-			    #     above) if the server sends
-			    #     "Connection: keep-alive" or the HTTP/1.0
-			    #     equivalent.
-			    set n 0
-			    set state(state) complete
-			}
-		    } else {
-		    }
-		} elseif {[info exists state(transfer_final)]} {
-		    # This code forgives EOF in place of the final CRLF.
-		    set line [GetTextLine $sock]
-		    set n [string length $line]
-		    set state(state) complete
-		    if {$n > 0} {
-			# - HTTP trailers (late response headers) are permitted
-			#   by Chunked Transfer-Encoding, and can be safely
-			#   ignored.
-			# - Do not count these bytes in the total received for
-			#   the response body.
-			Log "trailer of $n bytes after final chunk -\
-				token $token"
-			append state(transfer_final) $line
-			set n 0
-		    } else {
-			Log ^F$tk end of response body (chunked) - token $token
-			Log "final chunk part - token $token"
-			Eot $token
-		    }
-		} elseif {    [info exists state(transfer)]
-			   && ($state(transfer) eq "chunked")
-		} {
-		    ##Log chunked - token $token
-		    set size 0
-		    set hexLenChunk [GetTextLine $sock]
-		    #set ntl [string length $hexLenChunk]
-		    if {[string trim $hexLenChunk] ne ""} {
-			scan $hexLenChunk %x size
-			if {$size != 0} {
-			    ##Log chunk-measure $size - token $token
-			    set chunk [BlockingRead $sock $size]
-			    set n [string length $chunk]
-			    if {$n >= 0} {
-				append state(body) $chunk
-				incr state(log_size) [string length $chunk]
-				##Log chunk $n cumul $state(log_size) -\
-					token $token
-			    } else {
-			    }
-			    if {$size != [string length $chunk]} {
-				Log "WARNING: mis-sized chunk:\
-				    was [string length $chunk], should be\
-				    $size - token $token"
-				set n 0
-				set state(connection) close
-				Log ^X$tk end of response (chunk error) \
-					- token $token
-				set msg {error in chunked encoding - fetch\
-					terminated}
-				Eot $token $msg
-			    } else {
-			    }
-			    # CRLF that follows chunk.
-			    # If eof, this is handled at the end of this proc.
-			    GetTextLine $sock
-			} else {
-			    set n 0
-			    set state(transfer_final) {}
-			}
-		    } else {
-			# Line expected to hold chunk length is empty, or eof.
-			##Log bad-chunk-measure - token $token
-			set n 0
-			set state(connection) close
-			Log ^X$tk end of response (chunk error) - token $token
-			Eot $token {error in chunked encoding -\
-				fetch terminated}
-		    }
-		} else {
-		    ##Log unchunked - token $token
-		    if {$state(totalsize) == 0} {
-			# We know the transfer is complete only when the server
-			# closes the connection.
-			set state(state) complete
-			set reqSize $state(-blocksize)
-		    } else {
-			# Ask for the whole of the unserved response-body.
-			# This works around a problem with a tls::socket - for
-			# https in keep-alive mode, and a request for
-			# $state(-blocksize) bytes, the last part of the
-			# resource does not get read until the server times out.
-			set reqSize [expr {  $state(totalsize)
-					   - $state(currentsize)}]
-
-			# The workaround fails if reqSize is
-			# capped at $state(-blocksize).
-			# set reqSize [expr {min($reqSize, $state(-blocksize))}]
-		    }
-		    set c $state(currentsize)
-		    set t $state(totalsize)
-		    ##Log non-chunk currentsize $c of totalsize $t -\
-			    token $token
-		    set block [read $sock $reqSize]
-		    set n [string length $block]
-		    if {$n >= 0} {
-			append state(body) $block
-			##Log non-chunk [string length $state(body)] -\
-				token $token
-		    } else {
-		    }
-		}
-		# This calculation uses n from the -handler, chunked, or
-		# unchunked case as appropriate.
-		if {[info exists state]} {
-		    if {$n >= 0} {
-			incr state(currentsize) $n
-			set c $state(currentsize)
-			set t $state(totalsize)
-			##Log another $n currentsize $c totalsize $t -\
-				token $token
-		    } else {
-		    }
-		    # If Content-Length - check for end of data.
-		    if {
-			   ($state(totalsize) > 0)
-			&& ($state(currentsize) >= $state(totalsize))
-		    } {
-			Log ^F$tk end of response body (unchunked) -\
-				token $token
-			set state(state) complete
-			Eot $token
-		    } else {
-		    }
-		} else {
-		}
-	    } err]} {
-		Log ^X$tk end of response (error ${err}) - token $token
-		Finish $token $err
-		return
-	    } else {
-		if {[info exists state(-progress)]} {
-		    namespace eval :: $state(-progress) \
-			[list $token $state(totalsize) $state(currentsize)]
-		} else {
-		}
-	    }
-	}
-
-	# catch as an Eot above may have closed the socket already
-	# $state(state) may be connecting, header, body, or complete
-	if {(![catch {eof $sock} eof]) && $eof} {
-	    # [eof sock] succeeded and the result was 1
-	    ##Log eof - token $token
-	    if {[info exists $token]} {
-		set state(connection) close
-		if {$state(state) eq "complete"} {
-		    # This includes all cases in which the transaction
-		    # can be completed by eof.
-		    # The value "complete" is set only in http::Event, and it is
-		    # used only in the test above.
-		    Log ^F$tk end of response body (unchunked, eof) -\
-			    token $token
-		    Eot $token
-		} else {
-		    # Premature eof.
-		    Log ^X$tk end of response (unexpected eof) - token $token
-		    Eot $token eof
-		}
-	    } else {
-		# open connection closed on a token that has been cleaned up.
-		Log ^X$tk end of response (token error) - token $token
-		CloseSocket $sock
-	    }
-	} else {
-	    # EITHER [eof sock] failed - presumed done by Eot
-	    # OR     [eof sock] succeeded and the result was 0
-	}
-    }
-    return
-}
-
-# http::TestForReplay
-#
-#	Command called if eof is discovered when a socket is first used for a
-#	new transaction.  Typically this occurs if a persistent socket is used
-#	after a period of idleness and the server has half-closed the socket.
-#
-# token  - the connection token returned by http::geturl
-# doing  - "read" or "write"
-# err    - error message, if any
-# caller - code to identify the caller - used only in logging
-#
-# Return Value: boolean, true iff the command calls http::ReplayIfDead.
-
-proc http::TestForReplay {token doing err caller} {
-    variable http
-    variable $token
-    upvar 0 $token state
-    set tk [namespace tail $token]
-    if {$doing eq "read"} {
-	set code Q
-	set action response
-	set ing reading
-    } else {
-	set code P
-	set action request
-	set ing writing
-    }
-
-    if {$err eq {}} {
-	set err "detect eof when $ing (server timed out?)"
-    }
-
-    if {$state(method) eq "POST" && !$http(-repost)} {
-	# No Replay.
-	# The present transaction will end when Finish is called.
-	# That call to Finish will abort any other transactions
-	# currently in the write queue.
-	# For calls from http::Event this occurs when execution
-	# reaches the code block at the end of that proc.
-	set msg {no retry for POST with http::config -repost 0}
-	Log reusing socket failed "($caller)" - $msg - token $token
-	Log error - $err - token $token
-	Log ^X$tk end of $action (error) - token $token
-	return 0
-    } else {
-	# Replay.
-	set msg {try a new socket}
-	Log reusing socket failed "($caller)" - $msg - token $token
-	Log error - $err - token $token
-	Log ^$code$tk Any unfinished (incl this one) failed - token $token
-	ReplayIfDead $token $doing
-	return 1
-    }
-}
-
-# http::IsBinaryContentType --
-#
-#	Determine if the content-type means that we should definitely transfer
-#	the data as binary. [Bug 838e99a76d]
-#
-# Arguments
-#	type	The content-type of the data.
-#
-# Results:
-#	Boolean, true if we definitely should be binary.
-
-proc http::IsBinaryContentType {type} {
-    lassign [split [string tolower $type] "/;"] major minor
-    if {$major eq "text"} {
-	return false
-    }
-    # There's a bunch of XML-as-application-format things about. See RFC 3023
-    # and so on.
-    if {$major eq "application"} {
-	set minor [string trimright $minor]
-	if {$minor in {"json" "xml" "xml-external-parsed-entity" "xml-dtd"}} {
-	    return false
-	}
-    }
-    # Not just application/foobar+xml but also image/svg+xml, so let us not
-    # restrict things for now...
-    if {[string match "*+xml" $minor]} {
-	return false
-    }
-    return true
-}
-
-proc http::ParseCookie {token value} {
-    variable http
-    variable CookieRE
-    variable $token
-    upvar 0 $token state
-
-    if {![regexp $CookieRE $value -> cookiename cookieval opts]} {
-	# Bad cookie! No biscuit!
-	return
-    }
-
-    # Convert the options into a list before feeding into the cookie store;
-    # ugly, but quite easy.
-    set realopts {hostonly 1 path / secure 0 httponly 0}
-    dict set realopts origin $state(host)
-    dict set realopts domain $state(host)
-    foreach option [split [regsub -all {;\s+} $opts \u0000] \u0000] {
-	regexp {^(.*?)(?:=(.*))?$} $option -> optname optval
-	switch -exact -- [string tolower $optname] {
-	    expires {
-		if {[catch {
-		    #Sun, 06 Nov 1994 08:49:37 GMT
-		    dict set realopts expires \
-			[clock scan $optval -format "%a, %d %b %Y %T %Z"]
-		}] && [catch {
-		    # Google does this one
-		    #Mon, 01-Jan-1990 00:00:00 GMT
-		    dict set realopts expires \
-			[clock scan $optval -format "%a, %d-%b-%Y %T %Z"]
-		}] && [catch {
-		    # This is in the RFC, but it is also in the original
-		    # Netscape cookie spec, now online at:
-		    # <URL:http://curl.haxx.se/rfc/cookie_spec.html>
-		    #Sunday, 06-Nov-94 08:49:37 GMT
-		    dict set realopts expires \
-			[clock scan $optval -format "%A, %d-%b-%y %T %Z"]
-		}]} {catch {
-		    #Sun Nov  6 08:49:37 1994
-		    dict set realopts expires \
-			[clock scan $optval -gmt 1 -format "%a %b %d %T %Y"]
-		}}
-	    }
-	    max-age {
-		# Normalize
-		if {[string is integer -strict $optval]} {
-		    dict set realopts expires [expr {[clock seconds] + $optval}]
-		}
-	    }
-	    domain {
-		# From the domain-matches definition [RFC 2109, section 2]:
-		#   Host A's name domain-matches host B's if [...]
-		#	A is a FQDN string and has the form NB, where N is a
-		#	non-empty name string, B has the form .B', and B' is a
-		#	FQDN string. (So, x.y.com domain-matches .y.com but
-		#	not y.com.)
-		if {$optval ne "" && ![string match *. $optval]} {
-		    dict set realopts domain [string trimleft $optval "."]
-		    dict set realopts hostonly [expr {
-			! [string match .* $optval]
-		    }]
-		}
-	    }
-	    path {
-		if {[string match /* $optval]} {
-		    dict set realopts path $optval
-		}
-	    }
-	    secure - httponly {
-		dict set realopts [string tolower $optname] 1
-	    }
-	}
-    }
-    dict set realopts key $cookiename
-    dict set realopts value $cookieval
-    {*}$http(-cookiejar) storeCookie $realopts
-}
-
-# http::GetTextLine --
-#
-#	Get one line with the stream in crlf mode.
-#	Used if Transfer-Encoding is chunked, to read the line that
-#	reports the size of the following chunk.
-#	Empty line is not distinguished from eof.  The caller must
-#	be able to handle this.
-#
-# Arguments
-#	sock	The socket receiving input.
-#
-# Results:
-#	The line of text, without trailing newline
-
-proc http::GetTextLine {sock} {
-    set tr [fconfigure $sock -translation]
-    lassign $tr trRead trWrite
-    fconfigure $sock -translation [list crlf $trWrite]
-    set r [BlockingGets $sock]
-    fconfigure $sock -translation $tr
-    return $r
-}
-
-# http::BlockingRead
-#
-#	Replacement for a blocking read.
-#	The caller must be a coroutine.
-#	Used when we expect to read a chunked-encoding
-#	chunk of known size.
-
-proc http::BlockingRead {sock size} {
-    if {$size < 1} {
-	return
-    }
-    set result {}
-    while 1 {
-	set need [expr {$size - [string length $result]}]
-	set block [read $sock $need]
-	set eof [expr {[catch {eof $sock} tmp] || $tmp}]
-	append result $block
-	if {[string length $result] >= $size || $eof} {
-	    return $result
-	} else {
-	    yield
-	}
-    }
-}
-
-# http::BlockingGets
-#
-#	Replacement for a blocking gets.
-#	The caller must be a coroutine.
-#	Empty line is not distinguished from eof.  The caller must
-#	be able to handle this.
-
-proc http::BlockingGets {sock} {
-    while 1 {
-	set count [gets $sock line]
-	set eof [expr {[catch {eof $sock} tmp] || $tmp}]
-	if {$count >= 0 || $eof} {
-	    return $line
-	} else {
-	    yield
-	}
-    }
-}
-
-# http::CopyStart
-#
-#	Error handling wrapper around fcopy
-#
-# Arguments
-#	sock	The socket to copy from
-#	token	The token returned from http::geturl
-#
-# Side Effects
-#	This closes the connection upon error
-
-proc http::CopyStart {sock token {initial 1}} {
-    upvar 0 $token state
-    if {[info exists state(transfer)] && $state(transfer) eq "chunked"} {
-	foreach coding [ContentEncoding $token] {
-	    if {$coding eq {deflateX}} {
-		# Use the standards-compliant choice.
-		set coding2 decompress
-	    } else {
-		set coding2 $coding
-	    }
-	    lappend state(zlib) [zlib stream $coding2]
-	}
-	MakeTransformationChunked $sock [namespace code [list CopyChunk $token]]
-    } else {
-	if {$initial} {
-	    foreach coding [ContentEncoding $token] {
-		if {$coding eq {deflateX}} {
-		    # Use the standards-compliant choice.
-		    set coding2 decompress
-		} else {
-		    set coding2 $coding
-		}
-		zlib push $coding2 $sock
-	    }
-	}
-	if {[catch {
-	    # FIXME Keep-Alive on https tls::socket with unchunked transfer
-	    # hangs until the server times out. A workaround is possible, as for
-	    # the case without -channel, but it does not use the neat "fcopy"
-	    # solution.
-	    fcopy $sock $state(-channel) -size $state(-blocksize) -command \
-		[list http::CopyDone $token]
-	} err]} {
-	    Finish $token $err
-	}
-    }
-    return
-}
-
-proc http::CopyChunk {token chunk} {
-    upvar 0 $token state
-    if {[set count [string length $chunk]]} {
-	incr state(currentsize) $count
-	if {[info exists state(zlib)]} {
-	    foreach stream $state(zlib) {
-		set chunk [$stream add $chunk]
-	    }
-	}
-	puts -nonewline $state(-channel) $chunk
-	if {[info exists state(-progress)]} {
-	    namespace eval :: [linsert $state(-progress) end \
-		      $token $state(totalsize) $state(currentsize)]
-	}
-    } else {
-	Log "CopyChunk Finish - token $token"
-	if {[info exists state(zlib)]} {
-	    set excess ""
-	    foreach stream $state(zlib) {
-		catch {
-		    $stream put -finalize $excess
-		    set excess ""
-		    set overflood ""
-		    while {[set overflood [$stream get]] ne ""} { append excess $overflood }
-		}
-	    }
-	    puts -nonewline $state(-channel) $excess
-	    foreach stream $state(zlib) { $stream close }
-	    unset state(zlib)
-	}
-	Eot $token ;# FIX ME: pipelining.
-    }
-    return
-}
-
-# http::CopyDone
-#
-#	fcopy completion callback
-#
-# Arguments
-#	token	The token returned from http::geturl
-#	count	The amount transferred
-#
-# Side Effects
-#	Invokes callbacks
-
-proc http::CopyDone {token count {error {}}} {
-    variable $token
-    upvar 0 $token state
-    set sock $state(sock)
-    incr state(currentsize) $count
-    if {[info exists state(-progress)]} {
-	namespace eval :: $state(-progress) \
-	    [list $token $state(totalsize) $state(currentsize)]
-    }
-    # At this point the token may have been reset.
-    if {[string length $error]} {
-	Finish $token $error
-    } elseif {[catch {eof $sock} iseof] || $iseof} {
-	Eot $token
-    } else {
-	CopyStart $sock $token 0
-    }
-    return
-}
-
-# http::Eot
-#
-#	Called when either:
-#	a. An eof condition is detected on the socket.
-#	b. The client decides that the response is complete.
-#	c. The client detects an inconsistency and aborts the transaction.
-#
-#	Does:
-#	1. Set state(status)
-#	2. Reverse any Content-Encoding
-#	3. Convert charset encoding and line ends if necessary
-#	4. Call http::Finish
-#
-# Arguments
-#	token	The token returned from http::geturl
-#	force	(previously) optional, has no effect
-#	reason	- "eof" means premature EOF (not EOF as the natural end of
-#		  the response)
-#		- "" means completion of response, with or without EOF
-#		- anything else describes an error condition other than
-#		  premature EOF.
-#
-# Side Effects
-#	Clean up the socket
-
-proc http::Eot {token {reason {}}} {
-    variable $token
-    upvar 0 $token state
-    if {$reason eq "eof"} {
-	# Premature eof.
-	set state(status) eof
-	set reason {}
-    } elseif {$reason ne ""} {
-	# Abort the transaction.
-	set state(status) $reason
-    } else {
-	# The response is complete.
-	set state(status) ok
-    }
-
-    if {[string length $state(body)] > 0} {
-	if {[catch {
-	    foreach coding [ContentEncoding $token] {
-		if {$coding eq {deflateX}} {
-		    # First try the standards-compliant choice.
-		    set coding2 decompress
-		    if {[catch {zlib $coding2 $state(body)} result]} {
-			# If that fails, try the MS non-compliant choice.
-			set coding2 inflate
-			set state(body) [zlib $coding2 $state(body)]
-		    } else {
-			# error {failed at standards-compliant deflate}
-			set state(body) $result
-		    }
-		} else {
-		    set state(body) [zlib $coding $state(body)]
-		}
-	    }
-	} err]} {
-	    Log "error doing decompression for token $token: $err"
-	    Finish $token $err
-	    return
-	}
-
-	if {!$state(binary)} {
-	    # If we are getting text, set the incoming channel's encoding
-	    # correctly.  iso8859-1 is the RFC default, but this could be any
-	    # IANA charset.  However, we only know how to convert what we have
-	    # encodings for.
-
-	    set enc [CharsetToEncoding $state(charset)]
-	    if {$enc ne "binary"} {
-		if {[package vsatisfies [package provide Tcl] 9.0-]} {
-		    set state(body) [encoding convertfrom -profile tcl8 $enc $state(body)]
-		} else {
-		    set state(body) [encoding convertfrom $enc $state(body)]
-		}
-	    }
-
-	    # Translate text line endings.
-	    set state(body) [string map {\r\n \n \r \n} $state(body)]
-	}
-	if {[info exists state(-guesstype)] && $state(-guesstype)} {
-	    GuessType $token
-	}
-    }
-    Finish $token $reason
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::GuessType
-# ------------------------------------------------------------------------------
-# Command to attempt limited analysis of a resource with undetermined
-# Content-Type, i.e. "application/octet-stream".  This value can be set for two
-# reasons:
-# (a) by the server, in a Content-Type header
-# (b) by http::geturl, as the default value if the server does not supply a
-#     Content-Type header.
-#
-# This command converts a resource if:
-# (1) it has type application/octet-stream
-# (2) it begins with an XML declaration "<?xml name="value" ... >?"
-# (3) one tag is named "encoding" and has a recognised value; or no "encoding"
-#     tag exists (defaulting to utf-8)
-#
-# RFC 9110 Sec. 8.3 states:
-# "If a Content-Type header field is not present, the recipient MAY either
-# assume a media type of "application/octet-stream" ([RFC2046], Section 4.5.1)
-# or examine the data to determine its type."
-#
-# The RFC goes on to describe the pitfalls of "MIME sniffing", including
-# possible security risks.
-#
-# Arguments:
-# token       - connection token
-#
-# Return Value: (boolean) true iff a change has been made
-# ------------------------------------------------------------------------------
-
-proc http::GuessType {token} {
-    variable $token
-    upvar 0 $token state
-
-    if {$state(type) ne {application/octet-stream}} {
-        return 0
-    }
-
-    set body $state(body)
-    # e.g. {<?xml version="1.0" encoding="utf-8"?> ...}
-
-    if {![regexp -nocase -- {^<[?]xml[[:space:]][^>?]*[?]>} $body match]} {
-        return 0
-    }
-    # e.g. {<?xml version="1.0" encoding="utf-8"?>}
-
-    set contents [regsub -- {[[:space:]]+} $match { }]
-    set contents [string range [string tolower $contents] 6 end-2]
-    # e.g. {version="1.0" encoding="utf-8"}
-    # without excess whitespace or upper-case letters
-
-    if {![regexp -- {^([^=" ]+="[^"]+" )+$} "$contents "]} {
-        return 0
-    }
-    # The application/xml default encoding:
-    set res utf-8
-
-    set tagList [regexp -all -inline -- {[^=" ]+="[^"]+"} $contents]
-    foreach tag $tagList {
-        regexp -- {([^=" ]+)="([^"]+)"} $tag -> name value
-        if {$name eq {encoding}} {
-            set res $value
-        }
-    }
-    set enc [CharsetToEncoding $res]
-    if {$enc eq "binary"} {
-        return 0
-    }
-    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-	set state(body) [encoding convertfrom -profile tcl8 $enc $state(body)]
-    } else {
-	set state(body) [encoding convertfrom $enc $state(body)]
-    }
-    set state(body) [string map {\r\n \n \r \n} $state(body)]
-    set state(type) application/xml
-    set state(binary) 0
-    set state(charset) $res
-    return 1
-}
-
-
-# http::wait --
-#
-#	See documentation for details.
-#
-# Arguments:
-#	token	Connection token.
-#
-# Results:
-#	The status after the wait.
-
-proc http::wait {token} {
-    variable $token
-    upvar 0 $token state
-
-    if {![info exists state(status)] || $state(status) eq ""} {
-	# We must wait on the original variable name, not the upvar alias
-	vwait ${token}(status)
-    }
-
-    return [status $token]
-}
-
-# http::formatQuery --
-#
-#	See documentation for details.  Call http::formatQuery with an even
-#	number of arguments, where the first is a name, the second is a value,
-#	the third is another name, and so on.
-#
-# Arguments:
-#	args	A list of name-value pairs.
-#
-# Results:
-#	TODO
-
-proc http::formatQuery {args} {
-    if {[llength $args] % 2} {
-        return \
-            -code error \
-            -errorcode [list HTTP BADARGCNT $args] \
-            {Incorrect number of arguments, must be an even number.}
-    }
-    set result ""
-    set sep ""
-    foreach i $args {
-	append result $sep [quoteString $i]
-	if {$sep eq "="} {
-	    set sep &
-	} else {
-	    set sep =
-	}
-    }
-    return $result
-}
-
-# http::quoteString --
-#
-#	Do x-www-urlencoded character mapping
-#
-# Arguments:
-#	string	The string the needs to be encoded
-#
-# Results:
-#       The encoded string
-
-proc http::quoteString {string} {
-    variable http
-    variable formMap
-
-    # The spec says: "non-alphanumeric characters are replaced by '%HH'". Use
-    # a pre-computed map and [string map] to do the conversion (much faster
-    # than [regsub]/[subst]). [Bug 1020491]
-
-    if {[package vsatisfies [package provide Tcl] 9.0-]} {
-	set string [encoding convertto -profile tcl8 $http(-urlencoding) $string]
-    } else {
-	set string [encoding convertto $http(-urlencoding) $string]
-    }
-    return [string map $formMap $string]
-}
-
-# http::ProxyRequired --
-#	Default proxy filter.
-#
-# Arguments:
-#	host	The destination host
-#
-# Results:
-#       The current proxy settings
-
-proc http::ProxyRequired {host} {
-    variable http
-    if {(![info exists http(-proxyhost)]) || ($http(-proxyhost) eq {})} {
-        return
-    }
-    if {![info exists http(-proxyport)] || ($http(-proxyport) eq {})} {
-	set port 8080
-    } else {
-	set port $http(-proxyport)
-    }
-
-    # Simple test (cf. autoproxy) for hosts that must be accessed directly,
-    # not through the proxy server.
-    foreach domain $http(-proxynot) {
-        if {[string match -nocase $domain $host]} {
-            return {}
-        }
-    }
-    return [list $http(-proxyhost) $port]
-}
-
-# http::CharsetToEncoding --
-#
-#	Tries to map a given IANA charset to a tcl encoding.  If no encoding
-#	can be found, returns binary.
-#
-
-proc http::CharsetToEncoding {charset} {
-    variable encodings
-
-    set charset [string tolower $charset]
-    if {[regexp {iso-?8859-([0-9]+)} $charset -> num]} {
-	set encoding "iso8859-$num"
-    } elseif {[regexp {iso-?2022-(jp|kr)} $charset -> ext]} {
-	set encoding "iso2022-$ext"
-    } elseif {[regexp {shift[-_]?jis} $charset]} {
-	set encoding "shiftjis"
-    } elseif {[regexp {(?:windows|cp)-?([0-9]+)} $charset -> num]} {
-	set encoding "cp$num"
-    } elseif {$charset eq "us-ascii"} {
-	set encoding "ascii"
-    } elseif {[regexp {(?:iso-?)?lat(?:in)?-?([0-9]+)} $charset -> num]} {
-	switch -- $num {
-	    5 {set encoding "iso8859-9"}
-	    1 - 2 - 3 {
-		set encoding "iso8859-$num"
-	    }
-	    default {
-		set encoding "binary"
-	    }
-	}
-    } else {
-	# other charset, like euc-xx, utf-8,...  may directly map to encoding
-	set encoding $charset
-    }
-    set idx [lsearch -exact $encodings $encoding]
-    if {$idx >= 0} {
-	return $encoding
-    } else {
-	return "binary"
-    }
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::ContentEncoding
-# ------------------------------------------------------------------------------
-# Return the list of content-encoding transformations we need to do in order.
-#
-    # --------------------------------------------------------------------------
-    # Options for Accept-Encoding, Content-Encoding: the switch command
-    # --------------------------------------------------------------------------
-    # The symbol deflateX allows http to attempt both versions of "deflate",
-    # unless there is a -channel - for a -channel, only "decompress" is tried.
-    # Alternative/extra lines for switch:
-    # The standards-compliant version of "deflate" can be chosen with:
-    #		deflate { lappend r decompress }
-    # The Microsoft non-compliant version of "deflate" can be chosen with:
-    #		deflate { lappend r inflate }
-    # The previously used implementation of "compress", which appears to be
-    # incorrect and is rarely used by web servers, can be chosen with:
-    #		compress - x-compress { lappend r decompress }
-    # --------------------------------------------------------------------------
-#
-# Arguments:
-# token  - Connection token.
-#
-# Return Value: list
-# ------------------------------------------------------------------------------
-
-proc http::ContentEncoding {token} {
-    upvar 0 $token state
-    set r {}
-    if {[info exists state(coding)]} {
-	foreach coding [split $state(coding) ,] {
-	    switch -exact -- $coding {
-		deflate { lappend r deflateX }
-		gzip - x-gzip { lappend r gunzip }
-		identity {}
-		br {
-		    return -code error\
-			    "content-encoding \"br\" not implemented"
-		}
-		default {
-		    Log "unknown content-encoding \"$coding\" ignored"
-		}
-	    }
-	}
-    }
-    return $r
-}
-
-proc http::ReceiveChunked {chan command} {
-    set data ""
-    set size -1
-    yield
-    while {1} {
-	chan configure $chan -translation {crlf binary}
-	while {[gets $chan line] < 1} { yield }
-	chan configure $chan -translation {binary binary}
-	if {[scan $line %x size] != 1} {
-	    return -code error "invalid size: \"$line\""
-	}
-	set chunk ""
-	while {$size && ![chan eof $chan]} {
-	    set part [chan read $chan $size]
-	    incr size -[string length $part]
-	    append chunk $part
-	}
-	if {[catch {
-	    uplevel #0 [linsert $command end $chunk]
-	}]} {
-	    http::Log "Error in callback: $::errorInfo"
-	}
-	if {[string length $chunk] == 0} {
-	    # channel might have been closed in the callback
-	    catch {chan event $chan readable {}}
-	    return
-	}
-    }
-}
-
-# http::SplitCommaSeparatedFieldValue --
-# 	Return the individual values of a comma-separated field value.
-#
-# Arguments:
-#	fieldValue	Comma-separated header field value.
-#
-# Results:
-#       List of values.
-proc http::SplitCommaSeparatedFieldValue {fieldValue} {
-    set r {}
-    foreach el [split $fieldValue ,] {
-	lappend r [string trim $el]
-    }
-    return $r
-}
-
-
-# http::GetFieldValue --
-# 	Return the value of a header field.
-#
-# Arguments:
-#	headers	Headers key-value list
-#	fieldName	Name of header field whose value to return.
-#
-# Results:
-#       The value of the fieldName header field
-#
-# Field names are matched case-insensitively (RFC 7230 Section 3.2).
-#
-# If the field is present multiple times, it is assumed that the field is
-# defined as a comma-separated list and the values are combined (by separating
-# them with commas, see RFC 7230 Section 3.2.2) and returned at once.
-proc http::GetFieldValue {headers fieldName} {
-    set r {}
-    foreach {field value} $headers {
-	if {[string equal -nocase $fieldName $field]} {
-	    if {$r eq {}} {
-		set r $value
-	    } else {
-		append r ", $value"
-	    }
-	}
-    }
-    return $r
-}
-
-proc http::MakeTransformationChunked {chan command} {
-    coroutine [namespace current]::dechunk$chan ::http::ReceiveChunked $chan $command
-    chan event $chan readable [namespace current]::dechunk$chan
-    return
-}
-
-interp alias {} http::data {} http::responseBody
-interp alias {} http::code {} http::responseLine
-interp alias {} http::mapReply {} http::quoteString
-interp alias {} http::meta {} http::responseHeaders
-interp alias {} http::metaValue {} http::responseHeaderValue
-interp alias {} http::ncode {} http::responseCode
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::socketForTls
-# ------------------------------------------------------------------------------
-# Command to use in place of ::socket as the value of ::tls::socketCmd.
-# This command does the same as http::socket, and also handles https connections
-# through a proxy server.
-#
-# Notes.
-# - The proxy server works differently for https and http.  This implementation
-#   is for https.  The proxy for http is implemented in http::CreateToken (in
-#   code that was previously part of http::geturl).
-# - This code implicitly uses the tls options set for https in a call to
-#   http::register, and does not need to call commands tls::*.  This simple
-#   implementation is possible because tls uses a callback to ::socket that can
-#   be redirected by changing the value of ::tls::socketCmd.
-#
-# Arguments:
-# args        - as for ::socket
-#
-# Return Value: a socket identifier
-# ------------------------------------------------------------------------------
-
-proc http::socketForTls {args} {
-    variable http
-    set host [lindex $args end-1]
-    set port [lindex $args end]
-    if {    ($http(-proxyfilter) ne {})
-         && (![catch {$http(-proxyfilter) $host} proxy])
-    } {
-        set phost [lindex $proxy 0]
-        set pport [lindex $proxy 1]
-    } else {
-        set phost {}
-        set pport {}
-    }
-    if {$phost eq ""} {
-        set sock [::http::socket {*}$args]
-    } else {
-        set sock [::http::SecureProxyConnect {*}$args $phost $pport]
-    }
-    return $sock
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::SecureProxyConnect
-# ------------------------------------------------------------------------------
-# Command to open a socket through a proxy server to a remote server for use by
-# tls. The caller must perform the tls handshake.
-#
-# Notes
-# - Based on patch supplied by Melissa Chawla in ticket 1173760, and
-#   Proxy-Authorization header cf. autoproxy by Pat Thoyts.
-# - Rewritten as a call to http::geturl, because response headers and body are
-#   needed if the CONNECT request fails.  CONNECT is implemented for this case
-#   only, by state(bypass).
-# - FUTURE WORK: give http::geturl a -connect option for a general CONNECT.
-# - The request header Proxy-Connection is discouraged in RFC 7230 (June 2014),
-#   RFC 9112 (June 2022).
-#
-# Arguments:
-# args        - as for ::socket, ending in host, port; with proxy host, proxy
-#               port appended.
-#
-# Return Value: a socket identifier
-# ------------------------------------------------------------------------------
-
-proc http::SecureProxyConnect {args} {
-    variable http
-    variable ConnectVar
-    variable ConnectCounter
-    variable failedProxyValues
-    set varName ::http::ConnectVar([incr ConnectCounter])
-
-    # Extract (non-proxy) target from args.
-    set host [lindex $args end-3]
-    set port [lindex $args end-2]
-    set args [lreplace $args end-3 end-2]
-
-    # Proxy server URL for connection.
-    # This determines where the socket is opened.
-    set phost [lindex $args end-1]
-    set pport [lindex $args end]
-    if {[string first : $phost] != -1} {
-        # IPv6 address, wrap it in [] so we can append :pport
-        set phost "\[${phost}\]"
-    }
-    set url http://${phost}:${pport}
-    # Elements of args other than host and port are not used when
-    # AsyncTransaction opens a socket.  Those elements are -async and the
-    # -type $tokenName for the https transaction.  Option -async is used by
-    # AsyncTransaction anyway, and -type $tokenName should not be propagated:
-    # the proxy request adds its own -type value.
-
-    set targ [lsearch -exact $args -type]
-    if {$targ != -1} {
-        # Record in the token that this is a proxy call.
-        set token [lindex $args $targ+1]
-        upvar 0 ${token} state
-        set tim $state(-timeout)
-        set state(proxyUsed) SecureProxyFailed
-        # This value is overwritten with "SecureProxy" below if the CONNECT is
-        # successful.  If it is unsuccessful, the socket will be closed
-        # below, and so in this unsuccessful case there are no other transactions
-        # whose (proxyUsed) must be updated.
-    } else {
-        set tim 0
-    }
-    if {$tim == 0} {
-        # Do not use infinite timeout for the proxy.
-        set tim 30000
-    }
-
-    # Prepare and send a CONNECT request to the proxy, using
-    # code similar to http::geturl.
-    set requestHeaders [list Host $host]
-    lappend requestHeaders Connection keep-alive
-    if {$http(-proxyauth) != {}} {
-        lappend requestHeaders Proxy-Authorization $http(-proxyauth)
-    }
-
-    set token2 [CreateToken $url -keepalive 0 -timeout $tim \
-            -headers $requestHeaders -command [list http::AllDone $varName]]
-    variable $token2
-    upvar 0 $token2 state2
-
-    # Kludges:
-    # Setting this variable overrides the HTTP request line and also allows
-    # -headers to override the Connection: header set by -keepalive.
-    # The arguments "-keepalive 0" ensure that when Finish is called for an
-    # unsuccessful request, the socket is always closed.
-    set state2(bypass) "CONNECT $host:$port HTTP/1.1"
-
-    AsyncTransaction $token2
-
-    if {[info coroutine] ne {}} {
-        # All callers in the http package are coroutines launched by
-        # the event loop.
-        # The cwait command requires a coroutine because it yields
-        # to the caller; $varName is traced and the coroutine resumes
-        # when the variable is written.
-        cwait $varName
-    } else {
-        return -code error {code must run in a coroutine}
-        # For testing with a non-coroutine caller outside the http package.
-        # vwait $varName
-    }
-    unset $varName
-
-    if {    ($state2(state) ne "complete")
-         || ($state2(status) ne "ok")
-         || (![string is integer -strict $state2(responseCode)])
-    } {
-        set msg {the HTTP request to the proxy server did not return a valid\
-                and complete response}
-        if {[info exists state2(error)]} {
-            append msg ": " [lindex $state2(error) 0]
-        }
-        cleanup $token2
-        return -code error $msg
-    }
-
-    set code $state2(responseCode)
-
-    if {($code >= 200) && ($code < 300)} {
-        # All OK.  The caller in package tls will now call "tls::import $sock".
-        # The cleanup command does not close $sock.
-        # Other tidying was done in http::Event.
-
-        # If this is a persistent socket, any other transactions that are
-        # already marked to use the socket will have their (proxyUsed) updated
-        # when http::OpenSocket calls http::ConfigureNewSocket.
-        set state(proxyUsed) SecureProxy
-        set sock $state2(sock)
-        cleanup $token2
-        return $sock
-    }
-
-    if {$targ != -1} {
-        # Non-OK HTTP status code; token is known because option -type
-        # (cf. targ) was passed through tcltls, and so the useful
-        # parts of the proxy's response can be copied to state(*).
-        # Do not copy state2(sock).
-        # Return the proxy response to the caller of geturl.
-        foreach name $failedProxyValues {
-            if {[info exists state2($name)]} {
-                set state($name) $state2($name)
-            }
-        }
-        set state(connection) close
-        set msg "proxy connect failed: $code"
-	# - This error message will be detected by http::OpenSocket and will
-	#   cause it to present the proxy's HTTP response as that of the
-	#   original $token transaction, identified only by state(proxyUsed)
-	#   as the response of the proxy.
-	# - The cases where this would mislead the caller of http::geturl are
-	#   given a different value of msg (below) so that http::OpenSocket will
-	#   treat them as errors, but will preserve the $token array for
-	#   inspection by the caller.
-	# - Status code 305 (Proxy Required) was deprecated for security reasons
-	#   in RFC 2616 (June 1999) and in any case should never be served by a
-	#   proxy.
-	# - Other 3xx responses from the proxy are inappropriate, and should not
-	#   occur.
-	# - A 401 response from the proxy is inappropriate, and should not
-	#   occur.  It would be confusing if returned to the caller.
-
-	if {($code >= 300) && ($code < 400)} {
-	    set msg "the proxy server responded to the HTTP request with an\
-		    inappropriate $code redirect"
-	    set loc [responseHeaderValue $token2 location]
-	    if {$loc ne {}} {
-		append msg "to " $loc
-	    }
-	} elseif {($code == 401)} {
-	    set msg "the proxy server responded to the HTTP request with an\
-		    inappropriate 401 request for target-host credentials"
-	} else {
-	}
-    } else {
-	set msg "connection to proxy failed with status code $code"
-    }
-
-    # - ${token2}(sock) has already been closed because -keepalive 0.
-    # - Error return does not pass the socket ID to the
-    #   $token transaction, which retains its socket placeholder.
-    cleanup $token2
-    return -code error $msg
-}
-
-proc http::AllDone {varName args} {
-    set $varName done
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::socket
-# ------------------------------------------------------------------------------
-# This command is a drop-in replacement for ::socket.
-# Arguments and return value as for ::socket.
-#
-# Notes.
-# - http::socket is specified in place of ::socket by the definition of urlTypes
-#   in the namespace header of this file (http.tcl).
-# - The command makes a simple call to ::socket unless the user has called
-#   http::config to change the value of -threadlevel from the default value 0.
-# - For -threadlevel 1 or 2, if the Thread package is available, the command
-#   waits in the event loop while the socket is opened in another thread.  This
-#   is a workaround for bug [824251] - it prevents http::geturl from blocking
-#   the event loop if the DNS lookup or server connection is slow.
-# - FIXME Use a thread pool if connections are very frequent.
-# - FIXME The peer thread can transfer the socket only to the main interpreter
-#   in the present thread.  Therefore this code works only if this script runs
-#   in the main interpreter.  In a child interpreter, the parent must alias a
-#   command to ::http::socket in the child, run http::socket in the parent,
-#   and then transfer the socket to the child.
-# - The http::socket command is simple, and can easily be replaced with an
-#   alternative command that uses a different technique to open a socket while
-#   entering the event loop.
-# - Unexpected behaviour by thread::send -async (Thread 2.8.6).
-#   An error in thread::send -async causes return of just the error message
-#   (not the expected 3 elements), and raises a bgerror in the main thread.
-#   Hence wrap the command with catch as a precaution.
-# ------------------------------------------------------------------------------
-
-proc http::socket {args} {
-    variable ThreadVar
-    variable ThreadCounter
-    variable http
-
-    LoadThreadIfNeeded
-
-    set targ [lsearch -exact $args -type]
-    if {$targ != -1} {
-        set token [lindex $args $targ+1]
-        set args [lreplace $args $targ $targ+1]
-        upvar 0 $token state
-    }
-
-    if {!$http(usingThread)} {
-        # Use plain "::socket".  This is the default.
-        return [eval ::socket $args]
-    }
-
-    set defcmd ::socket
-    set sockargs $args
-    set script "
-        set code \[catch {
-            [list proc ::SockInThread {caller defcmd sockargs} [info body ::http::SockInThread]]
-            [list ::SockInThread [thread::id] $defcmd $sockargs]
-        } result opts\]
-        list \$code \$opts \$result
-    "
-
-    set state(tid) [thread::create]
-    set varName ::http::ThreadVar([incr ThreadCounter])
-    thread::send -async $state(tid) $script $varName
-    Log >T Thread Start Wait $args -- coro [info coroutine] $varName
-    if {[info coroutine] ne {}} {
-        # All callers in the http package are coroutines launched by
-        # the event loop.
-        # The cwait command requires a coroutine because it yields
-        # to the caller; $varName is traced and the coroutine resumes
-        # when the variable is written.
-        cwait $varName
-    } else {
-        return -code error {code must run in a coroutine}
-        # For testing with a non-coroutine caller outside the http package.
-        # vwait $varName
-    }
-    Log >U Thread End Wait $args -- coro [info coroutine] $varName [set $varName]
-    thread::release $state(tid)
-    set state(tid) {}
-    set result [set $varName]
-    unset $varName
-    if {(![string is list $result]) || ([llength $result] != 3)} {
-        return -code error "result from peer thread is not a list of\
-                length 3: it is \n$result"
-    }
-    lassign $result threadCode threadDict threadResult
-    if {($threadCode != 0)} {
-        # This is an error in thread::send.  Return the lot.
-        return -options $threadDict -code error $threadResult
-    }
-
-    # Now the results of the catch in the peer thread.
-    lassign $threadResult catchCode errdict sock
-
-    if {($catchCode == 0) && ($sock ni [chan names])} {
-        return -code error {Transfer of socket from peer thread failed.\
-		Check that this script is not running in a child interpreter.}
-    }
-    return -options $errdict -code $catchCode $sock
-}
-
-# The commands below are dependencies of http::socket and
-# http::SecureProxyConnect and are not used elsewhere.
-
-# ------------------------------------------------------------------------------
-#  Proc http::LoadThreadIfNeeded
-# ------------------------------------------------------------------------------
-# Command to load the Thread package if it is needed.  If it is needed and not
-# loadable, the outcome depends on $http(-threadlevel):
-# value 0 => Thread package not required, no problem
-# value 1 => operate as if -threadlevel 0
-# value 2 => error return
-#
-# Arguments: none
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-proc http::LoadThreadIfNeeded {} {
-    variable http
-    if {$http(usingThread) || ($http(-threadlevel) == 0)} {
-        return
-    }
-    if {[catch {package require Thread}]} {
-        if {$http(-threadlevel) == 2} {
-            set msg {[http::config -threadlevel] has value 2,\
-                     but the Thread package is not available}
-            return -code error $msg
-        }
-        return
-    }
-    set http(usingThread) 1
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::SockInThread
-# ------------------------------------------------------------------------------
-# Command http::socket is a ::socket replacement.  It defines and runs this
-# command, http::SockInThread, in a peer thread.
-#
-# Arguments:
-# caller
-# defcmd
-# sockargs
-#
-# Return value: list of values that describe the outcome.  The return is
-# intended to be a normal (non-error) return in all cases.
-# ------------------------------------------------------------------------------
-
-proc http::SockInThread {caller defcmd sockargs} {
-    package require Thread
-
-    set catchCode [catch {eval $defcmd $sockargs} sock errdict]
-    if {$catchCode == 0} {
-        set catchCode [catch {thread::transfer $caller $sock; set sock} sock errdict]
-    }
-    return [list $catchCode $errdict $sock]
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::cwaiter::cwait
-# ------------------------------------------------------------------------------
-# Command to substitute for vwait, without the ordering issues.
-# A command that uses cwait must be a coroutine that is launched by an event,
-# e.g. fileevent or after idle, and has no calling code to be resumed upon
-# "yield".  It cannot return a value.
-#
-# Arguments:
-# varName      - fully-qualified name of the variable that the calling script
-#                will write to resume the coroutine.  Any scalar variable or
-#                array element is permitted.
-# coroName     - (optional) name of the coroutine to be called when varName is
-#                written - defaults to this coroutine
-# timeout      - (optional) timeout value in ms
-# timeoutValue - (optional) value to assign to varName if there is a timeout
-#
-# Return Value: none
-# ------------------------------------------------------------------------------
-
-namespace eval http::cwaiter {
-    namespace export cwait
-    variable log   {}
-    variable logOn 0
-}
-
-proc http::cwaiter::cwait {
-    varName {coroName {}} {timeout {}} {timeoutValue {}}
-} {
-    set thisCoro [info coroutine]
-    if {$thisCoro eq {}} {
-        return -code error {cwait cannot be called outside a coroutine}
-    }
-    if {$coroName eq {}} {
-        set coroName $thisCoro
-    }
-    if {[string range $varName 0 1] ne {::}} {
-        return -code error {argument varName must be fully qualified}
-    }
-    if {$timeout eq {}} {
-        set toe {}
-    } elseif {[string is integer -strict $timeout] && ($timeout > 0)} {
-        set toe [after $timeout [list set $varName $timeoutValue]]
-    } else {
-        return -code error {if timeout is supplied it must be a positive integer}
-    }
-
-    set cmd [list ::http::cwaiter::CwaitHelper $varName $coroName $toe]
-    trace add variable $varName write $cmd
-    CoLog "Yield $varName $coroName"
-    yield
-    CoLog "Resume $varName $coroName"
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::cwaiter::CwaitHelper
-# ------------------------------------------------------------------------------
-# Helper command called by the trace set by cwait.
-# - Ignores the arguments added by trace.
-# - A simple call to $coroName works, and in error cases gives a suitable stack
-#   trace, but because it is inside a trace the headline error message is
-#   something like {can't set "::Result(6)": error}, not the actual
-#   error.  So let the trace command return.
-# - Remove the trace immediately.  We don't want multiple calls.
-# ------------------------------------------------------------------------------
-
-proc http::cwaiter::CwaitHelper {varName coroName toe args} {
-    CoLog "got $varName for $coroName"
-    set cmd [list ::http::cwaiter::CwaitHelper $varName $coroName $toe]
-    trace remove variable $varName write $cmd
-    after cancel $toe
-
-    after 0 $coroName
-    return
-}
-
-
-# ------------------------------------------------------------------------------
-#  Proc http::cwaiter::LogInit
-# ------------------------------------------------------------------------------
-# Call this command to initiate debug logging and clear the log.
-# ------------------------------------------------------------------------------
-
-proc http::cwaiter::LogInit {} {
-    variable log
-    variable logOn
-    set log {}
-    set logOn 1
-    return
-}
-
-proc http::cwaiter::LogRead {} {
-    variable log
-    return $log
-}
-
-proc http::cwaiter::CoLog {msg} {
-    variable log
-    variable logOn
-    if {$logOn} {
-        append log $msg \n
-    }
-    return
-}
-
-namespace eval http {
-    namespace import ::http::cwaiter::*
-}
-
-# Local variables:
-# indent-tabs-mode: t
-# End:
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/mime-1.7.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/mime-1.7.0.tm
deleted file mode 100644
index fa460769..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/mime-1.7.0.tm
+++ /dev/null
@@ -1,3942 +0,0 @@
-# mime.tcl - MIME body parts
-#
-# (c) 1999-2000 Marshall T. Rose
-# (c) 2000      Brent Welch
-# (c) 2000      Sandeep Tamhankar
-# (c) 2000      Dan Kuchler
-# (c) 2000-2001 Eric Melski
-# (c) 2001      Jeff Hobbs
-# (c) 2001-2008 Andreas Kupries
-# (c) 2002-2003 David Welton
-# (c) 2003-2008 Pat Thoyts
-# (c) 2005      Benjamin Riefenstahl
-# (c) 2013-2021 Poor Yorick
-#
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# Influenced by Borenstein's/Rose's safe-tcl (circa 1993) and Darren New's
-# unpublished package of 1999.
-#
-
-# new string features and inline scan are used, requiring 8.3.
-package require Tcl 8.5
-
-package provide mime 1.7.0
-package require tcl::chan::memchan
-
-
-if {[catch {package require Trf 2.0}]} {
-
-    # Fall-back to tcl-based procedures of base64 and quoted-printable
-    # encoders
-    ##
-    # Warning!
-    ##
-    # These are a fragile emulations of the more general calling
-    # sequence that appears to work with this code here.
-    ##
-    # The `__ignored__` arguments are expected to be `--` options on
-    # the caller's side. (See the uses in `copymessageaux`,
-    # `buildmessageaux`, `parsepart`, and `getbody`).
-
-    package require base64 2.0
-    set ::major [lindex [split [package require md5] .] 0]
-
-    # Create these commands in the mime namespace so that they
-    # won't collide with things at the global namespace level
-
-    namespace eval ::mime {
-        proc base64 {-mode what __ignored__ chunk} {
-            return [base64::$what $chunk]
-        }
-        proc quoted-printable {-mode what __ignored__ chunk} {
-            return [mime::qp_$what $chunk]
-        }
-
-        if {$::major < 2} {
-            # md5 v1, result is hex string ready for use.
-            proc md5 {__ignored__ string} {
-                return [md5::md5 $string]
-            }
-        } else {
-            # md5 v2, need option to get hex string
-            proc md5 {__ignored__ string} {
-                return [md5::md5 -hex $string]
-            }
-        }
-    }
-
-    unset ::major
-}
-
-#
-# state variables:
-#
-#     canonicalP: input is in its canonical form
-#     content: type/subtype
-#     params: dictionary (keys are lower-case)
-#     encoding: transfer encoding
-#     version: MIME-version
-#     header: dictionary (keys are lower-case)
-#     lowerL: list of header keys, lower-case
-#     mixedL: list of header keys, mixed-case
-#     value: either "file", "parts", or "string"
-#
-#     file: input file
-#     fd: cached file-descriptor, typically for root
-#     root: token for top-level part, for (distant) subordinates
-#     offset: number of octets from beginning of file/string
-#     count: length in octets of (encoded) content
-#
-#     parts: list of bodies (tokens)
-#
-#     string: input string
-#
-#     cid: last child-id assigned
-#
-
-
-namespace eval ::mime {
-    variable mime
-    array set mime {uid 0 cid 0}
-
-    # RFC 822 lexemes
-    variable addrtokenL
-    lappend addrtokenL \; , < > : . ( ) @ \" \[ ] \\
-    variable addrlexemeL {
-        LX_SEMICOLON LX_COMMA
-        LX_LBRACKET  LX_RBRACKET
-        LX_COLON     LX_DOT
-        LX_LPAREN    LX_RPAREN
-        LX_ATSIGN    LX_QUOTE
-        LX_LSQUARE   LX_RSQUARE
-        LX_QUOTE
-    }
-
-    # RFC 2045 lexemes
-    variable typetokenL
-    lappend typetokenL \; , < > : ? ( ) @ \" \[ \] = / \\
-    variable typelexemeL {
-        LX_SEMICOLON LX_COMMA
-        LX_LBRACKET  LX_RBRACKET
-        LX_COLON     LX_QUESTION
-        LX_LPAREN    LX_RPAREN
-        LX_ATSIGN    LX_QUOTE
-        LX_LSQUARE   LX_RSQUARE
-        LX_EQUALS    LX_SOLIDUS
-        LX_QUOTE
-    }
-
-    variable encList {
-        ascii US-ASCII
-        big5 Big5
-        cp1250 Windows-1250
-        cp1251 Windows-1251
-        cp1252 Windows-1252
-        cp1253 Windows-1253
-        cp1254 Windows-1254
-        cp1255 Windows-1255
-        cp1256 Windows-1256
-        cp1257 Windows-1257
-        cp1258 Windows-1258
-        cp437 IBM437
-        cp737 {}
-        cp775 IBM775
-        cp850 IBM850
-        cp852 IBM852
-        cp855 IBM855
-        cp857 IBM857
-        cp860 IBM860
-        cp861 IBM861
-        cp862 IBM862
-        cp863 IBM863
-        cp864 IBM864
-        cp865 IBM865
-        cp866 IBM866
-        cp869 IBM869
-        cp874 {}
-        cp932 {}
-        cp936 GBK
-        cp949 {}
-        cp950 {}
-        dingbats {}
-        ebcdic {}
-        euc-cn EUC-CN
-        euc-jp EUC-JP
-        euc-kr EUC-KR
-        gb12345 GB12345
-        gb1988 GB1988
-        gb2312 GB2312
-        iso2022 ISO-2022
-        iso2022-jp ISO-2022-JP
-        iso2022-kr ISO-2022-KR
-        iso8859-1 ISO-8859-1
-        iso8859-2 ISO-8859-2
-        iso8859-3 ISO-8859-3
-        iso8859-4 ISO-8859-4
-        iso8859-5 ISO-8859-5
-        iso8859-6 ISO-8859-6
-        iso8859-7 ISO-8859-7
-        iso8859-8 ISO-8859-8
-        iso8859-9 ISO-8859-9
-        iso8859-10 ISO-8859-10
-        iso8859-13 ISO-8859-13
-        iso8859-14 ISO-8859-14
-        iso8859-15 ISO-8859-15
-        iso8859-16 ISO-8859-16
-        jis0201 JIS_X0201
-        jis0208 JIS_C6226-1983
-        jis0212 JIS_X0212-1990
-        koi8-r KOI8-R
-        koi8-u KOI8-U
-        ksc5601 KS_C_5601-1987
-        macCentEuro {}
-        macCroatian {}
-        macCyrillic {}
-        macDingbats {}
-        macGreek {}
-        macIceland {}
-        macJapan {}
-        macRoman {}
-        macRomania {}
-        macThai {}
-        macTurkish {}
-        macUkraine {}
-        shiftjis Shift_JIS
-        symbol {}
-        tis-620 TIS-620
-        unicode {}
-        utf-8 UTF-8
-    }
-
-    variable encodings
-    array set encodings $encList
-    variable reversemap
-    # Initialized at the bottom of the file
-
-    variable encAliasList {
-        ascii ANSI_X3.4-1968
-        ascii iso-ir-6
-        ascii ANSI_X3.4-1986
-        ascii ISO_646.irv:1991
-        ascii ASCII
-        ascii ISO646-US
-        ascii us
-        ascii IBM367
-        ascii cp367
-        cp437 cp437
-        cp437 437
-        cp775 cp775
-        cp850 cp850
-        cp850 850
-        cp852 cp852
-        cp852 852
-        cp855 cp855
-        cp855 855
-        cp857 cp857
-        cp857 857
-        cp860 cp860
-        cp860 860
-        cp861 cp861
-        cp861 861
-        cp861 cp-is
-        cp862 cp862
-        cp862 862
-        cp863 cp863
-        cp863 863
-        cp864 cp864
-        cp865 cp865
-        cp865 865
-        cp866 cp866
-        cp866 866
-        cp869 cp869
-        cp869 869
-        cp869 cp-gr
-        cp936 CP936
-        cp936 MS936
-        cp936 Windows-936
-        iso8859-1 ISO_8859-1:1987
-        iso8859-1 iso-ir-100
-        iso8859-1 ISO_8859-1
-        iso8859-1 latin1
-        iso8859-1 l1
-        iso8859-1 IBM819
-        iso8859-1 CP819
-        iso8859-2 ISO_8859-2:1987
-        iso8859-2 iso-ir-101
-        iso8859-2 ISO_8859-2
-        iso8859-2 latin2
-        iso8859-2 l2
-        iso8859-3 ISO_8859-3:1988
-        iso8859-3 iso-ir-109
-        iso8859-3 ISO_8859-3
-        iso8859-3 latin3
-        iso8859-3 l3
-        iso8859-4 ISO_8859-4:1988
-        iso8859-4 iso-ir-110
-        iso8859-4 ISO_8859-4
-        iso8859-4 latin4
-        iso8859-4 l4
-        iso8859-5 ISO_8859-5:1988
-        iso8859-5 iso-ir-144
-        iso8859-5 ISO_8859-5
-        iso8859-5 cyrillic
-        iso8859-6 ISO_8859-6:1987
-        iso8859-6 iso-ir-127
-        iso8859-6 ISO_8859-6
-        iso8859-6 ECMA-114
-        iso8859-6 ASMO-708
-        iso8859-6 arabic
-        iso8859-7 ISO_8859-7:1987
-        iso8859-7 iso-ir-126
-        iso8859-7 ISO_8859-7
-        iso8859-7 ELOT_928
-        iso8859-7 ECMA-118
-        iso8859-7 greek
-        iso8859-7 greek8
-        iso8859-8 ISO_8859-8:1988
-        iso8859-8 iso-ir-138
-        iso8859-8 ISO_8859-8
-        iso8859-8 hebrew
-        iso8859-9 ISO_8859-9:1989
-        iso8859-9 iso-ir-148
-        iso8859-9 ISO_8859-9
-        iso8859-9 latin5
-        iso8859-9 l5
-        iso8859-10 iso-ir-157
-        iso8859-10 l6
-        iso8859-10 ISO_8859-10:1992
-        iso8859-10 latin6
-        iso8859-14 iso-ir-199
-        iso8859-14 ISO_8859-14:1998
-        iso8859-14 ISO_8859-14
-        iso8859-14 latin8
-        iso8859-14 iso-celtic
-        iso8859-14 l8
-        iso8859-15 ISO_8859-15
-        iso8859-15 Latin-9
-        iso8859-16 iso-ir-226
-        iso8859-16 ISO_8859-16:2001
-        iso8859-16 ISO_8859-16
-        iso8859-16 latin10
-        iso8859-16 l10
-        jis0201 X0201
-        jis0208 iso-ir-87
-        jis0208 x0208
-        jis0208 JIS_X0208-1983
-        jis0212 x0212
-        jis0212 iso-ir-159
-        ksc5601 iso-ir-149
-        ksc5601 KS_C_5601-1989
-        ksc5601 KSC5601
-        ksc5601 korean
-        shiftjis MS_Kanji
-        utf-8 UTF8
-    }
-
-    namespace export {*}{
-	copymessage finalize getbody getheader getproperty initialize
-	mapencoding parseaddress parsedatetime reversemapencoding setheader
-	uniqueID
-    }
-}
-
-# ::mime::initialize --
-#
-#    Creates a MIME part, and returnes the MIME token for that part.
-#
-# Arguments:
-#    args   Args can be any one of the following:
-#                  ?-canonical type/subtype
-#                  ?-param    {key value}?...
-#                  ?-encoding value?
-#                  ?-header   {key value}?... ?
-#                  (-file name | -string value | -parts {token1 ... tokenN})
-#
-#       If the -canonical option is present, then the body is in
-#       canonical (raw) form and is found by consulting either the -file,
-#       -string, or -parts option.
-#
-#       In addition, both the -param and -header options may occur zero
-#       or more times to specify "Content-Type" parameters (e.g.,
-#       "charset") and header keyword/values (e.g.,
-#       "Content-Disposition"), respectively.
-#
-#       Also, -encoding, if present, specifies the
-#       "Content-Transfer-Encoding" when copying the body.
-#
-#       If the -canonical option is not present, then the MIME part
-#       contained in either the -file or the -string option is parsed,
-#       dynamically generating subordinates as appropriate.
-#
-# Results:
-#    An initialized mime token.
-
-proc ::mime::initialize args {
-    global errorCode errorInfo
-
-    variable mime
-
-    set token [namespace current]::[incr mime(uid)]
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    if {[catch [list mime::initializeaux $token {*}$args] result eopts]} {
-        catch {mime::finalize $token -subordinates dynamic}
-        return -options $eopts $result
-    }
-    return $token
-}
-
-# ::mime::initializeaux --
-#
-#    Configures the MIME token created in mime::initialize based on
-#       the arguments that mime::initialize supports.
-#
-# Arguments:
-#       token  The MIME token to configure.
-#    args   Args can be any one of the following:
-#                  ?-canonical type/subtype
-#                  ?-param    {key value}?...
-#                  ?-encoding value?
-#                  ?-header   {key value}?... ?
-#                  (-file name | -string value | -parts {token1 ... tokenN})
-#
-# Results:
-#       Either configures the mime token, or throws an error.
-
-proc ::mime::initializeaux {token args} {
-    global errorCode errorInfo
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    array set params [set state(params) {}]
-    set state(encoding) {}
-    set state(version) 1.0
-
-    set state(header) {}
-    set state(lowerL) {}
-    set state(mixedL) {}
-
-    set state(cid) 0
-
-    set userheader 0
-
-    set argc [llength $args]
-    for {set argx 0} {$argx < $argc} {incr argx} {
-        set option [lindex $args $argx]
-        if {[incr argx] >= $argc} {
-            error "missing argument to $option"
-        }
-        set value [lindex $args $argx]
-
-        switch -- $option {
-            -canonical {
-                set state(content) [string tolower $value]
-            }
-
-            -param {
-                if {[llength $value] != 2} {
-		    error "-param expects a key and a value, not $value"
-                }
-                set lower [string tolower [set mixed [lindex $value 0]]]
-                if {[info exists params($lower)]} {
-                    error "the $mixed parameter may be specified at most once"
-                }
-
-                set params($lower) [lindex $value 1]
-                set state(params) [array get params]
-            }
-
-            -encoding {
-		set value [string tolower $value[set value {}]]
-
-                switch -- $value {
-                    7bit - 8bit - binary - quoted-printable - base64 {
-                    }
-
-                    default {
-                        error "unknown value for -encoding $state(encoding)"
-                    }
-                }
-                set state(encoding) [string tolower $value]
-            }
-
-            -header {
-                if {[llength $value] != 2} {
-                    error "-header expects a key and a value, not $value"
-                }
-                set lower [string tolower [set mixed [lindex $value 0]]]
-                if {$lower eq {content-type}} {
-                    error "use -canonical instead of -header $value"
-                }
-                if {$lower eq {content-transfer-encoding}} {
-                    error "use -encoding instead of -header $value"
-                }
-                if {$lower in {content-md5 mime-version}} {
-                    error {don't go there...}
-                }
-                if {$lower ni $state(lowerL)} {
-                    lappend state(lowerL) $lower
-                    lappend state(mixedL) $mixed
-                }
-
-		set userheader 1
-
-                array set header $state(header)
-                lappend header($lower) [lindex $value 1]
-                set state(header) [array get header]
-            }
-
-            -file {
-                set state(file) $value
-            }
-
-            -parts {
-                set state(parts) $value
-            }
-
-            -string {
-                set state(string) $value
-
-                set state(lines) [split $value \n]
-                set state(lines.count) [llength $state(lines)]
-                set state(lines.current) 0
-            }
-
-            -root {
-                # the following are internal options
-
-                set state(root) $value
-            }
-
-            -offset {
-                set state(offset) $value
-            }
-
-            -count {
-                set state(count) $value
-            }
-
-            -lineslist {
-                set state(lines) $value
-                set state(lines.count) [llength $state(lines)]
-                set state(lines.current) 0
-                #state(string) is needed, but will be built when required
-                set state(string) {}
-            }
-
-            default {
-                error "unknown option $option"
-            }
-        }
-    }
-
-    #We only want one of -file, -parts or -string:
-    set valueN 0
-    foreach value {file parts string} {
-        if {[info exists state($value)]} {
-            set state(value) $value
-            incr valueN
-        }
-    }
-    if {$valueN != 1 && ![info exists state(lines)]} {
-        error {specify exactly one of -file, -parts, or -string}
-    }
-
-    if {[set state(canonicalP) [info exists state(content)]]} {
-        switch -- $state(value) {
-            file {
-                set state(offset) 0
-            }
-
-            parts {
-                switch -glob -- $state(content) {
-                    text/*
-                        -
-                    image/*
-                        -
-                    audio/*
-                        -
-                    video/* {
-                        error "-canonical $state(content) and -parts do not mix"
-                    }
-
-                    default {
-                        if {$state(encoding) ne {}} {
-                            error {-encoding and -parts do not mix}
-                        }
-                    }
-                }
-            }
-            default {# Go ahead}
-        }
-
-        if {[lsearch -exact $state(lowerL) content-id] < 0} {
-            lappend state(lowerL) content-id
-            lappend state(mixedL) Content-ID
-
-            array set header $state(header)
-            lappend header(content-id) [uniqueID]
-            set state(header) [array get header]
-        }
-
-        set state(version) 1.0
-        return
-    }
-
-    if {$state(params) ne {}} {
-        error {-param requires -canonical}
-    }
-    if {$state(encoding) ne {}} {
-        error {-encoding requires -canonical}
-    }
-    if {$userheader} {
-        error {-header requires -canonical}
-    }
-    if {[info exists state(parts)]} {
-        error {-parts requires -canonical}
-    }
-
-    if {[set fileP [info exists state(file)]]} {
-        if {[set openP [info exists state(root)]]} {
-            # FRINK: nocheck
-            variable $state(root)
-            upvar 0 $state(root) root
-
-            set state(fd) $root(fd)
-        } else {
-            set state(root) $token
-            set state(fd) [open $state(file) RDONLY]
-            set state(offset) 0
-            seek $state(fd) 0 end
-            set state(count) [tell $state(fd)]
-
-            fconfigure $state(fd) -translation binary
-        }
-    }
-
-    set code [catch {mime::parsepart $token} result]
-    set ecode $errorCode
-    set einfo $errorInfo
-
-    if {$fileP} {
-        if {!$openP} {
-            unset state(root)
-            catch {close $state(fd)}
-        }
-        unset state(fd)
-    }
-
-    return -code $code -errorinfo $einfo -errorcode $ecode $result
-}
-
-# ::mime::parsepart --
-#
-#       Parses the MIME headers and attempts to break up the message
-#       into its various parts, creating a MIME token for each part.
-#
-# Arguments:
-#       token  The MIME token to parse.
-#
-# Results:
-#       Throws an error if it has problems parsing the MIME token,
-#       otherwise it just sets up the appropriate variables.
-
-proc ::mime::parsepart {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    if {[set fileP [info exists state(file)]]} {
-        seek $state(fd) [set pos $state(offset)] start
-        set last [expr {$state(offset) + $state(count) - 1}]
-    } else {
-        set string $state(string)
-    }
-
-    set vline {}
-    while 1 {
-        set blankP 0
-        if {$fileP} {
-            if {($pos > $last) || ([set x [gets $state(fd) line]] <= 0)} {
-                set blankP 1
-            } else {
-                incr pos [expr {$x + 1}]
-            }
-        } else {
-	    if {$state(lines.current) >= $state(lines.count)} {
-		set blankP 1
-		set line {}
-	    } else {
-		set line [lindex $state(lines) $state(lines.current)]
-		incr state(lines.current)
-		set x [string length $line]
-		if {$x == 0} {set blankP 1}
-	    }
-        }
-
-         if {!$blankP && [string match *\r $line]} {
-             set line [string range $line 0 $x-2]]
-             if {$x == 1} {
-                 set blankP 1
-             }
-         }
-
-        if {!$blankP && (
-	    [string first { } $line] == 0
-	    ||
-	    [string first \t $line] == 0
-	)} {
-            append vline \n $line
-            continue
-        }
-
-        if {$vline eq {}} {
-            if {$blankP} {
-                break
-            }
-
-            set vline $line
-            continue
-        }
-
-        if {
-	    [set x [string first : $vline]] <= 0
-	    ||
-	    [set mixed [string trimright [
-		string range $vline 0 [expr {$x - 1}]]]] eq {}
-	} {
-            error "improper line in header: $vline"
-        }
-        set value [string trim [string range $vline [expr {$x + 1}] end]]
-        switch -- [set lower [string tolower $mixed]] {
-            content-type {
-                if {[info exists state(content)]} {
-                    error "multiple Content-Type fields starting with $vline"
-                }
-
-                if {![catch {set x [parsetype $token $value]}]} {
-                    set state(content) [lindex $x 0]
-                    set state(params) [lindex $x 1]
-                }
-            }
-
-            content-md5 {
-            }
-
-            content-transfer-encoding {
-                if {
-		    $state(encoding) ne {}
-		    &&
-		    $state(encoding) ne [string tolower $value]
-		} {
-                    error "multiple Content-Transfer-Encoding fields starting with $vline"
-                }
-
-                set state(encoding) [string tolower $value]
-            }
-
-            mime-version {
-                set state(version) $value
-            }
-
-            default {
-                if {[lsearch -exact $state(lowerL) $lower] < 0} {
-                    lappend state(lowerL) $lower
-                    lappend state(mixedL) $mixed
-                }
-
-                array set header $state(header)
-                lappend header($lower) $value
-                set state(header) [array get header]
-            }
-        }
-
-        if {$blankP} {
-            break
-        }
-        set vline $line
-    }
-
-    if {![info exists state(content)]} {
-        set state(content) text/plain
-        set state(params) [list charset us-ascii]
-    }
-
-    if {![string match multipart/* $state(content)]} {
-        if {$fileP} {
-            set x [tell $state(fd)]
-            incr state(count) [expr {$state(offset) - $x}]
-            set state(offset) $x
-        } else {
-            # rebuild string, this is cheap and needed by other functions
-            set state(string) [join [
-                lrange $state(lines) $state(lines.current) end] \n]
-        }
-
-        if {[string match message/* $state(content)]} {
-            # FRINK: nocheck
-            variable [set child $token-[incr state(cid)]]
-
-            set state(value) parts
-            set state(parts) $child
-            if {$fileP} {
-                mime::initializeaux $child \
-                    -file $state(file) -root $state(root) \
-                    -offset $state(offset) -count $state(count)
-            } else {
-                if {[info exists state(encoding)]} {
-                    set strng [join [
-                        lrange $state(lines) $state(lines.current) end] \n]
-                    switch -- $state(encoding) {
-                        base64 -
-                        quoted-printable {
-                            set strng [$state(encoding) -mode decode -- $strng]
-                        }
-                        default {}
-                    }
-                    mime::initializeaux $child -string $strng
-                } else {
-                    mime::initializeaux $child -lineslist [
-                        lrange $state(lines) $state(lines.current) end]
-                }
-            }
-        }
-
-        return
-    }
-
-    set state(value) parts
-
-    set boundary {}
-    foreach {k v} $state(params) {
-        if {$k eq {boundary}} {
-            set boundary $v
-            break
-        }
-    }
-    if {$boundary eq {}} {
-        error "boundary parameter is missing in $state(content)"
-    }
-    if {[string trim $boundary] eq {}} {
-        error "boundary parameter is empty in $state(content)"
-    }
-
-    if {$fileP} {
-        set pos [tell $state(fd)]
-            # This variable is like 'start', for the reasons laid out
-            # below, in the other branch of this conditional.
-            set initialpos $pos
-        } else {
-            # This variable is like 'start', a list of lines in the
-            # part. This record is made even before we find a starting
-            # boundary and used if we run into the terminating boundary
-            # before a starting boundary was found. In that case the lines
-            # before the terminator as recorded by tracelines are seen as
-            # the part, or at least we attempt to parse them as a
-            # part. See the forceoctet and nochild flags later. We cannot
-            # use 'start' as that records lines only after the starting
-            # boundary was found.
-            set tracelines [list]
-    }
-
-    set inP 0
-    set moreP 1
-    set forceoctet 0
-    while {$moreP} {
-        if {$fileP} {
-            if {$pos > $last} {
-                # We have run over the end of the part per the outer
-                # information without finding a terminating boundary.
-                # We now fake the boundary and force the parser to
-                # give any new part coming of this a mime-type of
-                # application/octet-stream regardless of header
-                # information.
-                set line "--$boundary--"
-                set x [string length $line]
-                set forceoctet 1
-            } else {
-                if {[set x [gets $state(fd) line]] < 0} {
-                    error "end-of-file encountered while parsing $state(content)"
-                }
-            }
-            incr pos [expr {$x + 1}]
-        } else {
-            if {$state(lines.current) >= $state(lines.count)} {
-                error "end-of-string encountered while parsing $state(content)"
-            } else {
-                set line [lindex $state(lines) $state(lines.current)]
-                incr state(lines.current)
-                set x [string length $line]
-            }
-            set x [string length $line]
-        }
-        if {[string last \r $line] == $x - 1} {
-            set line [string range $line 0 [expr {$x - 2}]]
-            set crlf 2
-        } else {
-            set crlf 1
-        }
-
-        if {[string first --$boundary $line] != 0} {
-             if {$inP && !$fileP} {
-                 lappend start $line
-             }
-             continue
-        } else {
-            lappend tracelines $line
-        }
-
-        if {!$inP} {
-            # Haven't seen the starting boundary yet. Check if the
-            # current line contains this starting boundary.
-
-            if {$line eq "--$boundary"} {
-                # Yes. Switch parser state to now search for the
-                # terminating boundary of the part and record where
-                # the part begins (or initialize the recorder for the
-                # lines in the part).
-                set inP 1
-                if {$fileP} {
-                    set start $pos
-                } else {
-                    set start [list]
-                }
-                continue
-            } elseif {$line eq "--$boundary--"} {
-                # We just saw a terminating boundary before we ever
-                # saw the starting boundary of a part. This forces us
-                # to stop parsing, we do this by forcing the parser
-                # into an accepting state. We will try to create a
-                # child part based on faked start position or recorded
-                # lines, or, if that fails, let the current part have
-                # no children.
-
-                # As an example note the test case mime-3.7 and the
-                # referenced file "badmail1.txt".
-
-                set inP 1
-                if {$fileP} {
-                    set start $initialpos
-                } else {
-                    set start $tracelines
-                }
-                set forceoctet 1
-                # Fall through. This brings to the creation of the new
-                # part instead of searching further and possible
-                # running over the end.
-            } else {
-                continue
-            }
-        }
-
-        # Looking for the end of the current part. We accept both a
-        # terminating boundary and the starting boundary of the next
-        # part as the end of the current part.
-
-        if {[set moreP [string compare $line --$boundary--]]
-	    && $line ne "--$boundary"} {
-
-            # The current part has not ended, so we record the line
-            # if we are inside a part and doing string parsing.
-            if {$inP && !$fileP} {
-                lappend start $line
-            }
-            continue
-        }
-
-        # The current part has ended. We now determine the exact
-        # boundaries, create a mime part object for it and recursively
-        # parse it deeper as part of that action.
-
-        # FRINK: nocheck
-        variable [set child $token-[incr state(cid)]]
-
-        lappend state(parts) $child
-
-        set nochild 0
-        if {$fileP} {
-            if {[set count [expr {$pos - ($start + $x + $crlf + 1)}]] < 0} {
-                set count 0
-            }
-            if {$forceoctet} {
-                set ::errorInfo {}
-                if {[catch {
-                    mime::initializeaux $child \
-                        -file $state(file) -root $state(root) \
-                        -offset $start -count $count
-                }]} {
-                    set nochild 1
-                    set state(parts) [lrange $state(parts) 0 end-1]
-                } } else {
-                mime::initializeaux $child \
-                    -file $state(file) -root $state(root) \
-                    -offset $start -count $count
-            }
-            seek $state(fd) [set start $pos] start
-        } else {
-            if {$forceoctet} {
-                if {[catch {
-                    mime::initializeaux $child -lineslist $start
-                }]} {
-                    set nochild 1
-                    set state(parts) [lrange $state(parts) 0 end-1]
-                }
-            } else {
-                mime::initializeaux $child -lineslist $start
-            }
-            set start {}
-        }
-        if {$forceoctet && !$nochild} {
-            variable $child
-            upvar 0  $child childstate
-            set childstate(content) application/octet-stream
-        }
-        set forceoctet 0
-    }
-}
-
-# ::mime::parsetype --
-#
-#       Parses the string passed in and identifies the content-type and
-#       params strings.
-#
-# Arguments:
-#       token  The MIME token to parse.
-#       string The content-type string that should be parsed.
-#
-# Results:
-#       Returns the content and params for the string as a two element
-#       tcl list.
-
-proc ::mime::parsetype {token string} {
-    global errorCode errorInfo
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    variable typetokenL
-    variable typelexemeL
-
-    set state(input)   $string
-    set state(buffer)  {}
-    set state(lastC)   LX_END
-    set state(comment) {}
-    set state(tokenL)  $typetokenL
-    set state(lexemeL) $typelexemeL
-
-    set code [catch {mime::parsetypeaux $token $string} result]
-    set ecode $errorCode
-    set einfo $errorInfo
-
-    unset {*}{
-	state(input)
-	state(buffer)
-	state(lastC)
-	state(comment)
-	state(tokenL)
-	state(lexemeL)
-    }
-
-    return -code $code -errorinfo $einfo -errorcode $ecode $result
-}
-
-# ::mime::parsetypeaux --
-#
-#       A helper function for mime::parsetype.  Parses the specified
-#       string looking for the content type and params.
-#
-# Arguments:
-#       token  The MIME token to parse.
-#       string The content-type string that should be parsed.
-#
-# Results:
-#       Returns the content and params for the string as a two element
-#       tcl list.
-
-proc ::mime::parsetypeaux {token string} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    if {[parselexeme $token] ne {LX_ATOM}} {
-        error [format {expecting type (found %s)} $state(buffer)]
-    }
-    set type [string tolower $state(buffer)]
-
-    switch -- [parselexeme $token] {
-        LX_SOLIDUS {
-        }
-
-        LX_END {
-            if {$type ne {message}} {
-                error "expecting type/subtype (found $type)"
-            }
-
-            return [list message/rfc822 {}]
-        }
-
-        default {
-            error [format "expecting \"/\" (found %s)" $state(buffer)]
-        }
-    }
-
-    if {[parselexeme $token] ne {LX_ATOM}} {
-        error [format "expecting subtype (found %s)" $state(buffer)]
-    }
-    append type [string tolower /$state(buffer)]
-
-    array set params {}
-    while 1 {
-        switch -- [parselexeme $token] {
-            LX_END {
-                return [list $type [array get params]]
-            }
-
-            LX_SEMICOLON {
-            }
-
-            default {
-                error [format "expecting \";\" (found %s)" $state(buffer)]
-            }
-        }
-
-        switch -- [parselexeme $token] {
-            LX_END {
-                return [list $type [array get params]]
-            }
-
-            LX_ATOM {
-            }
-
-            default {
-                error [format "expecting attribute (found %s)" $state(buffer)]
-            }
-        }
-
-        set attribute [string tolower $state(buffer)]
-
-        if {[parselexeme $token] ne {LX_EQUALS}} {
-            error [format {expecting "=" (found %s)} $state(buffer)]
-        }
-
-        switch -- [parselexeme $token] {
-            LX_ATOM {
-            }
-
-            LX_QSTRING {
-                set state(buffer) [
-                    string range $state(buffer) 1 [
-                        expr {[string length $state(buffer)] - 2}]]
-            }
-
-            default {
-                error [format {expecting value (found %s)} $state(buffer)]
-            }
-        }
-        set params($attribute) $state(buffer)
-    }
-}
-
-# ::mime::finalize --
-#
-#   mime::finalize destroys a MIME part.
-#
-#   If the -subordinates option is present, it specifies which
-#   subordinates should also be destroyed. The default value is
-#   "dynamic".
-#
-# Arguments:
-#       token  The MIME token to parse.
-#       args   Args can be optionally be of the following form:
-#              ?-subordinates "all" | "dynamic" | "none"?
-#
-# Results:
-#       Returns an empty string.
-
-proc ::mime::finalize {token args} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    array set options [list -subordinates dynamic]
-    array set options $args
-
-    switch -- $options(-subordinates) {
-        all {
-            #TODO: this code path is untested
-            if {$state(value) eq {parts}} {
-                foreach part $state(parts) {
-                    eval [linsert $args 0 mime::finalize $part]
-                }
-            }
-        }
-
-        dynamic {
-            for {set cid $state(cid)} {$cid > 0} {incr cid -1} {
-                eval [linsert $args 0 mime::finalize $token-$cid]
-            }
-        }
-
-        none {
-        }
-
-        default {
-            error "unknown value for -subordinates $options(-subordinates)"
-        }
-    }
-
-    foreach name [array names state] {
-        unset state($name)
-    }
-    # FRINK: nocheck
-    unset $token
-}
-
-# ::mime::getproperty --
-#
-#   mime::getproperty returns the properties of a MIME part.
-#
-#   The properties are:
-#
-#       property    value
-#       ========    =====
-#       content     the type/subtype describing the content
-#       encoding    the "Content-Transfer-Encoding"
-#       params      a list of "Content-Type" parameters
-#       parts       a list of tokens for the part's subordinates
-#       size        the approximate size of the content (unencoded)
-#
-#   The "parts" property is present only if the MIME part has
-#   subordinates.
-#
-#   If mime::getproperty is invoked with the name of a specific
-#   property, then the corresponding value is returned; instead, if
-#   -names is specified, a list of all properties is returned;
-#   otherwise, a dictionary of properties is returned.
-#
-# Arguments:
-#       token      The MIME token to parse.
-#       property   One of 'content', 'encoding', 'params', 'parts', and
-#                  'size'. Defaults to returning a dictionary of
-#                  properties.
-#
-# Results:
-#       Returns the properties of a MIME part
-
-proc ::mime::getproperty {token {property {}}} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    switch -- $property {
-        {} {
-            array set properties [list content  $state(content) \
-                                       encoding $state(encoding) \
-                                       params   $state(params) \
-                                       size     [getsize $token]]
-            if {[info exists state(parts)]} {
-                set properties(parts) $state(parts)
-            }
-
-            return [array get properties]
-        }
-
-        -names {
-            set names [list content encoding params]
-            if {[info exists state(parts)]} {
-                lappend names parts
-            }
-
-            return $names
-        }
-
-        content
-            -
-        encoding
-            -
-        params {
-            return $state($property)
-        }
-
-        parts {
-            if {![info exists state(parts)]} {
-                error {MIME part is a leaf}
-            }
-
-            return $state(parts)
-        }
-
-        size {
-            return [getsize $token]
-        }
-
-        default {
-            error "unknown property $property"
-        }
-    }
-}
-
-# ::mime::getsize --
-#
-#    Determine the size (in bytes) of a MIME part/token
-#
-# Arguments:
-#       token      The MIME token to parse.
-#
-# Results:
-#       Returns the size in bytes of the MIME token.
-
-proc ::mime::getsize {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    switch -- $state(value)/$state(canonicalP) {
-        file/0 {
-            set size $state(count)
-        }
-
-        file/1 {
-            return [file size $state(file)]
-        }
-
-        parts/0
-            -
-        parts/1 {
-            set size 0
-            foreach part $state(parts) {
-                incr size [getsize $part]
-            }
-
-            return $size
-        }
-
-        string/0 {
-            set size [string length $state(string)]
-        }
-
-        string/1 {
-            return [string length $state(string)]
-        }
-        default {
-            error "Unknown combination \"$state(value)/$state(canonicalP)\""
-        }
-    }
-
-    if {$state(encoding) eq {base64}} {
-        set size [expr {($size * 3 + 2) / 4}]
-    }
-
-    return $size
-}
-
-
-proc ::mime::getContentType token {
-    variable $token
-    upvar 0 $token state
-    set boundary {}
-    set res $state(content)
-    foreach {k v} $state(params) {
-	set boundary $v
-        append res ";\n              $k=\"$v\""
-    }
-    if {([string match multipart/* $state(content)]) \
-        && ($boundary eq {})} {
-        # we're doing everything in one pass...
-        set key [clock seconds]$token[info hostname][array get state]
-        set seqno 8
-        while {[incr seqno -1] >= 0} {
-            set key [md5 -- $key]
-        }
-        set boundary "----- =_[string trim [base64 -mode encode -- $key]]"
-
-        append res ";\n              boundary=\"$boundary\""
-    }
-    return $res
-}
-
-# ::mime::getheader --
-#
-#    mime::getheader returns the header of a MIME part.
-#
-#    A header consists of zero or more key/value pairs. Each value is a
-#    list containing one or more strings.
-#
-#    If mime::getheader is invoked with the name of a specific key, then
-#    a list containing the corresponding value(s) is returned; instead,
-#    if -names is specified, a list of all keys is returned; otherwise, a
-#    dictionary is returned. Note that when a
-#    key is specified (e.g., "Subject"), the list returned usually
-#    contains exactly one string; however, some keys (e.g., "Received")
-#    often occur more than once in the header, accordingly the list
-#    returned usually contains more than one string.
-#
-# Arguments:
-#       token      The MIME token to parse.
-#       key        Either a key or '-names'.  If it is '-names' a list
-#                  of all keys is returned.
-#
-# Results:
-#       Returns the header of a MIME part.
-
-proc ::mime::getheader {token {key {}}} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    array set header $state(header)
-    switch -- $key {
-        {} {
-            set result {}
-	    lappend result MIME-Version $state(version)
-            foreach lower $state(lowerL) mixed $state(mixedL) {
-		foreach value $header($lower) {
-		    lappend result $mixed $value 
-		}
-            }
-	    set tencoding [getTransferEncoding $token]
-	    if {$tencoding ne {}} {
-		lappend result Content-Transfer-Encoding $tencoding
-	    }
-	    lappend result Content-Type [getContentType $token]
-            return $result
-        }
-
-        -names {
-            return $state(mixedL)
-        }
-
-        default {
-            set lower [string tolower $key]
-
-	    switch $lower {
-		content-transfer-encoding {
-		    return [getTransferEncoding $token]
-		}
-		content-type {
-		    return [list [getContentType $token]]
-		}
-		mime-version {
-		    return [list $state(version)]
-		}
-		default {
-		    if {![info exists header($lower)]} {
-			error "key $key not in header"
-		    }
-		    return $header($lower)
-		}
-	    }
-        }
-    }
-}
-
-
-proc ::mime::getTransferEncoding token {
-    variable $token
-    upvar 0 $token state
-    set res {}
-    if {[set encoding $state(encoding)] eq {}} {
-	set encoding [encoding $token]
-    }
-    if {$encoding ne {}} {
-	set res $encoding
-    }
-    switch -- $encoding {
-	base64
-	    -
-	quoted-printable {
-	    set converter $encoding
-	}
-	7bit - 8bit - binary - {} {
-	    # Bugfix for [#477088], also [#539952]
-	    # Go ahead
-	}
-	default {
-	    error "Can't handle content encoding \"$encoding\""
-	}
-    }
-    return $res
-}
-
-# ::mime::setheader --
-#
-#    mime::setheader writes, appends to, or deletes the value associated
-#    with a key in the header.
-#
-#    The value for -mode is one of:
-#
-#       write: the key/value is either created or overwritten (the
-#       default);
-#
-#       append: a new value is appended for the key (creating it as
-#       necessary); or,
-#
-#       delete: all values associated with the key are removed (the
-#       "value" parameter is ignored).
-#
-#    Regardless, mime::setheader returns the previous value associated
-#    with the key.
-#
-# Arguments:
-#       token      The MIME token to parse.
-#       key        The name of the key whose value should be set.
-#       value      The value for the header key to be set to.
-#       args       An optional argument of the form:
-#                  ?-mode "write" | "append" | "delete"?
-#
-# Results:
-#       Returns previous value associated with the specified key.
-
-proc ::mime::setheader {token key value args} {
-    # FRINK: nocheck
-    variable internal
-    variable $token
-    upvar 0 $token state
-
-    array set options [list -mode write]
-    array set options $args
-
-    set lower [string tolower $key]
-    array set header $state(header)
-    if {[set x [lsearch -exact $state(lowerL) $lower]] < 0} {
-        #TODO: this code path is not tested
-        if {$options(-mode) eq {delete}} {
-            error "key $key not in header"
-        }
-
-        lappend state(lowerL) $lower
-        lappend state(mixedL) $key
-
-        set result {}
-    } else {
-        set result $header($lower)
-    }
-    switch -- $options(-mode) {
-	append - write {
-	    if {!$internal} {
-		switch -- $lower {
-		    content-md5
-			-
-		    content-type
-			-
-		    content-transfer-encoding
-			-
-		    mime-version {
-			set values [getheader $token $lower]
-			if {$value ni $values} {
-			    error "key $key may not be set"
-			}
-		    }
-		    default {# Skip key}
-		}
-	    }
-	    switch -- $options(-mode) {
-		append {
-		    lappend header($lower) $value
-		}
-		write {
-		    set header($lower) [list $value]
-		}
-	    }
-	}
-        delete {
-            unset header($lower)
-            set state(lowerL) [lreplace $state(lowerL) $x $x]
-            set state(mixedL) [lreplace $state(mixedL) $x $x]
-        }
-
-        default {
-            error "unknown value for -mode $options(-mode)"
-        }
-    }
-
-    set state(header) [array get header]
-    return $result
-}
-
-# ::mime::getbody --
-#
-#    mime::getbody returns the body of a leaf MIME part in canonical form.
-#
-#    If the -command option is present, then it is repeatedly invoked
-#    with a fragment of the body as this:
-#
-#        uplevel #0 $callback [list "data" $fragment]
-#
-#    (The -blocksize option, if present, specifies the maximum size of
-#    each fragment passed to the callback.)
-#    When the end of the body is reached, the callback is invoked as:
-#
-#        uplevel #0 $callback "end"
-#
-#    Alternatively, if an error occurs, the callback is invoked as:
-#
-#        uplevel #0 $callback [list "error" reason]
-#
-#    Regardless, the return value of the final invocation of the callback
-#    is propagated upwards by mime::getbody.
-#
-#    If the -command option is absent, then the return value of
-#    mime::getbody is a string containing the MIME part's entire body.
-#
-# Arguments:
-#       token      The MIME token to parse.
-#       args       Optional arguments of the form:
-#                  ?-decode? ?-command callback ?-blocksize octets? ?
-#
-# Results:
-#       Returns a string containing the MIME part's entire body, or
-#       if '-command' is specified, the return value of the command
-#       is returned.
-
-proc ::mime::getbody {token args} {
-    global errorCode errorInfo
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    set decode 0
-    if {[set pos [lsearch -exact $args -decode]] >= 0} {
-        set decode 1
-        set args [lreplace $args $pos $pos]
-    }
-
-    array set options [list -command [
-        list mime::getbodyaux $token] -blocksize 4096]
-    array set options $args
-    if {$options(-blocksize) < 1} {
-        error "-blocksize expects a positive integer, not $options(-blocksize)"
-    }
-
-    set code 0
-    set ecode {}
-    set einfo {}
-
-    switch -- $state(value)/$state(canonicalP) {
-        file/0 {
-            set fd [open $state(file) RDONLY]
-
-            set code [catch {
-                fconfigure $fd -translation binary
-                seek $fd [set pos $state(offset)] start
-                set last [expr {$state(offset) + $state(count) - 1}]
-
-                set fragment {}
-                while {$pos <= $last} {
-                    if {[set cc [
-                        expr {($last - $pos) + 1}]] > $options(-blocksize)} {
-                        set cc $options(-blocksize)
-                    }
-                    incr pos [set len [
-                        string length [set chunk [read $fd $cc]]]]
-                    switch -exact -- $state(encoding) {
-                        base64
-                            -
-                        quoted-printable {
-                            if {([set x [string last \n $chunk]] > 0) \
-                                    && ($x + 1 != $len)} {
-                                set chunk [string range $chunk 0 $x]
-                                seek $fd [incr pos [expr {($x + 1) - $len}]] start
-                            }
-                            set chunk [
-                                $state(encoding) -mode decode -- $chunk]
-                        }
-                        7bit - 8bit - binary - {} {
-                            # Bugfix for [#477088]
-                            # Go ahead, leave chunk alone
-                        }
-                        default {
-                            error "Can't handle content encoding \"$state(encoding)\""
-                        }
-                    }
-                    append fragment $chunk
-
-                    set cc [expr {$options(-blocksize) - 1}]
-                    while {[string length $fragment] > $options(-blocksize)} {
-                        uplevel #0 $options(-command) [
-                            list data [string range $fragment 0 $cc]]
-
-                        set fragment [
-                            string range $fragment $options(-blocksize) end]
-                    }
-                }
-                if {[string length $fragment] > 0} {
-                    uplevel #0 $options(-command) [list data $fragment]
-                }
-            } result]
-            set ecode $errorCode
-            set einfo $errorInfo
-
-            catch {close $fd}
-        }
-
-        file/1 {
-            set fd [open $state(file) RDONLY]
-
-            set code [catch {
-                fconfigure $fd -translation binary
-
-                while {[string length [
-                    set fragment [read $fd $options(-blocksize)]]] > 0} {
-                        uplevel #0 $options(-command) [list data $fragment]
-                    }
-            } result]
-            set ecode $errorCode
-            set einfo $errorInfo
-
-            catch {close $fd}
-        }
-
-        parts/0
-            -
-        parts/1 {
-            error {MIME part isn't a leaf}
-        }
-
-        string/0
-            -
-        string/1 {
-            switch -- $state(encoding)/$state(canonicalP) {
-                base64/0
-                    -
-                quoted-printable/0 {
-                    set fragment [
-                        $state(encoding) -mode decode -- $state(string)]
-                }
-
-                default {
-                    # Not a bugfix for [#477088], but clarification
-                    # This handles no-encoding, 7bit, 8bit, and binary.
-                    set fragment $state(string)
-                }
-            }
-
-            set code [catch {
-                set cc [expr {$options(-blocksize) -1}]
-                while {[string length $fragment] > $options(-blocksize)} {
-                    uplevel #0 $options(-command) [
-                        list data [string range $fragment 0 $cc]]
-
-                    set fragment [
-                        string range $fragment $options(-blocksize) end]
-                }
-                if {[string length $fragment] > 0} {
-                    uplevel #0 $options(-command) [list data $fragment]
-                }
-            } result]
-            set ecode $errorCode
-            set einfo $errorInfo
-        }
-        default {
-            error "Unknown combination \"$state(value)/$state(canonicalP)\""
-        }
-    }
-
-    set code [catch {
-        if {$code} {
-            uplevel #0 $options(-command) [list error $result]
-        } else {
-            uplevel #0 $options(-command) [list end]
-        }
-    } result]
-    set ecode $errorCode
-    set einfo $errorInfo
-
-    if {$code} {
-        return -code $code -errorinfo $einfo -errorcode $ecode $result
-    }
-
-    if {$decode} {
-        array set params [mime::getproperty $token params]
-
-        if {[info exists params(charset)]} {
-            set charset $params(charset)
-        } else {
-            set charset US-ASCII
-        }
-
-        set enc [reversemapencoding $charset]
-        if {$enc ne {}} {
-            set result [::encoding convertfrom $enc $result]
-        } else {
-            return -code error "-decode failed: can't reversemap charset $charset"
-        }
-    }
-
-    return $result
-}
-
-# ::mime::getbodyaux --
-#
-#    Builds up the body of the message, fragment by fragment.  When
-#    the entire message has been retrieved, it is returned.
-#
-# Arguments:
-#       token      The MIME token to parse.
-#       reason     One of 'data', 'end', or 'error'.
-#       fragment   The section of data data fragment to extract a
-#                  string from.
-#
-# Results:
-#       Returns nothing, except when called with the 'end' argument
-#       in which case it returns a string that contains all of the
-#       data that 'getbodyaux' has been called with.  Will throw an
-#       error if it is called with the reason of 'error'.
-
-proc ::mime::getbodyaux {token reason {fragment {}}} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    switch $reason {
-        data {
-            append state(getbody) $fragment
-            return {}
-        }
-
-        end {
-            if {[info exists state(getbody)]} {
-                set result $state(getbody)
-                unset state(getbody)
-            } else {
-                set result {}
-            }
-
-            return $result
-        }
-
-        error {
-            catch {unset state(getbody)}
-            error $reason
-        }
-
-        default {
-            error "Unknown reason \"$reason\""
-        }
-    }
-}
-
-# ::mime::copymessage --
-#
-#    mime::copymessage copies the MIME part to the specified channel.
-#
-#    mime::copymessage operates synchronously, and uses fileevent to
-#    allow asynchronous operations to proceed independently.
-#
-# Arguments:
-#       token      The MIME token to parse.
-#       channel    The channel to copy the message to.
-#
-# Results:
-#       Returns nothing unless an error is thrown while the message
-#       is being written to the channel.
-
-proc ::mime::copymessage {token channel} {
-    global errorCode errorInfo
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    set openP [info exists state(fd)]
-
-    set code [catch {mime::copymessageaux $token $channel} result]
-    set ecode $errorCode
-    set einfo $errorInfo
-
-    if {!$openP && [info exists state(fd)]} {
-        if {![info exists state(root)]} {
-            catch {close $state(fd)}
-        }
-        unset state(fd)
-    }
-
-    return -code $code -errorinfo $einfo -errorcode $ecode $result
-}
-
-# ::mime::copymessageaux --
-#
-#    mime::copymessageaux copies the MIME part to the specified channel.
-#
-# Arguments:
-#       token      The MIME token to parse.
-#       channel    The channel to copy the message to.
-#
-# Results:
-#       Returns nothing unless an error is thrown while the message
-#       is being written to the channel.
-
-proc ::mime::copymessageaux {token channel} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    array set header $state(header)
-
-    set boundary {}
-
-    set result {}
-    foreach {mixed value} [getheader $token] {
-	puts $channel "$mixed: $value"
-    }
-
-    foreach {k v} $state(params) {
-        if {$k eq {boundary}} {
-            set boundary $v
-        }
-    }
-
-    set converter {}
-    set encoding {}
-    if {$state(value) ne {parts}} {
-        if {$state(canonicalP)} {
-            if {[set encoding $state(encoding)] eq {}} {
-                set encoding [encoding $token]
-            }
-            if {$encoding ne {}} {
-                puts $channel "Content-Transfer-Encoding: $encoding"
-            }
-            switch -- $encoding {
-                base64
-                    -
-                quoted-printable {
-                    set converter $encoding
-                }
-                7bit - 8bit - binary - {} {
-                    # Bugfix for [#477088], also [#539952]
-                    # Go ahead
-                }
-                default {
-                    error "Can't handle content encoding \"$encoding\""
-                }
-            }
-        }
-    } elseif {([string match multipart/* $state(content)]) \
-        && ($boundary eq {})} {
-        # we're doing everything in one pass...
-        set key [clock seconds]$token[info hostname][array get state]
-        set seqno 8
-        while {[incr seqno -1] >= 0} {
-            set key [md5 -- $key]
-        }
-        set boundary "----- =_[string trim [base64 -mode encode -- $key]]"
-
-        puts $channel ";\n              boundary=\"$boundary\""
-    }
-
-    if {[info exists state(error)]} {
-        unset state(error)
-    }
-
-    switch -- $state(value) {
-        file {
-            set closeP 1
-            if {[info exists state(root)]} {
-                # FRINK: nocheck
-                variable $state(root)
-                upvar 0 $state(root) root
-
-                if {[info exists root(fd)]} {
-                    set fd $root(fd)
-                    set closeP 0
-                } else {
-                    set fd [set state(fd) [open $state(file) RDONLY]]
-                }
-                set size $state(count)
-            } else {
-                set fd [set state(fd) [open $state(file) RDONLY]]
-                # read until eof
-                set size -1
-            }
-            seek $fd $state(offset) start
-            if {$closeP} {
-                fconfigure $fd -translation binary
-            }
-
-            puts $channel {}
-
-            while {$size != 0 && ![eof $fd]} {
-                if {$size < 0 || $size > 32766} {
-                    set X [read $fd 32766]
-                } else {
-                    set X [read $fd $size]
-                }
-                if {$size > 0} {
-                    set size [expr {$size - [string length $X]}]
-                }
-                if {$converter eq {}} {
-                    puts -nonewline $channel $X
-                } else {
-                    puts -nonewline $channel [$converter -mode encode -- $X]
-                }
-            }
-
-            if {$closeP} {
-                catch {close $state(fd)}
-                unset state(fd)
-            }
-        }
-
-        parts {
-            if {
-		![info exists state(root)]
-		&&
-		[info exists state(file)]
-	    } {
-                set state(fd) [open $state(file) RDONLY]
-                fconfigure $state(fd) -translation binary
-            }
-
-            switch -glob -- $state(content) {
-                message/* {
-                    puts $channel {}
-                    foreach part $state(parts) {
-                        mime::copymessage $part $channel
-                        break
-                    }
-                }
-
-                default {
-                    # Note RFC 2046: See buildmessageaux for details.
-                    #
-                    # The boundary delimiter MUST occur at the
-                    # beginning of a line, i.e., following a CRLF, and
-                    # the initial CRLF is considered to be attached to
-                    # the boundary delimiter line rather than part of
-                    # the preceding part.
-                    #
-                    # - The above means that the CRLF before $boundary
-                    #   is needed per the RFC, and the parts must not
-                    #   have a closing CRLF of their own. See Tcllib bug
-                    #   1213527, and patch 1254934 for the problems when
-                    #   both file/string branches added CRLF after the
-                    #   body parts.
-
-
-                    foreach part $state(parts) {
-                        puts $channel \n--$boundary
-                        mime::copymessage $part $channel
-                    }
-                    puts $channel \n--$boundary--
-                }
-            }
-
-            if {[info exists state(fd)]} {
-                catch {close $state(fd)}
-                unset state(fd)
-            }
-        }
-
-        string {
-            if {[catch {fconfigure $channel -buffersize} blocksize]} {
-                set blocksize 4096
-            } elseif {$blocksize < 512} {
-                set blocksize 512
-            }
-            set blocksize [expr {($blocksize / 4) * 3}]
-
-            # [893516]
-            fconfigure $channel -buffersize $blocksize
-
-            puts $channel {}
-
-            #TODO: tests don't cover these paths
-            if {$converter eq {}} {
-                puts -nonewline $channel $state(string)
-            } else {
-                puts -nonewline $channel [$converter -mode encode -- $state(string)]
-            }
-        }
-        default {
-            error "Unknown value \"$state(value)\""
-        }
-    }
-
-    flush $channel
-
-    if {[info exists state(error)]} {
-        error $state(error)
-    }
-}
-
-# ::mime::buildmessage --
-#
-#     Like copymessage, but produces a string rather than writing the message into a channel.
-#
-# Arguments:
-#       token      The MIME token to parse.
-#
-# Results:
-#       The message. 
-
-proc ::mime::buildmessage token {
-    global errorCode errorInfo
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    set openP [info exists state(fd)]
-
-    set code [catch {mime::buildmessageaux $token} result]
-    if {![info exists errorCode]} {
-        set ecode {}
-    } else {
-        set ecode $errorCode
-    }
-    set einfo $errorInfo
-
-    if {!$openP && [info exists state(fd)]} {
-        if {![info exists state(root)]} {
-            catch {close $state(fd)}
-        }
-        unset state(fd)
-    }
-
-    return -code $code -errorinfo $einfo -errorcode $ecode $result
-}
-
-
-proc ::mime::buildmessageaux token {
-	set chan [tcl::chan::memchan]
-	chan configure $chan -translation crlf
-	copymessageaux $token $chan
-	seek $chan 0
-	chan configure $chan -translation binary
-	set res [read $chan]
-	close $chan
-	return $res
-}
-
-# ::mime::encoding --
-#
-#     Determines how a token is encoded.
-#
-# Arguments:
-#       token      The MIME token to parse.
-#
-# Results:
-#       Returns the encoding of the message (the null string, base64,
-#       or quoted-printable).
-
-proc ::mime::encoding {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    switch -glob -- $state(content) {
-        audio/*
-            -
-        image/*
-            -
-        video/* {
-            return base64
-        }
-
-        message/*
-            -
-        multipart/* {
-            return {}
-        }
-        default {# Skip}
-    }
-
-    set asciiP 1
-    set lineP 1
-    switch -- $state(value) {
-        file {
-            set fd [open $state(file) RDONLY]
-            fconfigure $fd -translation binary
-
-            while {[gets $fd line] >= 0} {
-                if {$asciiP} {
-                    set asciiP [encodingasciiP $line]
-                }
-                if {$lineP} {
-                    set lineP [encodinglineP $line]
-                }
-                if {(!$asciiP) && (!$lineP)} {
-                    break
-                }
-            }
-
-            catch {close $fd}
-        }
-
-        parts {
-            return {}
-        }
-
-        string {
-            foreach line [split $state(string) "\n"] {
-                if {$asciiP} {
-                    set asciiP [encodingasciiP $line]
-                }
-                if {$lineP} {
-                    set lineP [encodinglineP $line]
-                }
-                if {(!$asciiP) && (!$lineP)} {
-                    break
-                }
-            }
-        }
-        default {
-            error "Unknown value \"$state(value)\""
-        }
-    }
-
-    switch -glob -- $state(content) {
-        text/* {
-            if {!$asciiP} {
-                #TODO: this path is not covered by tests
-                foreach {k v} $state(params) {
-                    if {$k eq "charset"} {
-                        set v [string tolower $v]
-                        if {($v ne "us-ascii") \
-                                && (![string match {iso-8859-[1-8]} $v])} {
-                            return base64
-                        }
-
-                        break
-                    }
-                }
-            }
-
-            if {!$lineP} {
-                return quoted-printable
-            }
-        }
-
-
-        default {
-            if {(!$asciiP) || (!$lineP)} {
-                return base64
-            }
-        }
-    }
-
-    return {}
-}
-
-# ::mime::encodingasciiP --
-#
-#     Checks if a string is a pure ascii string, or if it has a non-standard
-#     form.
-#
-# Arguments:
-#       line    The line to check.
-#
-# Results:
-#       Returns 1 if \r only occurs at the end of lines, and if all
-#       characters in the line are between the ASCII codes of 32 and 126.
-
-proc ::mime::encodingasciiP {line} {
-    foreach c [split $line {}] {
-        switch -- $c {
-            { } - \t - \r - \n {
-            }
-
-            default {
-                binary scan $c c c
-                if {($c < 32) || ($c > 126)} {
-                    return 0
-                }
-            }
-        }
-    }
-    if {
-	[set r [string first \r $line]] < 0
-	||
-	$r == {[string length $line] - 1}
-    } {
-        return 1
-    }
-
-    return 0
-}
-
-# ::mime::encodinglineP --
-#
-#     Checks if a string is a line is valid to be processed.
-#
-# Arguments:
-#       line    The line to check.
-#
-# Results:
-#       Returns 1 the line is less than 76 characters long, the line
-#       contains more characters than just whitespace, the line does
-#       not start with a '.', and the line does not start with 'From '.
-
-proc ::mime::encodinglineP {line} {
-    if {([string length $line] > 76) \
-            || ($line ne [string trimright $line]) \
-            || ([string first . $line] == 0) \
-            || ([string first {From } $line] == 0)} {
-        return 0
-    }
-
-    return 1
-}
-
-# ::mime::fcopy --
-#
-#    Appears to be unused.
-#
-# Arguments:
-#
-# Results:
-#
-
-proc ::mime::fcopy {token count {error {}}} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    if {$error ne {}} {
-        set state(error) $error
-    }
-    set state(doneP) 1
-}
-
-# ::mime::scopy --
-#
-#    Copy a portion of the contents of a mime token to a channel.
-#
-# Arguments:
-#    token     The token containing the data to copy.
-#       channel   The channel to write the data to.
-#       offset    The location in the string to start copying
-#                 from.
-#       len       The amount of data to write.
-#       blocksize The block size for the write operation.
-#
-# Results:
-#    The specified portion of the string in the mime token is
-#       copied to the specified channel.
-
-proc ::mime::scopy {token channel offset len blocksize} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    if {$len <= 0} {
-        set state(doneP) 1
-        fileevent $channel writable {}
-        return
-    }
-
-    if {[set cc $len] > $blocksize} {
-        set cc $blocksize
-    }
-
-    if {[catch {
-	    puts -nonewline $channel [
-		string range $state(string) $offset [expr {$offset + $cc - 1}]]
-	    fileevent $channel writable [
-		list mime::scopy $token $channel [
-		    incr offset $cc] [incr len -$cc] $blocksize]
-	} result]
-    } {
-        set state(error) $result
-        set state(doneP) 1
-        fileevent $channel writable {}
-    }
-    return
-}
-
-# ::mime::qp_encode --
-#
-#    Tcl version of quote-printable encode
-#
-# Arguments:
-#    string        The string to quote.
-#       encoded_word  Boolean value to determine whether or not encoded words
-#                     (RFC 2047) should be handled or not. (optional)
-#
-# Results:
-#    The properly quoted string is returned.
-
-proc ::mime::qp_encode {string {encoded_word 0} {no_softbreak 0}} {
-    # 8.1+ improved string manipulation routines used.
-    # Replace outlying characters, characters that would normally
-    # be munged by EBCDIC gateways, and special Tcl characters "[\]{}
-    # with =xx sequence
-
-    if {$encoded_word} {
-        # Special processing for encoded words (RFC 2047)
-        set regexp {[\x00-\x08\x0B-\x1E\x21-\x24\x3D\x40\x5B-\x5E\x60\x7B-\xFF\x09\x5F\x3F]}
-	lappend mapChars { } _
-    } else {
-        set regexp {[\x00-\x08\x0B-\x1E\x21-\x24\x3D\x40\x5B-\x5E\x60\x7B-\xFF]}
-    }
-    regsub -all -- $regexp $string {[format =%02X [scan "\\&" %c]]} string
-
-    # Replace the format commands with their result
-
-    set string [subst -novariables $string]
-
-    # soft/hard newlines and other
-    # Funky cases for SMTP compatibility
-    lappend mapChars " \n" =20\n \t\n =09\n \n\.\n =2E\n "\nFrom " "\n=46rom "
-
-    set string [string map $mapChars $string]
-
-    # Break long lines - ugh
-
-    # Implementation of FR #503336
-    if {$no_softbreak} {
-        set result $string
-    } else {
-        set result {}
-        foreach line [split $string \n] {
-            while {[string length $line] > 72} {
-                set chunk [string range $line 0 72]
-                if {[regexp -- (=|=.)$ $chunk dummy end]} {
-
-                    # Don't break in the middle of a code
-
-                    set len [expr {72 - [string length $end]}]
-                    set chunk [string range $line 0 $len]
-                    incr len
-                    set line [string range $line $len end]
-                } else {
-                    set line [string range $line 73 end]
-                }
-                append result $chunk=\n
-            }
-            append result $line\n
-        }
-
-        # Trim off last \n, since the above code has the side-effect
-        # of adding an extra \n to the encoded string and return the
-        # result.
-        set result [string range $result 0 end-1]
-    }
-
-    # If the string ends in space or tab, replace with =xx
-
-    set lastChar [string index $result end]
-    if {$lastChar eq { }} {
-        set result [string replace $result end end =20]
-    } elseif {$lastChar eq "\t"} {
-        set result [string replace $result end end =09]
-    }
-
-    return $result
-}
-
-# ::mime::qp_decode --
-#
-#    Tcl version of quote-printable decode
-#
-# Arguments:
-#    string        The quoted-printable string to decode.
-#       encoded_word  Boolean value to determine whether or not encoded words
-#                     (RFC 2047) should be handled or not. (optional)
-#
-# Results:
-#    The decoded string is returned.
-
-proc ::mime::qp_decode {string {encoded_word 0}} {
-    # 8.1+ improved string manipulation routines used.
-    # Special processing for encoded words (RFC 2047)
-
-    if {$encoded_word} {
-        # _ == \x20, even if SPACE occupies a different code position
-        set string [string map [list _ \u0020] $string]
-    }
-
-    # smash the white-space at the ends of lines since that must've been
-    # generated by an MUA.
-
-    regsub -all -- {[ \t]+\n} $string \n string
-    set string [string trimright $string " \t"]
-
-    # Protect the backslash for later subst and
-    # smash soft newlines, has to occur after white-space smash
-    # and any encoded word modification.
-
-    #TODO: codepath not tested
-    set string [string map [list \\ {\\} =\n {}] $string]
-
-    # Decode specials
-
-    regsub -all -nocase {=([a-f0-9][a-f0-9])} $string {\\u00\1} string
-
-    # process \u unicode mapped chars
-
-    return [subst -novariables -nocommands $string]
-}
-
-# ::mime::parseaddress --
-#
-#       This was originally written circa 1982 in C. we're still using it
-#       because it recognizes virtually every buggy address syntax ever
-#       generated!
-#
-#       mime::parseaddress takes a string containing one or more 822-style
-#       address specifications and returns a list of dictionaries, for each
-#       address specified in the argument.
-#
-#    Each dictionary contains these properties:
-#
-#       property    value
-#       ========    =====
-#       address     local@domain
-#       comment     822-style comment
-#       domain      the domain part (rhs)
-#       error       non-empty on a parse error
-#       group       this address begins a group
-#       friendly    user-friendly rendering
-#       local       the local part (lhs)
-#       memberP     this address belongs to a group
-#       phrase      the phrase part
-#       proper      822-style address specification
-#       route       822-style route specification (obsolete)
-#
-#    Note that one or more of these properties may be empty.
-#
-# Arguments:
-#    string        The address string to parse
-#
-# Results:
-#    Returns a list of dictionaries, one element for each address
-#       specified in the argument.
-
-proc ::mime::parseaddress {string} {
-    global errorCode errorInfo
-
-    variable mime
-
-    set token [namespace current]::[incr mime(uid)]
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    set code [catch {mime::parseaddressaux $token $string} result]
-    set ecode $errorCode
-    set einfo $errorInfo
-
-    foreach name [array names state] {
-        unset state($name)
-    }
-    # FRINK: nocheck
-    catch {unset $token}
-
-    return -code $code -errorinfo $einfo -errorcode $ecode $result
-}
-
-# ::mime::parseaddressaux --
-#
-#       This was originally written circa 1982 in C. we're still using it
-#       because it recognizes virtually every buggy address syntax ever
-#       generated!
-#
-#       mime::parseaddressaux does the actually parsing for mime::parseaddress
-#
-#    Each dictionary contains these properties:
-#
-#       property    value
-#       ========    =====
-#       address     local@domain
-#       comment     822-style comment
-#       domain      the domain part (rhs)
-#       error       non-empty on a parse error
-#       group       this address begins a group
-#       friendly    user-friendly rendering
-#       local       the local part (lhs)
-#       memberP     this address belongs to a group
-#       phrase      the phrase part
-#       proper      822-style address specification
-#       route       822-style route specification (obsolete)
-#
-#    Note that one or more of these properties may be empty.
-#
-# Arguments:
-#    token         The MIME token to work from.
-#    string        The address string to parse
-#
-# Results:
-#    Returns a list of dictionaries, one for each address specified in the
-#    argument.
-
-proc ::mime::parseaddressaux {token string} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    variable addrtokenL
-    variable addrlexemeL
-
-    set state(input)   $string
-    set state(glevel)  0
-    set state(buffer)  {}
-    set state(lastC)   LX_END
-    set state(tokenL)  $addrtokenL
-    set state(lexemeL) $addrlexemeL
-
-    set result {}
-    while {[addr_next $token]} {
-        if {[set tail $state(domain)] ne {}} {
-            set tail @$state(domain)
-        } else {
-            set tail @[info hostname]
-        }
-        if {[set address $state(local)] ne {}} {
-            #TODO: this path is not covered by tests
-            append address $tail
-        }
-
-        if {$state(phrase) ne {}} {
-            #TODO: this path is not covered by tests
-            set state(phrase) [string trim $state(phrase) \"]
-            foreach t $state(tokenL) {
-                if {[string first $t $state(phrase)] >= 0} {
-                    #TODO:  is this quoting robust enough?
-                    set state(phrase) \"$state(phrase)\"
-                    break
-                }
-            }
-
-            set proper "$state(phrase) <$address>"
-        } else {
-            set proper $address
-        }
-
-        if {[set friendly $state(phrase)] eq {}} {
-            #TODO: this path is not covered by tests
-            if {[set note $state(comment)] ne {}} {
-                if {[string first ( $note] == 0} {
-                    set note [string trimleft [string range $note 1 end]]
-                }
-                if {
-		    [string last ) $note]
-                        == [set len [expr {[string length $note] - 1}]]
-		} {
-                    set note [string range $note 0 [expr {$len - 1}]]
-                }
-                set friendly $note
-            }
-
-            if {
-		$friendly eq {}
-		&&
-		[set mbox $state(local)] ne {}
-	    } {
-                #TODO: this path is not covered by tests
-                set mbox [string trim $mbox \"]
-
-                if {[string first / $mbox] != 0} {
-                    set friendly $mbox
-                } elseif {[set friendly [addr_x400 $mbox PN]] ne {}} {
-                } elseif {
-		    [set friendly [addr_x400 $mbox S]] ne {}
-                    &&
-		    [set g [addr_x400 $mbox G]] ne {}
-		} {
-                    set friendly "$g $friendly"
-                }
-
-                if {$friendly eq {}} {
-                    set friendly $mbox
-                }
-            }
-        }
-        set friendly [string trim $friendly \"]
-
-        lappend result [list address  $address        \
-                             comment  $state(comment) \
-                             domain   $state(domain)  \
-                             error    $state(error)   \
-                             friendly $friendly       \
-                             group    $state(group)   \
-                             local    $state(local)   \
-                             memberP  $state(memberP) \
-                             phrase   $state(phrase)  \
-                             proper   $proper         \
-                             route    $state(route)]
-
-    }
-
-    unset {*}{
-	state(input)
-	state(glevel)
-	state(buffer)
-	state(lastC)
-	state(tokenL)
-	state(lexemeL)
-    }
-
-    return $result
-}
-
-# ::mime::addr_next --
-#
-#       Locate the next address in a mime token.
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns 1 if there is another address, and 0 if there is not.
-
-proc ::mime::addr_next {token} {
-    global errorCode errorInfo
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-    set nocomplain [package vsatisfies [package provide Tcl] 8.4]
-    foreach prop {comment domain error group local memberP phrase route} {
-        if {$nocomplain} {
-            unset -nocomplain state($prop)
-        } else {
-            if {[catch {unset state($prop)}]} {set ::errorInfo {}}
-        }
-    }
-
-    switch -- [set code [catch {mime::addr_specification $token} result]] {
-        0 {
-            if {!$result} {
-                return 0
-            }
-
-            switch -- $state(lastC) {
-                LX_COMMA
-                    -
-                LX_END {
-                }
-                default {
-                    # catch trailing comments...
-                    set lookahead $state(input)
-                    mime::parselexeme $token
-                    set state(input) $lookahead
-                }
-            }
-        }
-
-        7 {
-            set state(error) $result
-
-            while {1} {
-                switch -- $state(lastC) {
-                    LX_COMMA
-                        -
-                    LX_END {
-                        break
-                    }
-
-                    default {
-                        mime::parselexeme $token
-                    }
-                }
-            }
-        }
-
-        default {
-            set ecode $errorCode
-            set einfo $errorInfo
-
-            return -code $code -errorinfo $einfo -errorcode $ecode $result
-        }
-    }
-
-    foreach prop {comment domain error group local memberP phrase route} {
-        if {![info exists state($prop)]} {
-            set state($prop) {}
-        }
-    }
-
-    return 1
-}
-
-# ::mime::addr_specification --
-#
-#   Uses lookahead parsing to determine whether there is another
-#   valid e-mail address or not.  Throws errors if unrecognized
-#   or invalid e-mail address syntax is used.
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns 1 if there is another address, and 0 if there is not.
-
-proc ::mime::addr_specification {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    set lookahead $state(input)
-    switch -- [parselexeme $token] {
-        LX_ATOM
-            -
-        LX_QSTRING {
-            set state(phrase) $state(buffer)
-        }
-
-        LX_SEMICOLON {
-            if {[incr state(glevel) -1] < 0} {
-                return -code 7 "extraneous semi-colon"
-            }
-
-            catch {unset state(comment)}
-            return [addr_specification $token]
-        }
-
-        LX_COMMA {
-            catch {unset state(comment)}
-            return [addr_specification $token]
-        }
-
-        LX_END {
-            return 0
-        }
-
-        LX_LBRACKET {
-            return [addr_routeaddr $token]
-        }
-
-        LX_ATSIGN {
-            set state(input) $lookahead
-            return [addr_routeaddr $token 0]
-        }
-
-        default {
-            return -code 7 [
-		format "unexpected character at beginning (found %s)" \
-		   $state(buffer)]
-        }
-    }
-
-    switch -- [parselexeme $token] {
-        LX_ATOM
-            -
-        LX_QSTRING {
-            append state(phrase) " " $state(buffer)
-
-            return [addr_phrase $token]
-        }
-
-        LX_LBRACKET {
-            return [addr_routeaddr $token]
-        }
-
-        LX_COLON {
-            return [addr_group $token]
-        }
-
-        LX_DOT {
-            set state(local) "$state(phrase)$state(buffer)"
-            unset state(phrase)
-            mime::addr_routeaddr $token 0
-            mime::addr_end $token
-        }
-
-        LX_ATSIGN {
-            set state(memberP) $state(glevel)
-            set state(local) $state(phrase)
-            unset state(phrase)
-            mime::addr_domain $token
-            mime::addr_end $token
-        }
-
-        LX_SEMICOLON
-            -
-        LX_COMMA
-            -
-        LX_END {
-            set state(memberP) $state(glevel)
-            if {
-		$state(lastC) eq "LX_SEMICOLON"
-		&&
-		([incr state(glevel) -1] < 0)
-	    } {
-                #TODO: this path is not covered by tests
-                return -code 7 "extraneous semi-colon"
-            }
-
-            set state(local) $state(phrase)
-            unset state(phrase)
-        }
-
-        default {
-            return -code 7 [
-                format "expecting mailbox (found %s)" $state(buffer)]
-        }
-    }
-
-    return 1
-}
-
-# ::mime::addr_routeaddr --
-#
-#       Parses the domain portion of an e-mail address.  Finds the '@'
-#       sign and then calls mime::addr_route to verify the domain.
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns 1 if there is another address, and 0 if there is not.
-
-proc ::mime::addr_routeaddr {token {checkP 1}} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    set lookahead $state(input)
-    if {[parselexeme $token] eq "LX_ATSIGN"} {
-        #TODO: this path is not covered by tests
-        mime::addr_route $token
-    } else {
-        set state(input) $lookahead
-    }
-
-    mime::addr_local $token
-
-    switch -- $state(lastC) {
-        LX_ATSIGN {
-            mime::addr_domain $token
-        }
-
-        LX_SEMICOLON
-            -
-        LX_RBRACKET
-            -
-        LX_COMMA
-            -
-        LX_END {
-        }
-
-        default {
-            return -code 7 [
-                format "expecting at-sign after local-part (found %s)" \
-                $state(buffer)]
-        }
-    }
-
-    if {($checkP) && ($state(lastC) ne "LX_RBRACKET")} {
-        return -code 7 [
-            format "expecting right-bracket (found %s)" $state(buffer)]
-    }
-
-    return 1
-}
-
-# ::mime::addr_route --
-#
-#    Attempts to parse the portion of the e-mail address after the @.
-#    Tries to verify that the domain definition has a valid form.
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns nothing if successful, and throws an error if invalid
-#       syntax is found.
-
-proc ::mime::addr_route {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    set state(route) @
-
-    while 1 {
-        switch -- [parselexeme $token] {
-            LX_ATOM
-                -
-            LX_DLITERAL {
-                append state(route) $state(buffer)
-            }
-
-            default {
-                return -code 7 \
-                       [format "expecting sub-route in route-part (found %s)" \
-                               $state(buffer)]
-            }
-        }
-
-        switch -- [parselexeme $token] {
-            LX_COMMA {
-                append state(route) $state(buffer)
-                while 1 {
-                    switch -- [parselexeme $token] {
-                        LX_COMMA {
-                        }
-
-                        LX_ATSIGN {
-                            append state(route) $state(buffer)
-                            break
-                        }
-
-                        default {
-                            return -code 7 \
-                                   [format "expecting at-sign in route (found %s)" \
-                                           $state(buffer)]
-                        }
-                    }
-                }
-            }
-
-            LX_ATSIGN
-                -
-            LX_DOT {
-                append state(route) $state(buffer)
-            }
-
-            LX_COLON {
-                append state(route) $state(buffer)
-                return
-            }
-
-            default {
-                return -code 7 [
-		    format "expecting colon to terminate route (found %s)" \
-			$state(buffer)]
-            }
-        }
-    }
-}
-
-# ::mime::addr_domain --
-#
-#    Attempts to parse the portion of the e-mail address after the @.
-#    Tries to verify that the domain definition has a valid form.
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns nothing if successful, and throws an error if invalid
-#       syntax is found.
-
-proc ::mime::addr_domain {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    while 1 {
-        switch -- [parselexeme $token] {
-            LX_ATOM
-                -
-            LX_DLITERAL {
-                append state(domain) $state(buffer)
-            }
-
-            default {
-                return -code 7 [
-		    format "expecting sub-domain in domain-part (found %s)" \
-			$state(buffer)]
-            }
-        }
-
-        switch -- [parselexeme $token] {
-            LX_DOT {
-                append state(domain) $state(buffer)
-            }
-
-            LX_ATSIGN {
-                append state(local) % $state(domain)
-                unset state(domain)
-            }
-
-            default {
-                return
-            }
-        }
-    }
-}
-
-# ::mime::addr_local --
-#
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns nothing if successful, and throws an error if invalid
-#       syntax is found.
-
-proc ::mime::addr_local {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    set state(memberP) $state(glevel)
-
-    while 1 {
-        switch -- [parselexeme $token] {
-            LX_ATOM
-                -
-            LX_QSTRING {
-                append state(local) $state(buffer)
-            }
-
-            default {
-                return -code 7 \
-                       [format "expecting mailbox in local-part (found %s)" \
-                               $state(buffer)]
-            }
-        }
-
-        switch -- [parselexeme $token] {
-            LX_DOT {
-                append state(local) $state(buffer)
-            }
-
-            default {
-                return
-            }
-        }
-    }
-}
-
-# ::mime::addr_phrase --
-#
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns nothing if successful, and throws an error if invalid
-#       syntax is found.
-
-
-proc ::mime::addr_phrase {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    while {1} {
-        switch -- [parselexeme $token] {
-            LX_ATOM
-                -
-            LX_QSTRING {
-                append state(phrase) " " $state(buffer)
-            }
-
-            default {
-                break
-            }
-        }
-    }
-
-    switch -- $state(lastC) {
-        LX_LBRACKET {
-            return [addr_routeaddr $token]
-        }
-
-        LX_COLON {
-            return [addr_group $token]
-        }
-
-        LX_DOT {
-            append state(phrase) $state(buffer)
-            return [addr_phrase $token]
-        }
-
-        default {
-            return -code 7 [
-		format "found phrase instead of mailbox (%s%s)" \
-		    $state(phrase) $state(buffer)]
-        }
-    }
-}
-
-# ::mime::addr_group --
-#
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns nothing if successful, and throws an error if invalid
-#       syntax is found.
-
-proc ::mime::addr_group {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    if {[incr state(glevel)] > 1} {
-        return -code 7 [
-	    format "nested groups not allowed (found %s)" $state(phrase)]
-    }
-
-    set state(group) $state(phrase)
-    unset state(phrase)
-
-    set lookahead $state(input)
-    while 1 {
-        switch -- [parselexeme $token] {
-            LX_SEMICOLON
-                -
-            LX_END {
-                set state(glevel) 0
-                return 1
-            }
-
-            LX_COMMA {
-            }
-
-            default {
-                set state(input) $lookahead
-                return [addr_specification $token]
-            }
-        }
-    }
-}
-
-# ::mime::addr_end --
-#
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns nothing if successful, and throws an error if invalid
-#       syntax is found.
-
-proc ::mime::addr_end {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    switch -- $state(lastC) {
-        LX_SEMICOLON {
-            if {[incr state(glevel) -1] < 0} {
-                return -code 7 "extraneous semi-colon"
-            }
-        }
-
-        LX_COMMA
-            -
-        LX_END {
-        }
-
-        default {
-            return -code 7 [
-		format "junk after local@domain (found %s)" $state(buffer)]
-        }
-    }
-}
-
-# ::mime::addr_x400 --
-#
-#
-# Arguments:
-#       token         The MIME token to work from.
-#
-# Results:
-#    Returns nothing if successful, and throws an error if invalid
-#       syntax is found.
-
-proc ::mime::addr_x400 {mbox key} {
-    if {[set x [string first /$key= [string toupper $mbox]]] < 0} {
-        return {}
-    }
-    set mbox [string range $mbox [expr {$x + [string length $key] + 2}] end]
-
-    if {[set x [string first / $mbox]] > 0} {
-        set mbox [string range $mbox 0 [expr {$x - 1}]]
-    }
-
-    return [string trim $mbox \"]
-}
-
-# ::mime::parsedatetime --
-#
-#    Fortunately the clock command in the Tcl 8.x core does all the heavy
-#    lifting for us (except for timezone calculations).
-#
-#    mime::parsedatetime takes a string containing an 822-style date-time
-#    specification and returns the specified property.
-#
-#    The list of properties and their ranges are:
-#
-#       property     range
-#       ========     =====
-#       clock        raw result of "clock scan"
-#       hour         0 .. 23
-#       lmonth       January, February, ..., December
-#       lweekday     Sunday, Monday, ... Saturday
-#       mday         1 .. 31
-#       min          0 .. 59
-#       mon          1 .. 12
-#       month        Jan, Feb, ..., Dec
-#       proper       822-style date-time specification
-#       rclock       elapsed seconds between then and now
-#       sec          0 .. 59
-#       wday         0 .. 6 (Sun .. Mon)
-#       weekday      Sun, Mon, ..., Sat
-#       yday         1 .. 366
-#       year         1900 ...
-#       zone         -720 .. 720 (minutes east of GMT)
-#
-# Arguments:
-#       value       Either a 822-style date-time specification or '-now'
-#                   if the current date/time should be used.
-#       property    The property (from the list above) to return
-#
-# Results:
-#    Returns the string value of the 'property' for the date/time that was
-#       specified in 'value'.
-
-namespace eval ::mime {
-        variable WDAYS_SHORT  [list Sun Mon Tue Wed Thu Fri Sat]
-        variable WDAYS_LONG   [list Sunday Monday Tuesday Wednesday Thursday \
-                                    Friday Saturday]
-
-        # Counting months starts at 1, so just insert a dummy element
-        # at index 0.
-        variable MONTHS_SHORT [list {} \
-                                    Jan Feb Mar Apr May Jun \
-                                    Jul Aug Sep Oct Nov Dec]
-        variable MONTHS_LONG  [list {} \
-                                    January February March April May June July \
-                                    August Sepember October November December]
-}
-proc ::mime::parsedatetime {value property} {
-    if {$value eq "-now"} {
-        set clock [clock seconds]
-    } elseif {[regexp {^(.*) ([+-])([0-9][0-9])([0-9][0-9])$} $value \
-	-> value zone_sign zone_hour zone_min]
-    } {
-        set clock [clock scan $value -gmt 1]
-        if {[info exists zone_min]} {
-            set zone_min [scan $zone_min %d]
-            set zone_hour [scan $zone_hour %d]
-            set zone [expr {60 * ($zone_min + 60 * $zone_hour)}]
-            if {$zone_sign eq "+"} {
-                set zone -$zone
-            }
-            incr clock $zone
-        }
-    } else {
-        set clock [clock scan $value]
-    }
-
-    switch -- $property {
-        clock {
-            return $clock
-        }
-
-        hour {
-            set value [clock format $clock -format %H]
-        }
-
-        lmonth {
-            variable MONTHS_LONG
-            return [lindex $MONTHS_LONG \
-                            [scan [clock format $clock -format %m] %d]]
-        }
-
-        lweekday {
-            variable WDAYS_LONG
-            return [lindex $WDAYS_LONG [clock format $clock -format %w]]
-        }
-
-        mday {
-            set value [clock format $clock -format %d]
-        }
-
-        min {
-            set value [clock format $clock -format %M]
-        }
-
-        mon {
-            set value [clock format $clock -format %m]
-        }
-
-        month {
-            variable MONTHS_SHORT
-            return [lindex $MONTHS_SHORT [
-		scan [clock format $clock -format %m] %d]]
-        }
-
-        proper {
-            set gmt [clock format $clock -format "%Y-%m-%d %H:%M:%S" -gmt true]
-            if {[set diff [expr {($clock-[clock scan $gmt]) / 60}]] < 0} {
-                set s -
-                set diff [expr {-($diff)}]
-            } else {
-                set s +
-            }
-            set zone [format %s%02d%02d $s [
-                expr {$diff / 60}] [expr {$diff % 60}]]
-
-            variable WDAYS_SHORT
-            set wday [lindex $WDAYS_SHORT [clock format $clock -format %w]]
-            variable MONTHS_SHORT
-            set mon [lindex $MONTHS_SHORT [
-		scan [clock format $clock -format %m] %d]]
-
-            return [
-		clock format $clock -format "$wday, %d $mon %Y %H:%M:%S $zone"]
-        }
-
-        rclock {
-            #TODO: these paths are not covered by tests
-            if {$value eq "-now"} {
-                return 0
-            } else {
-                return [expr {[clock seconds] - $clock}]
-            }
-        }
-
-        sec {
-            set value [clock format $clock -format %S]
-        }
-
-        wday {
-            return [clock format $clock -format %w]
-        }
-
-        weekday {
-            variable WDAYS_SHORT
-            return [lindex $WDAYS_SHORT [clock format $clock -format %w]]
-        }
-
-        yday {
-            set value [clock format $clock -format %j]
-        }
-
-        year {
-            set value [clock format $clock -format %Y]
-        }
-
-        zone {
-            set value [string trim [string map [list \t { }] $value]]
-            if {[set x [string last { } $value]] < 0} {
-                return 0
-            }
-            set value [string range $value [expr {$x + 1}] end]
-            switch -- [set s [string index $value 0]] {
-                + - - {
-                    if {$s eq "+"} {
-                        #TODO: This path is not covered by tests
-                        set s {}
-                    }
-                    set value [string trim [string range $value 1 end]]
-                    if {(
-			    [string length $value] != 4)
-			||
-			    [scan $value %2d%2d h m] != 2
-			||
-			    $h > 12
-			||
-			    $m > 59
-			||
-			    ($h == 12 && $m > 0)
-		    } {
-                        error "malformed timezone-specification: $value"
-                    }
-                    set value $s[expr {$h * 60 + $m}]
-                }
-
-                default {
-                    set value [string toupper $value]
-                    set z1 [list  UT GMT EST EDT CST CDT MST MDT PST PDT]
-                    set z2 [list   0   0  -5  -4  -6  -5  -7  -6  -8  -7]
-                    if {[set x [lsearch -exact $z1 $value]] < 0} {
-                        error "unrecognized timezone-mnemonic: $value"
-                    }
-                    set value [expr {[lindex $z2 $x] * 60}]
-                }
-            }
-        }
-
-        date2gmt
-            -
-        date2local
-            -
-        dst
-            -
-        sday
-            -
-        szone
-            -
-        tzone
-            -
-        default {
-            error "unknown property $property"
-        }
-    }
-
-    if {[set value [string trimleft $value 0]] eq {}} {
-        #TODO: this path is not covered by tests
-        set value 0
-    }
-    return $value
-}
-
-# ::mime::uniqueID --
-#
-#    Used to generate a 'globally unique identifier' for the content-id.
-#    The id is built from the pid, the current time, the hostname, and
-#    a counter that is incremented each time a message is sent.
-#
-# Arguments:
-#
-# Results:
-#    Returns the a string that contains the globally unique identifier
-#       that should be used for the Content-ID of an e-mail message.
-
-proc ::mime::uniqueID {} {
-    variable mime
-
-    return <[pid].[clock seconds].[incr mime(cid)]@[info hostname]>
-}
-
-# ::mime::parselexeme --
-#
-#    Used to implement a lookahead parser.
-#
-# Arguments:
-#       token    The MIME token to operate on.
-#
-# Results:
-#    Returns the next token found by the parser.
-
-proc ::mime::parselexeme {token} {
-    # FRINK: nocheck
-    variable $token
-    upvar 0 $token state
-
-    set state(input) [string trimleft $state(input)]
-
-    set state(buffer) {}
-    if {$state(input) eq {}} {
-        set state(buffer) end-of-input
-        return [set state(lastC) LX_END]
-    }
-
-    set c [string index $state(input) 0]
-    set state(input) [string range $state(input) 1 end]
-
-    if {$c eq "("} {
-        set noteP 0
-        set quoteP 0
-
-        while 1 {
-            append state(buffer) $c
-
-            #TODO: some of these paths are not covered by tests
-            switch -- $c/$quoteP {
-                (/0 {
-                    incr noteP
-                }
-
-                \\/0 {
-                    set quoteP 1
-                }
-
-                )/0 {
-                    if {[incr noteP -1] < 1} {
-                        if {[info exists state(comment)]} {
-                            append state(comment) { }
-                        }
-                        append state(comment) $state(buffer)
-
-                        return [parselexeme $token]
-                    }
-                }
-
-                default {
-                    set quoteP 0
-                }
-            }
-
-            if {[set c [string index $state(input) 0]] eq {}} {
-                set state(buffer) "end-of-input during comment"
-                return [set state(lastC) LX_ERR]
-            }
-            set state(input) [string range $state(input) 1 end]
-        }
-    }
-
-    if {$c eq "\""} {
-        set firstP 1
-        set quoteP 0
-
-        while 1 {
-            append state(buffer) $c
-
-            switch -- $c/$quoteP {
-                "\\/0" {
-                    set quoteP 1
-                }
-
-                "\"/0" {
-                    if {!$firstP} {
-                        return [set state(lastC) LX_QSTRING]
-                    }
-                    set firstP 0
-                }
-
-                default {
-                    set quoteP 0
-                }
-            }
-
-            if {[set c [string index $state(input) 0]] eq {}} {
-                set state(buffer) "end-of-input during quoted-string"
-                return [set state(lastC) LX_ERR]
-            }
-            set state(input) [string range $state(input) 1 end]
-        }
-    }
-
-    if {$c eq {[}} {
-        set quoteP 0
-
-        while 1 {
-            append state(buffer) $c
-
-            switch -- $c/$quoteP {
-                \\/0 {
-                    set quoteP 1
-                }
-
-                ]/0 {
-                    return [set state(lastC) LX_DLITERAL]
-                }
-
-                default {
-                    set quoteP 0
-                }
-            }
-
-            if {[set c [string index $state(input) 0]] eq {}} {
-                set state(buffer) "end-of-input during domain-literal"
-                return [set state(lastC) LX_ERR]
-            }
-            set state(input) [string range $state(input) 1 end]
-        }
-    }
-
-    if {[set x [lsearch -exact $state(tokenL) $c]] >= 0} {
-        append state(buffer) $c
-
-        return [set state(lastC) [lindex $state(lexemeL) $x]]
-    }
-
-    while 1 {
-        append state(buffer) $c
-
-        switch -- [set c [string index $state(input) 0]] {
-            {} - " " - "\t" - "\n" {
-                break
-            }
-
-            default {
-                if {[lsearch -exact $state(tokenL) $c] >= 0} {
-                    break
-                }
-            }
-        }
-
-        set state(input) [string range $state(input) 1 end]
-    }
-
-    return [set state(lastC) LX_ATOM]
-}
-
-# ::mime::mapencoding --
-#
-#    mime::mapencodings maps tcl encodings onto the proper names for their
-#    MIME charset type.  This is only done for encodings whose charset types
-#    were known.  The remaining encodings return {} for now.
-#
-# Arguments:
-#       enc      The tcl encoding to map.
-#
-# Results:
-#    Returns the MIME charset type for the specified tcl encoding, or {}
-#       if none is known.
-
-proc ::mime::mapencoding {enc} {
-
-    variable encodings
-
-    if {[info exists encodings($enc)]} {
-        return $encodings($enc)
-    }
-    return {}
-}
-
-# ::mime::reversemapencoding --
-#
-#    mime::reversemapencodings maps MIME charset types onto tcl encoding names.
-#    Those that are unknown return {}.
-#
-# Arguments:
-#       mimeType  The MIME charset to convert into a tcl encoding type.
-#
-# Results:
-#    Returns the tcl encoding name for the specified mime charset, or {}
-#       if none is known.
-
-proc ::mime::reversemapencoding {mimeType} {
-
-    variable reversemap
-
-    set lmimeType [string tolower $mimeType]
-    if {[info exists reversemap($lmimeType)]} {
-        return $reversemap($lmimeType)
-    }
-    return {}
-}
-
-# ::mime::word_encode --
-#
-#    Word encodes strings as per RFC 2047.
-#
-# Arguments:
-#       charset   The character set to encode the message to.
-#       method    The encoding method (base64 or quoted-printable).
-#       string    The string to encode.
-#       ?-charset_encoded   0 or 1      Whether the data is already encoded
-#                                       in the specified charset (default 1)
-#       ?-maxlength         maxlength   The maximum length of each encoded
-#                                       word to return (default 66)
-#
-# Results:
-#    Returns a word encoded string.
-
-proc ::mime::word_encode {charset method string {args}} {
-
-    variable encodings
-
-    if {![info exists encodings($charset)]} {
-        error "unknown charset '$charset'"
-    }
-
-    if {$encodings($charset) eq {}} {
-        error "invalid charset '$charset'"
-    }
-
-    if {$method ne "base64" && $method ne "quoted-printable"} {
-        error "unknown method '$method', must be base64 or quoted-printable"
-    }
-
-    # default to encoded and a length that won't make the Subject header to long
-    array set options [list -charset_encoded 1 -maxlength 66]
-    array set options $args
-
-    if {$options(-charset_encoded)} {
-        set unencoded_string [::encoding convertfrom $charset $string]
-    } else {
-        set unencoded_string $string
-    }
-
-    set string_length [string length $unencoded_string]
-
-    if {!$string_length} {
-        return {}
-    }
-
-    set string_bytelength [string bytelength $unencoded_string]
-
-    # the 7 is for =?, ?Q?, ?= delimiters of the encoded word
-    set maxlength [expr {$options(-maxlength) - [string length $encodings($charset)] - 7}]
-    switch -exact -- $method {
-        base64 {
-            if {$maxlength < 4} {
-                error "maxlength $options(-maxlength) too short for chosen charset and encoding"
-            }
-            set count 0
-            set maxlength [expr {($maxlength / 4) * 3}]
-            while {$count < $string_length} {
-                set length 0
-                set enc_string {}
-                while {$length < $maxlength && $count < $string_length} {
-                    set char [string range $unencoded_string $count $count]
-                    set enc_char [::encoding convertto $charset $char]
-                    if {$length + [string length $enc_char] > $maxlength} {
-                        set length $maxlength
-                    } else {
-                        append enc_string $enc_char
-                        incr count
-                        incr length [string length $enc_char]
-                    }
-                }
-                set encoded_word [string map [
-                    list \n {}] [base64 -mode encode -- $enc_string]]
-                append result "=?$encodings($charset)?B?$encoded_word?=\n "
-            }
-            # Trim off last "\n ", since the above code has the side-effect
-            # of adding an extra "\n " to the encoded string.
-
-            set result [string range $result 0 end-2]
-        }
-        quoted-printable {
-            if {$maxlength < 1} {
-                error "maxlength $options(-maxlength) too short for chosen charset and encoding"
-            }
-            set count 0
-            while {$count < $string_length} {
-                set length 0
-                set encoded_word {}
-                while {$length < $maxlength && $count < $string_length} {
-                    set char [string range $unencoded_string $count $count]
-                    set enc_char [::encoding convertto $charset $char]
-                    set qp_enc_char [qp_encode $enc_char 1]
-                    set qp_enc_char_length [string length $qp_enc_char]
-                    if {$qp_enc_char_length > $maxlength} {
-                        error "maxlength $options(-maxlength) too short for chosen charset and encoding"
-                    }
-                    if {
-			$length + [string length $qp_enc_char] > $maxlength
-		    } {
-                        set length $maxlength
-                    } else {
-                        append encoded_word $qp_enc_char
-                        incr count
-                        incr length [string length $qp_enc_char]
-                    }
-                }
-                append result "=?$encodings($charset)?Q?$encoded_word?=\n "
-            }
-            # Trim off last "\n ", since the above code has the side-effect
-            # of adding an extra "\n " to the encoded string.
-
-            set result [string range $result 0 end-2]
-        }
-        {} {
-            # Go ahead
-        }
-        default {
-            error "Can't handle content encoding \"$method\""
-        }
-    }
-    return $result
-}
-
-# ::mime::word_decode --
-#
-#    Word decodes strings that have been word encoded as per RFC 2047.
-#
-# Arguments:
-#       encoded   The word encoded string to decode.
-#
-# Results:
-#    Returns the string that has been decoded from the encoded message.
-
-proc ::mime::word_decode {encoded} {
-
-    variable reversemap
-
-    if {[regexp -- {=\?([^?]+)\?(.)\?([^?]*)\?=} $encoded \
-	- charset method string] != 1
-    } {
-        error "malformed word-encoded expression '$encoded'"
-    }
-
-    set enc [reversemapencoding $charset]
-    if {$enc eq {}} {
-        error "unknown charset '$charset'"
-    }
-
-    switch -exact -- $method {
-        b -
-        B {
-            set method base64
-        }
-        q -
-        Q {
-            set method quoted-printable
-        }
-        default {
-            error "unknown method '$method', must be B or Q"
-        }
-    }
-
-    switch -exact -- $method {
-        base64 {
-            set result [base64 -mode decode -- $string]
-        }
-        quoted-printable {
-            set result [qp_decode $string 1]
-        }
-        {} {
-            # Go ahead
-        }
-        default {
-            error "Can't handle content encoding \"$method\""
-        }
-    }
-
-    return [list $enc $method $result]
-}
-
-# ::mime::field_decode --
-#
-#    Word decodes strings that have been word encoded as per RFC 2047
-#    and converts the string from the original encoding/charset to UTF.
-#
-# Arguments:
-#       field     The string to decode
-#
-# Results:
-#    Returns the decoded string in UTF.
-
-proc ::mime::field_decode {field} {
-    # ::mime::field_decode is broken.  Here's a new version.
-    # This code is in the public domain.  Don Libes <don@libes.com>
-
-    # Step through a field for mime-encoded words, building a new
-    # version with unencoded equivalents.
-
-    # Sorry about the grotesque regexp.  Most of it is sensible.  One
-    # notable fudge: the final $ is needed because of an apparent bug
-    # in the regexp engine where the preceding .* otherwise becomes
-    # non-greedy - perhaps because of the earlier ".*?", sigh.
-
-    while {[regexp {(.*?)(=\?(?:[^?]+)\?(?:.)\?(?:[^?]*)\?=)(.*)$} $field \
-	ignore prefix encoded field]
-    } {
-        # don't allow whitespace between encoded words per RFC 2047
-        if {{} ne $prefix} {
-            if {![string is space $prefix]} {
-                append result $prefix
-            }
-        }
-
-        set decoded [word_decode $encoded]
-        foreach {charset - string} $decoded break
-
-        append result [::encoding convertfrom $charset $string]
-    }
-    append result $field
-    return $result
-}
-
-## One-Shot Initialization
-
-::apply {{} {
-    variable encList
-    variable encAliasList
-    variable reversemap
-
-    foreach {enc mimeType} $encList {
-        if {$mimeType eq {}} continue
-	set reversemap([string tolower $mimeType]) $enc
-    }
-
-    foreach {enc mimeType} $encAliasList {
-        set reversemap([string tolower $mimeType]) $enc
-    }
-
-    # Drop the helper variables
-    unset encList encAliasList
-
-} ::mime}
-
-
-variable ::mime::internal 0
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/natsort-0.1.1.5.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/natsort-0.1.1.5.tm
deleted file mode 100644
index 0dcf57e7..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/natsort-0.1.1.5.tm
+++ /dev/null
@@ -1,1886 +0,0 @@
-#! /usr/bin/env tclsh
-
-
-package require flagfilter
-namespace import ::flagfilter::check_flags
-
-namespace eval natsort {
-     proc scriptdir {} {
-        set possibly_linked_script [file dirname [file normalize [file join [info script] ...]]]
-        if {[file isdirectory $possibly_linked_script]} {
-            return $possibly_linked_script
-        } else {
-            return [file dirname $possibly_linked_script]
-        }
-    }
-    tcl::tm::add [scriptdir]    
-}
-
-
-namespace eval natsort {
-    variable stacktrace_on 0
-
-    proc do_error {msg {then error}} {
-        #note we exit or error out even if debug selected - as every do_error call is meant to interrupt code processing at the site of call
-        #this is not just a 'logging' call even though it has log-like descriptors
-        lassign $then type code
-        if {$code eq ""} {
-          set code 1
-        }
-        set type [string tolower $type]
-        set levels [list debug info notice warn error critical]
-        if {$type in [concat $levels exit]} {
-            puts stderr "|$type> $msg"
-        } else {
-            puts stderr "|>natsort_call_err> unable to interpret 2nd argument to do_error: '$then' should be one of '$levels'  or 'exit <numericcode>'"
-        }
-        if {$::tcl_interactive} {
-            #may not always be desirable - but assumed to be more useful not to exit despite request, to aid in debugging
-            if {[string tolower $type] eq "exit"} {
-              puts stderr "    (exit suppressed due to tcl_interactive - raising error instead)"
-              if {![string is digit -strict $code]} {
-                puts stderr "|>natsort_call_err> unable to interpret 2nd argument to do_error: '$then' should be: 'exit <numericcode>'"
-              }
-            } 
-            return -code error $msg
-        } else {
-            if {$type ne "exit"} {
-              return -code error $msg
-            } else {
-              if {[string is digit -strict $code]} {
-                exit $code
-              } else {
-                puts stderr "|>natsort_call_err> unable to interpret 2nd argument to do_error: '$then' should be 'error' or 'exit <numericcode>'"
-                return -code error $msg
-              }
-            }
-        }
-    }
-
-
-
-
-
- 
-    variable debug 0
-    variable testlist
-    set testlist {
-        00.test-firstposition.txt
-        0001.blah.txt
-        1.test-sorts-after-all-leadingzero-number-one-equivs.txt
-        1010.thousand-and-ten.second.txt
-        01010.thousand-and-ten.first.txt
-        0001.aaa.txt
-        001.zzz.txt
-        08.octal.txt-last-octal
-        008.another-octal-first-octal.txt
-        08.again-second-octal.txt
-        001.a.txt
-        0010.reconfig.txt
-        010.etc.txt
-        005.etc.01.txt
-        005.Etc.02.txt
-        005.123.abc.txt
-        200.somewhere.txt
-        2zzzz.before-somewhere.txt
-        00222-after-somewhere.txt
-        005.00010.abc.txt
-        005.a3423bc.00010.abc.txt
-        005.001.abc.txt
-        005.etc.1010.txt
-        005.etc.010.txt
-        005.etc.10.txt
-        " 005.etc.10.txt"
-        005.etc.001.txt
-        20.somewhere.txt
-        4611686018427387904999999999-bignum.txt 
-        4611686018427387903-bigishnum.txt
-        9223372036854775807-bigint.txt
-        etca-a
-        etc-a
-        etc2-a
-        a0001blah.txt    
-        a010.txt
-        winlike-sort-difference-0.1.txt
-        winlike-sort-difference-0.1.1.txt
-        a1.txt
-        b1-a0001blah.txt    
-        b1-a010.txt
-        b1-a1.txt
-        -a1.txt
-        --a1.txt
-        --a10.txt
-        2.high-two.yml
-        02.higher-two.yml
-        reconfig.txt
-        _common.stuff.txt
-        CASETEST.txt
-        casetest.txt
-        something.txt
-        some~thing.txt
-        someathing.txt
-        someThing.txt
-        thing.txt
-        thing_revised.txt
-        thing-revised.txt
-        "thing revised.txt"
-        "spacetest.txt"
-        " spacetest.txt"
-        "  spacetest.txt"
-        "spacetest2.txt"
-        "spacetest 2.txt"
-        "spacetest02.txt"
-        name.txt
-        name2.txt
-        "name .txt"
-        "name2 .txt"
-        blah.txt
-        combined.txt
-        a001.txt
-        .test
-        .ssh
-        "Feb 10.txt"
-        "Feb  8.txt"
-        1ab23v23v3r89ad8a8a8a9d.txt
-        "Folder (10)/file.tar.gz"
-        "Folder/file.tar.gz"
-        "Folder (1)/file (1).tar.gz"
-        "Folder (1)/file.tar.gz"
-        "Folder (01)/file.tar.gz"
-        "Folder1/file.tar.gz"
-        "Folder(1)/file.tar.gz"
-        
-    }
-    lappend testlist "Some file.txt"
-    lappend testlist "  Some extra file1.txt"
-    lappend testlist "  Some extra file01.txt"
-    lappend testlist "  some extra file1.txt"
-    lappend testlist "  Some extra file003.txt"
-    lappend testlist " Some file.txt"
-    lappend testlist "Some extra file02.txt"
-    lappend testlist "Program Files (x86)"
-    lappend testlist "01999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991-bigger-pathologically-bignum.txt"
-    lappend testlist "199999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999-pathologically-bignum.txt"
-    lappend testlist "29999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999-smaller-pathologically-bignum.txt"
-    lappend testlist "199999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999-pathologically-bignum.txt with (more 1.txt"
-    lappend testlist "199999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999-pathologically-bignum.txt with (more 01.txt"
-    lappend testlist "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1.pathological-num-nonnum-swapping-leadzero-should-be-first.txt"
-    lappend testlist "a1a1a1a1a1a1a1a1a1a1a1a01a1a1a1a1a1a1a1a1a1a1a1a1.pathological-num-nonnum-swapping-leadzero-should-be-first.txt"
-    lappend testlist "b1b1b1b1.txt"
-    lappend testlist "b1b01z1z1.txt"
-    lappend testlist "c1c111c1.txt"
-    lappend testlist "c1c1c1c1.txt"
-
-    namespace eval overtype {
-        proc right {args} {
-            # @d !todo - implement overflow, length checks etc
-
-            if {[llength $args] < 2} {
-                error {usage: ?-overflow [1|0]? undertext overtext}
-            }
-            foreach {undertext overtext} [lrange $args end-1 end] break
-
-            set opt(-overflow)	0
-            array set opt [lrange $args 0 end-2]
-
-
-            set olen [string length $overtext]
-            set ulen [string length $undertext]
-
-            if {$opt(-overflow)} {
-                return [string range $undertext 0 end-$olen]$overtext
-            } else {
-                if {$olen > $ulen} {	
-                    set diff [expr {$olen - $ulen}]
-                    return [string range $undertext 0 end-$olen][string range $overtext 0 end-$diff]
-                } else {
-                    return [string range $undertext 0 end-$olen]$overtext
-                }
-            }
-        }
-        proc left {args} {
-            # @c overtype starting at left (overstrike) 
-            # @c can/should we use something like this?: 'format "%-*s" $len $overtext 
-
-            if {[llength $args] < 2} {
-                error {usage: ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
-            }
-            foreach {undertext overtext} [lrange $args end-1 end] break
-
-            set opt(-ellipsis)		0
-            set opt(-ellipsistext)	{...}
-            set opt(-overflow)	0
-            array set opt [lrange $args 0 end-2]
-
-            
-            set len [string length $undertext]
-            set overlen [string length $overtext]
-            set diff [expr {$overlen - $len}]
-
-            #puts stdout "====================>overtype: datalen:$len  overlen:$overlen diff:$diff"
-            #puts stdout "====================>overtype: data: $overtext"
-            if {$diff > 0} {
-                if {$opt(-overflow)} {
-                    return $overtext
-                } else {
-                    if {$opt(-ellipsis)} {
-                        return [overtype::left [string range $overtext 0 [expr {$len -1}]] $opt(-ellipsistext)]
-                    } else {
-                        return [string range $overtext 0 [expr {$len -1}]]
-                    }
-                }
-            } else {
-                return "$overtext[string range $undertext $overlen end]"
-            }
-        }
-        
-    }
-
-    #considered using hex to make large numbers more compact for viewing in debug output - but it's not that much shorter and probably obscures more than it helps.
-    proc hex2dec {largeHex} {
-        set res 0
-        set largeHex [string map [list _ ""] $largeHex]
-        foreach hexDigit [split $largeHex {}] {
-            set new 0x$hexDigit
-            set res [expr {16*$res + $new}]
-        }
-        return $res
-    }
-    proc dec2hex {decimalNumber} {
-        format %4.4llX $decimalNumber
-    }
-    proc trimzero {number} {
-        set trimmed [string trimleft $number 0]
-        if {[string length $trimmed] == 0} {
-            set trimmed 0
-        }
-        return $trimmed
-    }
-    #todo - consider human numeric split
-    #e.g consider SI suffixes k|KMGTPEZY in that order
-
-    #in this context, for natural sorting - numeric segments don't contain underscores or other punctuation such as . - + etc.
-    #review - what about unicode equivalents such as wide numerals \UFF10 to \UFF19?  unicode normalization?
-    proc split_numeric_segments {name} {
-        set segments [list]
-        while {[string length $name]} {
-            if {[scan $name {%[0-9]%n} chunk len] == 2} {
-                lappend segments $chunk 
-                set name [string range $name $len end]
-            }
-            if {[scan $name {%[^0-9]%n} chunk len] == 2} {
-                lappend segments $chunk
-                set name [string range $name $len end]
-            }
-        }
-        return $segments
-    }
-
-    proc padleft {str count {ch " "}} {
-        set val [string repeat $ch $count]
-        append val $str 
-        set diff [expr {max(0,$count - [string length $str])}]
-        set offset [expr {max(0,$count - $diff)}]
-        set val [string range $val $offset end]
-    }
-
-
-    # Sqlite may have limited collation sequences available in default builds.
-    # with custom builds - there may be others such as 'natsort' - see https://sqlite.org/forum/forumpost/e4dc6f3331
-    # This is of limited use with the few builtin collations available in 2023 ie binary,nocase & rtrim
-    #  but may provide a quicker,flexible sort option, especially if/when more collation sequences are added to sqlite
-    # There are also prebuilt packages such as sqlite3-icu  which allows things like "SELECT icu_load_collation('en_AU', 'australian');"
-    proc sort_sqlite {stringlist args} {
-        package require sqlite3
-
-    
-        set args [check_flags -caller natsort_sqlite -defaults [list -db :memory: -collate nocase  -winlike 0 -topchars "\uFFFF" -debug 0 -splitchars [list / . - _] -extras {all}] -values $args]
-        set db          [string trim [dict get $args -db]]
-        set collate     [string trim [dict get $args -collate]]
-        set debug       [string trim [dict get $args -debug]]
-        set topchars    [string trim [dict get $args -topchars]]
-
-        set topdot [expr {"." in $topchars}]
-        set topunderscore [expr {"_" in $topchars}]
-        
-        
-        sqlite3 db_sort_basic $db
-        set orderedlist [list]
-        db_sort_basic eval [string map [list %collate% $collate] {create table sqlitesort(index0 text COLLATE %collate%, name text COLLATE %collate%)}]
-        foreach nm $stringlist {
-            set segments [split_numeric_segments $nm]
-            set index ""
-            set s 0
-            foreach seg $segments {
-                if {($s == 0) && ![string length [string trim $seg]]} {
-                    #don't index leading space
-                } elseif {($s == 0) && ($topunderscore) && [string match _* [string trim $seg]]} {
-                    append index "[padleft "0" 5]-d -100 topunderscore "
-                    append index [string trim $seg]
-                } elseif {($s == 0) && ($topdot) && [string match .* [string trim $seg]]} {
-                    append index "[padleft "0" 5]-d -50 topdot "
-                    append index [string trim $seg]
-                } else {
-                    if {[string is digit [string trim $seg]]} {
-                        set basenum [trimzero [string trim $seg]]
-                        set lengthindex "[padleft [string length $basenum] 5]-d"
-                        append index "$lengthindex "
-                        #append index [padleft $basenum 40]
-                        append index $basenum
-                    } else {
-                        append index [string trim $seg]
-                    }
-                }
-                incr s
-            }
-            puts stdout ">>$index"
-            db_sort_basic eval {insert into sqlitesort values($index,$nm)} 
-        }
-        db_sort_basic eval [string map [list %collate% $collate] {select name from sqlitesort order by index0 COLLATE %collate% ASC, name COLLATE %collate% ASC }] {
-            lappend orderedlist $name
-        }
-        db_sort_basic close
-        return $orderedlist
-    }
-
-    proc get_leading_char_count {str char} {
-        #todo - something more elegant? regex?
-        set count 0
-        foreach c [split $str "" ] {
-            if {$c eq $char} {
-                incr count
-            } else {
-                break
-            }
-        }
-        return $count
-    }
-    proc stacktrace {} {
-        set stack "Stack trace:\n"
-        for {set i 1} {$i < [info level]} {incr i} {
-            set lvl [info level -$i]
-            set pname [lindex $lvl 0]
-            append stack [string repeat " " $i]$pname
-
-            if {![catch {info args $pname} pargs]} {
-                foreach value [lrange $lvl 1 end] arg $pargs {
-
-                    if {$value eq ""} {
-                        if {$arg != 0} {
-                            info default $pname $arg value
-                        }
-                    }
-                    append stack " $arg='$value'"
-                }
-            } else {
-                append stack " !unknown vars for $pname"
-            }
-
-            append stack \n
-        }
-        return $stack
-    }
-
-    proc get_char_count {str char} {
-        expr {[string length $str]-[string length [string map [list $char {}] $str]]}
-    }
-    
-    proc build_key {chunk  splitchars topdict tagconfig debug} {
-        variable stacktrace_on
-        if {$stacktrace_on} {
-            puts stderr "+++>[stacktrace]"
-        }
-
-        set index_map [list - "" _ ""]
-        #e.g - need to maintain the order
-        #a b.txt
-        #a book.txt
-        #ab.txt
-        #abacus.txt
-    
-
-        set original_splitchars [dict get $tagconfig original_splitchars]
-
-        # tag_dashes test moved from loop - review
-        set tag_dashes 0
-        if {![string length [dict get $tagconfig last_part_text_tag]]} {
-            #winlike
-            set tag_dashes 1
-        }
-        if {("-" ni $original_splitchars)} {
-            set tag_dashes 1 
-        }
-        if {$debug >= 3} {
-            puts stdout "START build_key chunk        : $chunk"
-            puts stdout "START build_key splitchars   : $splitchars $topdict $tagconfig  NO tag dashes"
-        }
-
-
-        ## index_map will have no effect if we've already split on the char anyway(?)
-        #foreach m [dict keys $index_map] {
-        #    if {$m in $original_splitchars} {
-        #        dict unset index_map $m
-        #    }
-        #}
-
-        #if {![string length $chunk]} return 
-        
-        set result ""
-        if {![llength $splitchars]} {
-            #no more structural splits - but we need to examine numeric/non-numeric segments at the lowest level.    
-            # we are at a leaf in the recursive split hierarchy 
-
-            set s "" ;#we never actually split on "" (unless that was put in splitchars.. but it probably shouldn't be)
-            set parts [list $chunk] ;#important to treat as list or leading/trailing whitespace lost
-
-        
-        } else {
-            set s [lindex $splitchars 0]
-            if {"spudbucket$s" in "[split $chunk {}]"} {
-                error "dead-branch spudbucket"
-                set partindex [build_key $chunk  [lrange $splitchars 1 end] $topdict $tagconfig $debug] 
-                if {[dict get $tagconfig showsplits]} {
-                    set pfx "(1${s}=)"  ;# = sorts before _ 
-                    set partindex ${pfx}$partindex
-                }
-
-                return $partindex
-            } else {
-                set parts_below_index ""
-
-                if {$s ni [split $chunk ""]} {
-                    #$s can be an empty string 
-                    set parts [list $chunk]
-                } else {
-                    set parts [split $chunk $s] ;#whitespace preserved - even if splitting on s that is not in string.
-                }
-                #assert - we have a splitchar $s that is in the chunk - so at least one part
-                if {(![string length $s] || [llength $parts] == 0)} {
-                    error "buld_key assertion false empty split char and/or no parts"
-                } 
-
-                set pnum 1 ;# 1 based for clarity of reading index in debug output
-                set subpart_count [llength $parts] 
-
-                set sub_splits [lrange $splitchars 1 end] ;#pass same splitchars to each subpart
-                foreach p $parts {
-                    set partindex [build_key $p  $sub_splits $topdict $tagconfig $debug] 
-                    set lastpart [expr {$pnum == $subpart_count}]
-
-
-                    #######################
-                    set showsplits [dict get $tagconfig showsplits]
-                    #split prefixing experiment - maybe not suitable for general use - as it affects sort order 
-                    #note that pfx must be consistent until last one, no matter how many partnumbers there are in total.
-                    # we don't want to influence sort order before reaching end.
-                    #e.g for:
-                    #(1.=)...
-                    #(1._)...(2._)...(3.=)
-                    #(1._)...(2.=)
-                    #Note that this is probably more suitable for highly structure dependant sorts where the results are maybe less.. natural.
-                    if {$showsplits} {
-                        if {$lastpart} {
-                            set pfx "(${pnum}${s}_"
-                            #set pfx "(${pnum}${s}=)"  ;# = sorts before _
-                        } else {
-                            set pfx "(${pnum}${s}_"
-                        }
-                        append parts_below_index $pfx
-                    } 
-                    #######################
-
-                    if {$lastpart} {
-                        if {[string length $p] && [string is digit $p]} {
-                            set last_part_tag "<22${s}>"
-                        } else {
-                            set last_part_tag "<33${s}>"
-                        }
-
-                        set last_part_text_tag [dict get $tagconfig last_part_text_tag]
-                        #for -winlike 1 there is no tag configured. Windows explorer likes to put things in the  order:
-                        #  module-0.1.1.tm
-                        #  module-0.1.1.2.tm
-                        #  module-0.1.tm
-                        # arguably -winlike 0 is more natural/human
-                        #  module-0.1.tm
-                        #  module-0.1.1.tm
-                        #  module-0.1.1.2.tm
-
-                        if {[string length $last_part_text_tag]} {
-                            #replace only the first text-tag (<30>) from the subpart_index 
-                            if {[string match "<30?>*" $partindex]} {
-                                #give textual string index  a specific tag   for last part in split only. e.g <130> for lower than integers
-                                set partindex "<130>[string range $partindex 5 end]" 
-                            }
-                            #append parts_below_index $last_part_tag
-                        }
-                        #set partindex $last_part_tag$partindex
-
-
-                    }
-                    append parts_below_index $partindex
-                    
-
-
-                    if {$showsplits} {
-                        if {$lastpart} {
-                            set suffix "${pnum}${s}=)"  ;# = sorts before _
-                        } else {
-                            set suffix "${pnum}${s}_)"
-                        }
-                        append parts_below_index $suffix
-                    } 
-
-
-                    incr pnum
-                }
-                append parts_below_index "" ;# don't add anything at the tail that may perturb sort order
-
-                if {$debug >= 3} {
-                    set pad [string repeat " " 20]
-                    puts stdout "END build_key chunk          : $chunk "
-                    puts stdout "END build_key splitchars     : $splitchars $topdict $tagconfig  NO tag dashes"
-                    puts stdout "END build_key ret below_index: $parts_below_index"
-                }
-                return $parts_below_index
-
-
-            }
-        }
-
-        
-
-        #puts stdout ">>>chunk:'$chunk'<<< split-on:$s parts: '$parts'   splitchars: $splitchars -topdict:$topdict"
-        
-            
-        
-
-       
-        #if {$chunk eq ""} {
-        #   puts "___________________________________________!!!____"
-        #}
-        #puts stdout "-->chunk:$chunk $s parts:$parts"
-
-        #puts stdout "---chunk:'$chunk' part:'$part' parts:'$parts' s:'$s'"
-        
-     
-
-
-            set segments [split_numeric_segments $chunk] ;#!  
-            set stringindex ""
-            set segnum 0
-            foreach seg $segments {
-                    #puts stdout "=================---->seg:$seg segments:$segments"
-                #-strict ?
-                if {[string length $seg] && [string is digit $seg]} {
-                    set basenum [trimzero [string trim $seg]]
-                    set lengthindex "[padleft [string length $basenum] 4]d" 
-                    #append stringindex "<20>$lengthindex $basenum $seg"
-                } else {
-                    set c1 [string range $seg 0 0]
-                    #puts stdout "==============> c1'$c1' topdict: $topdict stringindex:$stringindex"
-                    
-                    if {$c1 in [dict keys $topdict]} {
-                        set tag [dict get $topdict $c1]
-                        #append stringindex "${tag}$c1"
-                        #set seg [string range $seg 1 end]
-                    } 
-                    #textindex 
-                    set leader "<30>"
-                    set idx $seg 
-                    set idx [string trim $idx]
-                    set idx [string tolower $idx]
-                    set idx [string map $index_map $idx]
-
-
-                    
-
-                    
-                    #set the X-c count to match the length of the index - not the raw data      
-                    set lengthindex "[padleft [string length $idx] 4]c"
-                    
-                    #append stringindex "${leader}$idx $lengthindex $texttail"
-                }
-            } 
-
-            if {[llength $parts] != 1} {
-                error "build_key assertion fail llength parts != 1 parts:$parts"
-            }
-
-            set segtail_clearance_buffer " " ;#space to clear other split indicators if using showsplits
-            set segtail $segtail_clearance_buffer
-            append segtail "\["
-            set grouping ""
-            set pnum 0
-            foreach p $parts {
-                set sublen_list [list]
-                set subsegments [split_numeric_segments $p]
-                set i 0
-
-                set partsorter ""
-                foreach sub $subsegments {
-                    ##don't trim spaces here - it would be inconsistent. Some subs are pure whitespace - others have internal whitespace. e.g "a4 400b a b2" becomes "a 4 { } 400 {b a b} 2"
-                    #mapping away all whitespace would be consistent, but not necessarily desirable. If it's in the index_map it'll happen anyway - so we don't do it manually here except for evaluating conditions.
-                    set test_trim [string trim $sub]
-                    set str $sub 
-                    set str [string tolower $str]
-                    set str [string map $index_map $str]
-                    if {[string length $test_trim] && [string is digit $test_trim]} {
-                        append partsorter [trimzero $str]
-                    } else {
-                        append partsorter "$str"
-                    }
-                    append partsorter 
-                }
-
-
-                foreach sub $subsegments { 
-
-                    if {[string length $sub] && [string is digit $sub]} {
-                        set basenum [trimzero [string trim $sub]]
-                        set subequivs $basenum
-                        set lengthindex "[padleft [string length $subequivs] 4]d "
-                        set idx "$lengthindex [padleft $basenum 10]" ;#todo - cycle through data and determine longest 
-                        set tail [overtype::left [string repeat " " 10] $sub]
-                        #set tail ""
-                    } else {
-                        set idx ""
-                        
-
-                        set lookahead [lindex $subsegments $i+1]
-                        if {![string length $lookahead]} {
-                            set zeronum "[padleft 0 4]d0"
-                        } else {
-                            set zeronum ""
-                        }
-                        set subequivs $sub
-                        #set subequivs [string trim $subequivs]
-                        set subequivs [string tolower $subequivs]
-                        set subequivs [string map $index_map $subequivs]
-
-                        append idx $subequivs
-                        append idx $zeronum
-
-                        set idx $subequivs
-                        
-
-                        #<removed tag_dashes test put above - review>
-                        
-                        set ch "-"
-                        if {$tag_dashes} {    
-                            #puts stdout "____TAG DASHES"
-                            #winlike
-                            set numleading [get_leading_char_count $seg $ch]
-                            if {$numleading > 0} {
-                                set texttail "<31-leading[padleft $numleading 4]$ch>"
-                            } else {
-                                set texttail "<30>"
-                            }
-                            set numothers [expr {[get_char_count $seg $ch] - $numleading}]
-                            if {$debug >= 2} {
-                              puts stdout "____dashcount: [get_char_count $seg $ch] numothers: $numothers"
-                            }
-                            if {$numothers > 0} {
-                                append texttail "<31-others[padleft $numothers 4]$ch>"
-                            }  else {
-                                append textail "<30>"
-                            }
-                        } else {
-                            set texttail "<30>" 
-                        }
-
-
-
-
-                        #set idx $partsorter
-                        set tail ""
-                        #set tail [string tolower $sub] ;#raw
-                        #set tail $partsorter
-                        #append tail ":[string tolower $p]" ;#we need the whole part - even though it makes the index much larger. !todo - tagconfig switch to toggle case sensitive sorting
-                    }
-
-                    append grouping "$idx $tail<end>|$s"
-                    incr i
-                }
-
-
-
-
-
-                if {$p eq ""} {
-                    # no subsegments.. 
-                    set zeronum "[padleft 0 4]d0"
-                    #append grouping "\u000$zerotail"
-                    append grouping ".$zeronum"
-                }
-
-                #append grouping |
-                #append grouping $s
-                #foreach len $sublen_list {
-                #    append segtail "<[padleft $len 3]>"
-                #}
-                incr pnum
-            }
-            set grouping [string trimright $grouping $s]
-            append grouping "[padleft [llength $parts] 4]"
-            append segtail $grouping
-            
-
-            #append segtail " <[padleft [llength $parts] 4]>"
-            
-            append segtail "\]"
-
-
-            #if {[string length $seg] && [string is digit $seg]} {
-            #    append segtail "<20>"
-            #} else {
-            #    append segtail "<30>"
-            #}
-            append stringindex $segtail
-
-            incr segnum
-            
-     
-       
-        
-        lappend indices  $stringindex
-
-        if {[llength $indices] > 1} {
-            puts stderr "INDICES [llength $indices]: $stringindex"        
-            error "build_key assertion error deadconcept indices"
-        }
-
-        #topchar handling on splitter characters
-        #set c1 [string range $chunk 0 0]
-        if {$s  in [dict keys $topdict]} {
-            set tag [dict get $topdict $s]
-            set joiner [string map [list ">" "$s>"] ${tag}]
-            #we have split on this character $s so if the first part is empty string then $s was a leading character
-            # we need to bring a tag out front for this, or it will be dominated by the leading sections-remaing tag <S..> 
-            # (since the empty string produces no tag of it's own - ?)
-            if {[string length [lindex $parts 0]] == 0} {
-                set prefix ${joiner} 
-            } else {
-                set prefix ""
-            }
-        } else {
-            #use standard character-data positioning tag if no override from topdict
-            set joiner "<30J>$s"
-            set prefix ""
-        }
-
-
-        set  contentindex   $prefix[join $indices $joiner]
-        if {[string length $s]} {
-            set split_indicator "<split$s $chunk>"
-        } else {
-            set split_indicator "<split$s $chunk>"
-
-        }
-        if {![string length $s]} {
-            set s ~
-        }
-
-        #return  "[overtype::left [string repeat { } 80] $contentindex][overtype::left [string repeat { } 10] [list $s $chunk]]"
-        #return $contentindex$split_indicator
-        #return [overtype::left [string repeat - 40] $contentindex]
-
-        if {$debug >= 3} {
-            puts stdout "END build_key chunk          : $chunk"
-            puts stdout "END build_key splitchars     : $splitchars $topdict $tagconfig  NO tag dashes"
-            puts stdout "END build_key ret contentidx : $contentindex"
-        }
-        return $contentindex
-    }
-
-    #----------------------------------------
-    #line-processors - data always last argument - opts can be empty string
-    #all processor should accept empty opts and ignore opts if they don't use them 
-    proc _lineinput_as_tcl1 {opts line} {
-        set out ""
-        foreach i $line {
-            append out "$i "
-        }
-        set out [string range $out 0 end-1]
-        return $out
-    }
-    #should be equivalent to above
-    proc _lineinput_as_tcl {opts line} {
-        return [concat {*}$line]
-    }
-    #will put extra tcl quoting if it was already tcl-shaped  e.g text  "a" -> {"a"}
-    proc _lineoutput_as_tcl {opts line} {
-        return [regexp -inline -all {\S+} $line]
-    }
-
-    proc _lineinput_as_raw {opts line} {
-        return $line
-    }
-    proc _lineoutput_as_raw {opts line} {
-        return $line
-    }
-
-    #words is opposite of tcl
-    proc _lineinput_as_words {opts line} {
-        #wordlike_parts
-        return [regexp -inline -all {\S+} $line]
-    }
-    proc _lineoutput_as_words {opts line} {
-        return [concat {*}$line]
-    }
-
-    #opts same as tcllib csv::split - except without the 'line' element
-    #?-alternate? ?sepChar? ?delChar?
-    proc _lineinput_as_csv {opts line} {
-        package require csv
-        if {[lindex $opts 0] eq "-alternate"} {
-            return [csv::split -alternate $line {*}[lrange $opts 1 end]]
-        } else {
-            return [csv::split $line {*}$opts]
-        }
-    }
-    #opts same as tcllib csv::join 
-    #?sepChar? ?delChar? ?delMode?
-    proc _lineoutput_as_csv {opts line} {
-        package require csv
-        return [csv::join $line {*}$opts]
-    }
-    #----------------------------------------
-    proc sort {stringlist args} {
-        #puts stdout "natsort::sort args: $args"
-        variable debug
-        if {![llength $stringlist]} return
-        
-        #allow pass through of the check_flags flag -debugargs so it can be set by the caller
-        set debugargs 0
-        if {[set posn [lsearch $args -debugargs]] >=0} {
-            if {$posn == [llength $args]-1} {
-                #-debugargs at tail of list
-                set debugargs 1
-            } else {
-                set debugargs [lindex $args $posn+1]
-            }
-        }
-
-        #-return flagged|defaults doesn't work Review.
-        #flagfilter global processor/allocator not working 2023-08
-        set args [check_flags \
-          -caller natsort::sort \
-          -return supplied|defaults \
-          -debugargs $debugargs \
-          -defaults [list -collate nocase \
-                    -winlike 0 \
-                    -splits "\uFFFF" \
-                    -topchars {. _} \
-                    -showsplits 1 \
-                    -sortmethod ascii \
-                    -collate "\uFFFF" \
-                    -inputformat raw \
-                    -inputformatapply {index data} \
-                    -inputformatoptions "" \
-                    -outputformat raw \
-                    -outputformatoptions "" \
-                    -cols "\uFFFF" \
-                    -debug 0 -db "" -stacktrace 0 -splits "\uFFFF" -showsplits 0] \
-          -required {all} \
-          -extras {none} \
-          -commandprocessors {} \
-          -values $args]
-
-       #csv unimplemented
-
-        set winlike         [dict get $args -winlike]
-        set topchars        [dict get $args -topchars]
-        set cols            [dict get $args -cols]
-        set debug           [dict get $args -debug]
-        set stacktrace      [dict get $args -stacktrace]
-        set showsplits      [dict get $args -showsplits]
-        set splits          [dict get $args -splits]
-        set sortmethod      [dict get $args -sortmethod]
-        set opt_collate         [dict get $args -collate]
-        set opt_inputformat     [dict get $args -inputformat]
-        set opt_inputformatapply     [dict get $args -inputformatapply]
-        set opt_inputformatoptions     [dict get $args -inputformatoptions]
-        set opt_outputformat    [dict get $args -outputformat]
-        set opt_outputformatoptions    [dict get $args -outputformatoptions]
-        dict unset args -showsplits
-        dict unset args -splits 
-        if {$debug} {
-            puts stdout "natsort::sort processed_args: $args"
-            if {$debug == 1} {
-                puts stdout "natsort::sort - try also -debug 2, -debug 3"
-            }
-        }
-        
-        #set sortmethod "-dictionary" ;# sorts a2b before a001b   - possibly other strangenesses that are hard to reason about
-
-        if {$sortmethod in [list dictionary ascii]} {
-            set sortmethod "-$sortmethod"
-            # -ascii is default for tcl lsort.
-        } else {
-            set sortmethod "-ascii"
-        }
-
-        set allowed_collations [list nocase]
-        if {$opt_collate ne "\uFFFF"} {
-            if {$opt_collate ni $allowed_collations} {
-                error "natsort::sort unknown value for -collate option. Only acceptable value(s): $allowed_collations"
-            }
-            set nocaseopt "-$opt_collate"
-        } else {
-            set nocaseopt ""
-        }
-        set allowed_inputformats [list tcl raw csv words]
-        if {$opt_inputformat ni $allowed_inputformats} {
-            error "natsort::sort unknown value for -inputformat option. Only acceptable value(s): $allowed_inputformats"
-        }
-        set allowed_outputformats [list tcl raw csv words]
-        if {$opt_inputformat ni $allowed_outputformats} {
-            error "natsort::sort unknown value for -outputformat option. Only acceptable value(s): $allowed_outputformats"
-        }
-
-        #
-        set winsplits [list / . _]
-        set commonsplits [list / . _ -]
-        #set commonsplits [list]
-
-        set tagconfig [dict create]
-        dict set tagconfig last_part_text_tag "<19>"        
-        if {$winlike} {
-            set splitchars $winsplits 
-            #windows explorer sorts leading spaces at the top - which doesn't seem very helpful for keeping things together - but the explorer doesn't seem able to create leading spaces anyway.
-            set wintop [list "(" ")" { }  {.} {_}] ;#windows specific order  
-            foreach t $topchars {
-                if {$t ni $wintop} {
-                    lappend wintop $t
-                }
-            }
-            set topchars $wintop 
-            dict set tagconfig last_part_text_tag ""
-        } else {
-            set splitchars $commonsplits
-        }
-        if {$splits ne "\uFFFF"} {
-            set splitchars $splits 
-        }
-        dict set tagconfig original_splitchars $splitchars
-        dict set tagconfig showsplits $showsplits
-
-        #create topdict
-        set i 0
-        set topdict [dict create]
-        foreach c $topchars {   
-            incr i ;#start at 01 so that 00 reserved for final-split tag (allows x-0.1.txt to sort above x-0.1.1.txt  by default. Use tagconfig to change, or choose -winlike 1 for explorer-like sorting)
-            dict set topdict $c "<0$i>"
-        }
-        set keylist [list]    
-
-
-        if {$opt_inputformat eq "tcl"} {
-            set lineinput_transform [list  _lineinput_as_tcl $opt_inputformatoptions]
-        } elseif {$opt_inputformat eq "csv"} {
-            set lineinput_transform [list  _lineinput_as_csv $opt_inputformatoptions]
-        } elseif {$opt_inputformat eq "raw"} {
-            set lineinput_transform [list _lineinput_as_raw $opt_inputformatoptions] 
-        } elseif {$opt_inputformat eq "words"} {
-            set lineinput_transform [list _lineinput_as_words $opt_inputformatoptions] 
-        }
-        if {$opt_outputformat eq "tcl"} {
-            set lineoutput_transform [list  _lineoutput_as_tcl $opt_outputformatoptions]
-        } elseif {$opt_outputformat eq "csv"} {
-            set lineoutput_transform [list  _lineoutput_as_csv $opt_outputformatoptions]
-        } elseif {$opt_outputformat eq "raw"} {
-            set lineoutput_transform [list _lineoutput_as_raw $opt_outputformatoptions] 
-        } elseif {$opt_outputformat eq "words"} {
-            set lineoutput_transform [list _lineoutput_as_words $opt_outputformatoptions] 
-        }
-
-        
-        if {("data" in $opt_inputformatapply) || ("index" in $opt_inputformatapply)} {
-            if {$opt_inputformat eq "raw"} {
-                set tf_stringlist $stringlist
-            } else {
-                set tf_stringlist [list]
-                foreach v $stringlist {
-                    lappend tf_stringlist [{*}$lineinput_transform $v]
-                }
-            }
-            if {"data" in $opt_inputformatapply} {
-                set tf_data_stringlist $tf_stringlist
-            } else {
-                set tf_data_stringlist $stringlist
-            }
-            if {"index" in $opt_inputformatapply} {
-                set tf_index_stringlist $tf_stringlist
-            } else {
-                set tf_index_stringlist $stringlist
-            }
-        } else {
-            set tf_data_stringlist $stringlist
-            set tf_index_stringlist $stringlist
-        }
-
-
-
-        if {$stacktrace} {
-            puts stdout [natsort::stacktrace]
-            set natsort::stacktrace_on 1
-        }
-        if {$cols eq "\uFFFF"} {
-            set colkeys [lmap v $stringlist {}]
-        } else {
-            set colkeys [list]
-            foreach v $tf_index_stringlist {
-                set lineparts $v
-                set k [list]
-                foreach c $cols {
-                    lappend k [lindex $lineparts $c]
-                }
-                lappend colkeys [join $k "_"] ;#use a common-split char - Review
-            }
-        }
-        #puts stdout "colkeys: $colkeys"
-       
-        if {$opt_inputformat eq "raw"} {
-            #no inputformat was applied - can just use stringlist
-            foreach value $stringlist ck $colkeys {
-                set contentindex   [build_key $value $splitchars $topdict $tagconfig $debug]
-                set colindex       [build_key $ck $splitchars $topdict $tagconfig $debug]
-                lappend keylist ${colindex}-${contentindex}-$value ;#note: entire raw value  used for final sort disambiguation (can be whitespace that was ignored in indexing)
-            }
-        } else {
-            foreach keyinput $tf_index_stringlist datavalue  $tf_data_stringlist ck $colkeys {
-                #data may or may not have been transformed
-                #column index may or may not have been built with transformed data
-                
-                set contentindex   [build_key $keyinput $splitchars $topdict $tagconfig $debug]
-                set colindex       [build_key $ck $splitchars $topdict $tagconfig $debug]
-                lappend keylist ${colindex}-${contentindex}-$datavalue ;#note: entire value  used for final sort disambiguation (can be whitespace that was ignored in indexing)
-            }
-        }
-        #puts stderr "keylist: $keylist"
-
-        ###################################################################################################
-        #  Use the generated keylist to do the actual sorting
-        #  select either the transformed or raw data as the corresponding output
-        ###################################################################################################
-        if {[string length $nocaseopt]} {
-            set sortcommand [list lsort $sortmethod $nocaseopt -indices $keylist]
-        } else {
-            set sortcommand [list lsort $sortmethod -indices $keylist]
-        }
-        if {$opt_outputformat eq "raw"} {
-            #raw output means no further transformations - it doesn't mean there wasn't a transform applied on the input side
-            #use the tf_data_stringlist in the output - which will be the same as the input stringlist if no input transform applied for data.
-            #(Also - it may or may not have been *sorted* on transformed data depending on whether 'index' was in $opt_inputformatapply)
-            foreach idx [{*}$sortcommand] {
-                lappend result [lindex $tf_data_stringlist $idx]
-            }
-        } else {
-            #we need to apply an output format
-            #The data may or may not have been transformed at input
-            foreach idx [{*}$sortcommand] {
-                lappend result [{*}$lineoutput_transform [lindex $tf_data_stringlist $idx]]
-            }
-        }
-        ###################################################################################################
-       
-
-
-
-        
-        if {$debug >= 2} {
-            set screen_width 250
-            set max_val 0
-            set max_idx 0
-            #####  calculate colum widths
-            foreach i [{*}$sortcommand] {
-                set len_val [string length [lindex $stringlist $i]] 
-                if {$len_val > $max_val} {
-                    set max_val $len_val
-                }
-                set len_idx [string length [lindex $keylist $i]]
-                if {$len_idx > $max_idx} {
-                    set max_idx $len_idx
-                }
-            }
-            ####
-            set l_width [expr {$max_val + 1}]
-            set leftcol [string repeat " " $l_width]
-            set r_width [expr {$screen_width - $l_width - 1}]
-            set rightcol [string repeat " " $r_width]
-            set str [overtype::left $leftcol RAW]
-            puts stdout "  $str Index with possibly transformed data at tail"
-            foreach i [{*}$sortcommand] {
-                #puts stdout "|d> [overtype::left  $leftcol [lindex $stringlist $i] ]  [lindex $keylist $i]" 
-                set index [lindex $keylist $i]
-                set len_idx [string length $index]
-                set rowcount [expr {$len_idx / $r_width}]
-                if {($len_idx % $r_width) > 0} {
-                    incr rowcount
-                }
-                set rows [list]
-                for {set r 0} {$r < $rowcount} {incr r} {
-                    lappend rows [string range $index 0 $r_width-$r]
-                    set index [string range $index $r_width end]
-                }
-
-                set r 0
-                foreach idxpart $rows {
-                    if {$r == 0} {
-                        #use the untransformed stringlist 
-                        set str [overtype::left  $leftcol [lindex $stringlist $i]]
-                    } else {
-                        set str [overtype::left  $leftcol ...]]
-                    }
-                    puts stdout "  $str $idxpart" 
-                    incr r
-                }
-                #puts stdout "|> '[lindex $stringlist $i]'"
-                #puts stdout "|>    [lindex $keylist $i]"
-            }
-        
-            puts stdout "|debug> topdict:    $topdict"
-            puts stdout "|debug> splitchars: $splitchars"
-        }
-        return $result
-    }
-
-
-
-    #Note that although leading whitespace isn't a commonly used feature of filesystem names - it's possible at least on  FreeBSD,windows and linux so we should try to handle it sensibly.
-    proc sort_experiment {stringlist args} {
-        package require sqlite3
-
-        variable debug
-        set args [check_flags -caller natsort::sort \
-          -defaults [dict create -db :memory:  -collate nocase -nullvalue "->NULL<"  -winlike 0  -topchars [list] -debug 0] \
-          -extras {all} \
-          -values $args]
-        set db              [string trim [dict get $args -db]]
-        set collate         [string trim [dict get $args -collate]]
-        set winlike     [string trim [dict get $args -winlike]]
-        set debug           [string trim [dict get $args -debug]]
-        set nullvalue       [string trim [dict get $args -nullvalue]]
-
-
-        set topchars        [string trim [dict get $args -topchars]]
-        
-        set topdot [expr {"." in $topchars}]
-        set topunderscore [expr {"_" in $topchars}]
-        
-        
-        sqlite3 db_natsort2 $db
-        #--
-        #our table must handle the name with the greatest number of numeric/non-numeric splits.
-        #This means a single list member with pathological naming e.g a1a1a1a1a1a1a1a1a1a1a1.txt could greatly extend the number of columns and indices and affect performance.
-        #review: could be optimised to aggregate the tail into a single index, as the the extra columns won't assist in ordering, but make the table and query bigger.
-        # we should probably determine the longest common sequence of splits in the input list and add only one more index for the segment after that.
-        set maxsegments 0 
-        #--
-        set prefix "idx"
-        
-        #note - there will be more columns in the sorting table than segments.
-        # (a segment equals one of the numeric & non-numeric string portions returned from 'split_numeric_sgements')
-        #---------------------------
-        # consider 
-        #   a123b.v1.2.txt 
-        #   a123b.v1.3beta1.txt
-        # these have the following segments:
-        #   a 123 b.v 1 . 2 .txt
-        #   a 123 b.v 1 . 3 beta 1 .txt
-        #---------------------------
-        # The first string has 7 segments  (numbered 0 to 6)
-        # the second string has 9 segments
-        #
-        # for example when the data has any elements in a segment position that are numeric (e.g 0001 123)
-        #  - then an index column with numeric equivalents will be created (e.g 0001 becomes 1), and any non-numeric values in that column will get mapped to a negative value (for special cases) or a high value such as NULL  (with  NULLS LAST sql support)
-        # 
-        # when a segment 
-        
-        #cycle through all strings - we cannot build tabledef as we go because the column type depends on whether all segments for a particular column are text vs int-equivalent.
-        array set segmentinfo {}
-        foreach nm $stringlist {
-            set segments [split_numeric_segments $nm]
-            if {![string length [string trim [lindex $segments 0]]]} {
-                if {[string is digit [string trim [lindex $segments 1]]]} {
-                    #name is whitespace followed by a digit - special case - ignore the whitespace for numbers only. (whitespace still goes through to name column though)
-                    set segments [lrange $segments 1 end]
-                }
-            }
-            
-            
-            set c 0 ;#start of index columns
-            if {[llength $segments] > $maxsegments} {
-                set maxsegments [llength $segments]
-            }
-            foreach seg $segments {
-                set seg [string trim $seg]
-                set column_exists [info exists segmentinfo($c,type)]
-                if {[string is digit $seg]} {
-                    if {$column_exists} {
-                        #override it  (may currently be text or int)
-                        set segmentinfo($c,type) "int"
-                    } else {
-                        #new column
-                        set segmentinfo($c,name) ${prefix}$c
-                        set segmentinfo($c,type) "int"
-                    }
-                } else {
-                    #text never overrides int 
-                    if {!$column_exists} {
-                        set segmentinfo($c,name) ${prefix}$c
-                        set segmentinfo($c,type) "text"
-                    }
-                }
-                incr c
-            }
-        }
-        if {$debug} {
-            puts stdout "Largest number of num/non-num segments in data: $maxsegments"
-            #parray segmentinfo
-        }
-
-        #
-        set tabledef ""
-        set ordered_column_names [list]
-        set ordered_segmentinfo_tags [lsort -dictionary [array names segmentinfo *]]
-        foreach k $ordered_segmentinfo_tags {
-            lassign [split $k ,] c tag
-            if {$tag eq "type"} {
-                set type [set segmentinfo($k)]
-                if {$type eq "int"} {
-                    append tabledef "$segmentinfo($c,name) int,"
-                } else {
-                    append tabledef "$segmentinfo($c,name) text COLLATE $collate,"
-                }
-                append tabledef "raw$c text COLLATE $collate,"
-                lappend ordered_column_names $segmentinfo($c,name)
-                lappend ordered_column_names raw$c  ;#additional index column not in segmentinfo
-            }
-            if {$tag eq "name"} {
-                #lappend ordered_column_names $segmentinfo($k)
-            }
-        }
-        append tabledef "name text"
-        
-        #puts stdout "tabledef:$tabledef"
-
-
-        db_natsort2 eval [string map [list %tabledef% $tabledef] {create table natsort(%tabledef%)}]
-        
-        
-        foreach nm $stringlist {
-            array unset intdata
-            array set intdata {}
-            array set rawdata {}
-            #init array and build sql values string
-            set sql_insert "insert into natsort values("
-            for {set i 0} {$i < $maxsegments} {incr i} {
-                set intdata($i) ""
-                set rawdata($i) ""
-                append sql_insert "\$intdata($i),\$rawdata($i),"
-            }
-            append sql_insert "\$nm"  ;#don't manipulate name value in any way - e.g must leave all whitespace as the sort must return exactly the same elements as in the original list.
-            append sql_insert ")"
-            
-            set segments [split_numeric_segments $nm]
-            if {![string length [string trim [lindex $segments 0]]]} {
-                if {[string is digit [string trim [lindex $segments 1]]]} {
-                    #name is whitespace followed by a digit - special case - ignore the whitespace for numbers only. (whitespace still goes through to name column though)
-                    set segments [lrange $segments 1 end]
-                }
-            }
-            set values ""
-            set c 0
-            foreach seg $segments {
-                if {[set segmentinfo($c,type)] eq "int"} {
-                    if {[string is digit [string trim $seg]]} {
-                        set intdata($c) [trimzero [string trim $seg]]
-                    } else {
-                        catch {unset intdata($c)} ;#set NULL - sorts last
-                        if {($c == 0) && ($topunderscore) && [string match _* [string trim $seg]]} {
-                            set intdata($c) -100
-                        }
-                        if {($c == 0) && ($topdot) && [string match .* [string trim $seg]]} {
-                            set intdata($c) -50
-                        }
-                    }
-                    set rawdata($c)  [string trim $seg]
-                } else {
-                    #pure text column 
-                    #set intdata($c) [string trim $seg] ;#ignore leading/trailing whitespace - we sort first on trimmed version, then refine with the sort on rawdata index
-                    #catch {unset indata($c)}
-                    set indata($c) [string trim $seg]
-                    set rawdata($c)  $seg
-                }
-                #set rawdata($c) [string trim $seg]#
-                #set rawdata($c)  $seg
-                incr c
-            }
-            db_natsort2 eval $sql_insert
-        }
-
-        set orderedlist [list]
-   
-        if {$debug} {        
-            db_natsort2 eval {select * from pragma_table_info('natsort')} rowdata {
-                parray rowdata
-            }
-        }
-        set orderby "order by "
-        
-        foreach cname $ordered_column_names {
-            if {[string match "idx*" $cname]} {
-                append orderby "$cname ASC  NULLS LAST,"
-            } else {
-                append orderby "$cname ASC,"
-            }
-        }
-        append orderby " name ASC"
-        #append orderby " NULLS LAST" ;#??
-        
-        #e.g "order by idx0 ASC, raw0 ASC, idx1 ASC ....   name ASC"
-        if {$debug} {
-            puts stdout "orderby clause: $orderby"
-        }
-        db_natsort2 eval [string map [list %orderby% $orderby] {select * from natsort %orderby%}] rowdata {
-            set line "- "
-            #parray rowdata
-            set columnnames $rowdata(*)
-            #puts stdout "columnnames: $columnnames"
-            #[lsort -dictionary [array names rowdata]
-            append line "$rowdata(name) \n"
-            foreach nm $columnnames {
-                if {$nm ne "name"} {
-                    append line "$nm: $rowdata($nm) "
-                }
-            }
-            #puts stdout $line
-            #puts stdout "$rowdata(name)"
-            lappend orderedlist $rowdata(name)
-        }
-        
-        db_natsort2 close
-        return $orderedlist
-    }
-}
-
-
-#application section  e.g this file might be linked from /usr/local/bin/natsort 
-namespace eval natsort {
-    namespace import ::flagfilter::check_flags
-
-    proc called_directly_namematch {} {
-        global argv0
-        #see https://wiki.tcl-lang.org/page/main+script  
-        #trailing ... let's us resolve symlinks in last component of the path (could be something else like ___ but ... seems unlikely to collide with anything in the filesystem)
-        if {[info exists argv0] 
-        &&
-            [file dirname [file normalize [file join [info script] ...]]]
-            eq
-            [file dirname [file normalize [file join $argv0 ...]]]
-        } {
-            return 1
-        } else {
-            #puts stdout "norm info script: [file dirname [file normalize [file join [info script] ...]]]"
-            #puts stdout "norm argv0      : [file dirname [file normalize [file join $argv0 ...]]]"
-            return 0
-        }
-    }
-    #Review issues around comparing names vs using inodes (esp with respect to samba shares)
-    proc called_directly_inodematch {} {
-        global argv0
-        if {[info exists argv0]
-         && [file exists [info script]] && [file exists $argv0]} {
-            file stat $argv0        argv0Info
-            file stat [info script] scriptInfo
-            expr {$argv0Info(dev) == $scriptInfo(dev)
-               && $argv0Info(ino) == $scriptInfo(ino)}
-        } else {
-            return 0
-        }
-    }
-    
-    set is_namematch [called_directly_namematch]
-    set is_inodematch [called_directly_inodematch]
-    ####
-    #review - reliability of mechanisms to determine direct calls 
-    # we don't want application being called when being used as a library, but we need it to run if called directly or from symlinks etc 
-    #-- choose a policy and leave the others commented.
-    #set is_called_directly $is_namematch 
-    #set is_called_directly $is_inodematch 
-    set is_called_directly [expr {$is_namematch || $is_inodematch}] 
-    #set is_called_directly [expr {$is_namematch && $is_inodematch}] 
-    ###
-    
-    
-    #puts stdout "called_directly_name: [called_directly_namematch]  called_directly_inode: [called_directly_inodematch]"
-
-
-    #
-
-    
-    proc test_pass_fail_message {pass {additional ""}} {
-        variable test_fail_msg
-        variable test_pass_msg
-        if {$pass} {
-            puts stderr $test_pass_msg
-        } else {
-            puts stderr $test_fail_msg
-        }
-        puts stderr $additional
-    }
-
-    variable test_fail_msg "XXXXXXXXXXXX   FAIL   XXXXXXXXXXXXX"
-    variable test_pass_msg "------------   PASS   -------------"
-    proc test_sort_1 {args} {
-        package require struct::list
-        puts stderr "---$args"
-        set args [check_flags -caller natsort:test_sort_1 -defaults [list  -collate nocase -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0 ] -values $args]
-
-        puts stderr "test_sort_1 got args: $args"
-
-            set unsorted_input {
-                2.2.2
-                2.2.2.2
-                1a.1.1
-                1a.2.1.1
-                1.12.1
-                1.2.1.1
-                1.02.1.1
-                1.002b.1.1
-                1.1.1.2
-                1.1.1.1
-            }
-            set input {
-1.1.1
-1.1.1.2
-1.002b.1.1
-1.02.1.1
-1.2.1.1
-1.12.1
-1a.1.1
-1a.2.1.1
-2.2.2
-2.2.2.2
-            }
-
-            set sorted [natsort::sort $input {*}$args]
-            set is_match [struct::list equal $input $sorted]
-            
-            set msg "windows-explorer order"
-
-            test_pass_fail_message $is_match $msg  
-            puts stdout [string repeat - 40]
-            puts stdout INPUT
-            puts stdout [string repeat - 40]
-            foreach item $input {
-                puts stdout $item
-            }
-            puts stdout [string repeat - 40]
-            puts stdout OUTPUT
-            puts stdout [string repeat - 40]
-            foreach item $sorted {
-                puts stdout $item
-            }
-            test_pass_fail_message $is_match  $msg
-            return [expr {!$is_match}]
-    }
-    proc test_sort_showsplits {args} {
-        package require struct::list
-
-        set args [check_flags -caller natsort:test_sort_1 \
-          -defaults [list  -collate nocase -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 1 ] \
-          -extras {all} \
-          -values $args]
-
-        set input1 {
-            a-b.txt
-            a.b.c.txt
-            b.c-txt
-        }
-
-
-        set input2 {
-            a.b.c.txt
-            a-b.txt
-            b.c-text
-        }
-
-        foreach {msg testlist } [list "custom-order" $input1  "windows-explorer (should work with -winlike 1)" $input2] {
-            set sorted [natsort::sort $testlist {*}$args]
-            set is_match [struct::list equal $testlist $sorted]
-        
-            test_pass_fail_message $is_match  $msg
-            puts stderr "INPUT"
-            puts stderr "[string repeat - 40]"
-            foreach item $testlist {
-                puts stdout $item
-            }
-            puts stderr "[string repeat - 40]"
-            puts stderr "OUTPUT"
-            puts stderr "[string repeat - 40]"
-            foreach item $sorted {
-                puts stdout $item
-            }
-            
-            test_pass_fail_message $is_match  $msg
-        }
-
-        #return [expr {!$is_match}]
-
-    }
-
-    #tcl dispatch order - non flag items up front
-    #trailing flags are paired even if supplied as solo flags e.g -l becomes -l 1
-    proc commandline_ls {args} {
-        set operands [list]
-        set posn 0
-        foreach a $args {
-          if {![string match -* $a]} {
-            lappend operands $a
-          } else {
-            set flag1_posn $posn
-            break
-          }
-          incr posn
-        }
-        set args [lrange $args $flag1_posn end]
-
-
-        set debug 0
-        set posn [lsearch $args -debug]
-        if {$posn > 0} {
-          if {[lindex $args $posn+1]} {
-              set debug [lindex $args $posn+1] 
-          }
-        }
-        if {$debug} {
-           puts stderr "|debug>commandline_ls got $args"
-        }
-
-        #if first operand not supplied - replace it with current working dir
-        if {[lindex $operands 0] eq "\uFFFF"} {
-            lset operands 0 [pwd]
-        }
-
-        set targets [list]
-        foreach op $operands {
-          if {$op ne "\uFFFF"} {
-              set opchars [split [file tail $op] ""]
-              if {"?" in $opchars || "*" in $opchars} {
-                lappend targets $op
-              } else {
-                #actual file or dir
-                set targetitem $op
-                set targetitem [file normalize $op]
-                if {![file exists $targetitem]} {
-                    if {$debug} {
-                      puts stderr "|debug>commandline_ls Unable to access path '$targetitem'"
-                    }
-                }
-                lappend targets $targetitem
-                if {$debug} {
-                  puts stderr "|debug>commandline_ls  listing for $targetitem"    
-                }
-             }
-          }
-        }
-        set args [check_flags -caller commandline_ls \
-          -return flagged|defaults \
-          -debugargs 0 \
-          -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0 -algorithm sort] \
-          -required {all} \
-          -extras {all} \
-          -soloflags {-v -l} \
-          -commandprocessors {} \
-          -values $args ]
-        if {$debug} {
-            puts stderr "|debug>args: $args"
-        }
-
-
-        set algorithm [dict get $args -algorithm]
-        dict unset args -algorithm
-
-        set allfolders [list]
-        set allfiles [list]
-        foreach item $targets {
-            if {[file exists $item]} {
-                if {[file type $item] eq "directory"} {
-                  set dotfolders [glob -nocomplain -directory $item -type {d} -tail .*]
-                  set folders [glob -nocomplain -directory $item -type {d} -tail *]
-                  set allfolders [concat $allfolders $dotfolders $folders]
-
-                  set dotfiles [glob -nocomplain -directory $item -type {f} -tail .*]
-                  set files [glob -nocomplain -directory $item -type {f} -tail *]
-                  set allfiles [concat $allfiles $dotfiles $files]
-                } else {
-                  #file (or link?)
-                  set files [glob -nocomplain -directory [file dirname $item] -tail [file tail $item]]
-                  set allfiles [concat $allfiles $files]
-                }
-            } else {
-                 set folders [glob -nocomplain -directory $item -type {d} -tail [file tail $item]]
-                 set allfolders [concat $allfolders $folders]
-                 set files [glob -nocomplain -directory [file dirname $item] -tail [file tail $item]]
-                 set allfiles [concat $allfiles $files]
-            }
-        }
-
-
-        set sorted_folders [natsort::sort $allfolders {*}$args]
-        set sorted_files [natsort::sort $allfiles {*}$args]
-        
-        foreach fold $sorted_folders {
-            puts stdout $fold
-        }
-        foreach file $sorted_files {
-            puts stdout $file
-        }
-        
-        return "-- ok printed to stdout [llength $sorted_folders] folders and [llength $sorted_files] files --"
-    }
-
-    package require argp
-    argp::registerArgs commandline_test {
-      { -showsplits     boolean   0}
-      { -stacktrace     boolean   0}
-      { -debug          boolean   0}
-      { -winlike        boolean   0}
-      { -db             string   ":memory:"}
-      { -collate        string   "nocase"}
-      { -algorithm      string   "sort"}
-      { -topchars       string   "\uFFFF"}
-      { -testlist       string   {10 1 30 3}}
-    }
-    argp::setArgsNeeded commandline_test {-stacktrace}
-    proc commandline_test {test args} {
-      variable testlist
-      puts stdout "commandline_test got $args"
-      argp::parseArgs opts
-      puts stdout "commandline_test got [array get opts]"
-      set args [check_flags -caller natsort_commandline \
-        -return flagged|defaults \
-        -defaults [list -db :memory: -collate nocase -testlist $testlist -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] \
-        -values $args]
-
-      if {[string tolower $test] in [list "1" "true"]} {
-          set test "sort"
-      } else {
-        if {![llength [info commands $test]]} {
-          error "test $test not found"
-        }
-      }
-      dict unset args -test
-      set stacktrace [dict get $args -stacktrace]
-      # dict unset args -stacktrace
-
-      set argtestlist [dict get $args -testlist]
-      dict unset args -testlist 
-
-
-      set debug [dict get $args -debug]
-
-      set collate [dict get $args -collate]
-      set db      [dict get $args -db]
-      set winlike [dict get $args -winlike]
-      set topchars      [dict get $args -topchars]
-
-
-      puts stderr "|test>-----start natsort::$test--- input list size : [llength $argtestlist]"
-      #set resultlist [$test $argtestlist -db $db -collate $collate -topchars $topchars  -winlike $winlike]
-      set resultlist [$test  $argtestlist {*}$args]
-      foreach nm $resultlist {
-          puts stdout $nm
-      }
-      puts stdout "|test>-----end   natsort::$test--- sorted list size: [llength $resultlist]"
-      return "test end"
-    }
-    proc commandline_runtests {runtests args} {
-        set argvals [check_flags -caller commandline_runtests \
-          -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits "\uFFFF" -runtests 1] \
-          -values $args]
-
-        puts stderr "runtests args: $argvals"
-
-        #set runtests [dict get $argvals -runtests]
-        dict unset argvals -runtests
-        dict unset argvals -algorithm
-
-        puts stderr "runtests args: $argvals"
-        #exit 0
-
-        set test_prefix "::natsort::test_sort_"
-
-        if {$runtests eq "1"} {
-            set runtests "*"
-        }
-        
-
-        set testcommands [info commands ${test_prefix}${runtests}] 
-        if {![llength $testcommands]} {
-            puts stderr "No test commands matched -runtests argument '$runtests'"
-            puts stderr "Use 1 to run all tests"
-            set alltests [info commands ${test_prefix}*]
-            puts stderr "Valid tests are:"
-
-            set prefixlen [string length $test_prefix]
-            foreach t $alltests {
-                set shortname [string range $t $prefixlen end]
-                puts stderr "$t   =  -runtests  $shortname"
-            }
-
-        } else {
-            foreach cmd $testcommands {
-                puts stderr [string repeat - 40]
-                puts stderr "calling $cmd with args: '$argvals'"
-                puts stderr [string repeat - 40]
-                $cmd {*}$argvals
-            }
-        }
-        exit 0
-    }
-    proc help {args} {
-        puts stdout "natsort::help got '$args'"
-        return "Help not implemented"
-    }
-    proc natsort_pipe {args} {
-          #PIPELINE to take input list on stdin and write sorted list to stdout 
-          #strip - from arglist
-          #set args [check_flags -caller natsort_pipeline \
-          #  -return all \
-          #  -defaults [list -db :memory: -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] \
-          #  -values $args]
-
-          
-          set debug [dict get $args -debug]
-          if {$debug} {
-            puts stderr "|debug> natsort_pipe got args:'$args'"
-          }
-          set algorithm [dict get $args -algorithm]
-          dict unset args -algorithm 
-          
-          set proclist [info commands ::natsort::sort*]
-          set algos [list]
-          foreach p $proclist {
-              lappend algos [namespace tail $p]
-          }
-          if {$algorithm ni [list {*}$proclist {*}$algos]} {    
-              do_error "valid sort mechanisms: $algos" 2
-          }
-          
-          
-          set input_list [list]
-          while {![eof stdin]} {
-              if {[gets stdin line] > 0} {
-                  lappend input_list $line
-              } else {
-                  if {[eof stdin]} {
-                      
-                  } else {
-                      after 10
-                  }
-              }
-          }
-          
-          if {$debug} {
-              puts stderr "|debug> received [llength $input_list] list elements"
-          }
-              
-          set resultlist [$algorithm $input_list {*}$args]
-          if {$debug} {
-              puts stderr "|debug> returning [llength $resultlist] list elements"
-          }
-          foreach r $resultlist {
-              puts stdout $r
-          }
-          #exit 0    
-
-    } 
-    if {($is_called_directly)} {
-            set cmdprocessors {
-                {helpfinal {match "^help$" dispatch natsort::help}}
-                {helpfinal {sub -topic default "NONE"}}
-            }
-            #set args [check_flags \
-            #  -caller test1 \
-            #  -debugargs 2 \
-            #  -return arglist \
-            #  -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] \
-            #  -required {none} \
-            #  -extras {all} \
-            #  -commandprocessors $cmdprocessors \
-            #  -values $::argv ]
-            interp alias {} do_filter {} ::flagfilter::check_flags
-
-            #mashopts are generally single-letter opts that can be run together e.g -l -d  as -ld
-            set cmdprocessors {
-                {helpcmd {match "^help$" dispatch natsort::help singleopts {-v}}}
-                {helpcmd {sub -operand default \uFFFF singleopts {-l}}}
-                {lscmd  {match "^ls$" dispatch natsort::commandline_ls dispatchtype tcl dispatchglobal 1 mashopts {-l -a} singleopts {-l -a} pairopts {} longopts {--color=always}}}
-                {lscmd {sub dir default "\uFFFF"}}
-                {lscmd {sub dir2 default "\uFFFF"}}
-                {lscmd {sub dir3 default "\uFFFF"}}
-                {lscmd {sub dir4 default "\uFFFF"}}
-                {lscmd {sub dir5 default "\uFFFF"}}
-                {lscmd {sub dir6 default "\uFFFF"}}
-                {runtests {match "^-tests$" dispatch natsort::commandline_runtests singleopts {-l}}}
-                {runtests {sub testname  default "1" singleopts {-l}}}
-                {pipecmd {match "^-$"    dispatch natsort::natsort_pipe dispatchtype tcl}}
-            } 
-            set arglist [do_filter \
-              -debugargs 0 \
-              -debugargsonerror 2 \
-              -caller cline_dispatch1 \
-              -return all \
-              -soloflags {-v -x} \
-              -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0 ] \
-              -required {all} \
-              -extras {all} \
-              -commandprocessors $cmdprocessors \
-              -values $::argv ]
-
-
-            #mashopts are generally single-letter opts that can be run together e.g -l -d  as -ld
-            set cmdprocessors {
-                {testcmd {match "^test$" dispatch natsort::commandline_test singleopts {-l}}}
-                {testcmd {sub testname  default "1" singleopts {-l}}}
-            } 
-            set arglist [check_flags \
-              -debugargs 0 \
-              -caller cline_dispatch2 \
-              -return all \
-              -soloflags {-v -l} \
-              -defaults [list  -collate nocase -algorithm sort -testlist "1 2 3 10" -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0 ] \
-              -required {all} \
-              -extras {all} \
-              -commandprocessors $cmdprocessors \
-              -values $::argv ]
-
-
-
-
-            #set cmdprocessors [list]
-            #set args [check_flags -caller test1 -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] -required {all} -extras {none} -commandprocessors $cmdprocessors -values $::argv ]
-
-            #set args [check_flags -caller test1 -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] -required {all} -extras {none} -commandprocessors {-cmd {-cmd -cmdarg1 -default "."} {-cmd -cmdarg2 -default j}} -values $::argv ]
-            #set args [check_flags -caller test1 -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] -required {all} -extras {none} -commandprocessors {{-cmd -default help} {-cmd -cmdarg1 -default "."} {-cmd -cmdarg2 -default j}} -values $::argv ]
-            #set args [check_flags -caller test1 -defaults [list  -collate nocase -algorithm sort -topchars "\uFFFF" -winlike 0 -debug 0 -stacktrace 0 -showsplits 0] -required {all} -extras {none} -commandprocessors {ls {ls lsdir -default "\uFFFF"}} -values $::argv ]
-
-            exit 0
-
-        if {$::argc} {
-            
-        }
-    }
-}
-
-
-package provide natsort [namespace eval natsort {
-    variable version
-    set version 0.1.1.5
-}]
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/oolib-0.1.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/oolib-0.1.tm
deleted file mode 100644
index 3756fceb..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/oolib-0.1.tm
+++ /dev/null
@@ -1,195 +0,0 @@
-#JMN - api should be kept in sync with package patternlib where possible
-#
-package provide oolib [namespace eval oolib {
-    variable version
-    set version 0.1
-}]
-
-namespace eval oolib {
-    oo::class create collection {
-        variable o_data ;#dict
-        variable o_alias
-        constructor {} {
-            set o_data [dict create]
-        }
-        method info {} {
-            return [dict info $o_data]
-        }
-        method count {} {
-            return [dict size $o_data]
-        }
-        method isEmpty {} {
-            expr {[dict size $o_data] == 0}
-        }
-        method names {{globOrIdx {}}} {
-            if {[llength $globOrIdx]} {
-                if {[string is integer -strict $globOrIdx]} {
-                    if {$idx < 0} {
-                        set idx "end-[expr {abs($idx + 1)}]"
-                    }
-                    if {[catch {lindex [dict keys $o_data] $idx} result]} {
-                        error "[self object] no such index : '$idx'"
-                    } else {
-                        return $result
-                    }
-                } else {
-                    #glob
-                    return [lsearch -glob -all -inline [dict keys $o_data] $globOrIdx]
-                }
-            } else {
-                return [dict keys $o_data]
-            }
-        }
-        #like names but without globbing
-        method keys {} {
-            dict keys $o_data
-        }
-        method key {{posn 0}} {
-            if {$posn < 0} {
-                set posn "end-[expr {abs($posn + 1)}]"
-            }
-            if {[catch {lindex [dict keys $o_data] $posn} result]} {
-                error "[self object] no such index : '$posn'"
-            } else {
-                return $result
-            }
-        }
-        method hasKey {key} {
-            dict exists $o_data $key
-        }
-        method get {} {
-            return $o_data
-        }
-        method items {} {
-            return [dict values $o_data]
-        }
-        method item {key} {
-            if {[string is integer -strict $key]} {
-                if {$key > 0} {
-                    set valposn [expr {(2*$key) +1}]
-                    return [lindex $o_data $valposn]
-                } else {
-                    set key "end-[expr {abs($key + 1)}]"
-                    return [lindex [dict keys $o_data] $key]
-                }
-            }
-            if {[dict exists $o_data $key]} {
-                return [dict get $o_data $key]
-            }
-        }
-        #inverse lookup
-        method itemKeys {value} {
-            set value_indices [lsearch -all [dict values $o_data] $value]
-            set keylist [list]
-            foreach i $value_indices {
-                set idx [expr {(($i + 1) *2) -2}]
-                lappend keylist [lindex $o_data $idx]
-            }
-            return $keylist
-        }
-        method search {value args} {
-            set matches [lsearch {*}$args [dict values $o_data] $value]
-            if {"-inline" in $args} {
-                return $matches
-            } else {
-                set keylist [list]
-                foreach i $matches {
-                    set idx [expr {(($i + 1) *2) -2}]
-                    lappend keylist [lindex $o_data $idx]
-                }
-                return $keylist
-            }
-        }
-        #review - see patternlib. Is the intention for aliases to be configurable independent of whether the target exists?
-        method alias {newAlias existingKeyOrAlias} {
-            if {[string is integer -strict $newAlias]} {
-                error "[self object] collection key alias cannot be integer"
-            }
-            if {[string length $existingKeyOrAlias]} {
-                set o_alias($newAlias) $existingKeyOrAlias
-            } else {
-                unset o_alias($newAlias)
-            }
-        }
-        method aliases {{key ""}} {
-            if {[string length $key]} {
-                set result [list]
-                foreach {n v} [array get o_alias] {
-                    if {$v eq $key} {
-                        lappend result $n $v
-                    }
-                }		
-                return $result
-            } else {
-                return [array get o_alias]
-            }
-        }
-        #if the supplied index is an alias, return the underlying key; else return the index supplied.
-        method realKey {idx} {
-            if {[catch {set o_alias($idx)} key]} {
-                return $idx
-            } else {
-                return $key
-            }
-        }
-        method add {value key} {
-            if {[string is integer -strict $key]} {
-                error "[self object] collection key must not be an integer. Use another structure if integer keys required"
-            }
-            if {[dict exists $o_data $key]} {
-                error "[self object] col_processors object error: key '$key' already exists in collection"
-            }
-            dict set o_data $key $value
-            return [expr {[dict size $o_data] - 1}] ;#return index of item
-        }
-        method remove {idx {endRange ""}} {
-            if {[string length $endRange]} {
-                error "[self object] collection error: ranged removal not yet implemented.. remove one item at a time"
-            }
-            if {[string is integer -strict $idx]} {
-                if {$idx < 0} {
-                    set idx "end-[expr {abs($idx+1)}]"
-                }
-                set key [lindex [dict keys $o_data] $idx]
-                set posn $idx
-            } else {
-                set key $idx
-                set posn [lsearch -exact [dict keys $o_data] $key]
-                if {$posn < 0} {
-                    error "[self object] no such index: '$idx' in this collection"
-                }
-            }
-            dict unset o_data $key
-            return
-        }
-        method clear {} {
-            set o_data [dict create]
-            return
-        }
-        method reverse {} {
-            set dictnew [dict create]
-            foreach k [lreverse [dict keys $o_data]] {
-                dict set dictnew $k [dict get $o_data $k]
-            }
-            set o_data $dictnew
-            return
-        }
-        #review - cmd as list vs cmd as script?
-        method map {cmd} {
-            set seed [list]
-            dict for {k v} $o_data {
-                lappend seed [uplevel #0 [list {*}$cmd $v]]
-            }
-            return $seed
-        }
-        method objectmap {cmd} {
-            set seed [list]
-            dict for {k v} $o_data {
-                lappend seed [uplevel #0 [list $v {*}$cmd]]
-            }
-            return $seed
-        }
-    }
-
-}
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap-0.1.0.tm
deleted file mode 100644
index 1c70a227..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap-0.1.0.tm
+++ /dev/null
@@ -1,663 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::cap 0.1.0
-# Meta platform     tcl
-# Meta description  pkg capability register
-# Meta license      BSD
-# @@ Meta End
-
-
-#*** !doctools
-#[manpage_begin punkshell_module_punk::cap 0 0.1.0]
-#[copyright "2023 JMNoble - BSD licensed"]
-#[titledesc {capability provider and handler plugin system}]
-#[moddesc {punk capabilities plugin system}]
-#[require punk::cap]
-#[description]
-#[keywords module capability plugin]
-#[section Overview]
-#[para]punk::cap provides management of named capabilities and the provider packages and handler packages that implement a pluggable capability.
-#[para]see also [uri https://core.tcl-lang.org/tcllib/doc/trunk/embedded/md/tcllib/files/modules/pluginmgr/pluginmgr.md {tcllib pluginmgr}] for an alternative which uses safe interpreters
-#[subsection Concepts]
-#[para]A [term capability] may be something like providing a folder of files, or just a data dictionary, and/or an API 
-#
-#[para][term {capability handler}] - a package/namespace which may provide validation and standardised ways of looking up provider data
-# registered (or not) using register_capabilityname <capname> <capnamespace>
-#
-#[para][term {capability provider}] - a package which registers as providing one or more capablities.
-#[para]registered using register_package <pkg> <capabilitylist>
-#the capabilitylist is a list of 2-element lists where the first element is the capabilityname and the second element is a (possibly empty) dict of data relevant to that capability
-#A capabilityname may appear multiple times. ie a package may register that it provides the capability with multiple datasets.
-
-
-#*** !doctools
-#[section API]
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require oolib
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::cap {
-    variable pkgcapsdeclared [dict create] 
-    variable pkgcapsaccepted [dict create]
-    variable caps [dict create]
-    namespace eval class {
-        if {[info commands [namespace current]::interface_caphandler.registry] eq ""} {
-            #*** !doctools
-            #[subsection {Namespace punk::cap::class}]
-            #[para] class definitions
-            #[list_begin itemized] [comment {- punk::cap::class groupings -}]
-            #  [item]
-            #  [para] [emph {handler_classes}]
-            #  [list_begin enumerated]
-
-            oo::class create [namespace current]::interface_caphandler.registry {
-                #*** !doctools
-                #[enum] CLASS [class interface_caphandler.registry]
-                #[list_begin definitions]
-                #    [para] [emph METHODS]
-                method pkg_register {pkg capname capdict fullcapabilitylist} {
-                    #*** !doctools
-                    #[call class::interface_caphandler.registry [method pkg_register] [arg pkg] [arg capname] [arg capdict] [arg fullcapabilitylist]]
-                    #handler may override and return 0 (indicating don't register)e.g if pkg capdict data wasn't valid
-                    #overridden handler must be able to handle multiple calls for same pkg - but it may return 1 or 0 as it wishes. 
-                    return 1 ;#default to permit 
-                }
-                method pkg_unregister {pkg} {
-                    #*** !doctools
-                    #[call class::interface_caphandler.registry [method pkg_unregister] [arg pkg]]
-                    return ;#unregistration return is ignored - review
-                }
-                #*** !doctools
-                #[list_end]
-            }
-
-            oo::class create [namespace current]::interface_caphandler.sysapi {
-                #*** !doctools
-                #[enum] CLASS [class interface_caphandler.sysapi]
-                #[list_begin definitions]
-                #    [para] [emph METHODS]
-
-
-                #*** !doctools
-                #[list_end]
-            }
-
-            #*** !doctools
-            #  [list_end] [comment {- end enumeration handler classes -}]
-
-            #*** !doctools
-            #  [item]
-            #  [para] [emph {provider_classes}]
-            #  [list_begin enumerated]
-
-            #Provider classes
-            oo::class create [namespace current]::interface_capprovider.registration {
-                #*** !doctools
-                #    [enum] CLASS [class interface_cappprovider.registration]
-                #    [para]Your provider package will need to instantiate this object under a sub-namespace called [namespace capsystem] within your package namespace. 
-                #    [para]If your package namespace is mypackages::providerpkg then the object command would be at mypackages::providerpkg::capsystem::capprovider.registration
-                #    [para]Example code for your provider package to evaluate within its namespace: 
-                #    [example {
-                #namespace eval capsystem {
-                #    if {[info commands capprovider.registration] eq ""} {
-                #        punk::cap::class::interface_capprovider.registration create capprovider.registration
-                #        oo::objdefine capprovider.registration {
-                #            method get_declarations {} {
-                #                set decls [list]
-                #                lappend decls [list punk.templates {relpath ../templates}]
-                #                lappend decls [list another_capability_name {somekey blah key2 etc}]
-                #                return $decls
-                #            }
-                #        }
-                #    }
-                #}
-                #}]
-                #[para] The above example declares that your package can be registered as a provider for the capabilities named 'punk.templates' and 'another_capability_name'
-                #    [list_begin definitions]
-                #    [para] [emph METHODS]
-                method get_declarations {} {
-                    #***
-                    #[call class::interface_capprovider.registration [method get_declarations]]
-                    #[para] This method must be overridden by your provider using oo::objdefine cappprovider.registration as in the example above.
-                    # There must be at least one 2-element list in the result for the provider to be registerable.
-                    #[para]The first element of the list is the capabilityname - which can be custom to your provider/handler packages - or a well-known name that other authors may use/implement.
-                    #[para]The second element is a dictionary of keys specific to the capability being implemented. It may be empty if the any potential capability handlers for the named capability don't require registration data.  
-                    error "interface_capprovider.registration not implemented by provider"
-                }
-                #*** !doctools
-                #    [list_end]
-            }
-
-            oo::class create [namespace current]::interface_capprovider.provider {
-                #*** !doctools
-                #    [enum] CLASS [class interface_capprovider.provider] 
-                #    [para] Your provider package will need to instantiate this directly under it's own namespace with the command name of [emph {provider}] 
-                #    [example {
-                #       namespace eval mypackages::providerpkg { 
-                #           punk::cap::class::interface_capprovider.provider create provider mypackages::providerpkg 
-                #       }
-                #    }]
-                #    [list_begin definitions]
-                #    [para] [emph METHODS]
-                variable provider_pkg
-                variable registrationobj
-                constructor {providerpkg} {
-                    #*** !doctools
-                    #[call class::interface_capprovider.provider [method constructor] [arg providerpkg]]
-                    variable provider_pkg
-                    if {$providerpkg in [list "" "::"]} {
-                        error "interface_capprovider.provider constructor error. Invalid provider '$providerpkg'"
-                    }
-                    if {![namespace exists ::$providerpkg]} {
-                        error "interface_capprovider.provider constructor error. Invalid provider '$providerpkg' - matching namespace not found"
-                    }
-
-                    set registrationobj ::${providerpkg}::capsystem::capprovider.registration
-                    if {[info commands $registrationobj] eq ""} {
-                        error "capprovider.provider constructor error. Missing capprovider.registration interface at '$obj' (command not found) interface_capprovider.regstration instantiation must precede interface_capprovider.provider"
-                    }
-
-                    set provider_pkg [string trim $providerpkg ""]
-
-                }
-                method register {{capabilityname_glob *}} {
-                    #*** !doctools
-                    #[comment {- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---}]
-                    #[call class::interface_capprovider.provider [method register] [opt capabilityname_glob]]
-                    #
-                    #[para]This is the mechanism by which a user of your provider package will register your package as a provider of the capability named.
-                    #
-                    #[para]A user of your provider may elect to register all your declared capabilities:
-                    #[example {
-                    #  package require mypackages::providerpkg
-                    #  mypackages::providerpkg::provider register *
-                    #}]
-                    #[para] Or a specific capability may be registered:
-                    #[example {
-                    #  package require mypackages::providerpkg
-                    #  mypackages::providerpkg::provider register another_capability_name
-                    #}]
-                    #
-                    variable provider_pkg
-                    set all_decls [$registrationobj get_declarations]
-                    set register_decls [lsearch -all -inline -index 0 $all_decls $capabilityname_glob]
-                    punk::cap::register_package $provider_pkg $register_decls
-                }
-                method capabilities {} {
-                    #*** !doctools
-                    #[comment {- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---}]
-                    #[call class::interface_capprovider.provider [method capabilities]]
-                    #[para] return a list of capabilities supported by this provider package
-                    variable provider_pkg
-                    variable registrationobj
-
-                    set capabilities [list]
-                    set decls [$registrationobj get_declarations]
-                    foreach decl $decls {
-                        lassign $decl capname capdict
-                        if {$capname ni $capabilities} {
-                            lappend capabilities $capname
-                        }
-                    }
-                    return $capabilities
-                }
-                #*** !doctools
-                #    [list_end] [comment {- end class definitions -}]
-            }
-            #*** !doctools
-            #  [list_end] [comment {- end enumeration provider_classes }]
-            #[list_end] [comment {- end itemized list punk::cap::class groupings -}]
-        }
-    } ;# end namespace class
-
-    #*** !doctools
-    #[subsection {Namespace punk::cap}]
-    #[para] Main punk::cap API for client programs interested in using capability handler packages and associated (registered) provider packages
-    #[list_begin definitions]
-
-    #Not all capability names have to be registered.
-    #A package registering as a provider using register_package can include capabilitynames in it's capabilitylist which have no associated handler.
-    #such unregistered capabilitynames may be used just to flag something, or have datamembers significant to callers cooperatively interested in that capname. 
-    #we allow registering a capability with an empty handler (capnamespace) - but this means another handler could be registered later.
-    proc register_capabilityname {capname capnamespace} {
-        variable caps
-        variable pkgcapsdeclared
-        variable pkgcapsaccepted
-        if {$capnamespace ne ""} {
-            #normalize with leading :: in case caller passed in package name rather than fully qualified namespace
-            if {![string match ::* $capnamespace]} {
-                set capnamespace ::$capnamespace
-            }
-        }
-        #allow register of existing capname iff there is no current handler
-        #as handlers can be used to validate during provider registration - ideally handlers should be registered before any pkgs call register_package 
-        #we allow loading a handler later though - but will need to validate existing data from pkgs that have already registered as providers 
-        if {[set hdlr [capability_get_handler $capname]] ne ""} {
-            error "register_capabilityname cannot register capability:$capname with handler:$capnamespace. There is already a registered handler:$hdlr" 
-        }
-        #assert: capnamespace may or may not be empty string, capname may or may not already exist in caps dict, caps $capname providers may have existing entries.
-        dict set caps $capname handler $capnamespace
-        if {![dict exists $caps $capname providers]} {
-            dict set caps $capname providers [list]
-        }
-        if {[llength [set providers [dict get $caps $capname providers]]]} {
-            #some provider(s) were in place before the handler was registered
-            if {[set capreg [punk::cap::capsystem::get_caphandler_registry $capname]] ne ""} {
-                foreach pkg $providers {
-                    set fullcapabilitylist [dict get $pkgcapsdeclared $pkg]
-                    foreach capspec $fullcapabilitylist {
-                        lassign $capspec cn capdict
-                        if {$cn ne $capname} {
-                            continue
-                        }
-                        set do_register [$capreg pkg_register $pkg $capdict $fullcapabilitylist]
-                        set list_accepted [dict get $pkgcapsaccepted $pkg]
-                        if {$do_register} {
-                            if {$capspec ni $list_accepted} {
-                                dict lappend pkgcapsaccepted $pkg $capspec
-                            }
-                        } else {
-                            set posn [lsearch $list_accepted $capspec]
-                            if {$posn >=0} {
-                                set list_accepted [lreplace $list_accepted $posn $posn]
-                                dict set pkgcapsaccepted $pkg $list_accepted
-                            }
-                        }
-                    }
-                    #check if any accepted for this cap and remove from caps as necessary
-                    set count 0
-                    foreach accepted_capspec [dict get $pkgcapsaccepted $pkg] {
-                        if {[lindex $accepted_capspec 0] eq $capname} {
-                            incr count
-                        }
-                    }
-                    if {$count == 0} {
-                        set pkgposn [lsearch $providers $pkg]
-                        if {$pkgposn >= 0} {
-                           set updated_providers [lreplace $providers $posn $posn] 
-                           dict set caps $capname providers $updated_providers
-                        }
-                    }
-                }
-
-            }
-            
-        }
-    }
-    proc capability_exists {capname} {
-        #*** !doctools
-        # [call [fun capability_exists] [arg capname]]
-        # Return a boolean indicating if the named capability exists  (0|1)
-        variable caps
-        return [dict exists $caps $capname]
-    }
-    proc capability_has_handler {capname} {
-        #*** !doctools
-        # [call [fun capability_has_handler] [arg capname]]
-        #Return a boolean indicating if the named capability has a handler package installed (0|1)
-        variable caps
-        return [expr {[dict exists $caps $capname handler] && [dict get $caps $capname handler] ne ""}]
-    }
-    proc capability_get_handler {capname} {
-        #*** !doctools
-        # [call [fun capability_get_handler] [arg capname]]
-        #Return the base namespace of the active handler package for the named capability.
-        #[para] The base namespace for a handler will always be the package name, but prefixed with ::
-        variable caps
-        if {[dict exists $caps $capname]} {
-            return [dict get $caps $capname handler]
-        }
-        return "" 
-    }
-    proc call_handler {capname args} {
-        if {[set handler [capability_get_handler $capname]] eq ""} {
-            error "punk::cap::call_handler $capname $args - no handler registered for capability $capname"
-        }
-        set obj ${handler}::api_$capname
-        $obj [lindex $args 0] {*}[lrange $args 1 end]
-    }
-    proc get_providers {capname} {
-        variable caps
-        if {[dict exists $caps $capname]} {
-            return [dict get $caps $capname providers]
-        }
-        return [list]
-    }
-
-    #register package with arbitrary capnames from capabilitylist
-    #The registered pkg is a module that provides some service to that capname. Possibly just data members, that the capability will use.
-    proc register_package {pkg capabilitylist args} {
-        variable pkgcapsdeclared
-        variable pkgcapsaccepted
-        variable caps
-        set defaults [dict create\
-            -nowarnings false
-        ]
-        dict for {k v} $args {
-            if {$k ni $defaults} {
-                error "Unrecognized option $k. Known options [dict keys $defaults]"
-            }
-        }
-        set opts [dict merge $defaults $args]
-        set warnings [expr {! [dict get $opts -nowarnings]}]
-
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {[dict exists $pkgcapsaccepted $pkg]} {
-            set pkg_already_accepted [dict get $pkgcapsaccepted $pkg]
-        } else {
-            set pkg_already_accepted [list]
-        }
-        package require $pkg
-        set providerapi ::${pkg}::provider
-        if {[info commands $providerapi] eq ""} {
-            error "register_package error. pkg '$pkg' doesn't seem to be a punk::cap capability provider (no object found at $providerapi)"
-        }
-        set defined_caps [$providerapi capabilities]
-        #for each capability
-        # - ensure 1st element is a single word
-        # - ensure that if 2nd element (capdict) is present - it is dict shaped
-        foreach capspec $capabilitylist {
-            lassign $capspec capname capdict
-
-            if {$warnings} {
-                if {$capname ni $defined_caps} {
-                    puts stderr "WARNING: pkg '$pkg' doesn't declare support for capability '$capname'."
-                }
-            }
-            if {[llength $capname] !=1} {
-                error "register_package error. pkg: '$pkg' An entry in the capability list doesn't appear to have a single-word name. Problematic entry:'$capspec'"
-            }
-            if {[expr {[llength $capdict] %2 != 0}]} {
-                error "register_package error. pkg:'$pkg' The second element for capname:'$capname' doesn't appear to be a valid dict. Problematic entry: '$capspec'"
-            }
-            if {$capspec in $pkg_already_accepted} {
-                #review - multiple handlers? if so - will need to record which handler(s) accepted the capspec
-                if {$warnings} {
-                    puts stderr "WARNING: register_package pkg $pkg already has capspec marked as accepted: $capspec"
-                }
-                continue
-            }
-            if {[dict exists $caps $capname]} {
-                set cap_pkgs [dict get $caps $capname providers]
-            } else {
-                dict set caps $capname [dict create handler "" providers [list]]
-                set cap_pkgs [list]
-            }
-            #todo  - if there's a caphandler - call it's init/validation callback for the pkg
-            set do_register 1 ;#default assumption unless vetoed by handler
-            if {[set capreg [punk::cap::capsystem::get_caphandler_registry $capname]] ne ""} {
-                #Note that the interface_caphandler.registry instance must be able to handle multiple calls for same pkg
-                set do_register [$capreg pkg_register $pkg $capname $capdict $capabilitylist]
-            }
-            if {$do_register} {
-                if {$pkg ni $cap_pkgs} {
-                    lappend cap_pkgs $pkg
-                    dict set caps $capname providers $cap_pkgs
-                }
-                dict lappend pkgcapsaccepted $pkg $capspec ;#if pkg is being registered prior to handler-registration - the handler may undo this entry
-            }
-        }
-        #another call to register_pkg with same pkg may have been made (most likely with different capname) so we must append - but check not already present
-        #dict lappend pkgcapsdeclared $pkg $capabilitylist
-        if {[dict exists $pkgcapsdeclared $pkg]} {
-            set capspecs [dict get $pkgcapsdeclared $pkg]
-            foreach spec $capspecs {
-                if {$spec ni $capspecs} {
-                    lappend capspecs $spec
-                }
-            }
-            dict set pkgcapsdeclared $pkg $capspecs
-        } else {
-            dict set pkgcapsdeclared $pkg $capabilitylist
-        }
-    }
-
-    #todo!
-    proc unregister_package {pkg {capname *}} {
-        variable pkgcapsdeclared	
-        variable caps
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {[dict exists $pkgcapsdeclared $pkg]} {
-            #remove corresponding entries in caps
-            set capabilitylist [dict get $pkgcapsdeclared $pkg]
-            foreach c $capabilitylist {
-                set do_unregister 1
-                lassign $c capname _capdict 
-                set cap_info [dict get $caps $capname]
-                set pkglist [dict get $cap_info providers]
-                set posn [lsearch $pkglist $pkg]
-                if {$posn >= 0} {
-                    if {[set capreg [punk::cap::capsystem::get_caphandler_registry $capname]] ne ""} {
-                        #review
-                        # it seems not useful to allow the callback to block this unregister action
-                        #the pkg may have multiple datasets for each capname so callback will only be called for first dataset we encounter  
-                        #vetoing unregister would make this more complex for no particular advantage 
-                        #if per dataset deregistration required this should probably be a separate thing 
-                        $capreg pkg_unregister $pkg $capname
-                    }
-                    set pkglist [lreplace $pkglist $posn $posn]
-                    dict set caps $capname providers $pkglist
-                }
-            }
-            #delete the main registration record
-            dict unset pkgcapsdeclared $pkg
-        }
-    }
-
-    proc pkgcap {pkg} {
-        variable pkgcapsdeclared
-        variable pkgcapsaccepted
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {[dict exists $pkgcapsdeclared $pkg]} {
-            set accepted ""
-            if {[dict exists $pkgcapsaccepted $pkg]} {
-                set accepted [dict get $pkgcapsaccepted $pkg]
-            }
-            return [dict create declared [dict get $pkgcapsdeclared $pkg] accepted $accepted]
-        } else {
-            return
-        }
-    }
-    proc pkgcaps {} {
-        variable pkgcapsdeclared	
-        variable pkgcapsaccepted
-        set result [dict create]
-        foreach {pkg capsdeclared} $pkgcapsdeclared {
-            set accepted ""
-            if {[dict exists $pkgcapsaccepted $pkg]} {
-                set accepted [dict get $pkgcapsaccepted $pkg]
-            }
-            dict set result $pkg declared $capsdeclared
-            dict set result $pkg accepted $accepted
-        }
-        return $result
-    }	
-
-    proc capability {capname} {
-        variable caps
-        if {[dict exists $caps $capname]} {
-            return [dict get $caps $capname]
-        }
-        return ""
-    }
-    proc capabilities {{glob *}} {
-        variable caps
-        set capnames [lsort [dict keys $caps $glob]]
-        set cap_list [list]
-        foreach capname $capnames {
-            lappend cap_list [list $capname [dict get $caps $capname]]
-        }
-        return $cap_list
-    }
-
-    proc capabilitynames {{glob *}} {
-        variable caps
-        return [lsort [dict keys $caps $glob]]
-    }
-    #return only those capnames which have at least one provider
-    proc capabilitynames_provided {{glob *}} {
-        variable caps
-        set keys [lsort [dict keys $caps $glob]]
-        set cap_list [list]
-        foreach k $keys {
-            if {[llength [dict get $caps $k providers]] > 0} {
-                lappend cap_list $k
-            }
-        }
-        return $cap_list
-    }
-    #*** !doctools
-    #[list_end] [comment {- end definitions for namespace punk::cap -}]
-
-    namespace eval advanced {
-    #*** !doctools
-    #[subsection {Namespace punk::cap::advanced}]
-    #[para] punk::cap::advanced API. Functions here are generally not the preferred way to interact with punk::cap.
-    #[para] In some cases they may allow interaction in less safe ways or may allow use of features that are unavailable in the base namespace.
-    #[para] Some functions are here because they are only marginally or rarely useful, and they are here to keep the base API simple.  
-    #[list_begin definitions]
-
-    proc promote_provider {pkg} {
-        #*** !doctools
-        # [call advanced::[fun promote_provider] [arg pkg]]
-        #[para]Move the named provider package to the preferred end of the list (tail).
-        #[para]The active handler may or may not utilise this for preferencing. See documentation for the specific handler package to confirm. 
-        #[para]
-        #[para] promote/demote doesn't always make a lot of sense ..  should preferably be configurable per capapbility for multicap provider pkgs
-        #[para]The idea is to provide a crude way to preference/depreference packages independently of order the packages were loaded
-        #e.g a caller or cap-handler can ascribe some meaning to the order of the 'providers' key returned from punk::cap::capabilities <capname>
-        #[para]The order of providers will be the order the packages were loaded & registered
-        #[para]the naming: "promote vs demote" operates on a latest-package-in-list has higher preference assumption (matching last pkg loaded)
-        #[para]Each capability handler could and should implement specific preferencing methods within its own API if finer control needed.
-        #In some cases the preference/loading order may be inapplicable/irrelevant to a particular capability anyway.
-        #[para]As this is just a basic mechanism, which can't support independent per-cap preferencing for multi-cap packages -
-        # it only allows putting the pkgs to the head or tail of the lists.
-        #[para]Whether particular caps or users of caps do anything with this ordering is dependent on the cap-handler and/or calling code.
-        variable pkgcapsdeclared
-        variable caps
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {![dict exists $pkgcapsdeclared $pkg]} {
-            error "punk::cap::promote_package error pkg'$pkg' not registered. Use register_package \$pkg first"
-        }
-        if {[dict size $pkgcapsdeclared] > 1} {
-            set pkginfo [dict get $pkgcapsdeclared $pkg]
-            #remove and re-add at end of dict
-            dict unset pkgcapsdeclared $pkg
-            dict set pkgcapsdeclared $pkg $pkginfo
-            dict for {cap cap_info} $caps {
-                set cap_pkgs [dict get $cap_info providers]
-                if {$pkg in $cap_pkgs} {
-                    set posn [lsearch $cap_pkgs $pkg]
-                    if {$posn >=0} {
-                        #rewrite package list with pkg at tail of list for this capability
-                        set cap_pkgs [lreplace $cap_pkgs $posn $posn]
-                        lappend cap_pkgs $pkg
-                        dict set caps $cap providers $cap_pkgs
-                    }
-                }
-            }
-        }
-    }
-    proc demote_provider {pkg} {
-        #*** !doctools
-        # [call advanced::[fun demote_provider] [arg pkg]]
-        #[para]Move the named provider package to the preferred end of the list (tail).
-        #[para]The active handler may or may not utilise this for preferencing. See documentation for the specific handler package to confirm. 
-        variable pkgcapsdeclared
-        variable caps
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
-        }
-        if {![dict exists $pkgcapsdeclared $pkg]} {
-            error "punk::cap::promote_package error pkg'$pkg' not registered. Use register_package \$pkg first"
-        }
-        if {[dict size $pkgcapsdeclared] > 1} {
-            set pkginfo [dict get $pkgcapsdeclared $pkg]
-            #remove and re-add at start of dict
-            dict unset pkgcapsdeclared $pkg
-            dict set pkgcapsdeclared $pkg $pkginfo
-            set pkgcapsdeclared [dict merge [dict create $pkg $pkginfo] $pkgcapsdeclared]
-            dict for {cap cap_info} $caps {
-                set cap_pkgs [dict get $cap_info providers]
-                if {$pkg in $cap_pkgs} {
-                    set posn [lsearch $cap_pkgs $pkg]
-                    if {$posn >=0} {
-                        #rewrite package list with pkg at head of list for this capability
-                        set cap_pkgs [lreplace $cap_pkgs $posn $posn]
-                        set cap_pkgs [list $pkg {*}$cap_pkgs]
-                        dict set caps $cap providers $cap_pkgs
-                    }
-                }
-            }
-        }
-    }
-
-    #*** !doctools
-    #[list_end]
-    }
-
-
-#*** !doctools
-#[section Internal]
-
-    namespace eval capsystem {
-        #*** !doctools
-        #[subsection {Namespace punk::cap::capsystem}]
-        #[para] Internal functions used to communicate between punk::cap and capability handlers
-        #[list_begin definitions]
-        proc get_caphandler_registry {capname} {
-            set ns [::punk::cap::capability_get_handler $capname]::capsystem
-            if {[namespace exists ${ns}]} {
-                if {[info command ${ns}::caphandler.registry] ne ""} {
-                    if {[info object isa object ${ns}::caphandler.registry]} {
-                        return ${ns}::caphandler.registry
-                    }
-                }
-            }
-            return ""
-        }
-        #*** !doctools
-        #[list_end]
-    }
-}
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::cap [namespace eval punk::cap {
-    variable version
-    variable pkg punk::cap
-    set version 0.1.0 
-    variable README.md  [string map [list %pkg% $pkg %ver% $version] {
-        # punk capabilities system
-        ## pkg: %pkg% version: %ver%
-
-        punk::cap base namespace
-    }]
-    return $version
-}]
-return
-
-#*** !doctools
-#[manpage_end]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap/handlers/caphandler-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap/handlers/caphandler-0.1.0.tm
deleted file mode 100644
index 8fdce944..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap/handlers/caphandler-0.1.0.tm
+++ /dev/null
@@ -1,52 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::cap::handlers::caphandler 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::cap::handlers::caphandler {
-
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::cap::handlers::caphandler [namespace eval punk::cap::handlers::caphandler {
-    variable pkg punk::cap::handlers::caphandler
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap/handlers/scriptlibs-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap/handlers/scriptlibs-0.1.0.tm
deleted file mode 100644
index 8298ec18..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap/handlers/scriptlibs-0.1.0.tm
+++ /dev/null
@@ -1,52 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::cap::handlers::scriptlibs 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::cap::handlers::scriptlibs {
-
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::cap::handlers::scriptlibs [namespace eval punk::cap::handlers::scriptlibs {
-    variable pkg punk::cap::handlers::scriptlibs
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm
deleted file mode 100644
index 75a925dd..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/cap/handlers/templates-0.1.0.tm
+++ /dev/null
@@ -1,145 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::cap::handlers::templates 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#register using:
-# punk::cap::register_capabilityname templates ::punk::cap::handlers::templates 
-
-#By convention and for consistency, we don't register here during package loading - but require the calling app to do it.
-# (even if it tends to be done immediately after package require anyway)
-# registering capability handlers can involve validating existing provider data and is best done explicitly as required.
-# It is also possible for a capability handler to be registered to handle more than one capabilityname
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::cap::handlers::templates {
-    namespace eval capsystem {
-        #interfaces for punk::cap to call into
-        if {[info commands caphandler.registry] eq ""} {
-            punk::cap::class::interface_caphandler.registry create caphandler.registry
-            oo::objdefine caphandler.registry {
-                method pkg_register {pkg capname capdict caplist} {
-                    #caplist may not be complete set - which somewhat reduces its utility here regarding any decisions based on the context of this capname/capdict (review - remove this arg?)
-
-                    # -- --- --- --- --- --- --- ---- ---
-                    # validation of capdict
-                    # -- --- --- --- --- --- --- ---- ---
-                    if {![dict exists $capdict relpath]} {
-                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - package '$pkg'  is attempting to register with punk::cap as a provider of '$capname' capability, but is missing 'relpath' key"
-                        return 0
-                    }
-                    set provide_statement [package ifneeded $pkg [package require $pkg]]
-                    set tmfile [lindex $provide_statement end]
-                    if {![file exists $tmfile]} {
-                        puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING - unable to determine base folder for package '$pkg' which is attempting to register with punk::cap as a provider of '$capname' capability"
-                        return 0
-                    }
-                    set tpath [file normalize [file join $tmfile [dict get $capdict relpath]]] ;#relpath is relative to the tm *file* - not it's containing folder
-                    if {![file isdirectory $tpath]} {
-                        puts stderr "punk::cap::handlers::templates::capsystem pkg_register WARNING - unable to validate relpath location [dict get $capdict relpath] ($tpath) for package '$pkg' which is attempting to register with punk::cap as a provider of '$capname' capability"
-                        return 0
-                    }
-
-
-                    # -- --- --- --- --- --- --- ---- ---
-                    # update package internal data 
-                    # -- --- --- --- --- --- --- ---- ---
-                    if {$capname ni $::punk::cap::handlers::templates::handled_caps} {
-                        lappend ::punk::cap::handlers::templates::handled_caps $capname
-                    }
-                    set cname [string map [list . _] $capname]
-                    upvar ::punk::cap::handlers::templates::pkg_folders_$cname pfolders
-                    dict lappend pfolders $pkg $tpath
-
-
-                    # -- --- --- --- --- --- --- ---- ---
-                    # instantiation of api at punk::cap::handlers::templates::api_$capname 
-                    # -- --- --- --- --- --- --- ---- ---
-                    if {[info commands ::punk::cap::handlers::templates::$capname] eq ""} {
-                        punk::cap::handlers::templates::class::api create ::punk::cap::handlers::templates::api_$capname $capname
-                    }
-
-                    return 1
-                }
-                method pkg_unregister {pkg} {
-                    upvar ::punk::cap::handlers::templates::handled_caps hcaps
-                    foreach capname $hcaps {
-                        set cname [string map [list . _] $capname]
-                        upvar ::punk::cap::handlers::templates::pkg_folders_$cname pfolders
-                        dict unset pfolders $pkg
-                        #destroy api objects?
-                    }
-                }
-            } 
-        }
-    }
-
-    variable handled_caps [list]
-    #variable pkg_folders [dict create]
-
-    # -- --- --- --- --- --- ---
-    #handler api for clients of this capability - called via punk::cap::call_handler <capname> <method> ?args?
-    # -- --- --- --- --- --- ---
-    namespace export *
-    namespace eval class {
-        oo::class create api {
-            #return a dict keyed on folder with source pkg as value
-            constructor {capname} {
-                variable capabilityname
-                variable cname
-                set cname [string map [list . _] $capname]
-                set capabilityname $capname
-            }
-            method folders {} {
-                variable capabilityname
-                variable cname
-                upvar punk::cap::handlers::templates::pkg_folders_$cname pkg_folders
-                package require punk::cap
-                set capinfo [punk::cap::capability $capabilityname]
-                # e.g {punk.templates {handler punk::mix::templates providers ::somepkg}}
-
-                #use the order of pkgs as registered with punk::cap - may have been modified with punk::cap::promote_package/demote_package
-                set pkgs [dict get $capinfo providers]
-                set folderdict [dict create]
-                foreach pkg $pkgs { 
-                    foreach pfolder [dict get $pkg_folders $pkg] {
-                        dict set folderdict $pfolder [list source $pkg sourcetype package]
-                    }
-                }
-                return $folderdict
-            }
-        }
-    }
-
-
-
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::cap::handlers::templates [namespace eval punk::cap::handlers::templates {
-    variable pkg punk::cap::handlers::templates
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/docgen-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/docgen-0.1.0.tm
deleted file mode 100644
index f4d26342..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/docgen-0.1.0.tm
+++ /dev/null
@@ -1,71 +0,0 @@
-
-# -*- tcl -*
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::docgen 0.1.0
-# Meta platform     tcl
-# Meta license      BSD
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-package require punk::repo
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::docgen {
-    proc get_doctools_comments {fname} {
-        #does no validation of doctools commands
-        #existence of string match #\**!doctools is taken as evidence enough that the file has inline doctools - review
-        if {![file exists $fname]} {
-            error "get_doctools_comments file '$fname' not found"
-        }
-        set fd [open $fname r]
-        set data [read $fd]
-        close $fd
-        if {![string match "*#\**!doctools*" $data]} {
-            return
-        }
-        set data [string map [list \r\n \n] $data]
-        set in_doctools 0
-        set doctools ""
-        foreach ln [split $data \n] {
-            set ln [string trim $ln]
-            if {$in_doctools && [string index $ln 0] != "#"} {
-                set in_doctools 0
-            } elseif {[string range $ln 0 1] == "#*"} {
-                #todo - process doctools ordering hints in tail of line
-                set in_doctools 1
-            } elseif {$in_doctools} {
-                append doctools [string range $ln 1 end] \n
-            }
-        }
-        return $doctools
-    }
-    #todo - proc autogen_doctools_comments {fname} {}
-    # - will probably need to use something like parsetcl - as we won't be able to reliably source in an interp without side-effects and use info body etc.
-    # - mechanism will be to autodocument namespaces, procs, methods where no #*** doctools indication present - but use existing doctools comments for that particular item if it is present.
-
-
-
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::docgen [namespace eval punk::docgen {
-    variable pkg punk::docgen
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/du-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/du-0.1.0.tm
deleted file mode 100644
index fa02b3a9..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/du-0.1.0.tm
+++ /dev/null
@@ -1,1284 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::du 0.1.0
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require punk::mix::base
-
-
-namespace eval punk::du {
-    variable has_twapi 0
-}
-if {"windows" eq $::tcl_platform(platform)} {
-    package require zzzload
-    zzzload::pkg_require twapi
-
-    if {[catch {package require twapi}]} {
-        puts stderr "Warning: punk::du - unable to load twapi. Disk operations may be much slower on windows without the twapi package"
-    } else {
-        set punk::du::has_twapi 1
-    }
-    #package require punk::winpath
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::du {
-    
-
-    proc dirlisting {folderpath args} {
-        set defaults [dict create\
-            -glob *\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_glob            [dict get $opts -glob]
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        if {[lib::pathcharacterlen $folderpath] == 0} {
-           set folderpath [pwd]
-        } elseif {[file pathtype $folderpath] ne "absolute"} {
-            #file normalize relativelly slow - avoid in inner loops
-            #set folderpath [file normalize $folderpath]
-            
-        }
-        #run whichever of du_dirlisting_twapi, du_dirlisting_generic, du_dirlisting_unix has been activated
-        set dirinfo [active::du_dirlisting $folderpath {*}$opts]
-    }
-
-    
-
-    #Note that unix du seems to do depth-first - which makese sense when piping.. as output can be emitted as we go rather than requiring sort at end.
-    #breadth-first with sort can be quite fast .. but memory usage can easily get out of control
-    proc du { args } {
-        variable has_twapi
-        package require struct::set
-
-
-        if 0 {
-        switch -exact [llength $args] {
-            0 {
-                set dir .
-                set switch -k
-            }
-            1 {
-                set dir $args
-                set switch -k
-            }
-            2 {
-                set switch [lindex $args 0]
-                set dir [lindex $args 1]
-            }
-            default {
-                set msg "only one switch and one dir "
-                append msg "currently supported"
-                return -code error $msg
-            }
-        }
-
-        set switch [string tolower $switch]
-
-        set -b 1
-        set -k 1024
-        set -m [expr 1024*1024]
-        }
-
-
-        set opts $args
-        # flags in args are solos (or longopts --something=somethingelse) or sometimes pairopts
-        # we don't currently support mashopts  (ie -xy  vs separate -x -y)
-
-
-        #-------------------------------------------------------
-        # process any pairopts first and remove the pair
-        # (may also process some solo-opts)
-
-        set opt_depth -1
-        if {[set posn [lsearch $opts -d]] >= 0} {
-            set opt_depth [lindex $opts $posn+1]
-            set opts [lreplace $opts $posn $posn+1]
-        }
-        foreach o $opts {
-            if {[string match --max-depth=* $o]} {
-                set opt_depth [lindex [split $o =] 1]
-                if {![string is integer -strict $opt_depth]} {
-                    error "--max-depth=n  n must be an integer"
-                }
-            }
-        }
-        #-------------------------------------------------------
-        #only solos and longopts remain in the opts now
-        
-
-        set lastarg [lindex $opts end]
-        if {[string length $lastarg] && (![string match -* $lastarg])} {
-            set dir $lastarg
-            set opts [lrange $opts 0 end-1]
-        } else {
-            set dir . 
-            set opts $opts
-        }
-        foreach a $opts {
-            if {![string match -* $a]} {
-                error "unrecognized option '$a'"
-            } 
-        }
-
-        set -b 1
-        set -k 1024
-        set -m [expr 1024*1024]
-        set switch -k ;#default (same as unix)
-        set lc_opts [string tolower $opts] 
-
-
-
-        if {"-b" in $lc_opts} {
-            set switch -b
-        } elseif {"-k" in $lc_opts} {
-            set switch -k
-        } elseif {"-m" in $lc_opts} {
-            set switch -m
-        }
-        set opt_progress 0
-        if {"--prog" in $lc_opts || "--progress" in $lc_opts} {
-            set opt_progress 1
-        }
-        set opt_extra 0
-        if {"--extra" in $lc_opts} {
-            set opt_extra 1
-        }
-        set opt_vfs 0
-        #This configures whether to enter a vfsmount point 
-        #It will have no effect if cwd already with a vfs mount point - as then opt_vfs will be set to 1 automatically anyway.
-        if {"--vfs" in $lc_opts} {
-            set opt_vfs 1
-        }
-
-
-
-        set result [list]
-
-        set dir_depths_remaining [list]
-
-        set is_windows [expr {$::tcl_platform(platform) eq "windows"}]
-        set zero [expr {0}]
-
-        # ## ### ### ### ###
-        # containerid and itemid
-        set folders [list] ;#we lookup string by index
-        lappend folders [file dirname $dir]
-        lappend folders $dir ;#itemindex 1
-        # ## ### ### ### ###
-        if {![file isdirectory $dir]} {
-            lappend dir_depths_remaining [list $zero $zero [expr {1}] [lib::du_lit [file tail $dir]] [file size $dir]]
-            #set ary($dir,bytes) [file size $dir]
-            set leveldircount 0
-        } else {
-            lappend dir_depths_remaining [list $zero $zero [expr {1}] [lib::du_lit [file tail $dir]] $zero]
-            set leveldircount 1
-        }
-        set level [expr {0}] 
-        set nextlevel [expr {1}]
-        #dir_depths list structure
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        #0          1               2           3       4       5
-        #i_depth    i_containerid   i_itemid    i_item  i_size  i_index
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set i_depth         [expr {0}]
-        set i_containerid   [expr {1}]
-        set i_itemid        [expr {2}]
-        set i_item          [expr {3}]
-        set i_size          [expr {4}]
-        set i_index         [expr {5}]
-
-
-        set listlength [llength $dir_depths_remaining] 
-        set diridx 0
-        #this is a breadth-first algorithm
-        while {$leveldircount > 0} {
-            set leveldirs 0
-            set levelfiles 0
-            for {set i $diridx} {$i < $listlength} {incr i} {
-                #lassign [lindex $dir_depths_remaining $i] _d containeridx folderidx itm bytecount
-                set folderidx [lindex $dir_depths_remaining $i $i_itemid]
-                set folderpath [lindex $folders $folderidx] 
-                #puts stderr ->$folderpath
-                #if {$i >= 20} {
-                #return
-                #}
-
-                #twapi supports gathering file sizes during directory contents traversal
-                #for dirlisting methods that return an empty list in filesizes whilst files has entries - we will need to populate it below
-                #e.g tcl glob based dirlisting doesn't support gathering file sizes at the same time
-              
-                set in_vfs 0
-                if {[package provide vfs] ne ""} {
-                    foreach vfsmount [vfs::filesystem info] {
-                        if {[file pathtype $folderpath] ne "absolute"} {
-                            set testpath [file normalize $folderpath]
-                        } else {
-                            set testpath $folderpath
-                        }
-                            
-                        if {[punk::mix::base::lib::path_a_atorbelow_b $testpath $vfsmount]} {
-                            set in_vfs 1
-                            #if already descended to or below a vfs mount point - set opt_vfs true
-                            set opt_vfs 1
-                            break
-                        }
-                    }
-                }
-
-                if {$in_vfs} {
-                    set du_info [lib::du_dirlisting_tclvfs $folderpath]
-                } else {
-                    #run the activated function (proc imported to active namespace and renamed)
-                    set du_info [active::du_dirlisting $folderpath]
-                }
-
-                
-                set dirs [dict get $du_info dirs]
-                set files [dict get $du_info files]
-                set filesizes [dict get $du_info filesizes]
-                set vfsmounts [dict get $du_info vfsmounts]
-                #puts "---> vfsmounts $vfsmounts "
-                if {$opt_vfs} {
-                    foreach vm $vfsmounts {
-                        #puts stderr "vm: $vm"
-                        #check if vfs is mounted over a file or a dir
-                        if {$vm in $files} {
-                            puts stderr "vfs mounted over file $vm"
-                            set mposn [lsearch $files $vm]
-                            set files [lreplace $files $mposn $mposn]
-                            if {[llength $filesizes]} {
-                                set filesizes [lreplace $filesizes $mposn $mposn]
-                            }
-                        }
-                        if {$vm ni $dirs} {
-                            puts stderr "treating $vm as dir"
-                            lappend dirs $vm
-                        }
-                    }
-                }
-
-
-                incr leveldirs  [llength $dirs]
-                incr levelfiles [llength $files]
-
-                #lappend dir_depths_remaining {*}[lmap d $dirs {::list $nextdepth [lib::du_lit $cont/$itm] $d $zero}]
-                #folderidx is parent index for new dirs
-                lappend dir_depths_remaining {*}[lib::du_new_eachdir $dirs $nextlevel $folderidx]
-
-                #we don't need to sort files (unless we add an option such as -a to du (?))
-                set bytecount [expr {0}]
-
-                if {[llength $files] && ![llength $filesizes]} {
-                    #listing mechanism didn't supply corresponding sizes
-                    foreach filename $files {
-                        #incr bytecount [file size [file join $folderpath $filename]
-                        incr bytecount [file size $filename]
-                    }
-                } else {
-                    set filesizes [lsearch -all -inline -not $filesizes[unset filesizes] na] ;#only legal non-number is na
-                    set bytecount [tcl::mathop::+ {*}$filesizes]
-                }
-
-
-                #we can safely assume initial count was zero
-                lset dir_depths_remaining $i $i_size $bytecount
-                #incr diridx
-            }
-            #puts stdout "level: $level dirs: $leveldirs"
-            if {$opt_extra} {
-                puts stdout "level: $level dircount: $leveldirs filecount: $levelfiles"
-            }
-            incr level ;#zero based
-            set nextlevel [expr {$level + 1}]
-            set leveldircount [expr {[llength $dir_depths_remaining] - $listlength }]; #current - previous - while loop terminates when zero
-            #puts "diridx: $diridx i: $i rem: [llength $dir_depths_remaining] listlenth:$listlength levldircount: $leveldircount"
-            set diridx $i
-            set listlength  [llength $dir_depths_remaining]
-        }
-        #puts stdout ">>> loop done"
-        #flush stdout
-        #puts stdout $dir_depths_remaining
-        set dirs_as_encountered $dir_depths_remaining ;#index is in sync with 'folders' list
-        set dir_depths_longfirst $dirs_as_encountered
-
-        #store the index before sorting
-        for {set i 0} {$i < [llength $dir_depths_remaining]} {incr i} {
-            lset dir_depths_longfirst $i $i_index $i
-        }
-        set dir_depths_longfirst [lsort -integer -index 0 -decreasing $dir_depths_longfirst[set dir_depths_longfirst {}]]
-
-        #store main index in the reducing list
-        set dir_depths_remaining $dir_depths_longfirst
-        for {set i 0} {$i < [llength $dir_depths_remaining]} {incr i} {
-            #stored index at position 3
-            lset dir_depths_remaining $i $i_index $i
-        }
-
-        #index 3
-        #dir_depths_remaining -> dir_depths_longfirst -> dirs_as_encountered
-
-        #puts stdout "initial dir_depths_remaining: $dir_depths_remaining"
-
-
-        #summing performance is not terrible but significant on large tree - the real time is for large trees in the main loop above
-        #update - on really  large trees the reverse is true especiallyl now that twapi fixed the original speed issues.. todo - rework/simplify below - review natsort
-        #
-        #TODO - reconsider sorting by depth.. lreverse dirs_as_encountered should work.. 
-        if {[llength $dir_depths_longfirst] > 1} {
-            set i 0
-            foreach dd $dir_depths_longfirst {
-                lassign $dd d parentidx folderidx item bytecount
-                #set nm $cont/$item
-                set nm [lindex $folders $folderidx]
-                set dnext [expr {$d +1}]
-                set nextdepthposns [lsearch -all -integer -index 0 $dir_depths_remaining $dnext]
-                set nextdepthposns [lsort -integer -decreasing $nextdepthposns[set nextdepthposns {}]];#remove later elements first
-                foreach posn $nextdepthposns {
-                    set id [lindex $dir_depths_remaining $posn $i_itemid]
-                    set ndirname [lindex $folders $id]
-                    #set ndirname $cont/$item
-                    #set item [lindex $dir_depths_remaining $posn $i_item]
-                    #set ndirname [lindex $ndir 1]
-                    if {[string match $nm/* $ndirname]} {
-                        #puts stdout "dir $nm adding subdir size $ndirname"
-                        #puts stdout "incr $nm from $ary($nm,bytes) plus $ary($ndirname,bytes)"
-                        incr bytecount [lindex $dir_depths_remaining $posn $i_size]
-                        set dir_depths_remaining [lreplace $dir_depths_remaining[set dir_depths_remaining {}] $posn $posn]
-                    }
-                }
-                lset dir_depths_longfirst $i $i_size $bytecount
-                set p [lsearch -index $i_index -integer $dir_depths_remaining $i]
-                lset dir_depths_remaining $p $i_size $bytecount
-                #set ary($nm,bytes) $bytecount
-                incr i
-            }
-        }
-        #set dir_depths_longfirst [lsort -index 1 -decreasing $dir_depths_longfirst]
-        #
-
-        set retval [list]
-        #copy across the bytecounts
-        for {set i 0} {$i < [llength $dir_depths_longfirst]} {incr i} {
-            set posn [lindex $dir_depths_longfirst $i $i_index]
-            set bytes [lindex $dir_depths_longfirst $i $i_size]
-            lset dirs_as_encountered $posn $i_size $bytes 
-        }
-        foreach dirinfo [lreverse $dirs_as_encountered] {
-            set id [lindex $dirinfo $i_itemid]
-            set depth [lindex $dirinfo $i_depth]
-            if {($opt_depth >= 0) && $depth > $opt_depth} {
-                continue
-            }
-            set path [lindex $folders $id]
-            #set path $cont/$item
-            set item [lindex $dirinfo $i_item]
-            set bytes [lindex $dirinfo $i_size]
-            set size [expr {$bytes / [set $switch]}]
-            lappend retval [list $size $path]
-        }
-        # copyright 2002 by The LIGO Laboratory
-        return $retval
-    }
-    namespace eval active {
-        variable functions [list du_dirlisting ""]
-        variable functions_known [dict create]
-
-        #known functions from lib namespace
-        dict set functions_known du_dirlisting [list du_dirlisting_twapi du_dirlisting_generic du_dirlisting_unix du_dirlisting_undecided]
-
-        proc show_functions {} {
-            variable functions
-            variable functions_known
-            set msg ""
-            dict for {callname implementations} $functions_known {
-                append msg "callname: $callname" \n
-                foreach imp $implementations {
-                    if {[dict get $functions $callname] eq $imp} {
-                        append msg "  $imp (active)" \n
-                    } else {
-                        append msg "  $imp" \n
-                    }
-                }
-            }
-            return $msg
-        }
-        proc set_active_function {callname implementation} {
-            variable functions
-            variable functions_known
-            if {$callname ni [dict keys $functions_known]} {
-                error "unknown function callname $callname"
-            }
-            if {$implementation ni [dict get $functions_known $callname]} {
-                error "unknown implementation $implementation for callname $callname"
-            }
-            dict set functions $callname $implementation
-
-            catch {rename ::punk::du::active::$callname ""}
-            namespace eval ::punk::du::active [string map [list %imp% $implementation %call% $callname] {
-                namespace import ::punk::du::lib::%imp%
-                rename %imp% %call% 
-            }]
-
-            return $implementation
-        }
-        proc get_active_function {callname} {
-            variable functions
-            variable functions_known
-            if {$callname ni [dict keys $functions_known]} {
-                error "unknown function callname $callname known functions: [dict keys $functions_known]"
-            }
-            return [dict get $functions $callname]
-        }
-
-
-        #where we import & the appropriate du_listing.. function for the platform
-    }
-    namespace eval lib {
-        variable du_literal
-        variable winfile_attributes [list 16 directory 32 archive 1024 reparse_point 18 [list directory hidden] 34 [list archive hidden] ]
-        #caching this is faster than calling twapi api each time.. unknown if twapi is calculating from bitmask - or calling windows api
-        #we could work out all flags and calculate from bitmask.. but it's not necessarily going to be faster than some simple caching mechanism like this
-
-        proc decode_win_attributes {bitmask} {
-            variable winfile_attributes
-            if {[dict exists $winfile_attributes $bitmask]} {
-                return [dict get $winfile_attributes $bitmask]
-            } else {
-                #list/dict shimmering?
-                return [lindex [lappend winfile_attributes $bitmask [twapi::decode_file_attributes $bitmask]] end]
-            }
-        }
-        proc attributes_twapi {path {detail basic}} {
-            try {
-                set iterator [twapi::find_file_open $path -detail $detail] ;# -detail full only adds data to the altname field
-                if {[twapi::find_file_next $iterator iteminfo]} {
-                    set attrinfo [decode_win_attributes [dict get $iteminfo attrs]]
-                    set result [dict create -archive 0 -hidden 0 -longname $path -readonly 0 -shortname {} -system 0]
-                    if {"hidden" in $attrinfo} {
-                        dict set result -hidden 1
-                    }
-                    if {"system" in $attrinfo} {
-                        dict set result -system 1
-                    }
-                    if {"readonly" in $attrinfo} {
-                        dict set result -readonly 1
-                    }
-                    dict set result -shortname [dict get $iteminfo altname]
-                    dict set result -rawflags $attrinfo
-                    set extras [list]
-                    #foreach prop {ctime atime mtime size} {
-                    #    lappend extras $prop [dict get $iteminfo $prop]
-                    #}
-                    #dict set result -extras $extras
-                    dict set result -raw $iteminfo
-                    return $result
-                } else {
-                    error "could not read attributes for $path"
-                }
-            } finally {
-                catch {twapi::find_file_close $iterator}
-            }
-        }
-
-        #todo - review 'errors' key. We have errors relating to containing folder and args vs per child-item errors - additional key needed?
-        namespace export du_dirlisting_twapi du_dirlisting_generic du_dirlisting_unix du_dirlisting_undecided
-        # get listing without using unix-tools (may not be installed on the windows system)
-        # this dirlisting is customised for du - so only retrieves dirs,files,filesizes (minimum work needed to perform du function)
-        # This also preserves path rep for elements in the dirs/folders keys etc - which can make a big difference in performance 
-        proc du_dirlisting_twapi {folderpath args} {
-            set defaults [dict create\
-                -glob *\
-                -with_sizes 1\
-                -with_times 1\
-            ]
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_glob            [dict get $opts -glob]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_sizes      [dict get $opts -with_sizes]
-            set ftypes [list f d l]
-            if {"$opt_with_sizes" in {0 1}} {
-                #don't use string is boolean - (f false vs f file!)
-                #only accept 0|1 
-                if {$opt_with_sizes} {
-                    set sized_types $ftypes
-                } else {
-                    set sized_types [list]
-                }
-            } else {
-                set sized_types $opt_with_sizes
-            }
-            if {[llength $sized_types]} {
-                foreach st $sized_types {
-                    if {$st ni $ftypes} {
-                        error "du_dirlisting_twapi unrecognized element in -with_sizes '$st'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_times      [dict get $opts -with_times]
-            if {"$opt_with_times" in {0 1}} {
-                if {$opt_with_times} {
-                    set timed_types $ftypes
-                } else {
-                    set timed_types [list]
-                }
-            } else {
-                set timed_types $opt_with_times
-            }
-            if {[llength $timed_types]} {
-                foreach item $timed_types {
-                    if {$item ni $ftypes} {
-                        error "du_dirlisting_twapi unrecognised element in -with-times '$item'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-            set errors [dict create]
-            set altname "" ;#possible we have to use a different name e.g short windows name or dos-device path //?/
-            # return it so it can be stored and tried as an alternative for problem paths
-            #puts stderr ">>> glob: $opt_glob"
-            #REVIEW! windows api pattern matchttps://www.red-gate.com/simple-talk/blogs/the-unexpected-behaviour-of-directoryinfo-getfiles-with-three-letter-extensions/hing is .. weird. partly due to 8.3 filenames
-            #https://www.red-gate.com/simple-talk/blogs/the-unexpected-behaviour-of-directoryinfo-getfiles-with-three-letter-extensions/
-            #we will certainly need to check the resulting listing with our supplied glob.. but maybe we will have to change the glob passed to find_file_open too.
-            # using * all the time may be inefficient - so we might be able to avoid that in some cases.
-            try {
-                #glob of * will return dotfiles too on windows
-                set iterator [twapi::find_file_open [file join $folderpath $opt_glob] -detail basic] ;# -detail full only adds data to the altname field
-            } on error args {
-                try {
-                    if {[string match "*denied*" $args]} {
-                        #output similar format as unixy du
-                        puts stderr "[file dirname $folderpath] '[file tail $folderpath]':$args"
-                        dict lappend errors $folderpath $::errorCode
-                        return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                    }
-                    if {[string match "*TWAPI_WIN32 59*" $::errorCode]} {
-                        puts stderr "[file dirname $folderpath] '[file tail $folderpath]':$args (possibly blocked by permissions or share config e.g follow symlinks = no on samba)"
-                        puts stderr "  (errorcode: $::errorCode)\n"
-                        dict lappend errors $folderpath $::errorCode
-                        return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                    }
-
-
-                    #errorcode TWAPI_WIN32 2 {The system cannot find the file specified.}
-                    #This can be a perfectly normal failure to match the glob.. which means we shouldn't really warn or error
-                    #The find-all glob * won't get here because it returns . & .. 
-                    #so we should return immediately only if the glob has globchars ? or *  but isn't equal to just "*" ? (review)
-                    #Note that windows glob ? seems to return more than just single char results - it includes .. - which differs to tcl glob 
-                    #also ???? seems to returns items 4 or less - not just items exactly 4 long (review - where is this documented?)
-                    if {$opt_glob ne "*" && [regexp {[?*]} $opt_glob]} {
-                        if {[string match "*TWAPI_WIN32 2 *" $::errorCode]} {
-                            #looks like an ordinary no results for chosen glob
-                            return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                        }
-                    }
-
-
-                    if {[set plen [pathcharacterlen $folderpath]] >= 250} {
-                        set errmsg "error reading folder: $folderpath (len:$plen)\n"
-                        append errmsg "error: $args" \n
-                        append errmsg "errorcode: $::errorCode" \n
-                        # re-fetch this folder with altnames 
-                        #file normalize - aside from being slow - will have problems with long paths - so this won't work.
-                        #this function should only accept absolute paths
-                        #
-                        #
-                        #Note: using -detail full  only helps if the last segment of path has an altname..
-                        #To properly shorten we need to have kept track of altname all the way from the root!
-                        #We can .. for now call Tcl's file attributes to get shortname of the whole path - it is *expensive* e.g 5ms for a long path on local ssd
-                        #### SLOW
-                        set fixedpath [dict get [file attributes $folderpath] -shortname]
-                        #### SLOW
-                        
-                        
-                        append errmsg "retrying with with windows altname '$fixedpath'"
-                        puts stderr $errmsg
-                    } else {
-                        set errmsg "error reading folder: $folderpath (len:$plen)\n"
-                        append errmsg "error: $args" \n
-                        append errmsg "errorcode: $::errorCode" \n
-                        set tmp_errors [list $::errorCode]
-                        #possibly an illegal windows filename - easily happens on a machine with WSL or with drive mapped to unix share
-                        #we can use //?/path  dos device path - but not with tcl functions
-                        #unfortunately we can't call find_file_open directly on the problem name - we have to call the parent folder and iterate through again..
-                        #this gets problematic as we go deeper unless we rewrite the .. but we can get at least one level further here
-                       
-                        set fixedtail ""
-
-                        set parent [file dirname $folderpath]
-                        set badtail [file tail $folderpath]
-                        set iterator [twapi::find_file_open [file join $parent *] -detail full] ;#retrieve with altnames
-                        while {[twapi::find_file_next $iterator iteminfo]} {
-                            set nm [dict get $iteminfo name]
-                            if {$nm eq $badtail} {
-                                set fixedtail [dict get $iteminfo altname] 
-                                break
-                            }
-                        }
-
-                        if {![string length $fixedtail]} {
-                            dict lappend errors $folderpath {*}$tmp_errors
-                            puts stderr "[file dirname $folderpath] '[file tail $folderpath]':$args (Unable to retrieve altname to progress further with path - returning no contents for this folder)"
-                            return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                        }
-
-                        #twapi as at 2023-08 doesn't seem to support //?/ dos device paths.. 
-                        #Tcl can test only get as far as testing existence of illegal name by prefixing with //?/ - but can't glob inside it
-                        #we can call file attributes on it - but we get no shortname (but we could get shortname for parent that way)
-                        #so the illegalname_fix doesn't really work here
-                        #set fixedpath [punk::winpath::illegalname_fix $parent $fixedtail]
-
-                        #this has shortpath for the tail - but it's not the canonical-shortpath because we didn't call it on the $parent part REIEW.
-                        set fixedpath [file join $parent $fixedtail]
-                        append errmsg "retrying with with windows dos device path $fixedpath\n"
-                        puts stderr $errmsg
-                        
-                    }
-
-                    if {[catch {
-                        set iterator [twapi::find_file_open $fixedpath/* -detail basic]
-                    } errMsg]} {
-                        puts stderr "[file dirname $folderpath] '[file tail $folderpath]':$args (failed to read even with fixedpath:'$fixedpath')"
-                        puts stderr "  (errorcode: $::errorCode)\n"
-                        puts stderr "$errMsg"   
-                        dict lappend errors $folderpath $::errorCode
-                        return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                    }
-
-
-                } on error args {
-                        set errmsg "error reading folder: $folderpath\n"
-                        append errmsg "error: $args" \n
-                        append errmsg "errorInfo: $::errorInfo" \n
-                        puts stderr "$errmsg"
-                        puts stderr "FAILED to collect info for folder '$folderpath'"
-                        #append errmsg "aborting.."
-                        #error $errmsg
-                        return [list dirs {} vfsmounts {} links {} files {} filesizes {} sizes {} times {} flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-                    
-                }
-            }
-            set dirs [list]
-            set files [list]
-            set filesizes [list]
-            set allsizes [dict create]
-            set alltimes [dict create]
-
-            set links [list]
-            set flaggedhidden [list]
-            set flaggedsystem [list]
-            set flaggedreadonly [list]
-
-            while {[twapi::find_file_next $iterator iteminfo]} {
-                set nm [dict get $iteminfo name]
-                #recheck glob
-                #review!
-                if {![string match $opt_glob $nm]} {
-                    continue
-                }
-                set tail_altname [dict get $iteminfo altname] ;#altname of tail - not whole path
-                set attrinfo [decode_win_attributes [dict get $iteminfo attrs]]
-                #puts stderr "$iteminfo"
-                #puts stderr "$nm -> [dict get $iteminfo attrs] -> $attrinfo"
-                set ftype ""
-                #attributes applicable to any classification
-                set fullname [file_join_one $folderpath $nm]
-                
-                if {"hidden" in $attrinfo} {
-                    lappend flaggedhidden $fullname 
-                }
-                if {"system" in $attrinfo} {
-                    lappend flaggedsystem  $fullname
-                }
-                if {"readonly" in $attrinfo} {
-                    lappend flaggedreadonly  $fullname
-                }
-
-                #main classification
-                if {"reparse_point" in $attrinfo} {
-                    #this concept doesn't correspond 1-to-1 with unix links
-                    #https://learn.microsoft.com/en-us/windows/win32/fileio/reparse-points
-                    #review - and see which if any actually belong in the links key of our return
-
-
-                    #One thing it could be, is a 'mounted folder' https://learn.microsoft.com/en-us/windows/win32/fileio/determining-whether-a-directory-is-a-volume-mount-point
-                    #
-                    #we will treat as  zero sized for du purposes.. review - option -L  for symlinks like BSD du?
-                    #Note 'file readlink' can fail on windows - reporting 'invalid argument' - according to tcl docs, 'On systems that don't support symbolic links this option is undefined'
-                    #The link may be viewable ok in windows explorer, and cmd.exe /c dir and unix tools such as ls
-                    #if we need it without resorting to unix-tools that may not be installed: exec {*}[auto_execok dir] /A:L {c:\some\path}
-                    #e.g (stripped of headers/footers and other lines)
-                    #2022-10-02  04:07 AM    <SYMLINKD>     priv [\\?\c:\repo\elixir\gameportal\apps\test\priv]
-                    #Note we will have to parse beyond header fluff as /B strips the symlink info along with headers.
-                    #du includes the size of the symlink
-                    #but we can't get it with tcl's file size
-                    #twapi doesn't seem to have anything to help read it either (?)
-                    #the above was verified with a symlink that points to a non-existant folder.. mileage may vary for an actually valid link
-                    #
-                    #Note also - a shortcut created in explorer with drag and drop to an existant folder is a different animal to a symlink (file with .lnk extension) even though it looks the same in explorer window.
-                    #
-                    #links are techically files too, whether they point to a file/dir or nothing.
-
-                    lappend links $fullname
-                    set ftype "l"
-                } elseif {"directory" in $attrinfo} {
-                    if {$nm in {. ..}} {
-                        continue
-                    }
-                    lappend dirs $fullname
-                    set ftype "d"
-                } else {
-                    
-                    #review - is anything that isn't a reparse_point or a directory, some sort of 'file' in this context? What about the 'device' attribute? Can that occur in a directory listing of some sort?
-                    lappend files $fullname
-                    if {"f" in $sized_types} {
-                        lappend filesizes   [dict get $iteminfo size]
-                    }
-                    set ftype "f"
-                }
-                if {$ftype in $sized_types} {
-                    dict set allsizes $fullname [dict create bytes [dict get $iteminfo size]]
-                }
-                if {$ftype in $timed_types} {
-                    #convert time from windows (100ns units since jan 1, 1601) to Tcl time (seconds since Jan 1, 1970)
-                    #We lose some precision by not passing the boolean to the large_system_time_to_secs_since_1970 function which returns fractional seconds
-                    #but we need to maintain compatibility with other platforms and other tcl functions so if we want to return more precise times we will need another flag and/or result dict
-                    dict set alltimes $fullname [dict create\
-                        c [twapi::large_system_time_to_secs_since_1970 [dict get $iteminfo ctime]]\
-                        a [twapi::large_system_time_to_secs_since_1970 [dict get $iteminfo atime]]\
-                        m [twapi::large_system_time_to_secs_since_1970 [dict get $iteminfo mtime]]\
-                    ]
-                }
-            }
-            twapi::find_file_close $iterator
-            set vfsmounts [get_vfsmounts_in_folder $folderpath]
-
-            set effective_opts $opts
-            dict set effective_opts -with_times $timed_types
-            dict set effective_opts -with_sizes $sized_types
-
-            #also determine whether vfs.  file system x  is *much* faster than file attributes
-            #whether or not there is a corresponding file/dir add any applicable mountpoints for the containing folder
-            return [list dirs $dirs vfsmounts $vfsmounts links $links files $files filesizes $filesizes sizes $allsizes times $alltimes flaggedhidden $flaggedhidden flaggedsystem $flaggedsystem flaggedreadonly $flaggedreadonly altname $altname opts $effective_opts errors $errors]
-        }
-        proc get_vfsmounts_in_folder {folderpath} {
-            set vfsmounts [list]
-            if {![llength [package provide vfs]]} {
-               return [list] 
-            }
-            set fpath [punk::objclone $folderpath]
-            set is_rel 0
-            if {[file pathtype $fpath] ne "absolute"} {
-                set fpath [file normalize $fpath]
-                set is_rel 1
-            }
-            set known_vfs_mounts [vfs::filesystem info]
-            foreach mount $known_vfs_mounts {
-                if {[punk::mix::base::lib::path_a_above_b $fpath $mount]} {
-                    if {([llength [file split $mount]] - [llength [file split $fpath]]) == 1} {
-                        #the mount is in this folder
-                        if {$is_rel} {
-                            lappend vfsmounts [file join $folderpath [file tail $mount]]
-                        } else {
-                            lappend vfsmounts $mount
-                        }
-                    }
-                }
-            }
-            return $vfsmounts
-        }
-        #work around the horrible tilde-expansion thing (not needed for tcl 9+)
-        proc file_join_one {base newtail} {
-            if {[string index $newtail 0] ne {~}} {
-                return [file join $base $newtail]
-            }
-            return [file join $base ./$newtail]
-        }
-
-
-        #this is the cross-platform pure-tcl version - which calls glob multiple times to make sure it gets everythign it needs and can ignore everything it needs to.
-        #These repeated calls to glob will be a killer for performance  - especially on a network share or when walking a large directory structure
-        proc du_dirlisting_generic {folderpath args} {
-            set defaults [dict create\
-                -glob *\
-                -with_sizes 0\
-                -with_times 0\
-            ]
-            set errors [dict create]
-            set known_opts [dict keys $defaults] 
-            foreach k [dict keys $args] {
-                if {$k ni $known_opts} {
-                    error  "du_dirlisting_generic unknown-option $k"
-                }
-            }
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_glob            [dict get $opts -glob]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_sizes      [dict get $opts -with_sizes]
-            set ftypes [list f d l]
-            if {"$opt_with_sizes" in {0 1}} {
-                #don't use string is boolean (false vs f problem where f indicates file)
-                if {$opt_with_sizes} {
-                    set sized_types $ftypes
-                } else {
-                    set sized_types [list]
-                }
-            } else {
-                set sized_types $opt_with_sizes
-            }
-            if {[llength $sized_types]} {
-                foreach st $sized_types {
-                    if {$st ni $ftypes} {
-                        error "du_dirlisting_generic unrecognized element in -with_sizes '$st'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_times      [dict get $opts -with_times]
-            if {"$opt_with_times" in {0 1}} {
-                if {$opt_with_times} {
-                    set timed_types $ftypes
-                } else {
-                    set timed_types [list]
-                }
-            } else {
-                set timed_types $opt_with_times
-            }
-            if {[llength $timed_types]} {
-                foreach item $timed_types {
-                    if {$item ni $ftypes} {
-                        error "du_dirlisting_generic unrecognised element in -with-times '$item'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            # The repeated globs are a source of slowness for this function.
-            #TODO - we could minimize the number of globs if we know we need to do a file stat and/or file attributes on each entry anyway
-            #For the case where we don't need times,sizes or other metadata - it is faster to do multiple globs
-            #This all makes this function complicated to gather the required data efficiently.
-            
-            #note platform differences between what is considered hidden make this tricky.
-            # on windows 'glob .*' will not return some hidden dot items but will return . ..   and glob -types hidden .* will not return some dotted items
-            # glob -types hidden *  on windows will not necessarily return all dot files/folders
-            # unix-like platforms seem to consider all dot files as hidden so processing is more straightforward
-            #  we need to process * and .* in the same glob calls and remove duplicates 
-            #  if we do * and .* in separate iterations of this loop we lose the ability to filter duplicates easily
-
-            #note - with this design, we can't glob for all except dotfiles - this is for cross-platform consistency and efficiency (Review).
-            #dotfiles aren't considered hidden on all platforms
-            #some sort of antiglob is a possible enhancement and more consistent with the view that leading dot should be treated as any other filename character in this context.
-            if {$opt_glob eq "*"} {
-                #Note - glob operations seem to be faster than looped tests like 'file isdirectory' & 'file readlink' 
-                #set parent [lindex $folders $folderidx]
-                set hdirs  [glob -nocomplain -dir $folderpath -types {hidden d}  * .*]
-                #set hdirs {}
-                set dirs   [glob -nocomplain -dir $folderpath -types d           * .*]
-
-                set hlinks [glob -nocomplain -dir $folderpath -types {hidden l}  * .*]
-                #set hlinks {}
-                set links  [glob -nocomplain -dir $folderpath -types l           * .*] ;#links may have dupes - we don't care. struct::set difference will remove
-                #set links  [lsort -unique [concat $hlinks $links[unset links]]]
-
-                set hfiles [glob -nocomplain -dir $folderpath -types {hidden f}  * .*]
-                #set hfiles {}
-                set files  [glob -nocomplain -dir $folderpath -types f           * .*]
-                #set files  {}
-            } else {
-                set hdirs  [glob -nocomplain -dir $folderpath -types {hidden d}   $opt_glob]
-                set dirs   [glob -nocomplain -dir $folderpath -types d            $opt_glob]
-
-                set hlinks [glob -nocomplain -dir $folderpath -types {hidden l}   $opt_glob]
-                set links  [glob -nocomplain -dir $folderpath -types l            $opt_glob] ;#links may have dupes - we don't care. struct::set difference will remove
-
-                set hfiles [glob -nocomplain -dir $folderpath -types {hidden f}   $opt_glob]
-                set files  [glob -nocomplain -dir $folderpath -types f            $opt_glob]
-            }
-
-            #note struct::set difference produces unordered result
-            #struct::set difference removes duplicates
-            #remove links and . .. from directories, remove links from files
-            set files [struct::set difference [concat $hfiles $files[unset files]] $links]
-            set dirs  [struct::set difference [concat $hdirs $dirs[unset dirs]]    [concat $links [list [file join $folderpath .]  [file join $folderpath ..] ]]]
-            set links [lsort -unique [concat $links $hlinks]]
-
-
-            #----
-            set mdata_lists [du_get_metadata_lists $sized_types $timed_types $files $dirs $links]
-
-
-
-            if {"windows" eq $::tcl_platform(platform)} {
-                set flaggedhidden [concat $hdirs $hfiles $hlinks]
-            } else {
-                #unix dotted files/folders are not 'flagged' as such - it's a convention - so the client can use the same convention to decide if something is hidden
-                #this allows us to return less data - but more importantly - reserve flaggedhidden for systems where such a flag exists and avoid conflating the different concepts of what is hidden
-                set flaggedhidden {}
-            }
-
-            set vfsmounts [get_vfsmounts_in_folder $folderpath]
-
-            set effective_opts $opts
-            dict set effective_opts -with_times $timed_types
-            dict set effective_opts -with_sizes $sized_types
-
-            return [list dirs $dirs vfsmounts $vfsmounts links $links files $files filesizes [dict get $mdata_lists fsizes] sizes [dict get $mdata_lists allsizes] times [dict get $mdata_lists alltimes] flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $effective_opts errors $errors]
-        }
-
-        proc du_dirlisting_tclvfs {folderpath args} {
-            set defaults [dict create\
-                -glob *\
-                -with_sizes 0\
-                -with_times 0\
-            ]
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_glob            [dict get $opts -glob]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_sizes      [dict get $opts -with_sizes]
-            set ftypes [list f d l]
-            if {"$opt_with_sizes" in {0 1}} {
-                #don't use string is boolean (false vs f problem where f indicates file)
-                if {$opt_with_sizes} {
-                    set sized_types $ftypes
-                } else {
-                    set sized_types [list]
-                }
-            } else {
-                set sized_types $opt_with_sizes
-            }
-            if {[llength $sized_types]} {
-                foreach st $sized_types {
-                    if {$st ni $ftypes} {
-                        error "du_dirlisting_generic unrecognized element in -with_sizes '$st'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_times      [dict get $opts -with_times]
-            if {"$opt_with_times" in {0 1}} {
-                if {$opt_with_times} {
-                    set timed_types $ftypes
-                } else {
-                    set timed_types [list]
-                }
-            } else {
-                set timed_types $opt_with_times
-            }
-            if {[llength $timed_types]} {
-                foreach item $timed_types {
-                    if {$item ni $ftypes} {
-                        error "du_dirlisting_generic unrecognised element in -with-times '$item'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-            set errors [dict create]
-            if {$opt_glob eq "*"} {
-                set dirs   [glob -nocomplain -dir $folderpath -types d           * .*] ;# also returns links to dirs
-                #review - how are links handled in vfs? presumably if the vfs is a full implementation they should work at least within the vfs? 
-                set links  [glob -nocomplain -dir $folderpath -types l           * .*]  ;# links may have dupes - we don't care. struct::set difference will remove
-                set files  [glob -nocomplain -dir $folderpath -types f           * .*] ;# also returns links to files
-            } else {
-                set dirs   [glob -nocomplain -dir $folderpath -types d           $opt_glob]
-                set links  [glob -nocomplain -dir $folderpath -types l           $opt_glob]
-                set files  [glob -nocomplain -dir $folderpath -types f           $opt_glob]
-            }
-            #remove any links from our dirs and files collections
-            set dirs  [struct::set difference $dirs[unset dirs]    [concat $links [list [file join $folderpath .] [file join $folderpath ..] ]]]
-            set files [struct::set difference $files[unset files] $links]
-            #nested vfs mount.. REVIEW - does anything need special handling?
-            set vfsmounts [get_vfsmounts_in_folder $folderpath]
-
-            set mdata_lists [du_get_metadata_lists $sized_types $timed_types $files $dirs $links]
-
-
-            set effective_opts $opts
-            dict set effective_opts -with_times $timed_types
-            dict set effective_opts -with_sizes $sized_types
-
-            return [list dirs $dirs vfsmounts $vfsmounts links $links files $files filesizes [dict get $mdata_lists fsizes] sizes [dict get $mdata_lists allsizes] times $alltimes flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $effective_opts errors $errors]
-        }
-
-        #we can halve the number of round trips on unix-like systems, where 'hidden' always corresponds to dotted files
-        proc du_dirlisting_unix {folderpath args} {
-            set defaults [dict create\
-                -glob *\
-                -with_sizes 0\
-                -with_times 0\
-            ]
-            set errors [dict create]
-            dict lappend errors $folderpath "metadata support incomplete - prefer du_dirlisting_generic"
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_glob            [dict get $opts -glob]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_sizes      [dict get $opts -with_sizes]
-            set ftypes [list f d l]
-            if {"$opt_with_sizes" in {0 1}} {
-                #don't use string is boolean (false vs f problem where f indicates file) 
-                if {$opt_with_sizes} {
-                    set sized_types $ftypes
-                } else {
-                    set sized_types [list]
-                }
-            } else {
-                set sized_types $opt_with_sizes
-            }
-            if {[llength $sized_types]} {
-                foreach st $sized_types {
-                    if {$st ni $ftypes} {
-                        error "du_dirlisting_generic unrecognized element in -with_sizes '$st'"
-                    }
-                }
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_with_times      [dict get $opts -with_times]
-            if {"$opt_with_times" in {0 1}} {
-                if {$opt_with_times} {
-                    set timed_types $ftypes
-                } else {
-                    set timed_types [list]
-                }
-            } else {
-                set timed_types $opt_with_times
-            }
-            if {[llength $timed_types]} {
-                foreach item $timed_types {
-                    if {$item ni $ftypes} {
-                        error "du_dirlisting_generic unrecognised element in -with-times '$item'"
-                    }
-                }
-            }
-            
-            #this is not consistent with standard way * works for unix folders - but it is consistent with behaviour of this facility on windows 
-            if {$opt_glob eq "*"} {
-                set dirs   [glob -nocomplain -dir $folderpath -types d           * .*] ;# also returns links to dirs
-                set links  [glob -nocomplain -dir $folderpath -types l           * .*]  ;# links may have dupes - we don't care. struct::set difference will remove
-                set files  [glob -nocomplain -dir $folderpath -types f           * .*] ;# also returns links to files
-            } else {
-                set dirs   [glob -nocomplain -dir $folderpath -types d           $opt_glob]
-                set links  [glob -nocomplain -dir $folderpath -types l           $opt_glob]
-                set files  [glob -nocomplain -dir $folderpath -types f           $opt_glob]
-            }
-            #remove any links from our dirs and files collections
-            set dirs  [struct::set difference $dirs[unset dirs]    [concat $links [list [file join $folderpath .] [file join $folderpath ..] ]]]
-            set files [struct::set difference $files[unset files] $links]
-            set vfsmounts [get_vfsmounts_in_folder $folderpath]
-
-            set mdata_lists [du_get_metadata_lists $sized_types $timed_types $files $dirs $links]
-
-            set effective_opts $opts
-            dict set effective_opts -with_times $timed_types
-            dict set effective_opts -with_sizes $sized_types
-
-
-            return [list dirs $dirs vfsmounts $vfsmounts links $links files $files filesizes [dict get $mdata_lists fsizes] sizes [dict get $mdata_lists allsizes] times [dict get $mdata_lists alltimes] flaggedhidden {} flaggedsystem {} flaggedreadonly {} altname {} opts $opts errors $errors]
-        }
-
-        #return fsizes,allsizes,alltimes metadata in same order as files,dirs,links lists - if specified in sized_types 
-        proc du_get_metadata_lists {sized_types timed_types files dirs links} {
-            set meta_dict [dict create]
-            set meta_types [concat $sized_types $timed_types]
-            #known tcl stat keys 2023 - review
-            set empty_stat_dict [dict create atime {} ctime {} dev {} gid {} ino {} mode {} mtime {} nlink {} size {} type {} uid {}]
-            #make sure we call file stat only once per item
-            set statkeys [list]
-            if {[llength $meta_types]} {
-                foreach ft {f d l} lvar {files dirs links} {
-                    if {"$ft" in $meta_types} {
-                        foreach path [set $lvar] {
-                            #caller may have read perm on the containing folder - but not on child item - so file stat could raise an error
-                            if {![catch {file stat $path arrstat} errM]} {
-                                dict set meta_dict $path [dict create shorttype $ft {*}[array get arrstat]]
-                            } else {
-                                dict lappend errors $path "file stat error: $errM"
-                                dict set meta_dict $path [dict create shorttype $ft {*}$empty_stat_dict]
-                            }
-                        }
-                    }
-                }
-            }
-            set fsizes [list]
-            set allsizes [dict create]
-            set alltimes [dict create]
-            #review birthtime field of stat? cross-platform differences ctime etc?
-            dict for {path pathinfo} $meta_dict {
-                set ft [dict get $pathinfo shorttype]
-                if {$ft in $sized_types} {
-                    dict set allsizes $path [dict create bytes [dict get $pathinfo size]]
-                    if {$ft eq "f"} {
-                        #subst with na if empty? 
-                        lappend fsizes [dict get $pathinfo size]
-                    }
-                }
-                if {$ft in $timed_types} {
-                    dict set alltimes $path [dict create c [dict get $pathinfo ctime] a [dict get $pathinfo atime] m [dict get $pathinfo mtime]]
-                }
-            }
-            #todo - fix . The list lengths will presumably match but have empty values if failed to stat
-            if {"f" in $sized_types} {
-                if {[llength $fsizes] ne [llength $files]} {
-                    dict lappend errors $folderpath "failed to retrieve all file sizes"
-                }
-            }
-            return [dict create fsizes $fsizes allsizes $allsizes alltimes $alltimes]
-        }
-
-
-        proc du_lit value {
-            variable du_literal
-            if {![info exists du_literal($value)]} {
-                set du_literal($value) $value
-            }
-            return $du_literal($value)
-        }
-
-        #v1
-        proc du_new_eachdirtail {dirtails depth parentfolderidx} {
-            set newlist {}
-            upvar folders folders
-            set parentpath [lindex $folders $parentfolderidx]
-            set newindex [llength $folders]
-            foreach dt $dirtails {
-                lappend folders [file join $parentpath [du_lit $dt]]; #store as a 'path' rather than a string (see tcl::unsupported::representation)
-                lappend newlist [::list $depth $parentfolderidx $newindex [du_lit $dt] [expr {0}]]
-                incr newindex
-            }
-            return $newlist
-        }
-        proc du_new_eachdir {dirpaths depth parentfolderidx} {
-            set newlist {}
-            upvar folders folders
-            set newindex [llength $folders]
-            foreach dp $dirpaths {
-                lappend folders $dp
-                #puts stdout "--->$dp"
-                lappend newlist [::list $depth $parentfolderidx $newindex [du_lit [file tail $dp]] [expr {0}]]
-                incr newindex
-            }
-            return $newlist
-        }
-
-        #same implementation as punk::strlen
-        #get length of path which has internal rep of path - maintaining path/list rep without shimmering to string representation.
-        proc pathcharacterlen {pathrep} {
-            append str2 $pathrep {}
-            string length $str2
-        }
-        #just an experiment
-        proc pathcharacterlen1 {pathrep} {
-            #This works - but is unnecessarily complex
-            set l 0
-            set parts [file split $pathrep]
-            if {[llength $parts] < 2} {
-                return [string length [lindex $parts 0]]
-            }
-            foreach seg $parts {
-                incr l [string length $seg]
-            }
-            return [expr {$l + [llength $parts] -2}]
-        }
-        #slower - doesn't work for short paths like c:/
-        proc pathcharacterlen2 {pathrep} {
-            return [tcl::mathop::+ {*}[lmap v [set plist [file split $pathrep]] {[string length $v]}] [llength $plist] -2]
-        }
-
-        #Strip using lengths without examining path components
-        #without normalization is much faster
-        proc path_strip_alreadynormalized_prefixdepth {path prefix} {
-            set tail [lrange  [file split $path] [llength [file split $prefix]] end]
-            if {[llength $tail]} {
-                return [file join {*}$tail]
-            }  else {
-                return ""
-            }
-        }
-
-        proc du_dirlisting_undecided {folderpath args} {
-            if {"windows" eq $::tcl_platform(platform)} {
-                #jmn disable twapi
-                #tailcall du_dirlisting_generic $folderpath {*}$args                        
-
-                set loadstate [zzzload::pkg_require twapi]
-                if {$loadstate ni [list loading failed]} {
-                    #either already loaded by zzload or ordinary package require
-                    package require twapi ;#should be fast once twapi dll loaded in zzzload thread
-                    set ::punk::du::has_twapi 1
-                    punk::du::active::set_active_function du_dirlisting du_dirlisting_twapi
-                    tailcall du_dirlisting_twapi $folderpath {*}$args
-                } else {
-                    if {$loadstate eq "failed"} {
-                        puts stderr "punk::du defaulting to du_dirlisting_generic because twapi load failed"
-                        punk::du::active::set_active_function du_dirlisting du_dirlisting_generic
-                    }
-                    tailcall du_dirlisting_generic $folderpath {*}$args                        
-                }
-            } else {
-                punk::du::active::set_active_function du_dirlisting du_dirlisting_unix
-                tailcall du_dirlisting_unix $folderpath {*}$args
-            }
-        }
-
-
-    }
-    package require natsort
-    #interp alias {} du {} .=args>* punk::du |> .=>1 natsort::sort -cols 1 |> list_as_lines <args|
-    #use natsort -debug 2 to see index output
-    #this works better for display of directory/file names with spaces (doesn't show curly braces)
-    interp alias {} du2 {}   .=args>* punk::du::du |> .=>1 natsort::sort -cols 1  -outputformat words |> list_as_lines <args|
-
-    #experiment with csv as easy way to get column like format..
-    #The /r is somewhat cheating however.. as it messes up redirected output .. e.g if redirected to text file
-    interp alias {} du {}  .=args>* punk::du::du |> .=>1 natsort::sort -cols 1  -outputformat csv -outputformatoptions {\r\t\t\t} |> list_as_lines <args|
-
-
-}
-
-
- namespace eval ::punk::du::active {
-    variable functions
-    variable functions_kown
-    upvar ::punk::du::has_twapi has_twapi
-
-    set_active_function du_dirlisting du_dirlisting_undecided
-
-}
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::du [namespace eval punk::du {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix-0.2.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix-0.2.tm
deleted file mode 100644
index 482c79a4..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix-0.2.tm
+++ /dev/null
@@ -1,21 +0,0 @@
-
-package require punk::cap
-
-package require punk::cap::handlers::templates ;#handler for templates cap
-punk::cap::register_capabilityname punk.templates ::punk::cap::handlers::templates 
-
-package require punk::mix::templates ;#registers as provider pkg for 'punk.templates' capability with punk::cap
-punk::mix::templates::provider register *
-
-package require punk::mix::base
-package require punk::mix::cli
-
-namespace eval punk::mix {
-    
-}
-
-package provide punk::mix [namespace eval punk::mix {
-    variable version
-    set version 0.2
-
-}]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/base-0.1.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/base-0.1.tm
deleted file mode 100644
index 47f6c9d8..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/base-0.1.tm
+++ /dev/null
@@ -1,910 +0,0 @@
-package provide punk::mix::base [namespace eval punk::mix::base {
-	variable version
-	set version 0.1
-}]
-
-package require punk::path
-
-#base internal plumbing functions
-namespace eval punk::mix::base {
-    proc set_alias {cmdname args} {
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
- 
-        uplevel #0 [list interp alias {} $cmdname {} punk::mix::base::_cli -extension $extension]
-    }
-    proc _cli {args} {
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
-        if {![string length $extension]} {
-            set extension [namespace qualifiers [lindex [info level -1] 0]]
-        }
-        #puts stderr "punk::mix::base extension: [string trimleft $extension :]"
-        if {![string length $extension]} {
-            #if still no extension - must have been called dirctly as punk::mix::base::_cli
-            if {![llength $args]} {
-                set args "help"
-            }
-            set extension [namespace current]
-        }
-        if {![llength $args]} {
-            if {[info exists ${extension}::default_command]} {
-                tailcall $extension [set ${extension}::default_command]
-            }
-            tailcall $extension
-        } else {
-            tailcall $extension {*}$args
-        }
-    }
-    proc _unknown {ns args} {
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
-
-        if {![string length $extension]} {
-            set extension [namespace qualifiers [lindex [info level -1] 0]]
-        }
-        #puts stderr "arglen:[llength $args]"
-        #puts stdout "_unknown '$ns' '$args'"
-        
-        set d_commands [get_commands -extension $extension]
-        set all_commands [list {*}[dict get $d_commands main] {*}[dict get $d_commands base]]
-        error "Unknown subcommand \"[lindex $args 0]\": must be one of: $all_commands" "punk::mix::base _unknown $ns $args" [list unknown_ensemble_subcommand ensemble punk::mix::base]
-    }
-    proc _redirected {from_ns subcommand args} {
-        #puts stderr "_redirected from_ns: $from_ns subcommand:$subcommand args:$args"
-        set pname [namespace current]::$subcommand
-        if {$pname in [info procs $pname]} {
-            set argnames [info args $pname]
-            #puts stderr "_redirected $subcommand argnames: $argnames"
-            if {[lindex $argnames end] eq "args"} {
-                set pos_argnames [lrange $argnames 0 end-1]
-            } else {
-                set pos_argnames $argnames
-            }
-            set argvals [list]
-            set numargs [llength $pos_argnames]
-            if {$numargs > 0} {
-                set argvals [lrange $args 0 $numargs-1]
-                set args [lrange $args $numargs end]
-            }
-            if {[llength $argvals] < $numargs} {
-                error "wrong # args: $from_ns $subcommand requires args: $pos_argnames"
-            }
-            tailcall [namespace current] $subcommand {*}$argvals {*}$args -extension $from_ns
-        } else {
-            tailcall [namespace current] $subcommand {*}$args -extension $from_ns
-        }
-    }
-    proc _split_args {arglist} {
-        #don't assume arglist is fully paired.
-        set posn [lsearch $arglist -extension] 
-        set opts [list]
-        if {$posn >= 0} {
-            if {$posn+2 <= [llength $arglist]} {
-                set opts [list -extension [lindex $arglist $posn+1]]
-                set argsremaining [lreplace $arglist $posn $posn+1] 
-            } else {
-                #no value supplied to -extension
-                error "punk::mix::base::_split_args - no value found for option '-extension'. Supply a value or omit the option."
-            }
-        } else {
-            set argsremaining $arglist
-        }
-
-        return [list opts $opts args $argsremaining]
-    }
-}
-
-
-#base API (potentially overridden functions - may also be called from overriding namespace)
-#commands should either handle or silently ignore -extension <namespace/ensemble>
-namespace eval punk::mix::base {
-    namespace ensemble create
-    namespace export help dostuff get_commands set_alias
-    namespace ensemble configure [namespace current] -unknown punk::mix::base::_unknown
-    proc get_commands {args} {
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
-        if {![string length $extension]} {
-            set extension [namespace qualifiers [lindex [info level -1] 0]]
-        }
-       
-        set maincommands [list]
-        #extension may still be blank e.g if punk::mix::base::get_commands called directly
-        if {[string length $extension]} {
-            set nsmain $extension
-            #puts stdout "get_commands nsmain: $nsmain"
-            set parentpatterns [namespace eval $nsmain [list namespace export]]
-            set nscommands [list]
-            foreach p $parentpatterns {
-                lappend nscommands {*}[info commands ${nsmain}::$p]
-            }
-            foreach c $nscommands {
-                set cmd [namespace tail $c]
-                lappend maincommands $cmd 
-            }
-            set maincommands [lsort $maincommands]
-        }
-
-
-
-
-        set nsbase [namespace current]
-        set basepatterns [namespace export]
-        #puts stdout "basepatterns:$basepatterns"
-        set nscommands [list]
-        foreach p $basepatterns {
-            lappend nscommands {*}[info commands ${nsbase}::$p]
-        }
-
-        set basecommands [list]
-        foreach c $nscommands {
-            set cmd [namespace tail $c]
-            if {$cmd ni $maincommands} {
-                lappend basecommands $cmd
-            }
-        }
-        set basecommands [lsort $basecommands]
-
-
-        return [list main $maincommands base $basecommands] 
-    }
-    proc help {args} {
-        #' **%ensemblecommand% help** *args*
-        #' 
-        #'   Help for ensemble commands in the command line interface
-        #' 
-        #' 
-        #'   Arguments:
-        #' 
-        #'   * args  - first word of args is the helptopic requested - usually a command name
-        #'           - calling help with no arguments will list available commands
-        #' 
-        #'   Returns: help text (text)
-        #' 
-        #'   Examples:
-        #' 
-        #'   ```
-        #'   %ensemblecommand% help <commandname>
-        #'   ```
-        #' 
-        #' 
- 
-
-        #extension.= @@opts/@?@-extension,args@@args=>. [_split_args $args] {|
-        #    >}   inspect -label a              {|
-        #    >} .=e>end,data>end pipeswitch {
-        #        pipecase ,0/1/#= $switchargs {|
-        #            e/0
-        #            >} .=>. {set e}
-        #        pipecase /1,1/1/#= $switchargs 
-        #} |@@ok/result> <e/0| [namespace qualifiers [lindex [info level -1] 0]]
-
-
-        #---------
-        #extension@@opts/@?@-extension,args@@args= [_split_args $args] ;#dependency on punk pipeline/patternmatching system
-        lassign [_split_args $args] _opts opts _args args
-        if {[dict exists $opts -extension]} {
-            set extension [dict get $opts -extension]
-        } else {
-            set extension ""
-        }
-        #---------
-
-
-
-        if {![string length $extension]} {
-            set extension [namespace qualifiers [lindex [info level -1] 0]]
-        }
-        #puts stderr "-1:[info level -1]"
-
-        set command_info [punk::mix::base::get_commands -extension $extension]
-        set subhelp1 [lindex $args 0] 
-        if {[string length $subhelp1]} {
-            if {[regexp {[*?]} $subhelp1]} {
-                set helpstr ""
-                append helpstr "matched commands:\n"
-                dict for {source cmdlist} $command_info {
-                    set matches [lsearch -all -inline -glob $cmdlist $subhelp1] 
-                    if {[llength $matches]} {
-                        append helpstr \n    "  $source"
-                        foreach cmd $matches {
-                            append helpstr \n "  - $cmd"
-                        }
-                    }
-                }
-                return $helpstr
-            } else {
-                dict for {source cmdlist} $command_info {
-                    if {$subhelp1 in $cmdlist} {
-                        if {$source eq "base"} {
-                            set ns [namespace current]
-                        } else {
-                            set ns $extension
-                        }
-                        set procname ${ns}::$subhelp1
-                        if {$procname in [info procs $procname]} {
-                            return "proc: $subhelp1 arguments: [info args $procname]"
-                        } else {
-                            set a [interp alias {} ${ns}::$subhelp1]
-                            if {[string length $a]} {
-                                return "alias: $subhelp1 target: $a"             
-                            } else {
-                                return "command: $subhelp1 (No info available)"
-                            }
-                        }
-                    }
-                }
-
-                return "No info found"
-            }
-
-        }
-        #result for just 'pmix help'
-        set helpstr ""
-        append helpstr "commands:\n"
-
-        foreach {source cmdlist} $command_info {
-            append helpstr \n     "  $source"
-            foreach cmd $cmdlist {
-                append helpstr \n "  - $cmd"
-            }
-        }
-        return $helpstr
-    }
-    #proc dostuff {args} {
-    #    extension@@opts/@?@-extension,args@@args= [_split_args $args] 
-    #    puts stdout "base doingstuff-with-args:'$args'-in-namespace:'[namespace current]'"
-    #}
-    namespace eval lib {
-        variable sha3_implementation "" ;#set by cksum_algorithms (which is called by cksum_path) It looks for fossil or sqlite3. Todo - add proper Tcl implementation.
-        namespace export *
-
-        #-----------------------------------------------------
-        #literate-programming style naming for some path tests
-        #Note the naming of the operator portion of a_op_b is consistent in that it is the higher side of the filesystem tree first.
-        #hence aboveorat vs atorbelow
-        #These names also sort in the logical order of higher to lower in the filesystem (when considering the root as 'higher' in the filesystem)
-        proc path_a_above_b {path_a path_b} {
-            #stripPath prefix path
-            return [expr {[fileutil::stripPath $path_a $path_b] ni [list . $path_b]}]
-        }
-        proc path_a_aboveorat_b {path_a path_b} {
-            return [expr {[fileutil::stripPath $path_a $path_b] ne $path_b}]
-        }
-        proc path_a_at_b {path_a path_b} {
-            return [expr {[fileutil::stripPath $path_a $path_b] eq "." }]
-        }
-        proc path_a_atorbelow_b {path_a path_b} {
-            return [expr {[fileutil::stripPath $path_b $path_a] ne $path_a}]
-        }
-        proc path_a_below_b {path_a path_b} {
-            return [expr {[fileutil::stripPath $path_b $path_a] ni [list . $path_a]}]
-        }
-        proc path_a_inlinewith_b {path_a path_b} {
-            return [expr {[path_a_aboveorat_b $path_a $path_b] || [path_a_below_b $path_a $path_b]}]
-        }
-        #-----------------------------------------------------
-
-
-
-        #find src/something folders which are not certain known folders with other purposes, (such as: bootsupport .vfs folders or vendor folders etc) and contain .tm file(s)
-        proc find_source_module_paths {{path {}}} {
-            if {![string length [set candidate [punk::repo::find_candidate $path]]]} {
-                error "find_source_module_paths cannot determine a suitable project root at or above path '$path' - path supplied should be within a project"
-            }
-            #we can return module paths even if the project isn't yet under revision control 
-            set src_subs [glob -nocomplain -dir [file join $candidate src] -type d -tail *]
-            set antipatterns [list *.vfs vendor* lib _build doc embedded runtime bootsupport]
-            set tm_folders [list]
-            foreach sub $src_subs {
-                set is_ok 1
-                foreach anti $antipatterns {
-                    if {[string match $anti $sub]} {
-                        set is_ok 0 
-                        break 
-                    }
-                }
-                if {!$is_ok} {
-                    continue
-                }
-                set testfolder [file join $candidate src $sub]
-                set tmfiles [glob -nocomplain -dir $testfolder -type f -tail *.tm]
-                if {[llength $tmfiles]} {
-                    lappend tm_folders $testfolder
-                } 
-            }
-            return $tm_folders
-        }
-
-        proc mix_templates_dir {} {
-            puts stderr "mix_templates_dir WARNING: deprecated - use get_template_basefolders instead"
-            set provide_statement [package ifneeded punk::mix [package require punk::mix]]
-            set tmdir [file dirname [lindex $provide_statement end]]
-            set tpldir $tmdir/mix/templates
-            if {![file exists $tpldir]} {
-                error "punk::mix::lib::mix_templates_dir unable to locate mix templates folder at '$tpldir'"
-            }
-            return $tpldir
-        }
-
-        #get_template_basefolders
-        #   scriptpath - file or folder
-        #   It represents the base point from which to search for mixtemplates folders either directly related to the scriptpath (../) or in the containing project if any
-        #   The cwd will also be searched for project root - but with lower precedence in the resultset (later in list)
-        proc get_template_basefolders {{scriptpath ""}} {
-            #1 lowest precedence - templates from packages (ordered by order in which packages registered with punk::cap)
-            set folderdict [dict create]
-
-            package require punk::cap
-            if {[punk::cap::capability_has_handler punk.templates]} {
-                set template_folder_dict [punk::cap::call_handler punk.templates folders]
-                dict for {dir folderinfo} $template_folder_dict {
-                    dict set folderdict $dir $folderinfo
-                }
-            }
-
-            #2 middle precedence - mixtemplates folder relative to cwd
-            set searchbase [pwd] 
-            set fld [file join $searchbase mixtemplates]
-            if {[file isdirectory $fld]} {
-                if {![dict exists $folderdict $fld]} {
-                    dict set folderdict $fld [list source $searchbase sourcetype cwd]
-                }
-            }
-            set pathinfo    [punk::repo::find_repos $searchbase]
-            set pwd_projectroot [dict get $pathinfo closest]
-            if {$pwd_projectroot ne ""} {
-                set fld [file join $pwd_projectroot src/mixtemplates]
-                if {![dict exists $folderdict $fld]} {
-                    dict set folderdict $fld [list source $pwd_projectroot sourcetype project]
-                }
-            }
-
-            #3 highest precedence - mixtemplates relative to scriptpath argument
-            if {$scriptpath ne ""} {
-                if {[file type $scriptpath] eq "file"} {
-                    set searchbase [file dirname $scriptpath]
-                } else {
-                    set searchbase $scriptpath
-                }
-                if {[file isdirectory [file join $searchbase mixtemplates]]} {
-                    dict set folderdict [file join $searchbase mixtemplates] [list source $searchbase sourcetype pathsearch]
-                }
-                set pathinfo    [punk::repo::find_repos $searchbase]
-                set scriptpath_projectroot [dict get $pathinfo closest]
-                if {$scriptpath_projectroot ne ""} {
-                    set fld [file join $scriptpath_projectroot src/mixtemplates]
-                    if {[file isdirectory $fld]} {
-                        dict set folderdict $fld [list source $scriptpath_projectroot sourcetype project]
-                    }
-                }
-            }
-            #don't sort - order in which encountered defines the precedence - with later overriding earlier
-            return $folderdict
-        }
-
-        proc module_subpath {modulename} {
-            set modulename [string trim $modulename :]
-            set nsq [namespace qualifiers $modulename]
-            return [string map [list :: /] $nsq]
-        }
-
-        proc get_build_workdir {path} {
-            set repo_info [punk::repo::find_repos $path]
-            set base [lindex [dict get $repo_info project] 0]
-            if {![string length $base]} {
-                error "get_build_workdir unable to determine project base for path '$path'"
-            }
-            if {![file exists $base/src] || ![file writable $base/src]} {
-                error "get_build_workdir unable to access $base/src"
-            }
-            file mkdir $base/src/_build
-            return $base/src/_build
-        }
-
-
-   
-        #todo - move cksum stuff to punkcheck - more logical home
-        proc cksum_path_content {path args} {
-            dict set args -cksum_content 1
-            dict set args -cksum_meta 0
-            tailcall cksum_path $path {*}$args
-        }
-
-        #not just used by cksum_path. used by caller (e.g fill_relativecksums_from_base_and_relativepathdict via cksum_filter_opts) to determine what opt names passed through
-        proc cksum_default_opts {} {
-            return [dict create -cksum_content 1 -cksum_meta auto -cksum_acls 0 -cksum_usetar auto -cksum_algorithm sha1]
-        }
-
-        #crc::cksum is extremely slow in tcllib as at 2023 e.g 20x slower (no c implementation?)
-        #sha1 is performant - and this is not being used in a cryptographic or adversarial context - so performance and practical unlikelihood of accidental collisions should be the main consideration.
-        #adler32 is fastest for some larger files of a few MB but slower on small files (possibly due to Tcl-based file load?)
-        #sha1 as at 2023 seems a good default 
-        proc cksum_algorithms {} {
-            variable sha3_implementation
-            #sha2 is an alias for sha256
-            #2023 - no sha3 available in tcllib - we can exec fossil for now - which will be very slow
-            set algs [list md5 sha1 sha2 sha256 cksum adler32]
-            set sha3_algs [list sha3 sha3-224 sha3-256 sha3-384 sha3-512]
-            if {[auto_execok sqlite3] ne ""} {
-                lappend algs {*}$sha3_algs 
-                set sha3_implementation sqlite3_sha3
-            } else {
-                if {[auto_execok fossil] ne ""} {
-                    lappend algs {*}$sha3_algs 
-                    set sha3_implementation fossil_sha3
-                }
-            }
-            return $algs
-        }
-
-        proc sqlite3_sha3 {bits filename} {
-            return [exec sqlite3 :memory: "select lower(hex(sha3(readfile('$filename'),$bits)))"]
-        }
-        proc fossil_sha3 {bits filename} {
-            return [lindex [exec fossil sha3sum -$bits $filename] 0]
-        }
-
-        #adler32 via file-slurp
-        proc cksum_adler32_file {filename} {
-            package require zlib; #should be builtin anyway
-            set data [punk::mix::util::fcat -translation binary $filename]
-            #set data [fileutil::cat -translation binary $filename] ;#no significant performance diff on windows - and doesn't handle win-illegal names
-            zlib adler32 $data
-        }
-
-
-        #required to be able to accept relative paths
-        #for full cksum - using tar could reduce number of hashes to be made..
-        #but as it stores metadata such as permission - we don't know if/how the archive will vary based on platform/filesystem
-        #-noperms only available on extraction - so that doesn't help
-        #Needs to operate on non-existant paths and return empty string in cksum field
-        proc cksum_path {path args} {
-            variable sha3_implementation
-            if {$path eq {}} { set path [pwd] }
-            if {[file pathtype $path] eq "relative"} {
-                set path [file normalize $path]
-            }
-            set base [file dirname $path]
-            set startdir [pwd]
-            
-            set defaults [cksum_default_opts]
-            set known_opts [dict keys $defaults]
-            foreach {k v} $args {
-                if {$k ni $known_opts} {
-                    error "cksum_path unknown option '$k' known_options: $known_opts"
-                }
-            }
-
-            set opts [dict merge $defaults $args]
-            set opts_actual $opts ;#default  - auto updated to 0 or 1 later
-
-            #if {![file exists $path]} {
-            #    return [list cksum "" opts $opts]
-            #}
-        
-            if {[catch {file type $path} ftype]} {
-                return [list  cksum "<PATHNOTFOUND>" opts $opts]
-            }
-            if {$ftype ni [list file directory]} {
-                #review - links?
-                error "cksum_path error file type '$ftype' not supported"
-            }
-
-
-            set opt_cksum_algorithm [dict get $opts -cksum_algorithm]
-            if {$opt_cksum_algorithm ni [cksum_algorithms]} {
-                return [list error unsupported_cksum_algorithm cksum "<ERR>" opts $opts]
-            }
-            set opt_cksum_acls [dict get $opts -cksum_acls]
-            if {$opt_cksum_acls} {
-                puts stderr "cksum_path is not yet able to cksum ACLs"
-                return
-            }
-
-            set opt_cksum_meta [dict get $opts -cksum_meta]
-            set opt_use_tar [dict get $opts -cksum_usetar]
-            if {$ftype eq "file"} {
-                if {$opt_use_tar eq "auto"} {
-                    if {$opt_cksum_meta eq "1"} {
-                        set opt_use_tar 1
-                    } else {
-                        #prefer no tar if meta not required - faster/simpler
-                        #meta == auto or 0
-                        set opt_cksum_meta 0
-                        set opt_use_tar 0
-                    }
-                } elseif {$opt_use_tar eq "0"} {
-                    if {$opt_cksum_meta eq "1"} {
-                        puts stderr "cksum_path doesn't yet support a non-tar cksum with metadata for a file"
-                        return [list error unsupported_meta_without_tar cksum "<ERR>" opts $opts]
-                    } else {
-                        #meta == auto or 0
-                        set opt_cksum_meta 0
-                    }
-                } else {
-                    #tar == 1
-                    if {$opt_cksum_meta eq "0"} {
-                        puts stderr "cksum_path doesn't yet support a tar cksum without metadata for a file"
-                        return [list error unsupported_tar_without_meta cksum "<ERR>" opts $opts]
-                    } else {
-                        #meta == auto or 1
-                        set opt_cksum_meta 1
-                    }
-                }
-            } elseif {$ftype eq "directory"} {
-                if {$opt_use_tar eq "auto"} {
-                    if {$opt_cksum_meta in [list "auto" "1"]} {
-                        set opt_use_tar 1
-                        set opt_cksum_meta 1
-                    } else {
-                        puts stderr "cksum_path doesn't yet support a content-only cksum of a folder structure. Currently only files supported without metadata. For folders use cksum_path -cksum_meta 1 or auto"
-                        return [list error unsupported_directory_cksum_without_meta cksum "<ERR>" opts $opts]
-                    }
-                } elseif {$opt_use_tar eq "0"} {
-                        puts stderr "cksum_path doesn't yet support a cksum of a folder structure without tar. Currently only files supported without metadata. For folders use cksum_path -cksum_meta 1 or auto with -cksum_usetar 1 or auto"
-                        return [list error unsupported_directory_cksum_without_tar cksum "<ERR>" opts $opts]
-                } else {
-                    #tar 1
-                    if {$opt_cksum_meta eq "0"} {
-                        puts stderr "cksum_path doesn't yet support a tar checksum of a folder structure without metadat. Currently only files supported without metadata. For folders use cksum_path -cksum_meta 1 or auto with -cksum_usetar 1 or auto"
-                        return [list error unsupported_without_meta cksum "<ERR>" opts $opts]
-                    } else {
-                        #meta == auto or 1
-                        set opt_cksum_meta 1
-                    }
-                }
-            }
-
-            dict set opts_actual -cksum_meta $opt_cksum_meta
-            dict set opts_actual -cksum_usetar $opt_use_tar
-
-
-            if {$opt_use_tar} {
-                package require tar ;#from tcllib
-            }
-
-            if {$path eq $base} {
-                #attempting to cksum at root/volume level of a filesystem.. extra work
-                #This needs fixing for general use.. not necessarily just for project repos 
-                puts stderr "cksum_path doesn't yet support cksum of entire volume. (todo)"
-                return [list error unsupported_path opts $opts]
-            }
-
-            if {$opt_cksum_algorithm eq "sha1"} {
-                package require sha1
-                set cksum_command [list sha1::sha1 -hex -file]
-            } elseif {$opt_cksum_algorithm in [list "sha2" "sha256"]} {
-                package require sha256
-                set cksum_command [list sha2::sha256 -hex -file]
-            } elseif {$opt_cksum_algorithm eq "md5"} {
-                package require md5
-                set cksum_command [list md5::md5 -hex -file]
-            } elseif {$opt_cksum_algorithm eq "cksum"} {
-                package require cksum ;#tcllib
-                set cksum_command [list crc::cksum -format 0x%X -file]
-            } elseif {$opt_cksum_algorithm eq "adler32"} {
-                set cksum_command [list cksum_adler32_file]
-            } elseif {$opt_cksum_algorithm in [list "sha3" "sha3-256"]} {
-                #todo - replace with something that doesn't call another process
-                #set cksum_command [list apply {{file} {lindex [exec fossil sha3sum -256 $file] 0}}]
-                set cksum_command [list $sha3_implementation 256]
-            } elseif {$opt_cksum_algorithm in [list "sha3-224" "sha3-384" "sha3-512"]} {
-                set bits [lindex [split $opt_cksum_algorithm -] 1]
-                #set cksum_command [list apply {{bits file} {lindex [exec fossil sha3sum -$bits $file] 0}} $bits]
-                set cksum_command [list $sha3_implementation $bits]
-            }
-
-            set cksum ""
-            if {$opt_use_tar != 0} {
-                set target [file tail $path]
-                set tmplocation [punk::mix::util::tmpdir]
-                set archivename $tmplocation/[punk::mix::util::tmpfile].tar
-
-                cd $base ;#cd is process-wide.. keep cd in effect for as small a scope as possible. (review for thread issues)
-            
-                #temp emission to stdout.. todo - repl telemetry channel 
-                puts stdout "cksum_path: creating temporary tar archive for $path"
-                puts stdout "  at: $archivename .."
-                tar::create $archivename $target
-                if {$ftype eq "file"} {
-                    set sizeinfo "(size [file size $target])"
-                } else {
-                    set sizeinfo "(file type $ftype - size unknown)"
-                }
-                puts stdout "cksum_path: calculating cksum for $target $sizeinfo..."
-                set cksum [{*}$cksum_command $archivename]
-                #puts stdout "cksum_path: cleaning up.. "
-                file delete -force $archivename
-                cd $startdir
-
-            } else {
-                #todo
-                if {$ftype eq "file"} {
-                    if {$opt_cksum_meta} {
-                        return [list error unsupported_opts_combo cksum "<ERR>" opts $opts]
-                    } else {
-                        set cksum [{*}$cksum_command $path]
-                    }
-                } else {
-                    error "cksum_path unsupported $opts for path type [file type $path]"       
-                }
-            }
-            set result [dict create]
-            dict set result cksum $cksum
-            dict set result opts $opts_actual
-            return $result
-        }
-
-        #dict_path_cksum keyed on path - with value as a dict that must contain cksum key - but can contain other keys
-        #e.g -cksum_usetar  which is one of the keys understood by the punk::mix::base::lib::cksum_path function - or unrelated keys which will also be passed through
-        #cksum only calculated for keys in dict where cksum is empty - ie return same dict but with empty cksums filled out.
-        #base can be empty string in which case paths must be absolute
-        proc fill_relativecksums_from_base_and_relativepathdict {base {dict_path_cksum {}}} {
-            if {$base eq ""} {
-                set error_paths [list]
-                dict for {path pathinfo} $dict_path_cksum {
-                    if {[file pathtype $path] ne "absolute"} {
-                        lappend error_paths $path
-                    }
-                }
-                if {[llength $error_paths]} {
-                    puts stderr "get_relativecksums_from_base_and_relativepathdict has empty base - and non-absolute paths in the supplied checksum dict - aborting"
-                    puts stderr "error_paths: $error_paths"
-                    error "fill_relativecksums_from_base_and_relativepathdict error: non-absolute paths when base empty. $error_paths"
-                }
-            } else {
-                if {[file pathtype $base] ne "absolute"} {
-                    error "fill_relativecksums_from_base_and_relativepathdict error: base supplied but was not absolute path.  $base"
-                }
-                #conversely now we have a base - so we require all paths are relative.
-                #We will ignore/disallow volume-relative - as these shouldn't be used here either
-                set error_paths [list]
-                dict for {path pathinfo} $dict_path_cksum {
-                    if {[file pathtype $path] ne "relative"} {
-                        lappend error_paths $path
-                    }
-                }
-                if {[llength $error_paths]} {
-                    puts stderr "fill_relativecksums_from_base_and_relativepathdict has a supplied absolute base path, but some of the paths in the supplied dict are not relative - aborting"
-                    error "fill_relativecksums_from_base_and_relativepathdict error: non-relative paths when base supplied. $error_paths"
-                }
-            }
-
-
-            dict for {path pathinfo} $dict_path_cksum {
-                if {![dict exists $pathinfo cksum]} {
-                    dict set pathinfo cksum ""
-                } else {
-                    if {[dict get $pathinfo cksum] ne "" && ![cksum_is_tag [dict get $pathinfo cksum]]} {
-                        continue ;#already filled with non-tag value
-                    }
-                }
-                if {$base ne ""} {
-                   set fullpath [file join $base $path] 
-                } else {
-                    set fullpath $path
-                }
-
-                set ckopts [cksum_filter_opts {*}$pathinfo]
-
-                if {![file exists $fullpath]} {
-                    dict set dict_path_cksum $path cksum "<PATHNOTFOUND>"
-                } else {
-                    set ckinfo [cksum_path $fullpath {*}$ckopts]
-                    dict set dict_path_cksum $path cksum [dict get $ckinfo cksum]
-                    dict set dict_path_cksum $path cksum_all_opts [dict get $ckinfo opts]
-                    if {[dict exists $ckinfo error]} {
-                        dict set dict_path_cksum $path cksum_error [dict get $ckinfo error]
-                    }
-                }
-            }
-
-            return $dict_path_cksum
-        }
-        #whether cksum is <XXX>  e.g <ERR> <PATHNOTFOUND>
-        proc cksum_is_tag {cksum} {
-            expr {[string index $cksum 0] eq "<" && [string index $cksum end] eq ">"}
-        }
-        proc cksum_filter_opts {args} {
-            set ck_opt_names [dict keys [cksum_default_opts]]
-            set ck_opts [dict create]
-            dict for {k v} $args {
-                if {$k in $ck_opt_names} {
-                    dict set ck_opts $k $v
-                }
-            }
-            return $ck_opts
-        }
-
-        #convenience so caller doesn't have to pre-calculate the relative path from the base
-        #Note semantic difference from fill_relativecksums_from_base_and_relativepathdict  (hence get_ vs fill_)
-        #Here we will raise an error if cksum exists and is not empty or a tag - whereas the multiple path version will ignore valid-looking prefilled cksum values
-        #base is the presumed location to store the checksum file. The caller should retain (normalize if relative)
-        proc get_relativecksum_from_base {base specifiedpath args} {
-            if {$base ne ""} { 
-                #targetpath ideally should be within same project tree as base if base supplied - but not necessarily below it
-                #we don't necessarily want to restrict this to use in punk projects though - so we'll allow anything with a common prefix
-                if {[file pathtype $specifiedpath] eq "relative"} {
-                    if {[file pathtype $base] eq "relative"} {
-                        set normbase [file normalize $base]
-                        set normtarg [file normalize [file join $normbase $specifiedpath]]
-                        set targetpath $normtarg
-                        set storedpath [punk::path::relative $normbase $normtarg]
-                    } else {
-                        set targetpath [file join $base $specifiedpath]
-                        set storedpath $specifiedpath
-                    }
-                } else {
-                    #specifed absolute
-                    if {[file pathtype $base] eq "relative"} {
-                        #relative to cwd or to specifiedpath? For consistency it should arguably be cwd but a case could be made that when one path is relative it is in reference to the other
-                        #there is a strong possibility that allowing this combination will cause confusion - better to disallow
-                        error "get_relativecksum_from_base error: disallowed pathtype combination. Base must be empty or absolute when specified path is absolute"
-                    }
-                    #both absolute - compute relative path if they share a common prefix
-                    set commonprefix [punk::mix::util::path_common_prefix $base $specifiedpath]
-                    if {$commonprefix eq ""} {
-                        #absolute base with no shared prefix doesn't make sense - we could ignore it - but better to error-out and require the caller specify an empty base
-                        error "get_relativecksum_from_base error: base '$base' and specifiedpath '$specifiedpath' don't share a common root. Use empty-string for base if independent absolute path is required"
-                    }
-                    set targetpath $specifiedpath 
-                    set storedpath [punk::path::relative $base $specifiedpath]
-                    
-                }
-            } else {
-                if {[file type $specifiedpath] eq "relative"} {
-                    #if specifiedpath is relative - and we don't have a base, we now need to convert relative to cwd to an absolute path for storage
-                    set targetpath [file normalize $specifiedpath]
-                    set storedpath $targetpath
-                } else {
-                    set targetpath $specifiedpath
-                    set storedpath $targetpath
-                }
-            }
-
-            #
-            #NOTE: specifiedpath can be a relative path (to cwd) when base is empty
-            #OR - a relative path when base itself is relative  e.g base: somewhere  targetpath somewhere/etc 
-            #possibly also:  base: somewhere targetpath: ../elsewhere/etc
-            #
-            #todo - write tests
-
-
-            if {([llength $args] % 2) != 0} {
-                error "get_relativecksum_from_base error. args supplied must be in the form of key-value pairs. received '$args' "
-            }
-            if {[dict exists $args cksum]} {
-                if {[dict get $args cksum] ne "" && ![cksum_is_tag [dict get $args cksum]]} {
-                    error "get_relativecksum_from_base called with existing cksum value (and is not a tag or empty-value to be replaced) cksum: [dict get $args cksum]  Set cksum to be empty, any tag such as <REPLACE> or remove the key and try again."
-                }
-            }
-
-
-            set ckopts [cksum_filter_opts {*}$args]
-            set ckinfo [cksum_path $targetpath {*}$ckopts]
-            
-            set keyvals $args
-            dict set keyvals cksum [dict get $ckinfo cksum]
-            dict set keyvals cksum_all_opts [dict get $ckinfo opts]
-            if {[dict exists $ckinfo error]} {
-                dict set keyvals cksum_error [dict get $ckinfo error]
-            }
-
-            #set relpath [punk::repo::path_strip_alreadynormalized_prefixdepth $fullpath $base] ;#empty base ok noop
-            #storedpath is relative if possible 
-            return [dict create $storedpath $keyvals]
-        }
-
-        #calculate the runtime checksum and vfs checksums
-        proc get_all_vfs_build_cksums {path} {
-            set buildfolder [get_build_workdir $path]
-            set cksum_base_folder [file dirname $buildfolder] ;#this is the <project>/src folder - a reasonable base for our vfs cksums
-            set dict_cksums [dict create]
-
-            set buildrelpath [punk::repo::path_strip_alreadynormalized_prefixdepth $buildfolder $cksum_base_folder]
-            set vfs_tail_list [glob -nocomplain -dir $cksum_base_folder -type d -tails *.vfs]
-
-            foreach vfstail $vfs_tail_list {
-                set vname [file rootname $vfstail]
-                dict set dict_cksums $vfstail [list cksum ""]
-                dict set dict_cksums [file join $buildrelpath $vname.exe] [list cksum ""]
-            }
-
-            set fullpath_buildruntime $buildfolder/buildruntime.exe
-
-            set ckinfo_buildruntime [cksum_path $fullpath_buildruntime]
-            set ck [dict get $ckinfo_buildruntime cksum]
-
-
-            set relpath [file join $buildrelpath "buildruntime.exe"]
-            dict set dict_cksums $relpath [list cksum $ck]
-
-            set dict_cksums [fill_relativecksums_from_base_and_relativepathdict $cksum_base_folder $dict_cksums]
-
-            return $dict_cksums
-        }
-
-        proc get_vfs_build_cksums_stored {vfsfolder} {
-            set vfscontainer [file dirname $vfsfolder]
-            set buildfolder $vfscontainer/_build
-            set vfs [file tail $vfsfolder]
-            set vname [file rootname $vfs]
-            set dict_vfs [list $vname.vfs "" $vname.exe "" buildruntime.exe ""]
-            set ckfile $buildfolder/$vname.cksums
-            if {[file exists $ckfile]} {
-                set data [punk::mix::util::fcat -translation binary $ckfile]
-                foreach ln [split $data \n] {
-                    if {[string trim $ln] eq ""} {continue}
-                    lassign $ln path cksum
-                    dict set dict_vfs $path $cksum
-                }
-            }
-            return $dict_vfs
-        }
-        proc get_all_build_cksums_stored {path} {
-            set buildfolder [get_build_workdir $path]
-            
-            set vfscontainer [file dirname $buildfolder]
-            set vfslist [glob -nocomplain -dir $vfscontainer -type d -tail *.vfs]
-            set dict_cksums [dict create]
-            foreach vfs $vfslist {
-                set vname [file rootname $vfs]
-                set dict_vfs [get_vfs_build_cksums_stored $vfscontainer/$vfs]
-
-                dict set dict_cksums $vname $dict_vfs
-            }
-            return $dict_cksums
-        }
-
-        proc store_vfs_build_cksums {vfsfolder} {
-            if {![file isdirectory $vfsfolder]} {
-                error "Unable to find supplied vfsfolder: $vfsfolder"
-            }
-            set vfscontainer [file dirname $vfsfolder]
-            set buildfolder $vfscontainer/_build
-            set dict_vfs [get_vfs_build_cksums $vfsfolder] 
-            set data ""
-            dict for {path cksum} $dict_vfs {
-                append data "$path $cksum" \n
-            }
-            set fd [open $buildfolder/$vname.cksums w]
-            chan configure $fd -translation binary
-            puts $fd $data
-            close $fd
-            return $dict_vfs
-        }
-
-
-
-    }
-}
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/cli-0.3.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/cli-0.3.tm
deleted file mode 100644
index a845285c..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/cli-0.3.tm
+++ /dev/null
@@ -1,925 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::cli 0.3
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require punk::repo
-package require punkcheck ;#checksum and/or timestamp records 
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-
-namespace eval punk::mix::cli {
-    namespace eval temp_import {
-    }
-    namespace ensemble create
-
-    package require punk::overlay
-    catch {
-        punk::overlay::import_commandset module . ::punk::mix::commandset::module
-    }
-    punk::overlay::import_commandset debug . ::punk::mix::commandset::debug
-    punk::overlay::import_commandset repo  . ::punk::mix::commandset::repo
-    punk::overlay::import_commandset lib   . ::punk::mix::commandset::loadedlib
-
-    catch {
-        package require punk::mix::commandset::project
-        punk::overlay::import_commandset project    .       ::punk::mix::commandset::project
-        punk::overlay::import_commandset projects   .       ::punk::mix::commandset::project::collection 
-    }
-    if {[catch {
-        package require punk::mix::commandset::layout
-        punk::overlay::import_commandset project.layout       . ::punk::mix::commandset::layout
-        punk::overlay::import_commandset project.layouts      . ::punk::mix::commandset::layout::collection
-    } errM]} {
-        puts stderr "error loading punk::mix::commandset::layout"
-        puts stderr $errM
-    }
-    if {[catch {
-        package require punk::mix::commandset::buildsuite
-        punk::overlay::import_commandset buildsuite     .   ::punk::mix::commandset::buildsuite
-        punk::overlay::import_commandset buildsuites    .   ::punk::mix::commandset::buildsuite::collection
-    } errM]} {
-        puts stderr "error loading punk::mix::commandset::buildsuite"
-        puts stderr $errM
-    }
-    punk::overlay::import_commandset scriptwrap  . ::punk::mix::commandset::scriptwrap
-    if {[catch {
-        package require punk::mix::commandset::doc
-        punk::overlay::import_commandset doc . ::punk::mix::commandset::doc
-        punk::overlay::import_commandset ""  ""   ::punk::mix::commandset::doc::collection
-    } errM]} {
-        puts stderr "error loading punk::mix::commandset::doc"
-        puts stderr $errM
-    }
-
-
-    proc help {args} {
-        #set basehelp [punk::mix::base::help -extension [namespace current] {*}$args]
-        set basehelp [punk::mix::base help {*}$args]
-        #puts stdout "punk::mix help"
-        return $basehelp
-    }
-
-    proc stat {{workingdir ""} args} {
-        dict set args -v 0 
-        punk::mix::cli::lib::get_status $workingdir {*}$args 
-    }
-    proc status {{workingdir ""} args} {
-        dict set args -v 1 
-        punk::mix::cli::lib::get_status $workingdir {*}$args 
-    }
-
-
-
-
-
-
-
-}
-
-
-namespace eval punk::mix::cli {
-
-
-    #interp alias {} ::punk::mix::cli::project.new {} ::punk::mix::cli::new
-
-
-
-
-
-
-
-    proc make {args} {
-        set startdir [pwd]
-        set project_base "" ;#empty for unknown
-        if {[punk::repo::is_git $startdir]} {
-            set project_base [punk::repo::find_git]
-            set sourcefolder $project_base/src
-        } elseif {[punk::repo::is_fossil $startdir]} {
-            set project_base [punk::repo::find_fossil]
-            set sourcefolder $project_base/src
-        } else {
-            if {[punk::repo::is_candidate $startdir]} {
-                set project_base [punk::repo::find_candidate]
-                set sourcefolder $project_base/src
-                puts stderr "WARNING - project not under git or fossil control"
-                puts stderr "Using base folder $project_base" 
-            } else {
-                set sourcefolder $startdir
-            }
-        }
-
-        #review - why can't we be anywhere in the project? 
-        if {([file tail $sourcefolder] ne "src") || (![file exists $sourcefolder/make.tcl])} {
-            puts stderr "pmix make must be run from src folder containing make.tcl - unable to proceed (cwd: [pwd])"
-            if {[string length $project_base]} {
-                if {[file exists $project_base/src] && [string tolower [pwd]] ne [string tolower $project_base/src]} {
-                    puts stderr "Try cd to $project_base/src"
-                }
-            } else {
-                if {[file exists $startdir/Makefile]} {
-                    puts stdout "A Makefile exists at $startdir/Makefile."
-                    if {"windows" eq $::tcl_platform(platform)} {
-                        puts stdout "Try running: msys2 -ucrt64 -here -c \"make build\" or bash -c \"make build\""
-                    } else {
-                        puts stdout "Try runing: make build"
-                    }
-                }
-            }
-            return false
-        }
-
-        if {![string length $project_base]} {
-            puts stderr "WARNING no git or fossil repository detected."
-            puts stderr "Using base folder $startdir" 
-            set project_base $startdir
-        }
-
-        set lc_this_exe [string tolower [info nameofexecutable]]
-        set lc_proj_bin [string tolower $project_base/bin]
-        set lc_build_bin [string tolower $project_base/src/_build]
-
-        if {"project" in $args} {
-            set is_own_exe 0
-            if {[string match "${lc_proj_bin}*" $lc_this_exe] || [string match "${lc_build_bin}" $lc_this_exe]} {
-                set is_own_exe 1
-                puts stderr "WARNING - running make using executable that may be created by the project being built"
-                set answer [util::askuser "Do you want to proceed using this executable? (build will probably stop when it is unable to  update the executable) Y|N"]
-                if {[string tolower $answer] ne "y"} {
-                    puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                    return
-                }
-            }
-        }
-        cd $sourcefolder
-        #use run so that stdout visible as it goes
-        if {![catch {run --timeout=55000 -debug [info nameofexecutable] $sourcefolder/make.tcl {*}$args} exitinfo]} {
-            #todo - notify if exit because of timeout!
-            puts stderr "exitinfo: $exitinfo"
-            set exitcode [dict get $exitinfo exitcode]
-        } else {
-            puts stderr "Error unable to determine exitcode. err: $exitinfo"
-            cd $startdir
-            return false
-        }
-
-        cd $startdir
-        if {$exitcode != 0} {
-            puts stderr "FAILED with exitcode $exitcode"
-            return false
-        } else {
-            puts stdout "OK make finished "
-            return true
-        }
-    } 
-
-    proc Kettle {args} {
-        tailcall lib::kettle_call lib {*}$args
-    }
-    proc KettleShell {args} {
-        tailcall lib::kettle_call shell {*}$args
-    }
-
-
-
-    namespace eval lib {
-        namespace path ::punk::mix::util
-
-
-        proc module_types {} {
-            #first in list is default for unspecified -type when creating new module
-            return [list plain tarjar zipkit]
-        }
-
-        proc validate_modulename {modulename args} {
-            set defaults [list\
-                -name_description modulename\
-                ]
-            if {[llength $args] %2 != 0} {error "validate_modulename args must be name-value pairs: received '$args'"}
-            set known_opts [dict keys $defaults]
-            foreach k [dict keys $args] {
-                if {$k ni $known_opts} {
-                    error "validate_modulename error: unknown option $k. known options: $known_opts"
-                }
-            }
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_name_description            [dict get $opts -name_description]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-            validate_name_not_empty_or_spaced $modulename -name_description $opt_name_description
-            set testname [string map [list :: ""] $modulename]
-            if {[string first : $testname] >=0} {
-                error "$opt_name_description '$modulename' can only contain paired colons"
-            }
-            set badchars [list - "$" "?" "*"]
-            foreach bc $badchars {
-                if {[string first $bc $modulename] >= 0} {
-                    error "$opt_name_description '$modulename' can not contain character '$bc'"
-                }
-            }
-            return $modulename
-        }
-
-        proc validate_projectname {projectname args} {
-            set defaults [list\
-                -name_description projectname\
-                ]
-            if {[llength $args] %2 != 0} {error "validate_modulename args must be name-value pairs: received '$args'"}
-            set known_opts [dict keys $defaults]
-            foreach k [dict keys $args] {
-                if {$k ni $known_opts} {
-                    error "validate_modulename error: unknown option $k. known options: $known_opts"
-                }
-            }
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_name_description            [dict get $opts -name_description]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            validate_name_not_empty_or_spaced $projectname -name_description $opt_name_description
-            set reserved_words [list etc lib bin modules src doc vendorlib vendormodules embedded runtime _aside _build]
-            if {$projectname in $reserved_words } {
-                error "$opt_name_description '$projectname' cannot be one of reserved_words: $reserved_words"
-            }
-            if {[string first "::" $projectname] >= 0} {
-                error "$opt_name_description '$projectname' cannot contain namespace separator '::'"
-            }
-            return $projectname 
-        }
-        proc validate_name_not_empty_or_spaced {name args} {
-            set defaults [list\
-                -name_description projectname\
-                ]
-            if {[llength $args] %2 != 0} {error "validate_modulename args must be name-value pairs: received '$args'"}
-            set known_opts [dict keys $defaults]
-            foreach k [dict keys $args] {
-                if {$k ni $known_opts} {
-                    error "validate_modulename error: unknown option $k. known options: $known_opts"
-                }
-            }
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_name_description            [dict get $opts -name_description]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            if {![string length $name]} {
-                error "$opt_name_description cannot be empty"
-            }
-            if {[string length [string map [list " " "" \n "" \r "" \t ""] $name]] != [string length $name]} {
-                error "$opt_name_description cannot contain whitespace"
-            }
-            return $name
-        }
-
-        #split modulename (as present in a filename or namespaced name) into name/version ignoring leading namespace path
-        #ignore trailing .tm .TM if present
-        #if version doesn't pass validation - treat it as part of the modulename and return empty version string without error
-        #Up to caller to validate.
-        proc split_modulename_version {modulename} {
-            set lastpart [namespace tail $modulename]
-            set lastpart [file tail $lastpart] ;# should be ok to use file tail now that we've ensured no namespace components
-            if {[string equal -nocase [file extension $modulename] ".tm"]} {
-                 set fileparts [split [file rootname $lastpart] -]
-            } else {
-                 set fileparts [split $lastpart -]
-            }
-            if {[punk::mix::util::is_valid_tm_version [lindex $fileparts end]]} {
-                set versionsegment [lindex $fileparts end]
-                set namesegment [join [lrange $fileparts 0 end-1] -];#re-stitch
-            } else {
-                #
-                set namesegment [join $fileparts -]
-                set versionsegment ""
-            }
-            return [list $namesegment $versionsegment]
-        }
-
-        proc get_status {{workingdir ""} args} {
-            set result ""
-            if {$workingdir ne ""} {
-                if {[file pathtype $workingdir] ne "absolute"} {
-                set workingdir [file normalize $workingdir] 
-                }
-                set active_dir $workingdir
-            } else {
-                set active_dir [pwd]
-            }
-            set defaults [dict create\
-                -v 1\
-            ]
-            set opts [dict merge $defaults $args] 
-            # -- --- --- --- --- --- --- --- --- 
-            set opt_v       [dict get $opts -v]
-            # -- --- --- --- --- --- --- --- --- 
-
-
-            set repopaths [punk::repo::find_repos [pwd]]
-            set repos [dict get $repopaths repos]
-            if {![llength $repos]} {
-                append result [dict get $repopaths warnings]
-            } else {
-                append result [dict get $repopaths warnings]
-                lassign [lindex $repos 0] repopath repotypes
-                if {"fossil" in $repotypes} {
-                    #review - multiple process launches to fossil a bit slow on windows.. 
-                    #could we query global db in one go instead?
-                    #
-                    set fossil_prog [auto_execok fossil]
-                    append result "FOSSIL project based at $repopath with revision: [punk::repo::fossil_revision $repopath]" \n
-                    set fosinfo [exec {*}$fossil_prog info]
-                    append result [join [punk::repo::grep {repository:*}        $fosinfo] \n] \n
-
-                    set fosrem [exec {*}$fossil_prog remote ls]
-                    if {[string length $fosrem]} {
-                        append result "Remotes:\n"
-                        append result "    " $fosrem \n
-                    }
-
-
-                    append result [join [punk::repo::grep {tags:*}              $fosinfo] \n] \n
-
-                    set dbinfo [exec {*}$fossil_prog dbstat]
-                    append result [join [punk::repo::grep {project-name:*}      $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {tickets:*}           $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {project-age:*}       $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {latest-change:*}     $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {files:*}             $dbinfo] \n] \n
-                    append result [join [punk::repo::grep {check-ins:*}         $dbinfo] \n] \n
-                    if {"project" in $repotypes} {
-                        #punk project
-                        if {![catch {package require textblock; package require patternpunk}]} {
-                           set result [textblock::join [textblock::join [>punk . logo] "  "] $result]
-                           append result \n
-                        } 
-                    }  
-
-                    set timeline [exec fossil timeline -n 5 -t ci]
-                    set timeline [string map [list \r\n \n] $timeline]
-                    append result $timeline 
-                    if {$opt_v} {
-                        set repostate [punk::repo::workingdir_state $repopath -repopaths $repopaths -repotypes fossil]
-                        append result \n [punk::repo::workingdir_state_summary $repostate]
-                    }
-
-                }
-                #repotypes *could* be both git and fossil - so report both if so
-                if {"git" in $repotypes} {
-                    append result "GIT project based at $repopath with revision: [punk::repo::git_revision $repopath]" \n
-                    if {[string length [set git_prog [auto_execok git]]]} {
-                        set git_remotes [exec {*}$git_prog remote -v]
-                        append result $git_remotes
-                        if {$opt_v} {
-                            set repostate [punk::repo::workingdir_state $repopath -repopaths $repopaths -repotypes git]
-                            append result \n [punk::repo::workingdir_state_summary $repostate]
-                        }
-                    }
-                }
-
-            }
-
-            return $result
-        }
-
-
-        proc build_modules_from_source_to_base {srcdir basedir args} {
-            set antidir [list "#*" "_aside" ".git" ".fossil*"] ;#exact or glob patterns for folders we don't want to search in.
-            set defaults [list\
-                -installer punk::mix::cli::build_modules_from_source_to_base\
-                -call-depth-internal 0\
-                -max_depth 1000\
-                -subdirlist {}\
-                -punkcheck_eventobj "\uFFFF"\
-                -glob *.tm\
-                ]
-            set opts [dict merge $defaults $args]
-
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set installername                       [dict get $opts -installer]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set CALLDEPTH                               [dict get $opts -call-depth-internal]
-            set max_depth                               [dict get $opts -max_depth]
-            set subdirlist                              [dict get $opts -subdirlist]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set fileglob                                [dict get $opts -glob]
-            if {![string match "*.tm" $fileglob]} {
-                error "build_modules_from_source_to_base -glob '$fileglob' doesn't seem to target tcl modules."
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_punkcheck_eventobj                   [dict get $opts -punkcheck_eventobj]
-
-            set magicversion [punk::mix::util::magic_tm_version] ;#deliberately large so given load-preference when testing
-            set module_list [list]
-
-            if {[file tail [file dirname $srcdir]] ne "src"} {
-                puts stderr "ERROR build_modules_from_source_to_base can only be called with a srcdir that is a subfolder of your 'src' directory"
-                puts stderr "The .tm modules are namespaced based on their directory depth - so we need to start at the root"
-                puts stderr "To build a subtree of your modules - use an appropriate src/modules folder and pass in the -subdirlist."
-                puts stderr "e.g if your modules are based at /x/src/modules2 and you wish to build only the .tm files at /x/src/modules2/skunkworks/lib"
-                puts stderr "Use: >build_modules_from_source_to_base /x/src/modules2 /x/modules2 -subdirlist {skunkworks lib}"
-                exit 2
-            }
-            set srcdirname [file tail $srcdir] 
-
-            set build [file dirname $srcdir]/_build/$srcdirname ;#relative to *original* srcdir - not current_source_dir
-            if {[llength $subdirlist] == 0} {
-                set target_module_dir $basedir
-                set current_source_dir $srcdir
-            } else {
-                set target_module_dir $basedir/[file join {*}$subdirlist]
-                set current_source_dir $srcdir/[file join {*}$subdirlist]
-            }
-            if {![file exists $target_module_dir]} {
-                error "build_modules_from_source_to_base from current source dir: '$current_source_dir'.  Basedir:'$current_module_dir' doesn't exist or is empty"
-            }
-            if {![file exists $current_source_dir]} {
-                error "build_modules_from_source_to_base from current source dir:'$current_source_dir' doesn't exist or is empty"
-            }
-
-            #----------------------------------------
-            set punkcheck_file [file join $basedir/.punkcheck]
-            if {$CALLDEPTH == 0} {
-
-                set config [dict create\
-                    -glob $fileglob\
-                    -max_depth 0\
-                ]
-                #lassign [punkcheck::start_installer_event $punkcheck_file $installername $srcdir $basedir $config] _eventid punkcheck_eventid _recordset record_list
-                # -- ---
-                set installer [punkcheck::installtrack new $installername $punkcheck_file]
-                $installer set_source_target $srcdir $basedir
-                set event [$installer start_event $config]
-                # -- ---
-
-            } else {
-                set event $opt_punkcheck_eventobj
-            }
-            #----------------------------------------
-
-
-
-            set src_modules [glob -nocomplain -dir $current_source_dir -type f -tail $fileglob]
-
-            set did_skip 0 ;#flag for stdout/stderr formatting only
-            foreach m $src_modules {
-                set is_interesting 0
-                if {[string match "foobar" $current_source_dir]} {
-                    set  is_interesting 1
-                }
-                if {$is_interesting} {
-                    puts "build_modules_from_source_to_base >>> module $current_source_dir/$m"
-                }
-                set fileparts [split [file rootname $m] -]
-                set tmfile_versionsegment [lindex $fileparts end]
-                if {$tmfile_versionsegment eq $magicversion} {
-                    #rebuild the .tm from the #tarjar 
-                    set basename [join [lrange $fileparts 0 end-1] -]
-                    set versionfile $current_source_dir/$basename-buildversion.txt
-                    set versionfiledata ""
-                    if {![file exists $versionfile]} {
-                        puts stderr "\nWARNING: Missing buildversion text file: $versionfile"
-                        puts stderr "Using version 0.1 - create $versionfile containing the desired version number as the top line to avoid this warning\n"
-                        set module_build_version "0.1"
-                    } else {
-                        set fd [open $versionfile r]
-                        set versionfiledata [read $fd]; close $fd
-                        set ln0 [lindex [split $versionfiledata \n] 0]
-                        set ln0 [string trim $ln0]; set ln0 [string trim $ln0 \r]
-                        if {![util::is_valid_tm_version $ln0]} {
-                            puts stderr "ERROR: build version '$ln0' specified in $versionfile is not suitable. Please ensure a proper version number is at first line of file"
-                            exit 3
-                        }
-                        set module_build_version $ln0
-                    }
-
-
-                    if {[file exists $current_source_dir/#tarjar-$basename-$magicversion]} {
-                        #TODO
-                        file mkdir $buildfolder
-
-                        if {[file exists $current_source_dir/#tarjar-$basename-$magicversion/DESCRIPTION.txt]} {
-                        
-                        } else {
-                        
-                        }
-                        #REVIEW - should be in same structure/depth as $target_module_dir  in _build?
-                        set tmfile $basedir/_build/$basename-$module_build_version.tm
-                        file mkdir $basedir/_build
-                        file delete -force $basedir/_build/#tarjar-$basename-$module_build_version
-                        file delete -force $tmfile
-                        
-                        
-                        file copy -force $current_source_dir/#tarjar-$basename-$magicversion $basedir/_build/#tarjar-$basename-$module_build_version
-                        #
-                        #bsdtar doesn't seem to work.. or I haven't worked out the right options?
-                        #exec tar -cvf $basedir/_build/$basename-$module_build_version.tm $basedir/_build/#tarjar-$basename-$module_build_version
-                        package require tar
-                        tar::create $tmfile $basedir/_build/#tarjar-$basename-$module_build_version  
-                        if {![file exists $tmfile]} {
-                            puts stdout "ERROR: Failed to build tarjar file $tmfile"
-                            exit 4
-                        }
-                        #copy the file?
-                        #set target $target_module_dir/$basename-$module_build_version.tm                
-                        #file copy -force $tmfile $target
-                        
-                        lappend module_list $tmfile
-                    } else {
-                        #assume that either the .tm is not a tarjar - or the tarjar dir is capped (trailing #) and the .tm has been manually tarred.
-                        if {[file exists $current_source_dir/#tarjar-$basename-${magicversion}#]} {
-                            puts stderr "\nWarning: found 'capped' folder #tarjar-$basename-${magicversion}# - No attempt being made to update version in description.txt"
-                        }
-
-                        #------------------------------
-                        #
-                        #set target_relpath [punkcheck::lib::path_relative $basedir $target_module_dir/$basename-$module_build_version.tm]
-                        #set file_record [punkcheck::installfile_begin $basedir $target_relpath $installername -eventid $punkcheck_eventid]
-                        $event targetset_init INSTALL $target_module_dir/$basename-$module_build_version.tm 
-                        $event targetset_addsource $versionfile
-                        $event targetset_addsource $current_source_dir/$m
-
-                        #set changed_list [list]
-                        ## -- --- --- --- --- ---
-                        #set source_relpath [punkcheck::lib::path_relative $basedir $versionfile]
-                        #set file_record [punkcheck::installfile_add_source_and_fetch_metadata $basedir $source_relpath $file_record]
-                        ## -- --- --- --- --- ---
-                        #set source_relpath [punkcheck::lib::path_relative $basedir $current_source_dir/$m]
-                        #set file_record [punkcheck::installfile_add_source_and_fetch_metadata $basedir $source_relpath $file_record]
-                        ## -- --- --- --- --- ---
-                        #set changed_unchanged [punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $file_record body] end]]
-                        #set changed_list [dict get $changed_unchanged changed]
-
-
-                        if {\
-                                [llength [dict get [$event targetset_source_changes] changed]]\
-                            || [llength [$event get_targets_exist]] < [llength [$event get_targets]]\
-                            } {
-
-                            #set file_record [punkcheck::installfile_started_install $basedir $file_record]
-                            $event targetset_started
-                            # -- --- --- --- --- ---
-                            set target $target_module_dir/$basename-$module_build_version.tm
-                            if {$did_skip} {set did_skip 0; puts -nonewline stdout \n}
-                            puts stdout "copying module $current_source_dir/$m to $target as version: $module_build_version ([file tail $target])"
-                            set fd [open $current_source_dir/$m r]; fconfigure $fd -translation binary; set data [read $fd]; close $fd
-                            set data [string map [list $magicversion $module_build_version] $data]
-                            set fdout [open $target w]
-                            fconfigure $fdout -translation binary
-                            puts -nonewline $fdout $data
-                            close $fdout
-                            #file copy -force $srcdir/$m $target
-                            lappend module_list $target
-                            # -- --- --- --- --- ---
-                            #set file_record [punkcheck::installfile_finished_install $basedir $file_record]
-                            $event targetset_end OK
-                        } else {
-                            if {$is_interesting} {
-                                puts stdout "skipping module $current_source_dir/$m - no change in sources detected"
-                            }
-                            puts -nonewline stderr "."
-                            set did_skip 1
-                            #set file_record [punkcheck::installfile_skipped_install $basedir $file_record]
-                            $event targetset_end SKIPPED
-                        }
-
-                        #------------------------------
-
-                    }
-                     
-                    continue
-                }
-                
-                
-                if {![util::is_valid_tm_version $tmfile_versionsegment]} {
-                    #last segment doesn't look even slightly versiony - fail.
-                    puts stderr "ERROR: Unable to confirm file $current_source_dir/$m is a reasonably versioned .tm module - ABORTING."
-                    exit 1
-                }
-
-                ##------------------------------
-                ##
-                #set target_relpath [punkcheck::lib::path_relative $basedir $target_module_dir/$m]
-                #set file_record [punkcheck::installfile_begin $basedir $target_relpath $installername -eventid $punkcheck_eventid]
-                #set changed_list [list]
-                ## -- --- --- --- --- ---
-                #set source_relpath [punkcheck::lib::path_relative $basedir $current_source_dir/$m]
-                #set file_record [punkcheck::installfile_add_source_and_fetch_metadata $basedir $source_relpath $file_record]
-                ## -- --- --- --- --- ---
-                #set changed_unchanged [punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $file_record body] end]]
-                #set changed_list [dict get $changed_unchanged changed]
-
-                #----------
-                $event targetset_init INSTALL $target_module_dir/$m 
-                $event targetset_addsource $current_source_dir/$m
-                if {\
-                        [llength [dict get [$event targetset_source_changes] changed]]\
-                    || [llength [$event get_targets_exist]] < [llength [$event get_targets]]\
-                    } {
-
-                    #set file_record [punkcheck::installfile_started_install $basedir $file_record]
-                    $event targetset_started
-                    # -- --- --- --- --- ---
-                    if {$did_skip} {set did_skip 0; puts -nonewline stdout \n}
-                    lappend module_list $current_source_dir/$m
-                    file copy -force $current_source_dir/$m $target_module_dir
-                    puts stderr "Copied already versioned module $current_source_dir/$m to $target_module_dir"
-                    # -- --- --- --- --- ---
-                    #set file_record [punkcheck::installfile_finished_install $basedir $file_record]
-                    $event targetset_end OK -note "already versioned module"
-                } else {
-                    puts -nonewline stderr "."
-                    set did_skip 1
-                    if {$is_interesting} {
-                        puts stderr "$current_source_dir/$m [$event targetset_source_changes]"
-                    }
-                    #set file_record [punkcheck::installfile_skipped_install $basedir $file_record]
-                    $event targetset_end SKIPPED
-                }
-
-            }
-            if {$CALLDEPTH >= $max_depth} {
-                set subdirs [list]
-            } else {
-                set subdirs [glob -nocomplain -dir $current_source_dir -type d -tail *]
-            }
-            #puts stderr "subdirs: $subdirs"
-            foreach d $subdirs {
-                set skipdir 0
-                foreach dg $antidir {
-                    if {[string match $dg $d]} {
-                        set skipdir 1
-                        continue
-                    }
-                }
-                if {$skipdir} {
-                    continue
-                }
-                if {![file exists $target_module_dir/$d]} {
-                    file mkdir $target_module_dir/$d
-                }
-                lappend module_list {*}[build_modules_from_source_to_base $srcdir $basedir\
-                    -call-depth-internal [expr {$CALLDEPTH +1}]\
-                    -subdirlist [list {*}$subdirlist $d]\
-                    -punkcheck_eventobj $event\
-                    -glob $fileglob\
-                ]
-            }
-            if {$did_skip} {
-                puts -nonewline stdout \n
-            }
-            if {$CALLDEPTH == 0} {
-                $event destroy
-                $installer destroy 
-            }
-            return $module_list
-        }
-
-        variable kettle_reset_bodies [dict create]
-        variable kettle_reset_args [dict create]
-        #We are abusing kettle to run in-process.
-        # when we change to another project we need recipes to be reloaded.
-        # Kettle rewrites some of it's own procs - stopping reloading of recipes when we change folders
-        #kettle_init stores the original proc bodies & args
-        proc kettle_init {} {
-            variable kettle_reset_bodies ;#dict
-            variable kettle_reset_args
-            set reset_procs [list\
-                ::kettle::benchmarks\
-                ::kettle::doc\
-                ::kettle::figures\
-                ::kettle::meta::scan\
-                ::kettle::testsuite\
-            ]
-            foreach p $reset_procs {
-                set b [info body $p]
-                if {[string match "*Overwrite self*" $b]} {
-                    dict set kettle_reset_bodies $p $b
-                    set argnames [info args $p]
-                    set arglist [list]
-                    foreach a $argnames {
-                        if {[info default $p $a dval]} {
-                            lappend arglist [list $a $dval]
-                        } else {
-                            lappend arglist $a
-                        }
-                    }
-                    dict set kettle_reset_args $p $arglist
-                }
-            } 
-
-        }
-        #call kettle_reinit to ensure recipes point to current project
-        proc kettle_reinit {} {
-            variable kettle_reset_bodies
-            variable kettle_reset_args
-            foreach p [dict keys $kettle_reset_bodies] {
-                set b [dict get $kettle_reset_bodies $p]
-                set argl [dict get $kettle_reset_args $p]
-                uplevel 1 [list ::proc $p $argl $b]
-            }
-            #todo - determine standard recipes by examining standard.tcl instead of hard coding?
-            set standard_recipes [list\
-                null\
-                forever\
-                list-recipes\
-                help-recipes\
-                help-dump\
-                help-recipes\
-                help\
-                list\
-                list-options\
-                help-options\
-                show-configuration\
-                show-state\
-                show\
-                meta-status\
-                gui\
-            ]
-            #set ::kettle::recipe::recipe [dict create]
-            foreach r [dict keys $::kettle::recipe::recipe] {
-                if {$r ni $standard_recipes} {
-                    dict unset ::kettle::recipe::recipe $r
-                }
-            }
-        }
-        proc kettle_call {calltype args} {
-            variable kettle_reset_bodies
-            if {$calltype ni [list lib shell]} {
-                error "pmix kettle_call 1st argument must be one of: 'lib' for direct use of kettle module or 'shell' to call as separate process"
-            }
-            if {$calltype eq "shell"} {
-                set kettleappfile [file dirname [info nameofexecutable]]/kettle
-                set kettlebatfile [file dirname [info nameofexecutable]]/kettle.bat
-
-                if {(![file exists $kettleappfile]) && (![file exists $kettlebatfile])} {
-                    error "pmix kettle_call unable to find installed kettle application file '$kettleappfile' (or '$kettlebatfile' if on windows)"
-                }
-                if {[file exists $kettleappfile]} {
-                    set kettlescript $kettleappfile
-                }
-                if {$::tcl_platform(platform) eq "windows"} {
-                    if {[file exists $kettlebatfile]} {
-                        set kettlescript $kettlebatfile
-                    }
-                }
-            }
-            set startdir [pwd]
-            if {![file exists $startdir/build.tcl]} {
-                error "pmix kettle must be run from a folder containing build.tcl (cwd: [pwd])"
-            }
-            if {[package provide kettle] eq ""} {
-                puts stdout "Loading kettle package - may be delay on first load ..."
-                package require kettle
-                kettle_init ;#store original procs for those kettle procs that rewrite themselves
-            } else {
-                if {[dict size $kettle_reset_bodies] == 0} {
-                    #presumably package require kettle was called without calling our kettle_init hack.
-                    kettle_init
-                } else {
-                    #undo proc rewrites
-                    kettle_reinit
-                }
-            }
-            set first [lindex $args 0] 
-            if {[string match @* $first]} {
-                error "pmix kettle doesn't support special operations - try calling tclsh kettle directly"
-            }
-            if {$first eq "-f"} {
-                set args [lassign $args __ path]
-            } else {
-                set path $startdir/build.tcl 
-            }
-            set opts [list]
-
-            if {[lindex $args 0] eq "-trace"} {
-                set args [lrange $args 1 end]
-                lappend opts --verbose on
-            }
-            set goals [list]
-
-            if {$calltype eq "lib"} {
-                file mkdir ~/.kettle
-                set dotfile ~/.kettle/config
-                if {[file exists $dotfile] &&
-                    [file isfile $dotfile] &&
-                    [file readable $dotfile]} {
-                    ::kettle io trace {Loading dotfile $dotfile ...}
-                    set args [list {*}[::kettle path cat $dotfile] {*}$args]
-                }
-            }
-
-            #hardcoded kettle option names (::kettle option names) - retrieved using kettle::option names 
-            #This is done so we don't have to load kettle lib for shell call (both loading as module and running shell are annoyingly SLOW)
-            #REVIEW - needs to be updated to keep in sync with kettle. 
-            set knownopts [list\
-                --exec-prefix --bin-dir --lib-dir --prefix --man-dir --html-dir --markdown-dir --include-dir \
-                --ignore-glob --dry --verbose --machine --color --state --config --with-shell --log \
-                --log-append --log-mode --with-dia --constraints --file --limitconstraints --tmatch --notfile --single --valgrind --tskip --repeats \
-                --iters --collate --match --rmatch --with-doc-destination --with-git --target --test-include \
-                ]
-
-            while {[llength $args]} {
-                set o [lindex $args 0]
-                switch -glob -- $o {
-                    --* {
-                        #instead of using: kettle option known
-                        if {$o ni $knownopts} {
-                            error "Unable to process unknown option $o." {} [list KETTLE (pmix)]
-                        }
-                        lappend opts $o [lindex $args 1]
-                        #::kettle::option set $o [lindex $args 1]
-                        set args [lrange $args 2 end]
-                    }
-                    default {
-                        lappend goals $o
-                        set args [lrange $args 1 end]
-                    }
-                }
-            }
-
-            if {![llength $goals]} {
-                lappend goals help
-            }
-            if {"--prefix" ni [dict keys $opts]} {
-                dict set opts --prefix [file dirname $startdir]
-            }
-            if {$calltype eq "lib"} {
-                ::kettle status clear
-                ::kettle::option::set @kettle $startdir
-                foreach {o v} $opts {
-                    ::kettle option set $o $v
-                }
-                ::kettle option set @srcscript $path
-                ::kettle option set @srcdir [file dirname $path]
-                ::kettle option set @goals $goals
-                #load standard recipes as listed in build.tcl
-                ::source $path
-                puts stderr "recipes: [::kettle recipe names]"
-                ::kettle recipe run {*}[::kettle option get @goals]
-
-                set state [::kettle option get --state]
-                if {$state ne {}} {
-                    puts stderr "saving kettle state: $state"
-                    ::kettle status save $state
-                }
-
-            } else {
-                #shell
-                puts stdout "Running external kettle process with args: $opts $goals"
-                run -n tclsh $kettlescript -f $path {*}$opts {*}$goals
-            }
-
-        }
-        proc kettle_punk_recipes {} {
-            set txtdst ...
-        }
-
-    }
-}
-
-
-namespace eval punk::mix::cli {
-    proc _cli {args} {
-        #don't use tailcall - base uses info level to determine caller
-        ::punk::mix::base::_cli {*}$args
-    }
-    variable default_command help
-    package require punk::mix::base
-    package require punk::overlay
-    punk::overlay::custom_from_base [namespace current] ::punk::mix::base 
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::cli [namespace eval punk::mix::cli {
-    variable version
-    set version 0.3 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/buildsuite-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/buildsuite-0.1.0.tm
deleted file mode 100644
index 883e02d2..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/buildsuite-0.1.0.tm
+++ /dev/null
@@ -1,152 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::buildsuite 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::buildsuite {
-    namespace export *
-    proc projects {suite} {
-        set pathinfo [punk::repo::find_repos [pwd]]
-        set projectdir [dict get $pathinfo closest]
-        set suites_dir [file join $projectdir src buildsuites]
-        if {![file isdirectory [file join $suites_dir $suite]]} {
-            puts stderr "suite: $suite not found in buildsuites folder: $suites_dir"
-            return
-        }
-        set suite_dir [file join $suites_dir $suite]
-        set projects [glob -dir $suite_dir -type d -tails *]
-
-        #use internal du which although breadth-first is generally faster
-        puts stdout "Examining source folders in $suite_dir." ;#A hint that something is happening in case sources are large
-        set du_info [punk::du::du -d 1 -b $suite_dir]
-        set du_sizes [dict create]
-        set suite_total_size "-" 
-        foreach du_record $du_info {
-            if {[llength $du_record] != 2} {
-                #sanity precaution - punk::du::du should always output list of 2 element lists - at least with flags we're using
-                continue
-            }
-            set sz [lindex $du_record 0]
-            set path_parts [file split [lindex $du_record 1]] ;#should handle spaced-paths ok.
-            set s [lindex $path_parts end-1]
-            set p [lindex $path_parts end]
-            
-            #This handles case where a project folder is same name as suite  e.g src/buildsuites/tcl/tcl
-            #so we can't just use tail as dict key. We could assume last record is always total - but 
-            if {![string match -nocase $s $suite]} {
-                if {$s eq "buildsuites" && [string match -nocase $p $suite]} {
-                    set suite_total_size $sz ;#this includes config files in suite base - so we don't really want to use this to report the total source size
-                } else {
-                    #something else - shouldn't happen
-                    puts stderr "Unexpected output from du in suite_dir: $suite_dir"
-                    puts stderr "$du_record"
-                    #try to continue anyway
-                }
-            } else {
-                dict set du_sizes $p $sz
-            }
-        }
-
-        #build another dict for sizes where we ensure exactly one entry for each project exists and exclude total (don't blindly trust du output e.g in case weird filename/permission issue)
-        set psizes [list]
-        foreach p $projects {
-            if {[dict exists $du_sizes $p]} {
-                dict set psizes $p [dict get $du_sizes $p]
-            } else {
-                dict set psizes $p -
-            }
-        }
-        set total_source_size "-"
-        if {[catch {
-            set total_source_size [tcl::mathop::+ {*}[dict values $psizes]]
-        } errM]} {
-            puts stderr "Failed to calculate total source size. Errmsg: $errM"
-        }
-        package require overtype
-
-        set title1 "Projects"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $projects] {punk::strlen $v}]]
-        set col1 [string repeat " " $widest1] 
-
-        set size_values [dict values $psizes]
-        # Title is probably widest - but go through the process anyway!
-        set title2 "Source Bytes"
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $size_values] {punk::strlen $v}]]
-        set col2 [string repeat " " $widest2]
-
-
-        set output ""
-        append output "[overtype::left $col1 $title1] [overtype::right $col2 $title2]" \n
-        foreach p [lsort $projects] {
-            #todo - provide some basic info for each - last build time? last time-to-build?
-            append output "[overtype::left $col1 $p] [overtype::right $col2 [dict get $psizes $p]]" \n
-        }
-        append output "Total Source size: $total_source_size bytes" \n
-        return $output
-    }
-
-
-    namespace eval collection {
-        namespace export *
-        proc _default {{glob {}}} {
-            if {![string length $glob]} {
-                set glob *
-            }
-            #todo - review - we want the furthest not the closest if we are potentially inside a buildsuite project
-            set pathinfo [punk::repo::find_repos [pwd]]
-            set projectdir [dict get $pathinfo closest]
-            set suites_dir [file join $projectdir src buildsuites]
-            if {![file exists $suites_dir]} {
-                puts stderr "No buildsuites folder found at $suites_dir"
-                return
-            }
-            set suites [lsort [glob -dir $suites_dir -type d -tails *]]
-            if {$glob ne "*"} {
-                set suites [lsearch -all -inline $suites $glob]
-            }
-            return $suites
-        }
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::buildsuite [namespace eval punk::mix::commandset::buildsuite {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/debug-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/debug-0.1.0.tm
deleted file mode 100644
index 8ed735c1..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/debug-0.1.0.tm
+++ /dev/null
@@ -1,92 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::debug 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::debug {
-    namespace export get paths
-    namespace path ::punk::mix::cli
-
-    #Except for 'get' - all debug commands should emit to stdout 
-    proc paths {} {
-        set out ""
-        puts stdout "find_repos output:" 
-        set pathinfo [punk::repo::find_repos [pwd]]
-        pdict $pathinfo
-
-        set projectdir [dict get $pathinfo closest]
-        set modulefolders [lib::find_source_module_paths $projectdir]
-        puts stdout "modulefolders: $modulefolders"
-
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-        puts stdout "get_template_basefolders output:"
-        pdict $template_base_dict
-        return 
-    }
-
-    #call other debug command - but capture stdout as return value
-    proc get {args} {
-        set nm [lindex $args 0]
-        if {$nm eq ""} {
-            set nscmds [info commands [namespace current]::*]
-            set cmds [lmap v $nscmds {namespace tail $v}]
-            error "debug.get missing debug command argument. Try one of: $cmds"
-            return
-        }
-        set nextargs [lrange $args 1 end]
-        set out ""
-        if {[info commands [namespace current]::$nm] ne ""} {
-            append out [runout -n -tcl  [namespace current]::$nm {*}$nextargs] \n
-        } else {
-            set nscmds [info commands [namespace current]::*]
-            set cmds [lmap v $nscmds {namespace tail $v}]
-            error "debug.get invalid debug command '$nm' Try one of: $cmds"
-        }
-        return $out
-    }
-    namespace eval lib {
-
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::debug [namespace eval punk::mix::commandset::debug {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm
deleted file mode 100644
index 36a654b7..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/doc-0.1.0.tm
+++ /dev/null
@@ -1,286 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::doc 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-package require punk::path ;# for treefilenames, relative
-package require punk::repo
-package require punk::docgen ;#inline doctools - generate doctools .man files at src/docgen prior to using kettle to producing .html .md etc
-package require punk::mix::cli  ;#punk::mix::cli::lib used for kettle_call
-#package require punk::mix::util ;#for path_relative
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::doc {
-    namespace export *
-
-    proc _default {} {
-        puts "documentation subsystem"
-        puts "commands: doc.build"
-        puts "        build documentation from src/doc to src/embedded using the kettle build tool"
-    }
-
-    proc build {} {
-        puts "build docs"
-        set projectdir [punk::repo::find_project]
-        if {$projectdir eq ""} {
-            puts stderr "No current project dir - unable to build docs"
-            return
-        }
-        #user may delete the comment containing "--- punk::docgen::overwrites" and then manually edit, and we won't overwrite
-        #we still generate output in src/docgen so user can diff and manually update if thats what they prefer
-        set oldfiles [punk::path::treefilenames $projectdir/src/doc _module_*.man]
-        foreach maybedoomed $oldfiles {
-            set fd [open $maybedoomed r]
-            set data [read $fd]
-            close $fd
-            if {[string match "*--- punk::docgen overwrites *" $data]} {
-                file delete -force $maybedoomed
-            }
-        }
-        set generated [lib::do_docgen modules]
-        if {[dict get $generated count] > 0} {
-            #review
-            set doclist [dict get $generated docs]
-            set source_base [dict get $generated base]
-            set target_base $projectdir/src/doc
-            foreach dinfo $doclist {
-                lassign $dinfo module fpath
-                set relpath [punk::path::relative $source_base $fpath]
-                set relfolder [file dirname $relpath]
-                if {$relfolder eq "."} {
-                    set relfolder ""
-                }
-                file mkdir [file join $target_base $relfolder]
-                set target [file join $target_base $relfolder _module_[file tail $fpath]]
-                puts stderr "target --> $target"
-                if {![file exists $target]} {
-                    file copy $fpath $target
-                }
-            }
-        }
-
-        if {[file exists $projectdir/src/doc]} {
-            set original_wd [pwd]
-            cd $projectdir/src
-            #----------
-            set installer [punkcheck::installtrack new project.new $projectdir/src/.punkcheck]
-            $installer set_source_target $projectdir/src/doc $projectdir/src/embedded
-            set event [$installer start_event {-install_step kettledoc}]
-            #use same virtual id "kettle_build_doc" as project.new - review best way to keep identifiers like this in sync. 
-            $event targetset_init VIRTUAL kettle_build_doc ;#VIRTUAL - since there is no specific target file - and we don't know all the files that will be generated
-            $event targetset_addsource $projectdir/src/doc  ;#whole doc tree is considered the source 
-            #----------
-            if {\
-                    [llength [dict get [$event targetset_source_changes] changed]]\
-                } {
-                $event targetset_started
-                # -- --- --- --- --- ---
-                puts stdout "BUILDING DOCS at $projectdir/src/embedded from src/doc"
-                if {[catch {
-
-                    punk::mix::cli::lib::kettle_call lib doc
-                    #Kettle doc
-
-                } errM]} {
-                    $event targetset_end FAILED -note "kettle_build_doc failed: $errM"
-                } else {
-                    $event targetset_end OK
-                }
-                # -- --- --- --- --- ---
-            } else {
-                puts stderr "No change detected in src/doc"
-                $event targetset_end SKIPPED
-            }
-            $event end
-            $event destroy
-            $installer destroy
-            cd $original_wd
-        } else {
-            puts stderr "No doc folder found at $projectdir/src/doc"
-        }
-    }
-    proc status {} {
-        set projectdir [punk::repo::find_project]
-        if {$projectdir eq ""} {
-            puts stderr "No current project dir - unable to check doc status"
-            return
-        }
-        if {![file exists $projectdir/src/doc]} {
-            set result "No documentation source found. Expected .man files in doctools format at $projectdir/src/doc"
-            return $result
-        }
-        set original_wd [pwd]
-        cd $projectdir/src
-        puts stdout "Testing status of doctools source location $projectdir/src/doc ..."
-        flush stdout
-        #----------
-        set installer [punkcheck::installtrack new project.new $projectdir/src/.punkcheck]
-        $installer set_source_target $projectdir/src/doc $projectdir/src/embedded
-        set event [$installer start_event {-install_step kettledoc}]
-        #use same virtual id "kettle_build_doc" as project.new - review best way to keep identifiers like this in sync. 
-        $event targetset_init QUERY kettle_build_doc ;#usually VIRTUAL - since there is no specific target file - and we don't know all the files that will be generated - but here we use QUERY to ensure no writes to .punkcheck
-        set last_completion [$event targetset_last_complete]
-
-        if {[llength $last_completion]} {
-            #adding a source causes it to be checksummed
-            $event targetset_addsource $projectdir/src/doc  ;#whole doc tree is considered the source 
-            #----------
-            set changeinfo [$event targetset_source_changes]
-            if {\
-                    [llength [dict get $changeinfo changed]]\
-                } {
-                    puts stdout "changed"
-                    puts stdout $changeinfo
-            } else {
-                puts stdout "No changes detected in $projectdir/src/doc tree"
-            }
-        } else {
-            #no previous completion-record for this target - must assume changed - no need to trigger checksumming
-            puts stdout "No existing record of doc build in .punkcheck. Assume it needs to be rebuilt."
-        }
-
-
-        $event destroy
-        $installer destroy
-
-        cd $original_wd
-    }
-    proc validate {} {
-        #todo - run and validate punk::docgen output
-        set projectdir [punk::repo::find_project]
-        if {$projectdir eq ""} {
-            puts stderr "No current project dir - unable to check doc status"
-            return
-        }
-        if {![file exists $projectdir/src/doc]} {
-            set result "No documentation source found. Expected .man files in doctools format at $projectdir/src/doc"
-            return $result
-        }
-        set original_wd [pwd]
-        set docroot $projectdir/src/doc
-        cd $docroot
-
-        dtplite validate  $docroot
-
-        #punk::mix::cli::lib::kettle_call lib validate-doc
-
-        cd $original_wd
-    }
-
-    namespace eval collection {
-        variable pkg
-        set pkg punk::mix::commandset::doc
-
-        namespace export *
-        namespace path [namespace parent]
-
-    }
-
-    namespace eval lib {
-        variable pkg
-        set pkg punk::mix::commandset::doc
-        proc  do_docgen {{project_subpath modules}} {
-            #Extract doctools comments from source code
-            set projectdir [punk::repo::find_project]
-            set output_base [file join $projectdir src docgen]
-            set codesource_path [file join $projectdir $project_subpath]
-            if {![file isdirectory $codesource_path]} {
-                puts stderr "WARNING punk::mix::commandset::doc unable to find codesource_path $codesource_path during do_docgen - skipping inline doctools generation"
-                return
-            }
-            if {[file isdirectory $output_base]} {
-                if {[catch {
-                    file delete -force $output_base
-                }]}  {
-                    error "do_docgen failed to delete existing output base folder: $output_base"
-                }
-            }
-            file mkdir $output_base
-
-            set matched_paths [punk::path::treefilenames $codesource_path *.tm -antiglob_paths {**/mix/templates/** **/mixtemplates/**}]
-            set count 0
-            set newdocs [list] 
-            set docgen_header_comments ""
-            append docgen_header_comments {[comment {--- punk::docgen generated from inline doctools comments ---}]} \n
-            append docgen_header_comments {[comment {--- punk::docgen DO NOT EDIT DOCS HERE UNLESS YOU REMOVE THESE COMMENT LINES ---}]} \n
-            append docgen_header_comments {[comment {--- punk::docgen overwrites this file ---}]} \n
-            foreach fullpath $matched_paths {
-                set doctools [punk::docgen::get_doctools_comments $fullpath] 
-                if {$doctools ne ""} {
-                    set fname [file tail $fullpath]
-                    set mod_tail [file rootname $fname] 
-                    set relpath [punk::path::relative $codesource_path [file dirname $fullpath]]
-                    if {$relpath eq "."} {
-                        set relpath ""
-                    }
-                    set tailsegs [file split $relpath]
-                    set module_fullname [join $tailsegs ::]::$mod_tail
-                    set target_docname $fname.man
-                    set this_outdir [file join $output_base $relpath]
-
-                    if {[string length $fname] > 99} {
-                        #output needs to be tarballed to do checksum change tests in a reasonably straightforward and not-too-terribly slow way.
-                        #hack - review. Determine exact limit - test if tcllib tar fixed or if it's a limit of the particular tar format
-                        #work around tcllib tar filename length limit ( somewhere around 100?) This seems to be a limit on the length of a particular segment in the path.. not whole path length?
-                        #this case only came up because docgen used to path munge to long filenames - but left because we know there is a limit and renaming fixes it - even if it's ugly - but still allows doc generation.
-                        #review - if we're checking fname - should also test length of whole path and determine limits for tar
-                        package require md5
-                        set target_docname [md5::md5 -hex $fullpath]_overlongfilename.man
-                        puts stderr "WARNING - overlong file name - renaming $fullpath"
-                        puts stderr "          to                            [file dirname $fullpath]/$target_docname"
-                    }
-
-                    file mkdir $this_outdir
-                    puts stdout "saving [string length $doctools] bytes of doctools output from file $relpath/$fname"
-                    set outfile [file join $this_outdir $target_docname]
-                    set fd [open $outfile w]
-                    fconfigure $fd -translation binary
-                    puts -nonewline $fd $docgen_header_comments$doctools
-                    close $fd
-                    incr count
-                    lappend newdocs [list $module_fullname $outfile]
-                }
-            }
-            return [list count $count docs $newdocs base $output_base]
-        }
-
-    }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::doc [namespace eval punk::mix::commandset::doc {
-    variable pkg punk::mix::commandset::doc
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm
deleted file mode 100644
index 0a9ff2d4..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/layout-0.1.0.tm
+++ /dev/null
@@ -1,188 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::layout 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-#sort of a circular dependency when commandset loaded by punk::mix::cli - that's ok, but this could theoretically be loaded by another cli and with another base
-package require punk::mix
-package require punk::mix::base
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::layout {
-    namespace export *
-
-    #per layout functions
-    proc files {layout} {
-        set allfiles [lib::layout_all_files $layout]
-        return [join $allfiles \n]
-    }
-    proc templatefiles {layout} {
-        set templatefiles [lib::layout_scan_for_template_files $layout]
-        return [join $templatefiles \n]
-    }
-    proc templatefiles.relative {layout} {
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-
-        set bases_containing_layout [list]
-        dict for {tbase folderinfo} $template_base_dict {
-           if {[file exists $tbase/layouts/$layout]} {
-                lappend bases_containing_layout $tbase
-           } 
-        }
-        if {![llength $bases_containing_layout]} {
-            puts stderr "Unable to locate folder for layout '$layout'"
-            puts stderr "searched [dict size $template_base_dict] template folders"
-            return
-        }
-        set tpldir [lindex $bases_containing_layout end]
-
-        set layout_base $tpldir/layouts
-        set layout_dir [file join $layout_base $layout]
-
-        set stripprefix [file normalize $layout_dir]
-        set templatefiles [lib::layout_scan_for_template_files $layout]
-        set tails [list]
-        foreach templatefullpath $templatefiles {
-            lappend tails [punk::repo::path_strip_alreadynormalized_prefixdepth $templatefullpath $stripprefix]
-        }
-        return [join $tails \n]
-    }
-
-    #layout collection functions - to be imported with punk::overlay::import_commandset separately
-    namespace eval collection {
-        namespace export *
-        proc _default {{glob {}}} {
-            if {![string length $glob]} {
-                set glob *
-            }
-            set layouts [list]
-            #set tplfolderdict [punk::cap::call_handler punk.templates folders]
-            set tplfolderdict [punk::mix::base::lib::get_template_basefolders]
-            dict for {tdir folderinfo} $tplfolderdict {
-                set layout_base $tdir/layouts
-                #collect all layouts and use lsearch glob rather than the filesystem glob (avoid issues with dotted folder names)
-                set all_layouts [lsort [glob -nocomplain -dir $layout_base -type d -tail *]]
-                foreach match [lsearch -all -inline $all_layouts $glob] {
-                   lappend layouts [list $match $folderinfo] 
-                }
-            }
-            return [join [lsort -index 0 $layouts] \n]
-        }
-
-    }
-    namespace eval lib {
-        proc layout_all_files {layout} {
-            set tplbasedict [punk::mix::base::lib::get_template_basefolders]
-            set layouts_found [list]
-            dict for {tplbase folderinfo} $tplbasedict {
-                if {[file isdirectory $tplbase/layouts/$layout]} {
-                    lappend layouts_found $tplbase/layouts/$layout
-                }
-            } 
-            if {![llength $layouts_found]} {
-                puts stderr "layout '$layout' not found."
-                puts stderr "searched [dict size $tplbasedict] template folders"
-                dict for {tplbase pkg} $tplbasedict {
-                    puts stderr " - $tplbase $pkg"
-                }
-                return
-            }
-            set layoutfolder [lindex $layouts_found end]
-
-            if {![file isdirectory $layoutfolder]} {
-                puts stderr "layout '$layout' not found in /layouts within one of template_folders. (get_template_folder returned: $tplbasedict)"
-            }
-            set file_list [list] 
-            util::foreach-file $layoutfolder path {
-                lappend file_list $path
-            }
-
-            return $file_list
-        }
-
-        # 
-        #todo - allow specifying which package the layout is from:  e.g "punk::mix::templates project" ??
-        proc layout_scan_for_template_files {layout {tags {}}} {
-            #equivalent for projects? punk::mix::commandset::module::lib::templates_dict  -scriptpath "" 
-            set tplbasedict [punk::mix::base::lib::get_template_basefolders]
-            set layouts_found [list]
-            dict for {tpldir pkg} $tplbasedict {
-                if {[file isdirectory $tpldir/layouts/$layout]} {
-                    lappend layouts_found $tpldir/layouts/$layout
-                }
-            } 
-            if {![llength $layouts_found]} {
-                puts stderr "layout '$layout' not found."
-                puts stderr "searched [dict size $tplbasedict] template folders"
-                dict for {tpldir pkg} $tplbasedict {
-                    puts stderr " - $tpldir $pkg"
-                }
-                return
-            }
-            set layoutfolder [lindex $layouts_found end]
-
-            #use last matching layout found.  review silent if multiple?
-            if {![llength $tags]} {
-                #todo - get standard tags from somewhere
-                set tagnames [list project]
-                foreach tn $tagnames {
-                    lappend tags [string cat % $tn %]
-                }
-            }
-            set file_list [list] 
-            util::foreach-file $layoutfolder path {
-                set fd [open $path r]
-                fconfigure $fd -translation binary
-                set data [read $fd]
-                close $fd
-                foreach tag $tags {
-                    if {[string match "*$tag*" $data]} {
-                        lappend file_list $path
-                    }
-                }
-            }
-
-            return $file_list
-        }
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::layout [namespace eval punk::mix::commandset::layout {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm
deleted file mode 100644
index 0028c439..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/loadedlib-0.1.0.tm
+++ /dev/null
@@ -1,529 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::loadedlib 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require punk::ns
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::loadedlib {
-    namespace export *
-    #search automatically wrapped in * * - can contain inner * ? globs
-    proc search {searchstring} {
-        catch {package require frobznodule666} ;#ensure pkg system has loaded/searched for everything
-        if {[catch {package require natsort}]} {
-            set has_natsort 0
-        } else {
-            set has_natsort 1
-        }
-        if {[regexp {[?*]} $searchstring]} {
-            #caller has specified specific glob pattern - use it
-            #todo - respect supplied case only if uppers present? require another flag?
-            set matches [lsearch -all -inline -nocase [package names] $searchstring]
-        } else {
-            #make it easy to search for anything
-            set matches [lsearch -all -inline -nocase [package names] "*$searchstring*"]
-        }
-
-        set matchinfo [list]
-        foreach m $matches {
-            set versions [package versions $m]
-            if {$has_natsort} {
-                set versions [natsort::sort $versions]
-            } else {
-                set versions [lsort $versions]
-            }
-            lappend matchinfo [list $m $versions]
-        }
-        return [join [lsort $matchinfo] \n]
-    }
-    proc loaded.search {searchstring} {
-        set search_result [search $searchstring]
-        set all_libs [split $search_result \n]
-        set col1items [list]
-        set col2items [list]
-        set col3items [list]
-        foreach libinfo $all_libs {
-            if {[string trim $libinfo] eq ""} {
-                continue
-            }
-            set versions [lassign $libinfo libname]
-            if {[set ver [package provide $libname]] ne ""} {
-                lappend col1items $libname
-                lappend col2items $versions
-                lappend col3items $ver
-            }
-        }
-
-        package require overtype
-        set title1 "Library"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {string length $v}]]
-        set col1 [string repeat " " $widest1]
-        set title2 "Versions Avail."
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {string length $v}]]
-        set col2 [string repeat " " $widest2]
-        set title3 "Loaded Version"
-        set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {string length $v}]]
-        set col3 [string repeat " " $widest3]
-
-
-        set tablewidth [expr {$widest1 + 1 + $widest2 + 1 + $widest3}]
-
-        set table ""
-        append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col1 $title1] [overtype::left $col2 $title2] [overtype::left $col3 $title3]" \n
-        append table [string repeat - $tablewidth] \n
-        foreach c1 $col1items c2 $col2items c3 $col3items {
-            append table "[overtype::left $col1 $c1] [overtype::left $col2 $c2] [overtype::left $col3 $c3]" \n
-        }
-
-        return $table
-
-
-        set loaded_libs [list]
-        foreach libinfo $all_libs {
-            if {[string trim $libinfo] eq ""} {
-                continue
-            }
-            set versions [lassign $libinfo libname]
-            if {[set ver [package provide $libname]] ne ""} {
-                lappend loaded_libs "$libname $versions (loaded $ver)"
-            }
-        }
-        return [join $loaded_libs \n]
-    }
-
-    proc info {libname} {
-        if {[catch {package require natsort}]} {
-            set has_natsort 0
-        } else {
-            set has_natsort 1
-        }
-        catch {package require frobznodule666} ;#ensure pkg system has loaded/searched for everything
-        set pkgsknown [package names]
-        if {[set posn [lsearch $pkgsknown $libname]] >= 0} {
-            puts stdout "Found package [lindex $pkgsknown $posn]"
-        } else {
-            puts stderr "Package not found as available library/module - check tcl::tm::list and \$auto_path"
-        }
-        set versions [package versions [lindex $libname 0]]
-        if {$has_natsort} {
-            set versions [natsort::sort $versions]
-        } else {
-            set versions [lsort $versions]
-        }
-        if {![llength $versions]} {
-            puts stderr "No version numbers found for library/module $libname"
-            return false
-        }
-        puts stdout "Versions of $libname found: $versions"
-        set alphaposn [lsearch $versions "999999.*"]
-        if {$alphaposn >= 0} {
-            set alpha [lindex $versions $alphaposn]
-            #remove and tack onto beginning..
-            set versions [lreplace $versions $alphaposn $alphaposn] 
-            set versions [list $alpha {*}$versions]
-        }
-        foreach ver $versions {
-            set loadinfo [package ifneeded $libname $ver]
-            puts stdout "$libname $ver"
-            puts stdout "--- 'package ifneeded' script ---"
-            puts stdout $loadinfo
-            puts stdout "---"
-        }
-        return
-    }
-
-    proc copyasmodule {library modulefoldername args} {
-        set defaults [list -askme 1]
-        set opts [dict merge $defaults $args]
-        set opt_askme [dict get $opts -askme]
-
-        if {[catch {package require natsort}]} {
-            set has_natsort 0
-        } else {
-            set has_natsort 1
-        }
-
-        catch {package require frobznodule666} ;#ensure pkg system has loaded/searched for everything
-
-        if {[file pathtype $modulefoldername] eq "absolute"} {
-            if {![file exists $modulefoldername]} {
-                error "Path '$modulefoldername' not found. Enter a fully qualified path, or just the tail such as 'modules' if you are within the project to use <projectdir>/src/modules"
-            }
-            #use the target folder as the source of projectdir info
-            set pathinfo [punk::repo::find_repos $modulefoldername]
-            set projectdir [dict get $pathinfo closest]
-            set modulefolder_path $modulefoldername
-        } else {
-            #use the current working directory as the source of projectdir info
-            set pathinfo [punk::repo::find_repos [pwd]]
-            set projectdir [dict get $pathinfo closest]
-            if {$projectdir ne ""} {
-                set modulefolders [punk::mix::cli::lib::find_source_module_paths $projectdir]
-                foreach k [list modules vendormodules] {
-                    set knownfolder [file join $projectdir src $k]
-                    if {$knownfolder ni $modulefolders} {
-                        lappend modulefolders $knownfolder
-                    }
-                }
-                set mtails [list]
-                foreach path $modulefolders {
-                    lappend mtails [file tail $path]
-                }
-
-                #special case bootsupport/modules so it can be referred to as just bootsupport or bootsupport/modules
-                lappend modulefolders [file join $projectdir src bootsupport/modules]
-
-                if {$modulefoldername ni $mtails && $modulefoldername ni "bootsupport bootsupport/modules"} {
-                    set msg "Suplied modulefoldername '$modulefoldername' doesn't appear to be a known module folder within the project at $projectdir\n"
-                    append msg "Known module folders: [lsort $mtails]\n"
-                    append msg "Use a name from the above list, or a fully qualified path\n"
-                    error $msg
-                }
-
-                if {$modulefoldername eq "bootsupport"} {
-                    set modulefoldername "bootsupport/modules"
-                }
-                set modulefolder_path [file join $projectdir src $modulefoldername]
-            } else {
-                set msg     "No current project found at or above current directory\n"
-                append msg  "Supplied modulefoldername '$modulefoldername' is a name or relative path - cannot use when outside a project." \n
-                append msg  "Supply an absolute path for the target modulefolder, or try again from within a project directory" \n
-                error $msg
-            }
-        }
-        puts stdout "-----------------------------"
-        if {$projectdir ne ""} {
-            puts stdout "Using projectdir: $projectdir for lib.copyasmodule"
-        } else {
-            puts stdout "No current project."
-        }
-        puts stdout "-----------------------------"
-        if {![file exists $modulefolder_path]} {
-            error "Selected module folder path '$modulefolder_path' doesn't exist. Required subdirectories for namespaced modules will be created automatically - but base selected folder must exist first"
-        }
-
-       
-        set libfound [lsearch -all -inline [package names] $library]
-        if {[llength $libfound] != 1 || ![string length $libfound]} {
-            error "Library must match exactly one entry in the list of package names visible to the current interpretor: found '$libfound'"
-        }
-
-        set versions [package versions [lindex $libfound 0]]
-        if {$has_natsort} {
-            set versions [natsort::sort $versions]
-        } else {
-            set versions [lsort $versions]
-        }
-        if {![llength $versions]} {
-            error "No version numbers found for library/module $libfound - sorry, you will need to copy it across manually"
-        }
-        puts stdout "Versions of $libfound found: $versions"
-        set alphaposn [lsearch $versions "999999.*"]
-        if {$alphaposn >= 0} {
-            set alpha [lindex $versions $alphaposn]
-            #remove and tack onto beginning..
-            set versions [lreplace $versions $alphaposn $alphaposn] 
-            set versions [list $alpha {*}$versions]
-        }
-
-        set ver [lindex $versions end] ;# todo - make selectable! don't assume tail is latest?.. package vcompare?
-        if {[llength $versions] > 1} {
-            puts stdout  "Version selected: $ver"
-        }
-
-        set loadinfo [package ifneeded $libfound $ver]
-        set loadinfo [string map [list \r\n \n] $loadinfo]
-        set loadinfo_lines [split $loadinfo \n]
-        if {[catch {llength $loadinfo}]} {
-            set loadinfo_is_listshaped 0
-        } else {
-            set loadinfo_is_listshaped 1
-        }
-        
-        #check for redirection to differently cased version of self - this is only detected if this is the only command in the package ifneeded result
-        #- must have matching version. REVIEW this requirement. Is there a legitimate reason to divert to a differently cased other-version?
-        set is_package_require_self_recased 0
-        set is_package_require_diversion 0
-        set lib_diversion_name ""
-        if {[llength $loadinfo_lines] == 1} {
-            #e.g Thread 3.0b1 diverts to thread 3.0b1
-            set line1 [lindex $loadinfo_lines 0]
-            #check if multiparted with semicolon
-            #We need to distinguish "package require <lib> <ver>; more stuff"  from "package require <lib> ver> ;"  possibly with trailing comment?
-            set parts [list]
-            if {[regexp {;} $line1]} {
-                foreach p [split $line1 {;}] {
-                    set p [string trim $p]
-                    if {[string length $p]} {
-                        #only append parts with some content that doesn't look like a comment
-                        if {![string match "#*" $p]} {
-                            lappend parts $p
-                        }
-                    }
-                }
-
-            }
-            if {[llength $parts] == 1} {
-                #seems like a lone package require statement.
-                #check if package require, package\trequire etc
-                if {[string match "package*require" [lrange $line1 0 1]]} {
-                    set is_package_require_diversion 1
-                    if {[lindex $line1 2] eq "-exact"} {
-                        #package require -exact <pkg> <ver>
-                        set lib_diversion_name [lindex $line1 3]
-                        #check not an exact match - but is a -nocase match - i.e differs in case only
-                        if {($lib_diversion_name ne $libfound) && [string match -nocase $lib_diversion_name $libfound]} {
-                            if {[lindex $line1 4] eq $ver} {
-                                set is_package_require_self_recased 1
-                            } 
-                        }
-                    } else {
-                        #may be package require <pkg> <ver>
-                        #or package require <pkg> <ver> ?<ver>?...
-                        set lib_diversion_name [lindex $line1 2]
-                        #check not an exact match - but is a -nocase match - i.e differs in case only
-                        if {($lib_diversion_name ne $libfound) && [string match -nocase $lib_diversion_name $libfound]} {
-                            set requiredversions [lrange $line1 3 end]
-                            if {$ver in $requiredversions} {
-                                set is_package_require_self_recased 1
-                            }
-                        }
-                    }
-                } 
-            }
-        }
-
-        if {$is_package_require_self_recased && [string length $lib_diversion_name]} {
-            #we only follow one level of package require redirection - seems unlikely/imprudent to follow arbitrarily in a while loop(?)    
-            set libfound $lib_diversion_name
-            set loadinfo [package ifneeded $libfound $ver]
-            set loadinfo [string map [list \r\n \n] $loadinfo]
-            set loadinfo_lines [split $loadinfo \n]
-            if {[catch {llength $loadinfo}]} {
-                set loadinfo_is_listshaped 0
-            } else {
-                set loadinfo_is_listshaped 1
-            }
-
-
-        } else {
-            if {$is_package_require_diversion} {
-                #single 
-                #for now - we'll abort and tell the user to run again with specified pkg/version
-                #We could automate - but it seems likely to be surprising.
-                puts stderr "Loadinfo for $libfound seems to be diverting to another pkg/version: $loadinfo_lines"
-                puts stderr "Review and consider trying with the pkg/version described in the result above."
-                return
-            }
-        }
-
-
-        if {$loadinfo_is_listshaped && ([llength $loadinfo] == 2 && [lindex $loadinfo 0] eq "source")} {
-            set source_file [lindex $loadinfo 1]
-        } elseif {[string match "*source*" $loadinfo]} {
-            set parts [list]
-            foreach ln $loadinfo_lines {
-                if {![string length $ln]} {continue}
-                lappend parts {*}[split $ln ";"]
-            }
-            set sources_found [list]
-            set loads_found [list]
-            set dependencies [list]
-            set incomplete_lines [list]
-            foreach p $parts {
-                set p [string trim $p]
-                if {![string length $p]} {
-                    continue ;#empty line or trailing colon
-                }
-                if {[string match "*tclPkgSetup*" $p]} {
-                    puts stderr "Unable to process load script for library $libfound"
-                    puts stderr "The library appears to use the deprecated tcl library support utility 'tclPkgSetup'"
-                    return false
-                }
-                if {![::info complete $p]} {
-                    #
-                    #probably a perfectly valid script - but slightly more complicated than we can handle
-                    #better to defer to manual processing
-                    lappend incomplete_lines $p
-                    continue
-                }
-                if {[lindex $p 0] eq "source"} {
-                    #may have args.. e.g -encoding utf-8
-                    lappend sources_found [lindex $p end]
-                }
-                if {[lindex $p 0] eq "load"} {
-                    lappend loads_found [lrange $p 1 end]
-                }
-                if {[lrange $p 0 1] eq "package require"} {
-                    lappend dependencies [lrange $p 2 end]
-                }
-            }
-            if {[llength $incomplete_lines]} {
-                puts stderr "unable to interpret load script for library $libfound"
-                puts stderr "Load info: $loadinfo"
-                return false
-            }
-            if {[llength $loads_found]} {
-                puts stderr "package $libfound appears to have binary components"
-                foreach l $loads_found {
-                    puts stderr " binary - $l"
-                }
-                foreach s $sources_found {
-                    puts stderr " script - $s"
-                } 
-                puts stderr "Unable to automatically copy binary libraries to your module folder."
-                return false 
-            }
-
-            if {[llength $sources_found] != 1} {
-                puts stderr "sorry - unable to interpret source library location"
-                puts stderr "Only 1 source supported for now"
-                puts stderr "Load info: $loadinfo"
-                return false
-            }
-            if {[llength $dependencies]} {
-                #todo - check/ignore if dependency is Tcl ?
-                puts stderr "WARNING the package appears to depend on at least one other. Review and copy dependencies if required."
-                foreach d $dependencies {
-                    puts stderr " - $d"
-                }
-            } 
-
-            set source_file [lindex $sources_found 0]
-        } else {
-            puts stderr "sorry - unable to interpret source library location"
-            puts stderr "Load info: $loadinfo"
-            return false
-        }
-
-        # -- ---------------------------------------
-        #Analyse source file
-        if {![file exists $source_file]} {
-            error "Unable to verify source file existence at: $source_file"
-        }
-        set source_data [fcat $source_file -translation binary] 
-        if {![string match "*package provide*" $source_data]} {
-            puts stderr "Sorry - unable to verify source file contains 'package provide' statement of some sort  - copy manually"
-            return false
-        } else {
-            if {![string match "*$libfound*" $source_data]} {
-                # as an exception - look for the specific 'package provide $pkg $version' as occurs in the auto-name auto-version modules
-                #e.g anyname-0.1.tm example
-                if {![string match "*package provide \$pkg \$version*" $source_data]} {
-                    puts stderr "Sorry - unable to verify source file contains 'package provide' and '$libfound' - copy manually"
-                    return false
-                }
-            }
-        }
-
-
-        if {[string match "*lappend ::auto_path*" $source_data] || [string match "*lappend auto_path*" $source_data] || [string match "*set ::auto_path*" $source_data]} {
-            puts stderr "Sorry - '$libfound' source file '$source_file' appears to rely on ::auto_path and can't be automatically copied as a .tm module"
-            puts stderr "Copy the library across to a lib folder instead"
-            return false
-        }
-        # -- ---------------------------------------
-
-        set moduleprefix [punk::ns::nsprefix $libfound]
-        if {[string length $moduleprefix]} {
-            set moduleprefix_parts [punk::ns::nsparts $moduleprefix]
-            set relative_path [file join {*}$moduleprefix_parts]
-        } else {
-            set relative_path ""
-        }
-        set pkgtail [punk::ns::nstail $libfound] 
-        set target_path [file join $modulefolder_path $relative_path ${pkgtail}-${ver}.tm]
-
-        if {$opt_askme} {
-            puts stdout "WARNING - you should check that there aren't extra required files for the library/modules"
-            puts stdout ""
-            puts stdout "This is not intended for binary modules - use at own risk and check results"
-            puts stdout ""
-            puts stdout "Base module path: $modulefolder_path"
-            puts stdout "Target path     :  $target_path"
-            puts stdout "results of 'package ifneeded $libfound'"
-            puts stdout "---"
-            puts stdout "$loadinfo"
-            puts stdout "---"
-            puts stdout "Proceed to create ${pkgtail}-${ver}.tm module? Y|N" 
-            set stdin_state [fconfigure stdin]
-            fconfigure stdin -blocking 1 
-            set answer [string tolower [gets stdin]]
-            fconfigure stdin -blocking [dict get $stdin_state -blocking]
-            if {$answer ne "y"} {
-                puts stderr "mix libcopy.asmodule aborting due to user response '$answer' (required Y|y to proceed)  use -askme 0 to avoid prompts."
-                return
-            }
-        }
-
-        if {![file exists $modulefolder_path]} {
-            puts stdout "Creating module base folder at $modulefolder_path"
-            file mkdir $modulefolder_path
-        }
-        if {![file exists [file dirname $target_path]]} {
-            puts stdout "Creating relative folder at [file dirname $target_path]"
-            file mkdir [file dirname $target_path]
-        }
-
-        if {[file exists $target_path]} {
-            puts stdout "WARNING - module already exists at $target_path"
-            if {$opt_askme} {
-                puts stdout "Copy anyway? Y|N" 
-                set stdin_state [fconfigure stdin]
-                fconfigure stdin -blocking 1 
-                set answer [string tolower [gets stdin]]
-                fconfigure stdin -blocking [dict get $stdin_state -blocking]
-                if {$answer ne "y"} {
-                    puts stderr "mix libcopy.asmodule aborting due to user response '$answer' (required Y|y to proceed)  use -askme 0 to avoid prompts."
-                    return
-                }
-            }
-        }
-
-        file copy -force $source_file $target_path
-        
-        return $target_path
-    }
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::loadedlib [namespace eval punk::mix::commandset::loadedlib {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm
deleted file mode 100644
index 19fbadb3..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/module-0.1.0.tm
+++ /dev/null
@@ -1,419 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::module 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::module {
-    namespace export *
-
-    proc paths {} {
-        set roots [punk::repo::find_repos ""]
-        set project [lindex [dict get $roots project] 0]
-        if {$project ne ""} {
-            set is_project 1
-            set searchbase $project
-        } else {
-            set is_project 0
-            set searchbase [pwd]
-        }
-
-        if {[catch {
-            set source_module_folderlist [punk::mix::cli::lib::find_source_module_paths $searchbase]
-        } errMsg]} {
-            set source_module_folderlist [list]
-        }
-
-        set tm_folders [tcl::tm::list]
-        package require overtype
-
-        set result ""
-        if {$is_project} {
-            append result "Project module source paths:" \n
-            foreach f $source_module_folderlist {
-                append result "$f" \n    
-            }
-        }
-        append result \n
-        append result "tcl::tm::list" \n
-        foreach f $tm_folders {
-            if {$is_project} {
-                if {[punk::mix::cli::lib::path_a_aboveorat_b $project $f]} {
-                    set pinfo "(within project)"
-                } else {
-                    set pinfo ""
-                }
-            } else {
-                set pinfo ""
-            }
-            set warning ""
-            if {![file isdirectory $f]} {
-                set warning "(PATH NOT FOUND)"
-            }
-            append result "$f $pinfo $warning" \n
-        }
-
-
-        return $result
-    }
-    #require current dir when calling to be the projectdir, or 
-    proc templates {args} {
-        set tdict [templates_dict {*}$args]
-
-        package require overtype       
-        set paths [dict values $tdict]
-        set names [dict keys $tdict]
-
-        set title1 "Path"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $paths] {punk::strlen $v}]]
-        set col1 [string repeat " " $widest1] 
-
-        set title2 "Template Name"
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $names] {punk::strlen $v}]]
-        set col2 [string repeat " " $widest2]
-
-        set tablewidth [expr {$widest1 + 1 + $widest2}]
-        set table ""
-        append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col1 $title1] [overtype::left $col2 $title2]" \n
-        append table [string repeat - $tablewidth] \n
-
-        foreach p $paths n $names {
-           append table "[overtype::left $col1 $p] [overtype::left $col2 $n]" \n 
-        }
-
-        return $table
-    }
-    #return all module templates with repeated ones suffixed with .2 .3 etc
-    proc templates_dict {args} {
-        tailcall lib::templates_dict {*}$args
-    }
-    proc new {module args} {
-        set year [clock format [clock seconds] -format %Y]
-        set defaults [list\
-            -project \uFFFF\
-            -version \uFFFF\
-            -license <unspecified>\
-            -template module-0.0.1.tm\
-            -type \uFFFF\
-            -force 0\
-            ]
-        set opts [dict merge $defaults $args]
-
-        #todo - review compatibility between -template and -type
-        #-type is the wrapping technology e.g 'plain' for none or tarjar/zipkit etc (consider also snappy/snappy-tcl)
-        #-template may be a folder - but only if the selected -type suports it
-
-
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        # option -version
-        # we need this value before looking at the named argument
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_version_supplied                    [dict get $opts -version]
-        if {$opt_version_supplied eq "\uFFFF"} {
-            set opt_version "0.1.0"
-        } else {
-            set opt_version $opt_version_supplied
-            if {![util::is_valid_tm_version $opt_version]} {
-                error "pmix module.new error - supplied -version $opt_version doesn't appear to be a valid Tcl module version"
-            }
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        #named argument
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set mversion_supplied "" ;#version supplied directly in module argument
-        if {[string first - $module]> 0} {
-            #if it has a dash then version is required to be valid
-            lassign [punk::mix::cli::lib::split_modulename_version $module] modulename mversion
-            if {![util::is_valid_tm_version $mversion]} {
-                error "pmix module.new error - unable to determine modulename-version from supplied value '$module'"
-            }
-            set mversion_supplied $mversion ;#record as may need to compare to version from templatefile name
-            set vcompare_is_mversion_bigger [package vcompare $mversion $opt_version]
-            if {$vcompare_is_mversion_bigger > 0} {
-                set opt_version $mversion; #module parameter has higher value than -version
-                set vmsg "from module argument: $module"
-            } else {
-                set vmsg "from -version option: $opt_version_supplied"
-            }
-            if {$opt_version_supplied ne "\uFFFF"} {
-                if {$vcompare_is_mversion_bigger != 0} {
-                    #is bigger or smaller
-                    puts stderr "module.new WARNING: version supplied in module argument as well as -version option. Using the higher version number $vmsg"
-                }
-            }
-        } else {
-            set modulename $module
-        }
-        punk::mix::cli::lib::validate_modulename $modulename -name_description "mix module.new name"
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        #options
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_project                             [dict get $opts -project]
-        set testdir [pwd]
-        if {![string length [set projectdir [punk::repo::find_project $testdir]]]} {
-            if {![string length [set projectdir [punk::repo::find_candidate $testdir]]]} {
-                set msg [punkc::repo::is_candidate_root_requirements_msg]
-                error "module.new unable to create module in projectdir:$projectdir - directory doesn't appear to meet basic standards $msg"
-            }
-        }
-        if {$opt_project == "\uFFFF"} {
-            set projectname [file tail $projectdir]
-        } else {
-            set projectname $opt_project 
-            if {$projectname ne [file tail $projectdir]} {
-                error "module.new -project '$opt_project' doesn't match detected projectname '$projectname' at path: $projectdir"
-            }
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_license                             [dict get $opts -license]
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_template                            [dict get $opts -template]
-
-        set templates_dict [templates_dict] ;#possibly suffixed with .2 .3 etc
-        #todo - allow versionless name - pick latest which isn't suffixed with .2 etc
-        if {![dict exists $templates_dict $opt_template]} {
-            error "module.new unable to find template '$opt_template'. Known templates: [dict keys $templates_dict]"
-        }
-        set templatefile [dict get $templates_dict $opt_template]
-        set tpldir [file dirname $templatefile] ;#use same folder for modulename_buildversion.txt, modulename_description.txt if they exist
-
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_type                                [dict get $opts -type]
-        if {$opt_type eq "\uFFFF"} {
-            set opt_type [lindex [punk::mix::cli::lib::module_types] 0] ;#default to plain
-        }
-        if {$opt_type ni [punk::mix::cli::lib::module_types]} {
-            error "module.new - error - unknown -type '$opt_type' known-types: [punk::mix::cli::lib::module_types]"
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-
-
-
-
-        set subpath [punk::mix::cli::lib::module_subpath $modulename] ;#commonly empty string for simple modulename e.g "mymodule"  but x::mymodule has subpath 'x' and x::y::mymodule has subpath 'x/y'
-        if {![string length $subpath]} {
-            set modulefolder $projectdir/src/modules
-        } else {
-            set modulefolder $projectdir/src/modules/$subpath
-        }
-        file mkdir $modulefolder
-
-        set moduletail [namespace tail $modulename]
-        set magicversion [punk::mix::util::magic_tm_version] ;#deliberately large so given load-preference when testing
-
-
-
-
-        set template_tail [file tail $templatefile] ;#convert template_xxx-version.tm.x  to {xxx version}
-        set template_tail [string range $template_tail [string length template_] end]
-        set ext [string tolower [file extension $template_tail]]
-        if {$ext eq ".tm"} {
-            set template_modulename_part [file rootname $template_tail]
-        } elseif {[string is integer -strict [string range $ext 1 end]]} {
-            #something like modulename-0.0.1.tm.2
-            #strip of last 2 dotted parts
-            set shortened [file rootname $template_tail]
-            if {![string equal -nocase [file extension $shortened] ".tm"]} {
-                error "module.new error: Unable to interpret filename components of template file '$templatefile' (expected .tm as second-last or last component)"
-            }
-            set template_modulename_part [file rootname $shortened]
-        } else {
-            error "module.new error: Unable to interpret filename components of template file '$templatefile'"
-        }
-        lassign [punk::mix::cli::lib::split_modulename_version $template_modulename_part] t_mname t_version
-        #t_version may be empty string if template is unversioned e.g template_whatever.tm
-
-        set fd [open $templatefile r]; set template_filedata [read $fd]; close $fd
-        if {[string match "*$magicversion*" $template_filedata]} {
-            set use_magic 1
-            set build_version $opt_version
-            set infile_version $magicversion
-        } else {
-            set use_magic 0
-            if {$opt_version_supplied ne "\uFFFF"} {
-                set build_version $opt_version
-            } else {
-                if {[util::is_valid_tm_version $t_version]} {
-                    if {$mversion_supplied eq ""} {
-                        set build_version $t_version
-                    } else {
-                        #we have a version from the named argument 'module'
-                        if {[package vcompare $mversion_supplied $t_version] > 0} {
-                            set build_version $mversion_supplied
-                        } else {
-                            set build_version $t_version
-                        }
-                    }
-                } else {
-                    #probably an unversioned module template
-                    #use opt_version default from above
-                    set build_version $opt_version
-                }
-            }
-            set infile_version $build_version
-        }
-
-        set template_filedata [string map [list %project% $projectname %pkg% $modulename %year% $year %license% $opt_license %version% $infile_version] $template_filedata]
-
-        set modulefile $modulefolder/${moduletail}-$infile_version.tm
-        if {[file exists $modulefile]} {
-            set errmsg "module.new error: module file $modulefile already exists - aborting"
-            if {[string match "*$magicversion*" $modulefile]} {
-                append errmsg \n "If you are attempting to create a module file with a specific version in the source-file name - you will need to use a template that doesn't contain the string '$magicversion' e.g the provided template moduleexactversion-0.0.1.tm"
-            }
-            error $errmsg
-        }
-
-
-        if {[file exists $tpldir/modulename_buildversion.txt]} {
-            set fd [open $tpldir/modulename_buildversion.txt r]; set buildversion_filedata [read $fd]; close $fd
-        } else {
-            #mix_templates_dir warns of deprecation - review
-            set lib_tpldir [file join [punk::mix::cli::lib::mix_templates_dir] modules];#fallback for modulename_buildversion.txt, modulename_description.txt
-            set fd [open $lib_tpldir/modulename_buildversion.txt r]; set buildversion_filedata [read $fd]; close $fd
-        }
-        set buildversionfile [file join $modulefolder ${moduletail}-buildversion.txt]
-        set existing_build_version ""
-        if {[file exists $buildversionfile]} {
-            set buildversiondata [punk::mix::util::fcat $buildversionfile]
-            set lines [split $buildversiondata \n]
-            set existing_build_version [string trim [lindex $lines 0]]
-            if {[package vcompare $existing_build_version $build_version] >= 0} {
-                #existing version in -buildversion.txt file is lower than the module version we are creating
-                error "module.new error: there is an existing buildversion file $buildversionfile with version $existing_build_version equal to or higher than $build_version - unable to continue"
-            }
-        }
-
-        set existing_versions [glob -nocomplain -dir $modulefolder -tails ${moduletail}-*.tm]
-        #it shouldn't be possible to overmatch with the glob - because '-' is not valid in a Tcl module name
-        if {[llength $existing_versions]} {
-            set name_version_pairs [list]
-            lappend name_version_pairs [list $moduletail $infile_version]
-            foreach existing $existing_versions {
-                lappend name_version_pairs [punk::mix::cli::lib::split_modulename_version $existing] ;# .tm is stripped and ignored
-            }
-            set name_version_pairs [lsort -command {package vcompare} -index 1 $name_version_pairs] ;#while plain lsort will often work with versions - it can get order wrong with some - so use package vcompare
-            if {[lindex $name_version_pairs end] ne [list $moduletail $infile_version]} {
-                set thisposn [lsearch -index 1 $name_version_pairs $infile_version]
-                set name_version_pairs [lreplace $name_version_pairs $thisposn $thisposn]
-                set other_versions [lsearch -all -inline -index 1 -subindices $name_version_pairs *]
-                set errmsg      "module.new error: There are existing modules in the target folder with higher versions than $infile_version."
-                append errmsg  \n "Other versions found: $other_versions"
-                if {$magicversion in $other_versions} {
-                    append errmsg \n "Existing build version for special source file name: '$magicversion'  is: '$existing_build_version'"
-                    append errmsg \n "If '$magicversion' file doesn't represent the latest source it should be removed or the filename and contents adjusted to be a specific version"
-                }
-                error $errmsg
-            } else {
-                puts stderr "module.new WARNING: There are existing modules in the target folder with lower versions than $infile_version - manual review recommended"
-                puts stderr "Other versions found: [lsearch -all -inline -index 1 -subindices [lrange $name_version_pairs 0 end-1] *]"
-            }
-        }
-
-
-        set fd [open $modulefile w]
-        fconfigure $fd -translation binary
-        puts -nonewline $fd $template_filedata
-        close $fd
-
-
-        set buildversion_filedata [string map [list %Major.Minor.Level% $build_version] $buildversion_filedata]
-        set fd [open $buildversionfile w]
-        fconfigure $fd -translation binary
-        puts -nonewline $fd $buildversion_filedata
-        close $fd
-
-        return [list file $modulefile version $build_version]
-    }
-
-    namespace eval lib {
-        proc templates_dict {args} {
-            set defaults [list -scriptpath ""]
-            set opts [dict merge $defaults $args]
-            set opt_scriptpath [dict get $opts -scriptpath]
-
-            set module_template_bases [list]
-            set tbasedict [punk::mix::base::lib::get_template_basefolders $opt_scriptpath]
-            dict for {tbase folderinfo} $tbasedict {
-                lappend module_template_bases [file join $tbase modules]
-            }
-
-
-
-            set template_files [list]
-            foreach basefld $module_template_bases {
-                set matched_files [glob -nocomplain -dir $basefld -type f template_*]
-                foreach tf $matched_files {
-                    if {[string match ignore* $tf]} {
-                        continue
-                    }
-                    set ext [file extension $tf]
-                    if {$ext in [list ".tm"]} {
-                        lappend template_files $tf
-                    }
-                }
-            }
-
-            set tdict [dict create]
-            set seen_dict [dict create]
-            foreach fullpath $template_files {
-                set ftail [file tail $fullpath]
-                set tname [string range $ftail [string length template_] end]
-                if {![dict exists $seen_dict $tname]} {
-                    dict set seen_dict $tname 1 
-                    dict set tdict $tname $fullpath ; #first seen of filename gets no number
-                } else {
-                    set n [dict get $seen_dict $tname]
-                    incr n
-                    dict incr seen_dict $tname
-                    dict set tdict ${tname}.$n $fullpath
-                }
-            }
-            return $tdict
-        }
-    }
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::module [namespace eval punk::mix::commandset::module {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm
deleted file mode 100644
index d8da3a47..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/project-0.1.0.tm
+++ /dev/null
@@ -1,983 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::project 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin punkshell_module_punk::mix::commandset::project 0 0.1.0]
-#[copyright "2023"]
-#[titledesc {pmix commandset - project}]  [comment {-- Name section and table of contents description --}]
-#[moddesc {pmix CLI commandset - project}]             [comment {-- Description at end of page heading --}] 
-#[require punk::mix::commandset::project]
-#[description]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section Overview]
-#[para] overview of punk::mix::commandset::project
-#[para]Import into an ensemble namespace similarly to the way it is done with punk::mix::cli e.g 
-#[example {
-#    namespace eval myproject::cli {
-#        namespace export *
-#        namespace ensemble create
-#        package require punk::overlay
-#    
-#        package require punk::mix::commandset::project
-#        punk::overlay::import_commandset project    .       ::punk::mix::commandset::project
-#        punk::overlay::import_commandset projects   .       ::punk::mix::commandset::project::collection 
-#    }
-#}]
-#[para] Where the . in the above example is the prefix/command separator
-#[para]The prefix ('project' in the above example) can be any string desired to disambiguate commands imported from other commandsets.
-#[para]The above results in the availability of the ensemble command: ::myproject::cli project.new, which is implemented in ::punk::mix::commandset::project::new  
-#[para]Similarly, procs under ::punk::mix::commandset::project::collection will be available as subcommands of the ensemble as <ensemblecommand> projects.<procname>
-#[para]
-#[subsection Concepts]
-#[para] see punk::overlay 
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[subsection dependencies]
-#[para] packages used by punk::mix::commandset::project 
-#[list_begin itemized]
-
-package require Tcl 8.6
-#*** !doctools
-#[item] [package {Tcl 8.6}]
-#[item] [package punk::ns]
-#[item] [package sqlite3] (binary)
-#[item] [package overtype]
-#[item] [package textutil] (tcllib)
-
-
-# #package require frobz
-# #*** !doctools
-# #[item] [package {frobz}]
-
-#*** !doctools
-#[list_end]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section API]
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::project {
-    namespace export *
-    #*** !doctools
-    #[subsection {Namespace punk::mix::commandset::project}]
-    #[para] core commandset functions for punk::mix::commandset::project 
-    #[list_begin definitions]
-
-    proc _default {} {
-        package require punk::ns
-        set dispatched_to [lindex [info level 2] 0] ;#e.g ::punk::mix::cli::project
-        set dispatch_tail [punk::ns::nstail $dispatched_to]
-        set dispatch_ensemble [punk::ns::nsprefix $dispatched_to] ;#e.g ::punk::mix::cli
-        set sibling_commands [namespace eval $dispatch_ensemble {namespace export}]
-        #todo - get separator?
-        set sep "."
-        set result [list]
-        foreach sib $sibling_commands {
-            if {[string match ${dispatch_tail}${sep}* $sib]} {
-                lappend result $sib
-            }
-        }
-        return [lsort $result]
-    }
-
-
-
-
-    proc new {newprojectpath_or_name args} {
-        #*** !doctools
-        # [call [fun new] [arg newprojectpath_or_name] [opt args]]
-        #new project structure - may be dedicated to one module, or contain many. 
-        #create minimal folder structure only by specifying in args:  -modules {}
-        if {[file pathtype $newprojectpath_or_name] eq "absolute"} {
-            set projectfullpath [file normalize $newprojectpath_or_name]
-            set projectname [file tail $projectfullpath]
-            set projectparentdir [file dirname $newprojectpath_or_name]
-        } else {
-            set projectfullpath [file join [pwd] $newprojectpath_or_name]
-            set projectname [file tail $projectfullpath]
-            set projectparentdir [file dirname $projectfullpath]
-        }
-        if {[file type $projectparentdir] ne "directory"} {
-            error "punk::mix::cli::new error: unable to determine containing folder for '$newprojectpath_or_name'"
-        }
-
-        punk::mix::cli::lib::validate_projectname $projectname -name_description "punk mix project.new"
-
-
-        set defaults [list\
-            -type plain\
-            -empty 0\
-            -force 0\
-            -update 0\
-            -confirm 1\
-            -modules \uFFFF\
-            -layout project
-        ] ;#todo
-        set known_opts [dict keys $defaults]
-        foreach {k v} $args {
-            if {$k ni $known_opts} {
-                error "project.new error: option '$k' not known. Known options: $known_opts"
-            }
-        }
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_type                                [dict get $opts -type]
-        if {$opt_type ni [punk::mix::cli::lib::module_types]} {
-            error "pmix new error - unknown type '$opt_type' known types: [punk::mix::cli::lib::module_types]"
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_force                               [dict get $opts -force]
-        set opt_confirm                             [string tolower [dict get $opts -confirm]]
-        # -- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_modules                             [dict get $opts -modules]
-        if {[llength $opt_modules] == 1 && [lindex $opt_modules 0] eq "\uFFFF"} {
-            #if not specified - add a single module matching project name
-            set opt_modules [list $projectname]
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_layout                              [dict get $opts -layout]
-        set opt_update                              [dict get $opts -update]
-        # -- --- --- --- --- --- --- --- --- --- --- --- ---
-
-
-        set fossil_prog [auto_execok fossil]
-        if {![string length $fossil_prog]} {
-            puts stderr "The fossil program was not found. A fossil executable is required to use most pmix features."
-            if {[string length [set scoop_prog [auto_execok scoop]]]} {
-                #restrict to windows?
-                set answer [util::askuser "scoop detected. Would you like pmix to install fossil now using scoop? Y|N"]
-                if {[string tolower $answer] ne "y"} {
-                    puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                    return
-                }
-                #we don't assume 'unknown' is configured to run shell commands
-                if {[string length [package provide shellrun]]} {
-                    set exitinfo [run {*}$scoop_prog install fossil] 
-                    #scoop tends to return successful exitcode (0) even when packages not found etc. - so exitinfo not much use.
-                    puts stdout "scoop install fossil ran with result: $exitinfo"
-                } else {
-                    puts stdout "Please wait while scoop runs - there may be a slight delay and then scoop output will be shown. (use punk shellrun package for )"
-                    set result [exec {*}$scoop_prog install fossil] 
-                    puts stdout $result
-                }
-                catch {::auto_reset}   ;#can be missing (unsure under what circumstances - but I've seen it raise error 'invalid command name "auto_reset"')
-                if {![string length [auto_execok fossil]]} {
-                    puts stderr "Fossil still not detected. If it was successfully installed, try restarting your punk/tcl shell."
-                    return
-                }
-                #todo - ask user if they want to configure fosssil first..
-                set answer [util::askuser "Fossil command now appears to be available. You may wish to answer N to exit and customize it - but default config may be ok. Type the word 'continue' to proceed with default configuration."]
-                if {[string tolower $answer] ne "continue"} {
-                    return
-                }
-
-            } else {
-                puts stdout "See: https://fossil-scm.org/home/uv/download.html"
-                if {"windows" eq $::tcl_platform(platform)} {
-                    puts stdout "Consider using a package manager such as scoop: https://scoop.sh"
-                    puts stdout "(Then: scoop install fossil)"
-                }
-                return
-            }
-        }
-        set startdir [pwd]
-        if {[set in_project [punk::repo::find_project $startdir]] ne ""} {
-            # use this project as source of templates
-            puts stdout "-------------------------------------------"
-            puts stdout "Currently in a project directory '$in_project'"
-            puts stdout "This project will be searched for templates"
-            puts stdout "-------------------------------------------"
-        }
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-        set template_bases_containing_layout [list]
-        dict for {tbase folderinfo} $template_base_dict {
-           if {[file exists $tbase/layouts/$opt_layout]} {
-                lappend template_bases_containing_layout $tbase
-           } 
-        }
-        if {![llength $template_bases_containing_layout]} {
-            puts stderr "layout '$opt_layout' was not found in template dirs"
-            puts stderr "searched [dict size $template_base_dict] template folders"
-            dict for  {tbase folderinfo} $template_base_dict {
-                puts stderr " - $tbase $folderinfo"
-            }
-            return
-        }
-        #review: silently use last entry which had the layout (?)
-        set templatebase [lindex $template_bases_containing_layout end]
-
-
-
-        #todo - detect whether inside cwd-project or inside a different project
-        set projectdir $projectparentdir/$projectname
-        if {[set target_in_project [punk::repo::find_project $projectparentdir]] ne ""} {
-            puts stderr "Target location for new project is already within a project: $target_in_project"
-            error "Nested projects not yet supported aborting"
-        }
-
-
-
-        if {[punk::repo::is_git $projectparentdir]} {
-            puts stderr "mix new WARNING: target project location is within a git repo based at [punk::repo::find_git $projectparentdir]"
-            puts stderr "The new project will create a fossil repository (which you are free to ignore - but but will be used to confirm project base)"
-            puts stderr "If you intend to use both git and fossil in the same project space - you should research and understand the details and any possible interactions/issues"
-            set answer [util::askuser "Do you want to proceed to create a project based at: $projectdir? Y|N"]
-            if {[string tolower $answer] ne "y"} {
-                puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                return
-            }
-        }
-        set is_nested_fossil 0 ;#default assumption
-        if {[punk::repo::is_fossil $projectparentdir]} {
-            puts stderr "mix new WARNING: target project location is within an open fossil repo based at [punk::repo::find_fossil $projectparentdir] NESTED fossil repository"
-            if {$opt_confirm ni [list 0 no false]} {
-                puts stderr "If you proceed - the new project's fossil repo will be created using the --nested flag"
-                set answer [util::askuser "Do you want to proceed to create a NESTED project based at: $projectdir? Y|N"]
-                if {[string tolower $answer] ne "y"} {
-                    puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                    return
-                }
-                set is_nested_fossil 1
-            }
-        }
-
-        
-        set project_dir_exists [file exists $projectdir]
-        if {$project_dir_exists && !($opt_force || $opt_update)} {
-            puts stderr "Unable to create new project at $projectdir - file/folder already exists use -update 1 to fill in missing items from template use -force 1 to overwrite from template"
-            return
-        } elseif {$project_dir_exists && $opt_force} {
-            puts stderr "mix new WARNING: -force 1 was supplied. Will copy layout $templatebase/layouts/$opt_layout using -force option to overwrite from template"
-            if {$opt_confirm ni [list 0 no false]} {
-                set answer [util::askuser "Do you want to proceed to possibly overwrite existing files in $projectdir? Y|N"]
-                if {[string tolower $answer] ne "y"} {
-                    puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -confirm 0 to avoid prompts."
-                    return
-                }
-            }
-        } elseif {$project_dir_exists && $opt_update} {
-            puts stderr "mix new WARNING: -update 1 was supplied. Will copy layout $templatebase/layouts/$opt_layout using -update option to add missing items"
-        }
-
-        set fossil_repo_file "" 
-        set is_fossil_root 0
-        if {$project_dir_exists && [punk::repo::is_fossil_root $projectdir]} {
-            set is_fossil_root 1
-            set fossil_repo_file [punk::repo::fossil_get_repository_file $projectdir]
-            if {$fossil_repo_file ne ""} {
-                set repodb_folder [file dirname $fossil_repo_file]
-            }
-        }
-
-        if {$fossil_repo_file eq ""} {
-            set repodb_folder [punk::repo::fossil_get_repository_folder_for_project $projectname -parentfolder $startdir]
-            if {![string length $repodb_folder]} {
-                puts stderr "No usable repository database folder selected for $projectname.fossil file"
-                return
-            }
-        }
-        if {[file exists $repodb_folder/$projectname.fossil]} {
-            puts stdout "NOTICE: $repodb_folder/$projectname.fossil already exists"
-            if {!($opt_force || $opt_update)} {
-                puts stderr "-force 1 or -update 1 not specified - aborting"
-                return
-            }
-        }
-
-        if {$fossil_repo_file eq ""} {
-            puts stdout "Initialising fossil repo: $repodb_folder/$projectname.fossil"
-            set fossilinit [runx -n {*}$fossil_prog init $repodb_folder/$projectname.fossil -project-name $projectname]
-            if {[dict get $fossilinit exitcode] != 0} {
-                puts stderr "fossil init failed:"
-                puts stderr [dict get $fossilinit stderr]
-                return
-            } else {
-                puts stdout "fossil init result:"
-                puts stdout [dict get $fossilinit stdout]
-            }
-        }
-
-        file mkdir $projectdir
-
-        set layout_dir $templatebase/layouts/$opt_layout
-        puts stdout ">>> about to call punkcheck::install $layout_dir $projectdir" 
-        set resultdict [dict create]
-        set antipaths [list\
-            src/doc/*\
-            src/doc/include/*\
-        ]
-
-        #default antiglob_dir_core will stop .fossil* from being updated - which is generally desirable as these are likely to be customized
-        if {$opt_force} {
-            puts stdout "copying layout files - with force applied - overwrite all-targets" 
-            set resultdict [punkcheck::install $layout_dir $projectdir -installer project.new  -overwrite ALL-TARGETS -antiglob_paths $antipaths]
-            #file copy -force $layout_dir $projectdir
-        } else {
-            puts stdout "copying layout files - (if source file changed)" 
-            set resultdict [punkcheck::install $layout_dir $projectdir -installer project.new -overwrite installedsourcechanged-targets -antiglob_paths $antipaths]
-        }
-        puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-        puts stdout "copying layout src/doc files (if target missing)"
-        set resultdict [punkcheck::install $layout_dir/src/doc $projectdir/src/doc -punkcheck_folder $projectdir -installer project.new  -overwrite SYNCED-TARGETS]
-        puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-        #target folders .fossil-custom and .fossil-settings may not exist. use -createdir 1 to ensure existence. 
-        #In this case we need to override the default dir antiglob - as .fossil-xxx folders need to be installed from template if missing, or if target is uncustomized.
-        ## default_antiglob_dir_core  [list "#*" "_aside" ".git" ".fossil*"]
-        set override_antiglob_dir_core [list #* _aside .git] 
-        puts stdout "copying layout src/.fossil-custom files (if target missing or uncustomised)"
-        set resultdict [punkcheck::install $layout_dir/.fossil-custom $projectdir/.fossil-custom -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
-        puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-        puts stdout "copying layout src/.fossil-settings files (if target missing or uncustomised)"
-        set resultdict [punkcheck::install $layout_dir/.fossil-settings $projectdir/.fossil-settings -createdir 1 -punkcheck_folder $projectdir -installer project.new -antiglob_dir_core $override_antiglob_dir_core -overwrite SYNCED-TARGETS]
-        puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-
-
-
-        #lappend substfiles $projectdir/README.md
-        #lappend substfiles $projectdir/src/README.md
-        #lappend substfiles $projectdir/src/doc/main.man
-        #expect this in all templates? - todo make these substitutions independent of specific paths and filenames?
-        #scan all files in template 
-        #
-        #TODO - pmix command to substitute templates? 
-        set templatefiles [punk::mix::commandset::layout::lib::layout_scan_for_template_files $opt_layout]
-        set stripprefix [file normalize $layout_dir]
-
-        foreach templatefullpath $templatefiles {
-            set templatetail [punk::repo::path_strip_alreadynormalized_prefixdepth $templatefullpath $stripprefix]
-
-            set fpath [file join $projectdir $templatetail]
-            if {[file exists $fpath]} {
-                set fd [open $fpath r]; fconfigure $fd -translation binary; set data [read $fd]; close $fd
-                set data2 [string map [list [lib::template_tag project] $projectname] $data]
-                if {$data2 ne $data} {
-                    puts stdout "updated template file: $fpath"
-                    set fdout [open $fpath w]; fconfigure $fdout -translation binary; puts -nonewline $fdout $data2; close $fdout 
-                }
-            } else {
-                puts stderr "warning: Missing template file $fpath"
-            }
-        }
-        #todo - tag substitutions in src/doc tree
-
-
-        ::cd $projectdir
-
-        if {[file exists $projectdir/src/modules]} {
-            foreach m $opt_modules {
-                if {![file exists $projectdir/src/modules/$m-[punk::mix::util::magic_tm_version].tm]} {
-                    punk::mix::commandset::module::new $m -project $projectname -type $opt_type 
-                } else {
-                    if {$opt_force} {
-                        punk::mix::commandset::module::new $m -project $projectname -type $opt_type -force 1
-                    }
-                }
-            }
-        } else {
-            puts stderr "project.new WARNING template hasn't created src/modules - skipping creation of new module(s) for project"
-        }
-
-        #generate www/man/md output in 'embedded' folder which should be checked into repo for online documentation
-        if {[file exists $projectdir/src]} {
-            ::cd $projectdir/src
-            #----------
-            set installer [punkcheck::installtrack new project.new $projectdir/src/.punkcheck]
-            $installer set_source_target $projectdir/src/doc $projectdir/src/embedded
-            set event [$installer start_event {-install_step kettledoc}]
-            $event targetset_init VIRTUAL kettle_build_doc ;#VIRTUAL - since there is no specific target file - and we don't know all the files that will be generated
-            $event targetset_addsource $projectdir/src/doc  ;#whole doc tree is considered the source 
-            #----------
-            if {\
-                    [llength [dict get [$event targetset_source_changes] changed]]\
-                } {
-                $event targetset_started
-                # -- --- --- --- --- ---
-                puts stdout "BUILDING DOCS at src/embedded from src/doc"
-                if {[catch {
-
-                    punk::mix::cli::lib::kettle_call lib doc
-                    #Kettle doc
-
-                } errM]} {
-                    $event targetset_end FAILED -note "kettle_build_doc failed: $errM"
-                } else {
-                    $event targetset_end OK
-                }
-                # -- --- --- --- --- ---
-            } else {
-                puts stderr "No change detected in src/doc"
-                $event targetset_end SKIPPED
-            }
-            $event end
-            $event destroy
-            $installer destroy
-        }
-
-        ::cd $projectdir
-
-        if {![punk::repo::is_fossil_root $projectdir]} {
-            set first_fossil 1
-            #-k  = keep.  (only modify the manifest file(s))  
-            if {$is_nested_fossil} {
-                set fossilopen [runx -n {*}$fossil_prog open --nested $repodb_folder/$projectname.fossil -k --workdir $projectdir]
-            } else {
-                set fossilopen [runx -n {*}$fossil_prog open $repodb_folder/$projectname.fossil -k --workdir $projectdir]
-            }
-            if {[file exists $projectdir/_FOSSIL_] && ![file exists $projectdir/.fslckout]} {
-                file rename $projectdir/_FOSSIL_ $projectdir/.fslckout
-            }
-            if {[dict get $fossilopen exitcode] != 0} {
-                puts stderr "fossil open in project workdir '$projectdir' FAILED:"
-                puts stderr [dict get $fossilopen stderr]
-                return
-            } else {
-                puts stdout "fossil open in project workdir '$projectdir' OK:"
-                puts stdout [dict get $fossilopen stdout]
-            }
-        } else {
-            set first_fossil 0
-        }
-        set fossiladd [runx -n {*}$fossil_prog add --dotfiles $projectdir]
-        if {[dict get $fossiladd exitcode] != 0} {
-            puts stderr "fossil add workfiles in workdir '$projectdir' FAILED:"
-            puts stderr [dict get $fossiladd stderr]
-            return
-        } else {
-            puts stdout "fossil add workfiles in workdir '$projectdir' OK:"
-            puts stdout [dict get $fossiladd stdout]
-        }
-        if {$first_fossil} {
-            #fossil commit may prompt user for input.. runx runout etc will pause with no prompts
-            util::do_in_path $projectdir {
-                set fossilcommit [run -n {*}$fossil_prog commit -m "initial project commit"]
-            }
-            if {[dict get $fossilcommit exitcode] != 0} {
-                puts stderr "fossil commit in workdir '$projectdir' FAILED"
-                return
-            } else {
-                puts stdout "fossil commit in workdir '$projectdir' OK"
-            }
-        }
-
-        puts stdout "-done- project:$projectname projectdir: $projectdir"
-    }
-
-    #*** !doctools
-    #[list_end] [comment {--- end definitions namespace punk::mix::commandset::project ---}]
-
-    namespace eval collection {
-        #*** !doctools
-        #[subsection {Namespace punk::mix::commandset::project::collection}]
-        #[para] commandset functions for operating with multiple projects.
-        #[para] It would usually be imported with the prefix "projects" and separator "." to result in commands such as: <ensemblecommand> projects.detail
-        #[list_begin definitions]
-        namespace export *
-        namespace path [namespace parent]
-
-        #e.g imported as 'projects'
-        proc _default {{glob {}} args} {
-            #*** !doctools
-            #[call [fun _default] [arg glob] [opt {option value...}]]
-            #[para]List projects under fossil management, showing fossil db location and number of checkouts
-            #[para]The glob argument is optional unless option/value pairs are also supplied, in which case * should be explicitly supplied
-            #[para]glob restricts output based on the name of the fossil db file e.g s* for all projects beginning with s
-            #[para]The _default function is made available in the ensemble by the name of the prefix used when importing the commandset.
-            #[para]e.g  
-            #[para]    punk::overlay::import_commandset projects   .       ::punk::mix::commandset::project::collection 
-            #[para]Will result in the command being available as <ensemblecommand> projects
-            package require overtype
-            set db_projects [lib::get_projects $glob] 
-            set col1items [lsearch -all -inline -index 0 -subindices $db_projects *]
-            set col2items [lsearch -all -inline -index 1 -subindices $db_projects *]
-            set checkouts [lsearch -all -inline -index 2 -subindices $db_projects *]
-            set col3items [lmap v $checkouts {llength $v}]
-
-            set title1 "Fossil Repo DB"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {punk::strlen $v}]]
-            set col1 [string repeat " " $widest1]
-            set title2 "File Name"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
-            set col2 [string repeat " " $widest2]
-            set title3 "Checkouts"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {punk::strlen $v}]]
-            set col3 [string repeat " " $widest3]
-            set tablewidth [expr {$widest1 + 1 + $widest2 + 1 + $widest3}]
-            
-            
-            append msg "[overtype::left $col1 $title1] [overtype::left $col2 $title2] [overtype::left $col3 $title3]" \n
-            append msg [string repeat "=" $tablewidth] \n
-            foreach p $col1items n $col2items c $col3items {
-                append msg "[overtype::left $col1 $p] [overtype::left $col2 $n] [overtype::right $col3 $c]" \n
-            } 
-            return $msg
-            #return [list_as_lines [lib::get_projects $glob]] 
-        }
-        proc detail {{glob {}} args} {
-            package require overtype
-            package require textutil
-            set defaults [dict create\
-                -description 0\
-            ]
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- ---
-            set opt_description     [dict get $opts -description]
-            # -- --- --- --- --- --- ---
-             
-
-            set db_projects [lib::get_projects $glob] 
-            set col1_dbfiles [lsearch -all -inline -index 0 -subindices $db_projects *]
-            set col2items [lsearch -all -inline -index 1 -subindices $db_projects *]
-            set checkouts [lsearch -all -inline -index 2 -subindices $db_projects *]
-            set col3items [lmap v $checkouts {llength $v}]
-            
-            set col4_pnames [list]
-            set col5_pcodes [list]
-            set col6_dupids [list]
-            set col7_pdescs [list]
-            set codes [dict create]
-            foreach dbfile $col1_dbfiles {
-                set project_name ""
-                set project_code ""
-                set project_desc ""
-                sqlite3 dbp $dbfile
-                dbp eval {select name,value from config where name like 'project-%';}  r {
-                    if {$r(name) eq "project-name"} {
-                       set project_name $r(value) 
-                    } elseif {$r(name) eq "project-code"} {
-                        set project_code $r(value)
-                    } elseif {$r(name) eq "project-description"} {
-                        set project_desc $r(value)
-                    }
-                }
-                dbp close
-                lappend col4_pnames $project_name
-                lappend col5_pcodes $project_code
-                dict lappend codes $project_code $dbfile
-                lappend col7_pdescs $project_desc
-            }
-            
-            set setid 1
-            set codeset [dict create]
-            dict for {code dbs} $codes {
-                if {[llength $dbs]>1} {
-                    dict set codeset $code setid $setid
-                    dict set codeset $code count [llength $dbs]
-                    dict set codeset $code seen 0
-                    incr setid
-                } 
-            }
-            set dupid 1
-            foreach pc $col5_pcodes {
-                if {[dict exists $codeset $pc]} {
-                   set seen [dict get $codeset $pc seen] 
-                   set this_seen [expr {$seen + 1}]
-                   dict set codeset $pc seen $this_seen
-                   lappend col6_dupids "[dict get $codeset $pc setid].${this_seen}/[dict get $codeset $pc count]" 
-                } else {
-                   lappend col6_dupids "" 
-                }
-            }
-
-            set title1 "Fossil Repo DB"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1_dbfiles] {punk::strlen $v}]]
-            set col1 [string repeat " " $widest1]
-            set title2 "File Name"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
-            set col2 [string repeat " " $widest2]
-            set title3 "Checkouts"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col3items] {punk::strlen $v}]]
-            set col3 [string repeat " " $widest3]
-            set title4 "Project Name"
-            set widest4 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col4_pnames] {punk::strlen $v}]]
-            set col4 [string repeat " " $widest4]
-            set title5 "Project Code"
-            set widest5 [tcl::mathfunc::max {*}[lmap v [concat [list $title5] $col5_pcodes] {punk::strlen $v}]]
-            set col5 [string repeat " " $widest5]
-            set title6 "Dup"
-            set widest6 [tcl::mathfunc::max {*}[lmap v [concat [list $title6] $col6_dupids] {punk::strlen $v}]]
-            set col6 [string repeat " " $widest6]
-            set title7 "Description"
-            #set widest7 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col7_pdescs] {punk::strlen $v}]]
-            set widest7 35
-            set col7 [string repeat " " $widest7]
-            
-            
-            set tablewidth [expr {$widest1 + 1 + $widest2 + 1 + $widest3 +1 + $widest4 + 1 + $widest5 + 1 + $widest6}]
-            
-            append msg "[overtype::left $col1 $title1] [overtype::left $col2 $title2] [overtype::left $col3 $title3]\
-                        [overtype::left $col4 $title4] [overtype::left $col5 $title5] [overtype::left $col6 $title6]"
-            if {!$opt_description} {
-                append msg \n
-            } else {
-                append msg            "[overtype::left $col7 $title7]" \n
-                set tablewidth [expr {$tablewidth + 1 + $widest7}]
-            }
-
-            append msg [string repeat "=" $tablewidth] \n
-            foreach p $col1_dbfiles n $col2items c $col3items pn $col4_pnames pc $col5_pcodes dup $col6_dupids desc $col7_pdescs {
-                set desclines [split [textutil::adjust $desc -length $widest7] \n] 
-                set desc1 [lindex $desclines 0]
-                append msg "[overtype::left $col1 $p] [overtype::left $col2 $n] [overtype::right $col3 $c]\
-                [overtype::left $col4 $pn] [overtype::left $col5 $pc] [overtype::left $col6 $dup]"
-                if {!$opt_description} {
-                    append msg \n
-                } else {
-                    append msg  " [overtype::left $col7 $desc1]" \n
-                    foreach dline [lrange $desclines 1 end] {
-                    append msg "$col1 $col2 $col3 $col4 $col5 $col6 [overtype::left $col7 $dline]" \n 
-                    }
-                }
-            } 
-            return $msg            
-            #return [list_as_lines [lib::get_projects $glob]] 
-        }
-        proc cd {{glob {}} args} {
-            dict set args -cd 1
-            work $glob {*}$args 
-        }
-        proc work {{glob {}} args} {
-            package require sqlite3
-            set db_projects [lib::get_projects $glob] 
-            if {[llength $db_projects] == 0} {
-                puts stderr "::punk::mix::commandset::project::work No Repo DB name matches found for '$glob'"
-                return ""
-            }
-            #list of lists of the form:
-            #{fosdb fname workdirlist}
-            set defaults [dict create\
-                -cd 0\
-                -detail "\uFFFF"\
-            ] 
-            set opts [dict merge $defaults $args]
-            # -- --- --- --- --- --- --- 
-            set opt_cd      [dict get $opts -cd]
-            # -- --- --- --- --- --- --- 
-            set opt_detail  [dict get $opts -detail]
-            set opt_detail_explicit_zero 1 ;#default assumption only
-            if {$opt_detail eq "\uFFFF"} {
-                set opt_detail_explicit_zero 0
-                set opt_detail 0; #default
-            }
-            # -- --- --- --- --- --- ---             
-            set workdir_dict [dict create]
-            set all_workdirs [list]
-            foreach pinfo $db_projects {
-                lassign $pinfo fosdb name workdirs 
-                foreach wdir $workdirs {
-                    dict set workdir_dict $wdir $pinfo
-                    lappend all_workdirs $wdir
-                }
-            }
-            set col_rowids  [list]
-            set workdirs [lsort -index 0 $all_workdirs]
-            set col_dupids [list]
-            set col_fnames [list]
-            set col_pnames [list]
-            set col_pcodes [list]
-            set col_dupids [list]
-
-            set fosdb_count [dict create]            
-            set fosdb_dupset [dict create]
-            set fosdb_cache [dict create]
-            set dupset 0
-            set rowid 1
-            foreach wd $workdirs {
-                set wdinfo [dict get $workdir_dict $wd]
-                lassign $wdinfo fosdb nm siblingworkdirs 
-                dict incr fosdb_count $fosdb 
-                set dbcount [dict get $fosdb_count $fosdb]
-                if {[llength $siblingworkdirs] > 1}  {
-                    if {![dict exists $fosdb_dupset $fosdb]} {
-                        #first time this multi-checkout fosdb seen
-                        dict set fosdb_dupset $fosdb [incr dupset]
-                    }
-                    set dupid "[dict get $fosdb_dupset $fosdb].$dbcount/[llength $siblingworkdirs]"
-                } else {
-                    set dupid "" 
-                }
-                if {$dbcount == 1} {
-                    set pname ""
-                    set pcode ""
-                    if {[file exists $fosdb]} {
-                        if {[catch {
-                            sqlite3 fdb $fosdb
-                            set pname [lindex [fdb eval {select value from config where name = 'project-name'}] 0]
-                            set pcode [lindex [fdb eval {select value from config where name = 'project-code'}] 0]
-                            fdb close
-                            dict set fosdb_cache $fosdb [list name $pname code $pcode]
-                        }  errM]} {
-                            puts stderr "!!! problem with fossil db: $fosdb when examining workdir $wd"
-                            puts stderr "!!! error: $errM"
-                        }
-                    } else {
-                        puts stderr "!!! missing fossil db $fosdb" 
-                    }
-                } else {
-                    set info [dict get $fosdb_cache $fosdb]
-                    lassign $info _name pname _code pcode
-                }
-                lappend col_rowids $rowid
-                lappend col_fnames $nm
-                lappend col_dupids $dupid
-                lappend col_pnames $pname
-                lappend col_pcodes [string range $pcode 0 9]
-                incr rowid
-            }
-
-            set col_states [list]
-            set state_title ""
-            #if only one set of fossil checkouts in the resultset and opt_detail is 0 and not explicit - retrieve workingdir state for each co 
-            if {([llength [dict keys $fosdb_cache]] == 1)} {
-                if {!$opt_detail_explicit_zero} {
-                    set opt_detail 1
-                }
-                puts stderr "Result is from a single repo db [dict keys $fosdb_cache]"
-            }
-            if {$opt_detail} {
-                puts stderr "Gathering file state for [llength $workdirs] checkout folder(s). Use -detail 0 to omit file state"
-                set c_rev [list]
-                set c_rev_iso [list]
-                set c_unchanged [list]
-                set c_changed [list]
-                set c_new [list]
-                set c_missing [list]
-                set c_extra [list]
-                foreach wd $workdirs {
-                    set wd_state [punk::repo::workingdir_state $wd]
-                    set state_dict [punk::repo::workingdir_state_summary_dict $wd_state]
-                    lappend c_rev       [string range [dict get $state_dict revision] 0 9]
-                    lappend c_rev_iso   [dict get $state_dict revision_iso8601]
-                    lappend c_unchanged [dict get $state_dict unchanged] 
-                    lappend c_changed   [dict get $state_dict changed]
-                    lappend c_new       [dict get $state_dict new]
-                    lappend c_missing   [dict get $state_dict missing]
-                    lappend c_extra     [dict get $state_dict extra]
-                    puts -nonewline stderr "."
-                } 
-                puts -nonewline stderr \n
-                set t0 "Revision"
-                set w0 [tcl::mathfunc::max {*}[lmap v [concat [list $t0] $c_rev] {string length $v}]]
-                set c0 [string repeat " " $w0]
-                set t0b "Revision iso8601"
-                set w0b [tcl::mathfunc::max {*}[lmap v [concat [list $t0] $c_rev_iso] {string length $v}]]
-                set c0b [string repeat " " $w0b]
-                set t1 "Unch"
-                set w1 [tcl::mathfunc::max {*}[lmap v [concat [list $t1] $c_unchanged] {string length $v}]]
-                set c1 [string repeat " " $w1]
-                set t2 "Chgd"
-                set w2 [tcl::mathfunc::max {*}[lmap v [concat [list $t2] $c_changed] {string length $v}]]
-                set c2 [string repeat " " $w2]
-                set t3 "New"
-                set w3 [tcl::mathfunc::max {*}[lmap v [concat [list $t3] $c_new] {string length $v}]]
-                set c3 [string repeat " " $w3]
-                set t4 "Miss"
-                set w4 [tcl::mathfunc::max {*}[lmap v [concat [list $t4] $c_missing] {string length $v}]]
-                set c4 [string repeat " " $w4]
-                set t5 "Extr"
-                set w5 [tcl::mathfunc::max {*}[lmap v [concat [list $t5] $c_extra] {string length $v}]]
-                set c5 [string repeat " " $w5]
-                
-                set state_title "[overtype::left $c0 $t0] [overtype::left $c0b $t0b] [overtype::right $c1 $t1] [overtype::right $c2 $t2] [overtype::right $c3 $t3] [overtype::right $c4 $t4] [overtype::right $c5 $t5]"
-                foreach r $c_rev iso $c_rev_iso u $c_unchanged c $c_changed n $c_new m $c_missing e $c_extra {
-                    lappend col_states "[overtype::left $c0 $r] [overtype::left $c0b $iso] [overtype::right $c1 $u] [overtype::right $c2 $c] [overtype::right $c3 $n] [overtype::right $c4 $m] [overtype::right $c5 $e]"
-                }
-            }
-            
-            set msg ""
-            if {$opt_cd} {
-                set title0 "CD"
-            } else {
-                set title0 ""
-            }
-            set widest0 [tcl::mathfunc::max {*}[lmap v [concat [list $title0] $col_rowids] {punk::strlen $v}]]
-            set col0 [string repeat " " $widest0]
-            set title1 "Checkout dir"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $workdirs] {punk::strlen $v}]]
-            set col1 [string repeat " " $widest1]
-            set title2 "Repo DB name"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col_fnames] {string length $v}]]
-            set col2 [string repeat " " $widest2]
-            set title3 "CO dup"
-            set widest3 [tcl::mathfunc::max {*}[lmap v [concat [list $title3] $col_dupids] {string length $v}]]
-            set col3 [string repeat " " $widest3]
-            set title4 "Project Name"
-            set widest4 [tcl::mathfunc::max {*}[lmap v [concat [list $title4] $col_pnames] {string length $v}]]
-            set col4 [string repeat " " $widest4]
-            set title5 "Project Code"
-            set widest5 [tcl::mathfunc::max {*}[lmap v [concat [list $title5] $col_pcodes] {string length $v}]]
-            set col5 [string repeat " " $widest5]
-
-            set tablewidth [expr {$widest0 + 1 + $widest1 + 1 + $widest2 + 1 + $widest3 +1 + $widest4 + 1 + $widest5}]
-            append msg "[overtype::right $col0 $title0] [overtype::left $col1 $title1] [overtype::left $col2 $title2] [overtype::left $col3 $title3] [overtype::left $col4 $title4] [overtype::left $col5 $title5]"
-
-            if {[llength $col_states]} {
-                set title6 $state_title 
-                set widest6 [tcl::mathfunc::max {*}[lmap v [concat [list $title6] $col_states] {string length $v}]]
-                set col6 [string repeat " " $widest6]
-                incr tablewidth [expr {$widest6 + 1}]
-                append msg " [overtype::left $col6 $title6]" \n
-            } else {
-                append msg \n
-            }
-            append msg [string repeat "=" $tablewidth] \n
-
-            if {[llength $col_states]} {
-                foreach row $col_rowids wd $workdirs db $col_fnames dup $col_dupids pname $col_pnames pcode $col_pcodes s $col_states {
-                    append msg "[overtype::right $col0 $row] [overtype::left $col1 $wd] [overtype::left $col2 $db] [overtype::right $col3 $dup] [overtype::left $col4 $pname] [overtype::left $col5 $pcode] [overtype::left $col6 $s]" \n
-                } 
-            } else {
-                foreach row $col_rowids wd $workdirs db $col_fnames dup $col_dupids pname $col_pnames pcode $col_pcodes {
-                    append msg "[overtype::right $col0 $row] [overtype::left $col1 $wd] [overtype::left $col2 $db] [overtype::right $col3 $dup] [overtype::left $col4 $pname] [overtype::left $col5 $pcode]" \n
-                } 
-            }
-            set numrows [llength $col_rowids]
-            if {$opt_cd && $numrows >= 1} {
-                puts stdout $msg
-                if {$numrows == 1} {
-                    set workingdir [lindex $workdirs 0]
-                    puts stdout "1 result. Changing dir to $workingdir"
-                    if {[file exists $workingdir]} {
-                        ::cd $workingdir
-                        return $workingdir
-                    } else {
-                        puts stderr "path $workingdir doesn't appear to exist" 
-                        return [pwd]
-                    }
-                } else {
-                    set answer [util::askuser "Change directory to working folder - select a number from 1 to [llength $col_rowids] or any other key to cancel."]
-                    if {[string trim $answer] in $col_rowids} {
-                        set index [expr {$answer - 1}]
-                        set workingdir [lindex $workdirs $index]
-                        ::cd $workingdir
-                        puts stdout [pmix stat]
-                        return $workingdir
-                    }
-                }
-            }
-            return $msg
-        }
-        #*** !doctools
-        #[list_end] [comment {-- end collection namespace definitions --}]
-    }
-    
-    namespace eval lib {
-        proc template_tag {tagname} {
-            #todo - support different tagwrappers - it shouldn't be so likely to collide with common code idioms etc.
-            #we need to detect presence of tags intended for punk::mix system
-            #consider using punk::cap to enable multiple template-substitution providers with their own set of tagnames and/or tag wrappers, where substitution providers are all run 
-            return [string cat % $tagname %]
-        }
-        #get project info only by opening the central confg-db
-        #(will not have proper project-name etc)
-        proc get_projects {{globlist {}} args} {
-            if {![llength $globlist]} {
-                set globlist [list *]
-            }
-            set fossil_prog [auto_execok fossil]
-
-            set fossilinfo [exec {*}$fossil_prog info] ;#will give us the necessary config-db info whether in a project folder or not
-            set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
-            if {[llength $matching_lines] != 1} {
-                puts stderr "Unable to find config-db info from fossil. Check your fossil installation."
-                puts stderr "Fossil output was:"
-                puts stderr "-------------" 
-                puts stderr "$fossilinfo"
-                puts stderr "-------------"
-                puts stderr "config-db info:"
-                puts stderr "$matching_lines"
-                return
-            }
-            set ln [lindex $matching_lines 0]
-            set configdb [string trim [string range $ln [string length "config-db: "] end]]
-            if {![file exists $configdb]} {
-                error "config-db not found at path $configdb"
-            }
-            package require sqlite3
-            ::sqlite3 fosconf $configdb
-            #set testresult [fosconf eval {select name,value from global_config;}]
-            #puts stderr $testresult
-            set project_repos [fosconf eval {select name from global_config where name like 'repo:%';}]
-            set paths_and_names [list]
-            foreach pr $project_repos {
-                set path [string trim [string range $pr 5 end]]
-                set nm [file rootname [file tail $path]]
-                set ckouts [fosconf eval {select name from global_config where value = $path;}]
-                set checkout_paths [list]
-                #strip "ckout:"
-                foreach ck $ckouts {
-                   lappend checkout_paths [string trim [string range $ck 6 end]]
-                }
-                lappend paths_and_names [list $path $nm $checkout_paths] 
-            }
-            set filtered_list [list]
-            foreach glob $globlist {
-                set matches [lsearch -all -inline -index 1 $paths_and_names $glob]
-                foreach m $matches {
-                    if {$m ni $filtered_list} {
-                        lappend filtered_list $m
-                    } 
-                }
-            }
-            set projects [lsort -index 1 $filtered_list]
-            return $projects
-        }
-    
-    }
-    
-    
-
-
-
-}
-
-
-#*** !doctools
-#[manpage_end]
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::project [namespace eval punk::mix::commandset::project {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm
deleted file mode 100644
index abfb0e55..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/repo-0.1.0.tm
+++ /dev/null
@@ -1,92 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::repo 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::repo {
-    namespace export *
-    proc tickets {{project ""}} {
-        set result ""
-        if {[string length $project]} {
-            puts stderr "project status unimplemented"
-            return
-        }
-        set active_dir [pwd]
-        append result "Retrieving top 10 tickets only (for more, use fossil timeline -n <int> -t t)" \n
-        append result [exec fossil timeline -n 10 -t t]
-
-        return $result
-    }
-
-    proc fossilize { args} {
-        #check if project already managed by fossil.. initialise and check in if not.
-        puts stderr "unimplemented"
-    }
-
-    proc unfossilize {projectname args} {
-        #remove/archive .fossil 
-        puts stderr "unimplemented"
-    }
-    proc state {} {
-        set result ""
-        set repopaths [punk::repo::find_repos [pwd]]
-        set repos [dict get $repopaths repos]
-        if {![llength $repos]} {
-            append result [dict get $repopaths warnings]
-        } else {
-            append result [dict get $repopaths warnings]
-            lassign [lindex $repos 0] repopath repotypes
-            if {"fossil" in $repotypes} {
-                append result \n "Fossil repo based at $repopath"
-                set repostate [punk::repo::workingdir_state $repopath -repopaths $repopaths -repotypes fossil]
-                append result \n [punk::repo::workingdir_state_summary $repostate]
-            }
-            if {"git" in $repotypes} {
-                append result \n "Git repo based at $repopath"
-                set repostate [punk::repo::workingdir_state $repopath -repopaths $repopaths -repotypes git]
-                append result \n [punk::repo::workingdir_state_summary $repostate]
-            }
-        }
-        return $result
-    }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::repo [namespace eval punk::mix::commandset::repo {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm
deleted file mode 100644
index e40bc899..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/commandset/scriptwrap-0.1.0.tm
+++ /dev/null
@@ -1,681 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::commandset::scriptwrap 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-package require punk::mix
-package require punk::mix::base
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::commandset::scriptwrap {
-    namespace export *
-
-
-    #scriptpath allows templates command to use same custom template set as when multishell pointed to a filepath
-    #it may or may not be within a project
-    #by using the same folder or path, the same project root will be discovered. REVIEW.
-    proc templates_dict {args} {
-        set defaults [list -scriptpath ""]
-        set opts [dict merge $defaults $args]
-        set opt_scriptpath [dict get $opts -scriptpath]
-
-        set wrapper_folders [lib::get_wrapper_folders $opt_scriptpath]
-
-        set wrapper_templates [list]
-        foreach fld $wrapper_folders {
-            set templates [glob -nocomplain -dir $fld -type f *]
-            foreach tf $templates {
-                if {[string match ignore* $tf]} {
-                    continue
-                }
-                set ext [file extension $tf]
-                if {$ext in [list "" ".bat" ".cmd" ".sh"]} {
-                    lappend wrapper_templates $tf
-                }
-            }
-        }
-
-        set tdict [dict create]
-        set seen_dict [dict create]
-        foreach fullpath $wrapper_templates {
-            set ftail [file tail $fullpath]
-            if {![dict exists $seen_dict $ftail]} {
-                dict set seen_dict $ftail 1 
-                dict set tdict $ftail $fullpath ; #first seen of filename gets no number
-            } else {
-                set n [dict get $seen_dict $ftail]
-                incr n
-                dict incr seen_dict $ftail
-                dict set tdict ${ftail}.$n $fullpath
-            }
-        }
-        return $tdict
-    }
-    proc templates {args} {
-        package require overtype
-        set tdict [templates_dict {*}$args]
-
-       
-        set paths [dict values $tdict]
-        set names [dict keys $tdict]
-
-        set title1 "Path"
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $paths] {punk::strlen $v}]]
-        set col1 [string repeat " " $widest1] 
-
-        set title2 "Template Name"
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $names] {punk::strlen $v}]]
-        set col2 [string repeat " " $widest2]
-
-        set tablewidth [expr {$widest1 + 1 + $widest2}]
-        set table ""
-        append table [string repeat - $tablewidth] \n
-        append table "[overtype::left $col1 $title1] [overtype::left $col2 $title2]" \n
-        append table [string repeat - $tablewidth] \n
-
-        foreach p $paths n $names {
-           append table "[overtype::left $col1 $p] [overtype::left $col2 $n]" \n 
-        }
-
-
-        return $table
-    }
-    #specific filepath to just wrap one script at the tcl-payload or xxx-payload-pre-tcl site
-    #scriptset name to substiture multiple scriptset.xxx files at the default locations - or as specified in scriptset.wrapconf
-    proc multishell {filepath_or_scriptset args} {
-        set defaults [dict create\
-             -askme 1\
-             -outputfolder "\uFFFF"\
-             -template "\uFFFF"\
-        ]
-        set known_opts [dict keys $defaults]
-        dict for {k v} $args {
-            if {$k ni $known_opts} {
-
-                error "punk::mix::commandset::scriptwrap error. Unrecognized option '$k'. Known-options: $known_opts"
-            }
-        }
-        set usage ""
-        append usage "Use directly with the script file to wrap, or supply the name of a scriptset" \n
-        append usage "The scriptset name will be used to search for yourname.sh|tcl|ps1 or names as you specify in  yourname.wrapconfig if it exists" \n
-        append usage "If no template is specified in a .wrapconfig and no -template argument is supplied, it will default to punk-multishell.cmd" \n
-        if {![string length $filepath_or_scriptset]} {
-            puts stderr "No filepath_or_scriptset specified"
-            puts stderr $usage
-            return false
-        }
-        set opts            [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_askme       [dict get $opts -askme]
-        set opt_template    [dict get $opts -template]
-        set opt_outputfolder [dict get $opts -outputfolder]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-
-
-        set ext [file extension $filepath_or_scriptset]
-        set startdir [pwd]
-
-
-
-        #first check if relative or absolute path matches a file
-        if {[file pathtype $filepath_or_scriptset] eq "absolute"} {
-            set specified_path $filepath_or_scriptset 
-        } else {
-            set specified_path [file join $startdir $filepath_or_scriptset]
-        }
-        set ext [string trim [file extension $filepath_or_scriptset] .]
-        set allowed_extensions [list wrapconfig tcl ps1 sh bash]
-        #set allowed_extensions [list tcl]
-        set found_script 0  
-        if {[file exists $specified_path]} {
-            set found_script 1
-        } else {
-            foreach e $allowed_extensions {
-                if {[file exists $filepath_or_scriptset.$e]} {
-                    set found_script 1
-                    break
-                }
-            }
-        }
-
-        #TODO! - use get_wrapper_folders - multishell should use same available templates as the 'templates' function
-        set scriptset [file rootname [file tail $specified_path]] 
-        if {$found_script} {
-            if {[file type $specified_path] eq "file"} {
-                set specified_root [file dirname $specified_path]
-                set pathinfo    [punk::repo::find_repos [file dirname $specified_path]]
-                set projectroot [dict get $pathinfo closest]
-                if {[string length $projectroot]} {
-                    #use the specified files folder - but use the main scriptapps/wrappers folder if specified one has no wrappers subfolder
-                    set scriptroot [file dirname $specified_path] 
-                    if {[file exists $scriptroot/wrappers]} {
-                        set customwrapper_folder $scriptroot/wrappers
-                    } else {
-                        set customwrapper_folder $projectroot/src/scriptapps/wrappers
-                    }
-                } else {
-                    #outside of any project
-                    set scriptroot [file dirname $specified_path] 
-                    if {[file exists $scriptroot/wrappers]} {
-                        set customwrapper_folder $scriptroot/wrappers
-                    } else {
-                        #no customwrapper folder available
-                        set customwrapper_folder ""
-                    }
-                }
-            } else {
-                puts stderr "wrap_in_multishell doesn't currently support a directory as the path."
-                puts stderr $usage
-                return false
-            }
-        } else {
-            set pathinfo [punk::repo::find_repos $startdir]
-            set projectroot [dict get $pathinfo closest]
-            if {[string length $projectroot]} {
-                if {[llength [file split $filepath_or_scriptset]] > 1} {
-                    puts stderr "filepath_or_scriptset looks like a path - but doesn't seem to point to a file"
-                    puts stderr "Ensure you are within a project and use just the name of the scriptset, or pass in the full correct path or relative path to current directory"
-                    puts stderr $usage
-                    return false
-                } else {
-                    #we've already ruled out empty string - so must have a single element representing scriptset - possibly with file extension
-                    set scriptroot $projectroot/src/scriptapps
-                    set customwrapper_folder $projectroot/src/scriptapps/wrappers
-                    #check something matches the scriptset.. 
-                    set something_found ""
-                    if {[file exists $scriptroot/$scriptset]} {
-                        set found_script 1
-                        set something_found $scriptroot/$scriptset  ;#extensionless file - that's ok too
-                    } else {
-                        foreach e $allowed_extensions {
-                            if {[file exists $scriptroot/$scriptset.$e]} {
-                                set found_script 1
-                                set something_found $scriptroot/$scriptset.$e
-                                break
-                            }
-                        }
-                    }
-                    if {!$found_script} {
-                        puts stderr "Searched within $scriptroot"
-                        puts stderr "Unable to find a file matching $scriptset or one of the extensions: $allowed_extensions"
-                        puts stderr $usage
-                        return false
-                    } else {
-                        if {[file type $something_found] ne "file"} {
-                            puts stderr "Found '$something_found'"
-                            puts stderr "wrap_in_multishell doesn't currently support a directory as the path."
-                            puts stderr $usage
-                            return false
-                        }
-                    }
-                }
-
-            } else {
-                puts stderr "filepath_or_scriptset parameter doesn't seem to refer to a file, and you are not within a directory where projectroot and src/scriptapps/wrappers can be determined"
-                puts stderr $usage
-                return false
-            }
-        }
-        #assert - customwrapper_folder var exists - but might be empty
-
-        
-        if {[string length $ext]} {
-            #If there was an explicitly supplied extension - then that file should exist
-            if {![file exists $scriptroot/$scriptset.$ext]} {
-                puts stderr "Explicit extension .$ext was supplied - but matching file not found."
-                puts stderr $usage
-                return false
-            } else {
-                if {$ext eq "wrapconfig"} {
-                    set process_extensions ALLFOUNDORCONFIGURED
-                } else {
-                    set process_extensions $ext
-                }
-            }
-        } else {
-            #no explicit extension - process all for scriptset
-            set process_extensions ALLFOUNDORCONFIGURED
-        }
-        #process_extensions - either a single one - or all found or as per .wrapconfig
-
-        if {$opt_template eq "\uFFFF"} {
-            set templatename punk-multishell.cmd
-        } else {
-            set templatename $opt_template
-        }
-
-
-
-        set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-        set tpldirs [list]
-        dict for {tdir tsourceinfo} $template_base_dict {
-           if {[file exists $tdir/utility/scriptappwrappers/$templatename]} {
-                lappend tpldirs $tdir
-           } 
-        }
-
-        if {[string length $customwrapper_folder] && [file exists [file join $customwrapper_folder $templatename] ]} {
-            set wrapper_template [file join $customwrapper_folder $templatename]
-        } else {
-            if {![llength $tpldirs]} {
-                set msg "No template named '$templatename' found in src/scriptapps/wrappers or in template dirs from packages"
-                append msg \n "Searched [dict size $template_base_dict] template dirs"
-                error $msg
-            }
-
-            #last pkg with templates cap which was loaded has highest precedence
-            set wrapper_template ""
-            foreach tdir [lreverse $tpldirs] {
-                set ftest [file join $tdir utility scriptappwrappers $templatename]
-                if {[file exists $ftest]} {
-                    set wrapper_template $ftest
-                    break
-                }
-            }
-        }
-
-        if {$wrapper_template eq "" || ![file exists $wrapper_template]} {
-            error "wrap_in_multishell: unable to find multishell template $templatename in template folders [concat $tpldirs $customwrapper_folder]"
-        }
-
-
-        if {$opt_outputfolder eq "\uFFFF"} {
-            #outputfolder not explicitly specified by caller
-            if {[string length $projectroot]} {
-                set output_folder [file join $projectroot/bin]
-            } else {
-                set output_folder $startdir
-            }
-        } else {
-            if {[file pathtype $opt_outputfolder] eq "relative"} {
-               if {[string length $projectroot]} {
-                    set output_folder [file join $projectroot $opt_outputfolder]
-               } else {
-                    set output_folder [file join $startdir $opt_outputfolder]
-               }
-            } else {
-                set output_folder $opt_outputfolder
-            }
-        }
-        if {![file isdirectory $output_folder]} {
-            error "wrap_in_multishell: output folder '$output_folder' not found. Please ensure target directory exists"
-        }
-
-
-        #todo
-        #output_file extension may also depend on the template being used.. and/or the .wrapconfig
-        if {$::tcl_platform(platform) eq "windows"} {
-            set output_extension cmd
-        } else {
-            set output_extension sh
-        }
-        set output_file [file join $output_folder $scriptset.$output_extension]
-        if {[file exists $output_file]} {
-            error "wrap_in_multishell: target file $output_file already exists.. aborting"
-        }
-        
-
-        set fdt [open $wrapper_template r]
-        fconfigure $fdt -translation binary
-        set template_data [read $fdt]
-        close $fdt
-        puts stdout "Read [string length $template_data] bytes of template data.."
-        set template_lines [split $template_data \n]
-        puts stdout "Displaying first 3 lines of template between dashed lines..."
-        puts stdout "-----------------------------------------------"
-        foreach ln [lrange $template_lines 0 3] {
-            puts stdout $ln
-        }
-        puts stdout "-----------------------------------------------\n"
-        #foreach  ln $template_lines {
-        #}
-
-        set list_input_files [list]
-        if {$process_extensions eq "ALLFOUNDORCONFIGURED"} {
-            #todo - look for .wrapconfig  or all extensions for the scriptset
-            puts stderr "Sorry - only single input file supported. Supply a file extension or use a .wrapconfig with a single input file for now - implementation incomplete"
-            return false
-        } else {
-            lappend list_input_files $scriptroot/$scriptset.$ext
-        }
-
-        #todo - split template at each <ext-payload> etc marker and build a dict of parts
-
-
-        #hack - process one input
-        set filepath [lindex $list_input_files 0]
-
-        set fdscript [open $filepath r]
-        fconfigure $fdscript -translation binary
-        set script_data [read $fdscript]
-        close $fdscript
-        puts stdout "Read [string length $script_data] bytes of template data.."
-        set script_lines [split $script_data \n]
-        puts stdout "Displaying first 3 lines of your script between dashed lines..."
-        puts stdout "-----------------------------------------------"
-        foreach ln [lrange $script_lines 0 3] {
-            puts stdout $ln
-        }
-        puts stdout "-----------------------------------------------\n"
-        puts stdout "Target for above data is '$output_file'"
-        if {$opt_askme} {
-            set answer [util::askuser "Does this look correct? Y|N"]
-            if {[string tolower $answer] ne "y"} {
-                puts stderr "mix new aborting due to user response '$answer' (required Y or y to proceed)  use -askme 0 to avoid prompts."
-                return
-            }
-        }
-
-        set start_idx 0
-        set end_idx 0
-        set line_idx 0
-        set existing_payload [list]
-        foreach ln $template_lines {
-
-            if {[string match  "#<tcl-payload>*" $ln]} {
-                set start_idx $line_idx
-            } elseif {[string match "#</tcl-payload>*" $ln]} {
-                set end_idx $line_idx
-                break
-            } elseif {$start_idx > 0} {
-                 if {$end_idx > 0} {
-                     lappend existing_payload [string trim $ln]
-                 }   
-            } else {
-
-            }
-            incr line_idx
-        }
-        if {($start_idx == 0) || ($end_idx == 0)} {
-            error "wrap_in_multishell was unable to find payload area in template marked with #<tcl-payload>  and #</tcl-payload> on separate lines"
-        }
-        set existing_string [join $existing_payload \n]
-        if {[string length [string trim $existing_string]]} {
-            puts stdout "EXISTING PAYLOAD!!"
-            puts stdout "-----------------------------------------------\n"
-            puts stdout $existing_string
-            puts stdout "-----------------------------------------------\n"
-            error "wrap_in_multishell found existing payload.. aborting."
-            #todo - allow overwrite only in files outside of punkshell distribution?
-            if 0 {
-                puts stderr "Found existing payload.. overwrite?" 
-                if {$opt_askme} {
-                    set answer [util::askuser "Are you sure you want to replace the tcl payload shown above? Y|N"]
-                    if {[string tolower $answer] ne "y"} {
-                        puts stderr "mix new aborting due to user response '$answer' (required Y|y to proceed)  use -askme 0 to avoid prompts."
-                        return
-                    }
-                }
-            }
-        }
-
-        set tpl_head_lines [lrange $template_lines 0 $start_idx] ;#include tag line
-        set tpl_tail_lines [lrange $template_lines $end_idx end]
-        set newscript [join $tpl_head_lines \n]\n[join $script_lines \n]\n[join $tpl_tail_lines \n]
-        puts stdout "New script is [string length $newscript] bytes"
-        puts stdout $newscript
-        set fdtarget [open $output_file w]
-        fconfigure $fdtarget -translation binary
-        puts -nonewline $fdtarget $newscript
-        close $fdtarget
-        puts stdout "Wrote script file at $output_file"
-
-        #even though chmod might exist on windows - we will leave permissions alone
-        if {$::tcl_platform(platform) ne "windows"} {
-            catch {exec chmod +x $output_file}
-        }
-        puts stdout "-done-"
-        return $output_file
-    }
-
-    namespace eval lib {
-
-        #get_wrapper_folders
-        #   scriptpath - file or folder
-        #   It represents the base point from which to search for /wrapper folders either directly above the scriptpath or in the containing project if any
-        #   The cwd will also be searched for /wrapper folder and project - but with lower precedence in the resultset (later in list)
-        proc get_wrapper_folders {{scriptpath ""}} {
-            set wrapper_folders [list]
-            if {$scriptpath ne ""} {
-                if {[file type $scriptpath] eq "file"} {
-                    set searchbase [file dirname $scriptpath]
-                } else {
-                    set searchbase $scriptpath
-                }
-                if {[file isdirectory [file join $searchbase wrappers]]} {
-                    lappend wrapper_folders [file join $searchbase wrappers]
-                }
-                set pathinfo    [punk::repo::find_repos $searchbase]
-                set scriptpath_projectroot [dict get $pathinfo closest]
-                if {$scriptpath_projectroot ne ""} {
-                    set fld [file join $scriptpath_projectroot src/scriptapps/wrappers]
-                    if {[file isdirectory $fld]} {
-                        if {$fld ni $wrapper_folders} {
-                            lappend wrapper_folders $fld
-                        }
-                    }
-                }
-            }
-            set searchbase [pwd] 
-            set fld [file join $searchbase wrappers]
-            if {[file isdirectory $fld]} {
-                if {$fld ni $wrapper_folders} {
-                    lappend wrapper_folders $fld
-                }
-            }
-            set pathinfo    [punk::repo::find_repos $searchbase]
-            set pwd_projectroot [dict get $pathinfo closest]
-            if {$pwd_projectroot ne ""} {
-                set fld [file join $pwd_projectroot src/scriptapps/wrappers]
-                if {[file isdirectory $fld]} {
-                    if {$fld ni $wrapper_folders} {
-                        lappend wrapper_folders $fld
-                    }
-                }
-            }
-
-            set template_base_dict [punk::mix::base::lib::get_template_basefolders]
-            set tpldirs [list]
-            dict for {tdir tsourceinfo} $template_base_dict {
-                if {[file exists $tdir/utility/scriptappwrappers]} {
-                        lappend tpldirs $tdir
-                } 
-            }
-            foreach tpldir $tpldirs {
-                set fld [file join $tpldir utility scriptappwrappers]
-                if {[file isdirectory $fld]} {
-                    if {$fld ni $wrapper_folders} {
-                        lappend wrapper_folders $fld
-                    }
-                }
-            }
-            return $wrapper_folders
-        }
-        proc _scriptapp_tag_from_line {line} {
-            set result [list istag 0 raw ""] ;#default assumption. All 
-            #----
-            set startc [string first "#" $line] ;#tags must be commented
-            #todo - review. next line is valid - note # doesn't have to be the only one before <tagname>  
-            # @REM # etc < blah # <tagname> etc 
-            #---
-            #fix - we should use a regexp on at least <tagname> </tagname> <tagname/> and only catch tagname without whitespace
-            regexp {(\s*).*} $line _ln indent  ;#will match on empty line, whitespace only line - or anything really.
-            set indent [string map [list \t "    "] $indent] ;#opinionated I guess - but need to normalize to something. The spec is that spaces should be used anyway.
-            dict set result indent [string length $indent]
-            set starttag [string first "<" $line]
-            set pretag [string range $line $startc $starttag-1] 
-            if {[string match "*>*" $pretag]} {
-                return [list istag 0 raw $line reason pretag_contents]
-            }
-            set closetag [string first ">" $line] 
-            set inelement [string range $line $starttag+1 $closetag-1]
-            if {[string match "*<*" $inelement]} {
-                return [list istag 0 raw $line reason tag_malformed_angles]
-            }
-            set elementchars [split $inelement ""]
-            set numslashes [llength [lsearch -all $elementchars "/"]]
-            if {$numslashes == 0} {
-                dict set result type "open"
-            } elseif {$numslashes == 1} {
-                if {[lindex $elementchars 0] eq "/"} {
-                    dict set result type "close"
-                } elseif {[lindex $elementchars end] eq "/"} {
-                    dict set result type "openclose"
-                } else {
-                    return [list istag 0 raw $line reason tag_malformed_slashes]
-                }
-            } else {
-               return [list istag 0 raw $line reason tag_malformed_extraslashes]
-            }
-            if {[dict get $result type] eq "open"} {
-                dict set result name $inelement
-            } elseif {[dict get $result type] eq "close"} {
-                dict set result name [string range $inelement 1 end]
-            } else {
-                dict set result name [string range $inelement 0 end-1]
-            }
-            dict set result istag 1
-            dict set result raw $line
-            return $result
-        }
-
-        #get all \n#<something>\n ...\n#</something>  data - where number of intervening newlines is at least one (and whitespace and/or other data can precede #)
-        #we don't verify 'something' against known tags - as custom templates can have own tags
-        #An openclose tag #<xxx/>  is used to substitute a specific line in its entirety - but the tag *must* remain in the line
-        #
-        #e.g for the line:
-        #   @set "nextshell=pwsh" & :: #<batch-nextshell-line/>
-        #The .wrapconfig might contain
-        #   tag <batch-nextshell-line> line {@set "nextshell=tclsh" & :: @<batch-nextshell-line/>}
-        #
-        proc scriptapp_wrapper_get_tags {wrapperdata} {
-            set wrapperdata [string map [list \r\n \n] $wrapperdata]
-            set lines [split $wrapperdata \n]
-            #set tags_in_data [dict create];#active tags - list of lines accumulating. supports nested tags
-            set status 0
-            set tags [dict create]
-            set errors [list]
-            set errortags [dict create] ;#mark names invalid on first error so that more than 2 tags can't obscure config problem
-            set linenum 1 ;#editors and other utils use 1-based indexing when referencing files - we should too to avoid confusion, despite it being less natural for lindex operations on the result.
-            foreach ln $lines {
-                set lntrim [string trim $ln]
-                if {![string length $lntrim]} {
-                    incr linenum
-                    continue
-                }
-                if {[string match "*#*<*>*" $lntrim]} {
-                    set taginfo [_scriptapp_tag_from_line $ln] ;#use untrimmed line - to get indent
-                    if {[dict get $taginfo istag]} {
-                       set nm [dict get $taginfo name]
-                       if {[dict exists $errortags $nm]} {
-                           #tag is already in error condition - 
-                       } else {
-                            set tp [dict get $taginfo type] ;# type singular - related to just one line
-                            #set raw [dict get $taginfo raw] #equivalent to $ln
-                            if {[dict exists $tags $nm]} {
-                                    #already seen tag name
-                                    #tags dict has types key *plural* - need to track whether we have type open and type close (or openclose for self-closing tags)
-                                    if {[dict get $tags $nm types] ne "open"} { 
-                                        lappend errors "line: $linenum tag $nm encountered type $tp after existing type [dict get $tags $nm types]"
-                                        dict incr errortags $nm
-                                    } else {
-                                        #we already have open - expect only close
-                                        if {$tp ne "close"} {
-                                            lappend errors "line: $linenum tag $nm encountered type $tp after existing type [dict get $tags $nm types]"
-                                            dict incr errortags $nm 
-                                        } else {
-                                            #close after open
-                                            dict set tags $nm types [list open close]
-                                            dict set tags $nm end $linenum
-                                            set taglines [dict get $tags $nm taglines]
-                                            if {[llength $taglines] != 1} {
-                                                error "Unexpected result when closing tag $nm. Existing taglines length not 1."
-                                            }
-                                            dict set tags $nm taglines [concat $taglines $ln]
-                                        }
-                                    }
-                            } else {
-                                    #first seen of tag name
-                                    if {$tp eq "close"} {
-                                            lappend errors "line: $linenum tag $nm encountered type $p close first"
-                                            dict incr errortags $nm
-                                    } else {
-                                        dict set tags $nm types $tp 
-                                        dict set tags $nm indent [dict get $taginfo indent]
-                                        if {$tp eq "open"} {
-                                            dict set tags $nm start $linenum
-                                            dict set tags $nm taglines [list $ln] ;#first entry - another will be added on encountering matching closing tag
-                                        } elseif {$tp eq "openclose"} {
-                                            dict set tags $nm start $linenum
-                                            dict set tags $nm end $linenum
-                                            dict set tags $nm taglines [list $ln] ;#single entry is final result for self-closing tag
-                                        }
-                                    }
-                            }
-                        }
-                    } else {
-                        #looks like it should be a tag.. but failed to even parse for some reason.. just add to errorlist
-                        lappend errors "line: $linenum tag parse failure reason: [dict get $taginfo reason] raw line: [dict get $taginfo raw]"
-                    }
-                }
-                #whether the line is tag or not append to any tags_in_data
-                #foreach t [dict keys $tags_in_data] {
-                #    dict lappend tags_in_data $t $ln ;#accumulate raw lines - written to the tag entry in tags only on encountering a closing tag, then removed from tags_in_data
-                #}
-                incr linenum
-            }
-            #assert [expr {$linenum -1 == [llength $lines]}]
-            if {[llength $errors]} {
-                set status 0
-            } else {
-                set status 1
-            }
-            if {$linenum == 0} {
-                
-            }
-            return [dict create ok $status linecount [llength $lines] data $tags errors $errors]
-        }
-
-
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::commandset::scriptwrap [namespace eval punk::mix::commandset::scriptwrap {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/templates-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/templates-0.1.0.tm
deleted file mode 100644
index 46065bda..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/templates-0.1.0.tm
+++ /dev/null
@@ -1,84 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::templates 0.1.0
-# Meta platform     tcl
-# Meta license      BSD
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require punk::cap
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::templates {
-    variable pkg punk::mix::templates
-    variable cap_provider
-
-    #punk::cap::register_package punk::mix::templates [list\
-    #   {punk.templates {relpath ../templates}}\
-    #]
-
-    namespace eval capsystem {
-        if {[info commands capprovider.registration] eq ""} {
-            punk::cap::class::interface_capprovider.registration create capprovider.registration
-            oo::objdefine capprovider.registration {
-                method get_declarations {} {
-                    set decls [list]
-                    lappend decls [list punk.templates {relpath ../templates}]
-                    lappend decls [list punk.templates {relpath ../templates2}]
-                    lappend decls [list punk.test {something blah}]
-                    return $decls
-                }
-            }
-        }
-    }
-
-    if {[info commands provider] eq ""} {
-        punk::cap::class::interface_capprovider.provider create provider punk::mix::templates
-        oo::objdefine provider {
-            method register {{capabilityname_glob *}} {
-                #puts  registering punk::mix::templates $capabilityname
-                next
-            }
-            method capabilities {} {
-                next
-            }
-        }
-    }
-
-    # -- ---
-    #provider api
-    # -- ---
-    #none - declarations only
-}
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::templates [namespace eval punk::mix::templates {
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/util-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/util-0.1.0.tm
deleted file mode 100644
index 5622bc02..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/mix/util-0.1.0.tm
+++ /dev/null
@@ -1,350 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::mix::util 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-namespace eval punk::mix::util {
-    variable has_winpath 0
-}
-
-if {"windows" eq $::tcl_platform(platform)} {
-   if {![catch {package require punk::winpath}]} {
-       set punk::mix::util::has_winpath 1
-   }
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::mix::util {
-    variable tmpfile_counter 0 ;#additional tmpfile collision avoidance
-
-    namespace export *
-
-
-    proc fcat {args} {
-        variable has_winpath
-
-        if {$::tcl_platform(platform) ne "windows"} {
-            return [fileutil::cat {*}$args]
-        }
-
-        set knownopts [list -eofchar -translation -encoding --]
-        set last_opt 0
-        for {set i 0} {$i < [llength $args]} {incr i} {
-            set ival [lindex $args $i]
-            #puts stdout "i:$i a: $ival known: [expr {$ival in $knownopts}]"
-            if {$ival eq "--"} {
-                set last_opt $i
-                break
-            } else {
-                if {$ival in $knownopts} {
-                    #puts ">known at $i : [lindex $args $i]"
-                    if {($i % 2) != 0} {
-                        error "unexpected option at index $i. known options: $knownopts must come in -opt val pairs."
-                    }
-                    incr i
-                    set last_opt $i
-                } else {
-                set last_opt [expr {$i - 1}] 
-                break
-                }
-            }
-        }
-        set first_non_opt [expr {$last_opt + 1}]
-
-        #puts stderr "first_non_opt: $first_non_opt"
-        set opts [lrange $args -1 $first_non_opt-1]
-        set paths [lrange $args $first_non_opt end]
-        if {![llength $paths]} {
-            error "Unable to find file in the supplied arguments: $args. Ensure options are all -opt val pairs and that file name(s) follow"
-        }
-        #puts stderr "opts: $opts  paths: $paths"
-        set finalpaths [list]
-        foreach p $paths {
-            if {$has_winpath && [punk::winpath::illegalname_test $p]} {
-                lappend finalpaths [punk::winpath::illegalname_fix $p]
-            } else {
-                lappend finalpaths $p
-            }
-        }
-        fileutil::cat {*}$opts {*}$finalpaths
-    }
-
-    #----------------------------------------
-    namespace eval internal {
-        proc path_common_prefix_pop {varname} {
-            upvar 1 $varname var
-            set var [lassign $var head]
-            return $head
-        }
-    }
-    proc path_common_prefix {args} {
-        set dirs $args
-        set parts [file split [internal::path_common_prefix_pop dirs]]
-        while {[llength $dirs]} {
-            set r {}
-            foreach cmp $parts elt [file split [internal::path_common_prefix_pop dirs]] {
-                if {$cmp ne $elt} break
-                lappend r $cmp
-            }
-            set parts $r
-        }
-        if {[llength $parts]} {
-            return [file join {*}$parts]
-        } else {
-            return ""
-        }
-    }
-
-    #retains case from first argument only - caseless comparison
-    proc path_common_prefix_nocase {args} {
-        set dirs $args
-        set parts [file split [internal::path_common_prefix_pop dirs]]
-        while {[llength $dirs]} {
-            set r {}
-            foreach cmp $parts elt [file split [internal::path_common_prefix_pop dirs]] {
-                if {![string equal -nocase $cmp $elt]} break
-                lappend r $cmp
-            }
-            set parts $r
-        }
-        if {[llength $parts]} {
-            return [file join {*}$parts]
-        } else {
-            return ""
-        }
-    }
-    #----------------------------------------
-
-    #namespace import ::punk::ns::nsimport_noclobber 
-
-    proc namespace_import_pattern_to_namespace_noclobber {pattern ns} {
-        set source_ns [namespace qualifiers $pattern]
-        if {![namespace exists $source_ns]} {
-            error "namespace_import_pattern_to_namespace_noclobber error namespace $source_ns not found"
-        }
-        if {![string match ::* $ns]} {
-            set nscaller [uplevel 1 {namespace current}]
-            set ns [punk::nsjoin $nscaller $ns]
-        }
-        set a_export_patterns [namespace eval $source_ns {namespace export}] 
-        set a_commands [info commands $pattern]
-        set a_tails [lmap v $a_commands {namespace tail $v}]
-        set a_exported_tails [list]
-        foreach pattern $a_export_patterns {
-            set matches [lsearch -all -inline $a_tails $pattern]
-            foreach m $matches {
-                if {$m ni $a_exported_tails} {
-                    lappend a_exported_tails $m
-                }
-            }
-        }
-        set imported_commands [list]
-        foreach e $a_exported_tails {
-            set imported [namespace eval $ns [string map [list <func> $e <a> $source_ns] {
-                set cmd ""
-                if {![catch {namespace import <a>::<func>}]} {
-                    set cmd <func>
-                }
-                set cmd
-            }]]
-            if {[string length $imported]} {
-                lappend imported_commands $imported
-            }
-        }
-        return $imported_commands
-    }
-
-    proc askuser {question} {
-        puts stdout $question
-        flush stdout
-        set stdin_state [fconfigure stdin]
-        fconfigure stdin -blocking 1
-        set answer [gets stdin]
-        fconfigure stdin -blocking [dict get $stdin_state -blocking]
-        return $answer
-    }
-
-    proc do_in_path {path script} {
-        #from ::kettle::path::in
-        set here [pwd]
-        try {
-            cd $path
-            uplevel 1 $script
-        } finally {
-            cd $here
-        }
-    }
-
-    proc foreach-file {path script_pathvariable script} {
-        upvar 1 $script_pathvariable thepath
-
-        set known {}
-        lappend waiting $path
-        while {[llength $waiting]} {
-        set pending $waiting
-        set waiting {}
-        set at 0
-        while {$at < [llength $pending]} {
-            set current [lindex $pending $at]
-            incr at
-
-            # Do not follow into parent.
-            if {[string match *.. $current]} continue
-
-            # Ignore what we have visited already.
-            set c [file dirname [file normalize $current/___]]
-            if {[dict exists $known $c]} continue
-            dict set known $c .
-
-            if {[file tail $c] eq ".git"} {
-                continue
-            }
-
-            # Expand directories.
-            if {[file isdirectory $c]} {
-                lappend waiting {*}[lsort -unique [glob -directory $c * .*]]
-                continue
-            }
-
-            # Handle files as per the user's will.
-            set thepath $current
-            switch -exact -- [catch { uplevel 1 $script } result] {
-            0 - 4 {
-                # ok, continue - nothing
-            }
-            2 {
-                # return, abort, rethrow
-                return -code return
-            }
-            3 {
-                # break, abort
-                return
-            }
-            1 - default {
-                # error, any thing else - rethrow
-                return -code error $result
-            }
-            }
-        }
-        }
-        return
-    }
-
-    proc is_valid_tm_version {versionpart} {
-        #Needs to be suitable for use with Tcl's 'package vcompare'
-        if {![catch [list package vcompare $versionpart $versionpart]]} {
-            return 1
-        } else {
-            return 0
-        }
-    }
-    #Note that semver only has a small overlap with tcl tm versions.
-    #todo - work out what overlap and whether it's even useful
-    #see also TIP #439: Semantic Versioning (tcl 9??)
-    proc semver {versionstring} {
-        set re {^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$}
-    }
-    #todo - semver conversion/validation for other systems?
-    proc magic_tm_version {} {
-        set magicbase 999999  ;#deliberately large so given load-preference when testing!
-        #we split the literal to avoid the literal appearing here - reduce risk of accidentally converting to a release version
-        return ${magicbase}.0a1.0
-    }
-
-
-
-    proc tmpfile {{prefix tmp_}} {
-        #note risk of collision if pregenerating a list of tmpfile names
-        #we will maintain an icrementing id so the caller doesn't have to bear that in mind
-        variable tmpfile_counter
-        global tcl_platform
-        return .punkutil_$prefix[pid]_[clock microseconds]_[incr tmpfile_counter]_[info hostname]_$tcl_platform(user)
-    }
-
-    proc tmpdir {} {
-        # Taken from tcllib fileutil.
-        global tcl_platform env
-
-        set attempdirs [list]
-        set problems   {}
-
-        foreach tmp {TEMP TMP TMPDIR} {
-            if { [info exists env($tmp)] } {
-                lappend attempdirs $env($tmp)
-            } else {
-                lappend problems "No environment variable $tmp"
-            }
-        }
-
-        switch $tcl_platform(platform) {
-        windows {
-            lappend attempdirs "C:\\TEMP" "C:\\TMP" "\\TEMP" "\\TMP"
-        }
-        macintosh {
-            lappend attempdirs $env(TRASH_FOLDER)  ;# a better place?
-        }
-        default {
-            lappend attempdirs \
-            [file join / tmp] \
-            [file join / var tmp] \
-            [file join / usr tmp]
-        }
-        }
-
-        lappend attempdirs [pwd]
-
-        foreach tmp $attempdirs {
-            if { [file isdirectory $tmp] &&
-                [file writable $tmp] } {
-                return [file normalize $tmp]
-            } elseif { ![file isdirectory $tmp] } {
-                lappend problems "Not a directory: $tmp"
-            } else {
-                lappend problems "Not writable: $tmp"
-            }
-        }
-
-        # Fail if nothing worked.
-        return -code error "Unable to determine a proper directory for temporary files\n[join $problems \n]"
-    }
-
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::mix::util [namespace eval punk::mix::util {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/ns-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/ns-0.1.0.tm
deleted file mode 100644
index 156d51d1..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/ns-0.1.0.tm
+++ /dev/null
@@ -1,1698 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::ns 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-namespace eval ::punk_dynamic::ns {
-
-}
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::ns {
-    variable ns_current "::"
-    variable ns_re_cache [dict create] ;#cache regular expressions used in globmatchns
-    namespace export nsjoin nsprefix nstail nsparts nseval nsimport_noclobber corp
-
-    #leading colon makes it hard (impossible?) to call directly if not within the namespace 
-    proc ns/ {v {ns_or_glob ""} args}  {
-        variable ns_current ;#change active ns of repl by setting ns_current
-
-        set ns_caller [uplevel 1 {::namespace current}]
-        #puts stderr "ns_cur:$ns_current ns_call:$ns_caller"
-
-
-        set types [list all]
-        set nspathcommands 0
-        if {$v eq "/"} {
-            set types [list children]
-        }
-        if {$v eq "///"} {
-            set nspathcommands 1
-        }
-
-        #todo - cooperate with repl?
-        set out ""
-        if {$ns_or_glob eq ""} {
-            set is_absolute 1
-            set ns_queried  $ns_current
-            set out [nslist [nsjoin $ns_current *] -types $types -nspathcommands $nspathcommands]
-        } else {
-            set is_absolute [string match ::* $ns_or_glob]
-            set has_globchars [regexp {[*?]} $ns_or_glob]
-            if {$is_absolute} {
-                if {!$has_globchars} {
-                    if {![namespace exists $ns_or_glob]} {
-                        error "cannot change to namespace $ns_or_glob"
-                    }
-                    set ns_current $ns_or_glob
-                    set ns_queried $ns_current
-                    tailcall ns/ $v "" 
-                } else {
-                    set ns_queried $ns_or_glob
-                    set out [nslist $ns_or_glob -types $types -nspathcommands $nspathcommands]
-                }
-            } else {
-                if {!$has_globchars} {
-                    set nsnext [nsjoin $ns_current $ns_or_glob]
-                    if {![namespace exists $nsnext]} {
-                        error "cannot change to namespace $ns_or_glob"
-                    }
-                    set ns_current $nsnext
-                    set ns_queried $nsnext
-                    set out [nslist [nsjoin $nsnext *] -types $types -nspathcommands $nspathcommands]
-                } else {
-                    set ns_queried [nsjoin $ns_current $ns_or_glob]
-                    set out [nslist [nsjoin $ns_current $ns_or_glob] -types $types -nspathcommands $nspathcommands]
-                }
-            }
-        }
-        set ns_display "\n$ns_queried"
-        if {$ns_current eq $ns_queried} {
-            if {$ns_current in [info commands $ns_current] } {
-                if {![catch [list namespace ensemble configure $ns_current] ensemble_info]} {
-                    if {[llength $ensemble_info] > 0} {
-                        #this namespace happens to match ensemble command. 
-                        #todo - keep cache of encountered ensembles from commands.. and examine namespace in the configure info.
-                        set ns_display  "\n[a+ yellow bold]$ns_current  (ensemble)[a+]"
-                    }
-                }
-            }
-        }
-        append out $ns_display
-        return $out
-
-
-    }
-
-
-    #create possibly nested namespace structure - but only if not already existant
-    proc n/new {args} {
-        variable ns_current
-        if {![llength $args]} {
-            error "usage: :/new <ns> \[<ns> ...\]"
-        }
-        set a1 [lindex $args 0]
-        set is_absolute [string match ::* $a1]
-        if {$is_absolute} {
-            set nspath [nsjoinall {*}$args]
-        } else {
-            if {[string match :* $a1]} {
-                puts stderr "n/new WARNING namespace with leading colon '$a1' is likely to have unexpected results"
-            }
-            set nspath [nsjoinall $ns_current {*}$args]
-        }
-
-        set ns_exists [nseval [nsprefix $nspath] [list ::namespace exists [nstail $nspath] ]]
-
-        if {$ns_exists} {
-            error "Namespace $nspath already exists"
-        }
-        #namespace eval [nsprefix $nspath] [list namespace eval [nstail $nspath] {}]
-        nseval [nsprefix $nspath] [list ::namespace eval [nstail $nspath] {}]
-        n/ $nspath
-    }
-
-
-    #nn/ ::/ nsup/ - back up one namespace level
-    proc nsup/ {v args} {
-        variable ns_current
-        if {$ns_current eq "::"} {
-            puts stderr "Already at global namespace '::'"
-        } else {
-            set out ""
-            set nsq [nsprefix $ns_current]
-            if {$v eq "/"} {
-                set out [get_nslist -match [nsjoin $nsq *] -types [list children]]
-            } else {
-                set out [get_nslist -match [nsjoin $nsq *] -types [list all]]
-            }
-            #set out [nslist [nsjoin $nsq *]] 
-            set ns_current $nsq
-            append out "\n$ns_current"
-            return $out
-        }
-    }
-
-    #todo - walk up each ns - testing for possibly weirdly named namespaces
-    #review - do we even need it.
-    proc nsexists {nspath} {
-        error "unimplemented"
-    }
-
-    #recursive nseval - for introspection of weird namespace trees
-    #approx 10x slower than normal namespace eval - but still only a few microseconds.. fine for repl introspection
-    proc nseval_script {location} {
-        set parts [nsparts $location]
-        if {[lindex $parts 0] eq ""} {
-            lset parts 0 ::
-        }
-        if {[lindex $parts end] eq ""} {
-            set parts [lrange $parts 0 end-1]
-        }
-
-        set body ""
-        set i 0
-        set tails [lrepeat [llength $parts] ""]
-        foreach ns $parts {
-            set cmdlist [list ::namespace eval $ns]
-            set t ""
-            if {$i > 0} {
-                append body " <lb>"
-            }
-            append body $cmdlist
-            if {$i == ([llength $parts] -1)} {
-                append body " <script>"
-            }
-            if {$i > 0} {
-                set t {<rb>}
-            }
-            lset tails $i $t
-            incr i
-        }
-        append body [join [lreverse $tails] " "]
-        #puts stdout "tails: $tails"
-        #puts stdout "i: $i"
-        set body [string map [list <lb> "\{" <rb> "\}"] $body]
-
-        set scr {[::list ::eval [::uplevel <i>  {::set script}]]}
-
-        set up [expr {$i - 1}]
-        set scr [string map [list <i> $up] $scr]
-
-        set body [string map [list <script> $scr] $body]
-        return $body
-    }
-    proc nseval {fqns script} {
-        if {![string match ::* $fqns]} {
-            error "nseval only accepts a fully qualified namespace"
-        }
-        set loc [string map [list :: "_sep_"] $fqns]
-        #set cmd ::punk::pipecmds::nseval_$loc
-        set cmd ::punk_dynamic::ns::eval-$loc
-        if {$cmd ni [info commands $cmd]} {
-            append body \n [nseval_script $fqns]
-            proc $cmd {script} $body
-            debug.punk.pipe.compile {proc $cmd} 6
-        }
-        tailcall $cmd $script
-    }
-    proc nschildren {fqns} {
-        if {![string match ::* $fqns]} {
-            error "nschildren only accespts a fully qualified namespace"
-        }
-        set parent [nsprefix $fqns]
-        set tail [nstail $fqns]
-        #puts ">>> parent $parent tail $tail"
-        #set nslist [nseval $parent [list ::namespace children $tail]]
-        set nslist [namespace eval $parent [list ::namespace children $tail]]
-        return [lsort $nslist]
-    }
-
-    proc nsjoin {prefix name} {
-        if {[string match ::* $name]} {
-            if {"$prefix" ne ""} {
-                error "nsjoin: won't join non-empty prefix to absolute namespace path '$name'"
-            }
-            return $name
-        }
-        if {"$prefix" eq "::"} {
-            return ::$name
-        }
-        #if {"$name" eq ""} {
-        #    return $prefix
-        #}
-        #nsjoin ::x::y ""  should return ::x::y::   - this is the correct fully qualified form used to call a command that is the empty string
-        return ${prefix}::$name
-    }
-    proc nsjoinall {prefix args} {
-        #if {![llength $args]} {
-        #    error "usage: nsjoinall prefix relativens \[relativens ...\]"
-        #}
-        set segments [list $prefix]
-        foreach sub $args {
-            if {[string match ::* $sub]} {
-                if {[string length [concat {*}$segments]]} {
-                    error "nsjoin: won't join non-empty namespace prefix to absolute namespace path '$sub'"
-                }
-            }
-            lappend segments $sub
-        }
-        set nonempty_segments [list]
-        foreach s $segments {
-            if {[string length $s]} {
-                lappend nonempty_segments $s
-            }
-        }
-        if {$prefix eq "::"} {
-            return ::[join [lrange $nonempty_segments 1 end] ::]
-        }
-        return [join $nonempty_segments ::]
-    }
-    proc nsprefix {{nspath ""}} {
-        #normalize the common case of ::::
-        set nspath [string map [list :::: ::] $nspath]
-        set rawprefix [string range $nspath 0 end-[string length [nstail $nspath]]]
-        if {$rawprefix eq "::"} {
-            return $rawprefix
-        } else {
-            if {[string match *:: $rawprefix]} {
-                return  [string range $rawprefix 0 end-2]
-            } else {
-                return $rawprefix
-            }
-            #return [string trimright $rawprefix :]
-        }
-    }
-
-    #namespace tail which handles :::cmd  ::x:::y  ::x:::/y  etc
-    #todo - raise error for unexpected sequences such as ::::  or more than 2 colons together.
-    proc nstail {nspath args} {
-        #normalize the common case of ::::
-        set nspath [string map [list :::: ::] $nspath]
-        set mapped [string map [list :: \u0FFF] $nspath] 
-        set parts [split $mapped \u0FFF]
-
-        set defaults [list -strict 0]
-        set opts [dict merge $defaults $args]
-        set strict [dict get $opts -strict]
-
-        if {$strict} {
-            foreach p $parts {
-                if {[string match :* $p]} {
-                    error "nstail unpaired colon ':' in $nspath"
-                }
-            }
-        }
-
-        #e.g  ::x::y:::z  should return ":z"
-        return [lindex $parts end]
-    }
-
-    #return a list of namespace segments - always with leading empty string for fully qualified namespace (ie for ::x)
-    #'supports' to some extent unreasonable namespaces /commands such as x:  ::x:  ::x:::y
-    #Can be used to either support use of such namespaces/commands - or as part of validation to disallow them 
-    #as opposed to silent behaviour of Tcl namespace commands which don't handle them consistently (for tcl 8.x anyway  Review tcl 9)
-    #Note that for  ::x::   the trailing :: cannot represent a trailing namespace part being an empty string 
-    #This is because Tcl's 'namespace eval "" ""' reports 'only global namespace can have empty name'
-    #NOTE tcl allows creating ambiguous namespaces.  e.g ::punk:::etc:::blah 
-    # is this :: punk :etc :blah  or :: punk :etc: blah 
-    #clearly leading/trailing colons in namespaces and commands are just a bad idea. 
-    #nsparts will prefer leading colon (ie greedy on ::)
-    #This is important to support leading colon commands such as :/
-    # ie ::punk:::jjj:::etc -> :: punk :jjj :etc
-    proc nsparts {nspath} {
-        set nspath [string map [list :::: ::] $nspath]
-        set mapped [string map [list  :: \u0FFF] $nspath] 
-        set parts [split $mapped \u0FFF]
-        if {[lindex $parts end] eq ""} {
-
-        }
-        return $parts
-    }
-
-    #tcl 8.x has creative writing var weirdness.. tcl 9 is likely to differ
-    proc nsvars {{nsglob "*"}} {
-        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $nsglob]]
-        #set commandns [uplevel 1 [list namespace current]]
-
-        set searchns [nsprefix $ns_absolute] ;#the ns within which we want to searchns
-        set searchall [nsjoin $searchns *] ;#will correctly form ::*  or ::childns::*
-
-        set rawresult [info vars $searchall] ;#will not find vars in ::x:::y   etc.  - seems to be impossible in tcl 8.x
-        set matched_fullpath [list]
-        foreach r $rawresult {
-            lappend matched_fullpath [nstail $r]
-        }
-
-        set location [nsprefix $ns_absolute]
-        set tailmatch [nstail $ns_absolute]
-        set raw_matched_in_ns [nseval $location [list ::info vars $tailmatch]]
-        #NOTE: tcl <9 will read vars from global namespace - so we are only checking the intersection here
-        #(this is due to info vars ::etc:::blah failing to handle additional colon)
-        set matched_in_ns [list]
-        set result [list]
-        foreach r $raw_matched_in_ns {
-            set m [nstail $r]
-            lappend matched_in_ns $m
-            if {$m in $matched_fullpath} {
-                lappend result $m
-            }
-        }
-
-
-        return [list_as_lines [lsort $result]]
-        #.= lsort $result |> list_as_lines
-    }
-
-    proc nsglob_as_re {glob} {
-        #any segment that is not just * must match exactly one segment in the path
-        set pats [list]
-        foreach seg [nsparts $glob] {
-            if {$seg eq ""} {
-                set seg ""
-            }
-            if {$seg eq "*"} {
-                lappend pats {[^:]*}
-            } elseif {$seg eq "**"} {
-                lappend pats {.*}
-            } else {
-                set seg [string map [list  . {[.]}] $seg]
-                if {[regexp {[*?]} $seg]} {
-                    set pat [string map [list ** {.*} * {[^:]*} ? {[^:]}] $seg]
-                    lappend pats "$pat"
-                } else {
-                    lappend pats "$seg"
-                }
-            }
-        }
-        return  "^[join $pats ::]\$"
-    }
-    proc globmatchns {glob path} {
-        #the total set of namespaces is *generally* reasonably bounded so we could just cache all globs, perhaps with some pretty high limit for sanity.. (a few thousand?) review - memory cost?
-        # Tcl (reportedly https://wiki.tcl-lang.org/page/regexp) only caches 'up to 30'dynamically - but should cache more if more stored.
-        variable ns_re_cache
-        if {![dict exists $ns_re_cache $glob]} {
-            if {[dict size $ns_re_cache] > 4200} {
-                #shimmer dict to list and back doesn't seem to affect internal rep of regexp items therein.
-                set ns_re_cache [lrange $ns_re_cache 400 end] ;#chop 200 items off beginning of dict
-            }
-            dict set ns_re_cache $glob [nsglob_as_re $glob]
-        }
-        return [regexp [dict get $ns_re_cache $glob] $path]
-    }
-
-    proc nstree {{location ""}} {
-        if {![string match ::* $location]} {
-            set nscaller [uplevel 1 {::namespace current}]
-             set location [nsjoin $nscaller $location] 
-        }
-        list_as_lines [nstree_list $location]
-    }
-
-
-    #important: add tests for tricky cases - e.g punk::m**::util  vs punk::m*::util vs punk::m*::**::util  - these should all be able to return different results depending on namespace structure.
-    #e.g punk::m**::util will return punk::mix::util  but punk::m*::**::util will not because punk::mix::util is too short to match. Both will return deeper matches such as: punk::mix::commandset::repo::util
-    proc nstree_list {location args} {
-        package require struct::list
-        #puts "> nstree_list $location $args"
-        set defaults [dict create\
-            -call-depth-internal 0\
-            -subnslist {}\
-            -allbelow 1\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- ---- --- --- --- ---
-        set CALLDEPTH   [dict get $opts -call-depth-internal]
-        set subnslist   [dict get $opts -subnslist]
-        set allbelow    [dict get $opts -allbelow] ;#whether to return matches longer than the matched glob-path
-        # -- ---- --- --- --- ---
-    
-        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $location]]
-        set has_globchars [regexp {[*?]} $ns_absolute] ;#don't use regexes on plain namespaces with no glob chars
-        if {!$has_globchars && !$allbelow && ![llength $subnslist]} {
-            #short circuit trivial case 
-            return [list $location]
-        }
-        
-
-        set base ""    
-        set tailparts [list]
-        if {$CALLDEPTH == 0} { 
-            set parts [nsparts $ns_absolute]
-            lset parts 0 ::
-            set idx 0
-            if {$has_globchars} {
-                foreach seg $parts {
-                    if {![regexp {[*?]} $seg]} {
-                        set base [nsjoin $base $seg]
-                    } else {
-                        set tailparts [lrange $parts $idx end]
-                        break
-                    }
-                    incr idx
-                }
-            } else {
-                set base $ns_absolute
-            }
-        } else {
-           set base $location 
-           set tailparts $subnslist
-        }
-        if {![namespace exists $base]} {
-           return [list]
-        } 
-        #set parent [nsprefix $ns_absolute]
-        #set tail [nstail $ns_absolute]
-
-        #set allchildren [lsort [nseval $base [list ::namespace children]]]
-        set allchildren [lsort [namespace eval $base [list ::namespace children]]]
-
-        #puts "->base:$base tailparts:$tailparts allchildren: $allchildren"
-        #puts "->base:$base tailparts:$tailparts childcount: [llength $allchildren]"
-
-        #** only significant when it is the trailing part of a segment eg ::**::xxx  ::a**::xxx  
-        if {[llength $tailparts]} {
-            set nextglob [lindex $tailparts 0]
-            if {$nextglob eq "**"} {
-                set nslist [nstree_list $base -subnslist {} -allbelow 1] 
-            } elseif {[regexp {[*]{2}$} $nextglob]} {
-                set nslist [list]
-                lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
-                foreach ch $nsmatches {
-                    lappend nslist $ch
-                    #lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow 1] 
-                    lappend nslist {*}[nstree_list $ch -subnslist [list "**" {*}[lrange $tailparts 1 end]] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow 0] 
-                }                
-            } else {
-                #lsearch with -glob ok even if nextglob has no globchars (no discernable speed diff, and earlier parts may have globchars anyway)
-                set nslist [list]
-                lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
-                if {[llength $tailparts] >1 || $allbelow} {
-                    foreach ch $nsmatches {
-                        lappend nslist $ch
-                        lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow $allbelow] 
-                    }
-                } else {
-                    #if only one tailpart remaining and not $allbelow - then we already have what we need
-                    set nslist $nsmatches
-                }
-            }
-        } else {
-            #puts "nstree_list: no tailparts base:$base"
-            if {$allbelow} {
-                set nsmatches $allchildren
-                set nslist [list]
-                foreach ch $nsmatches {
-                    lappend nslist $ch
-                    lappend nslist {*}[nstree_list $ch -subnslist {} -call-depth-internal 0 -allbelow 1] 
-                }
-            } else {
-                set nslist $allchildren
-            }
-           #set nsmatches $allchildren
-           #set nslist [nstree_list $base -subnslist {} -allbelow 0] 
-        }
-        set nslist [lsort -unique $nslist]
-
-
-        if 0 {
-            set nextglob [lindex $tailparts 0]
-            if {$nextglob ne "**"} {
-                set nslist [list]
-                if {[llength $tailparts]} {
-                    set nsmatches [list]
-                    #lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]::*]
-                    lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
-                } else {
-                    set nsmatches $allchildren
-                }
-                #return
-
-                foreach ch $nsmatches {
-                    lappend nslist $ch
-                    lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow $allbelow] 
-                }
-            } else {
-            set nslist [nstree_list $base -subnslist {} -allbelow 1] 
-            }
-        }
-
-        #foreach ns $nslist {
-        #    puts "== $ns"
-        #}
-        set nslist_filtered [list]
-        if {$CALLDEPTH == 0} {
-            #puts "--base: $base"
-            #puts "-- globmatchns [nsjoin ${ns_absolute} **]"
-            #puts "-- globmatchns ${ns_absolute}"
-            if {$base ni $nslist} {
-                #puts stderr "> adding $base to $nslist"
-                set nslist [list $base {*}$nslist]
-            } 
-            if {$has_globchars} {
-                if {$allbelow} {
-                    foreach ns $nslist {
-                        if {[globmatchns ${ns_absolute} $ns] || [globmatchns [nsjoin ${ns_absolute} **] $ns]} {
-                            lappend nslist_filtered $ns
-                        }
-                    } 
-                } else {
-                    set nslist_filtered [struct::list::Lfilter $nslist [list globmatchns ${ns_absolute}]]
-                }
-            } else {
-                if {$allbelow} {
-                    foreach ns $nslist {
-                        if {[string equal ${ns_absolute} $ns] || [globmatchns [nsjoin ${ns_absolute} **] $ns]} {
-                            lappend nslist_filtered $ns
-                        }
-                    } 
-                } else {
-                    #set nslist_filtered [struct::list::Lfilter $nslist [list string match ${ns_absolute}]]
-                    set nslist_filtered [list $ns_absolute]
-                }
-            }
-            return $nslist_filtered
-        }
-        return $nslist
-    }
-
-
-    #REVIEW - ansi codes can be *very*  confusing to the user when trying to handle lists etc..
-    proc get_nslist {args} {
-   
-        set known_types [list children commands exported imported aliases procs ensembles ooclasses ooobjects]
-        set defaults [dict create\
-            -match ""\
-            -types $known_types\
-            -nsdict ""\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- 
-        set fq_glob             [dict get $opts -match]
-        set requested_types     [dict get $opts -types]
-        set opt_nsdict          [dict get $opts -nsdict]
-
-        set types $requested_types
-        if {"all" in $requested_types} {
-            foreach t $known_types {
-                if {$t ni $types} {
-                    lappend types $t
-                }
-            }
-        }
-        if {"oo" in $requested_types} {
-            if {"ooclasses" ni $types} {
-                lappend types "ooclasses"
-            }
-            if {"ooobjects" ni $types} {
-                lappend types "ooobjects"
-            }
-        }
-        foreach t $types {
-            if {$t in [list "oo" "all"]} {
-                continue
-            }
-            if {$t ni $known_types} {
-                error "Unrecognised namespace member type: $t known types: $known_types"
-            }
-        }
-
-        set glob_is_absolute [expr {[string match ::* $fq_glob]}]
-        if {!$glob_is_absolute} {
-            error "get_nslist requires fully-qualified namespace glob e.g ::*"
-        }
-        #2 columns for namespaces 4 for commands/procs/aliases - todo make less duplicated - generalize to specified number of columns for each?
-        #NOTE aliases may not be commands in current namespace - but we want to show them (marked red and with R)
-        #
-
-        set children [list]
-        set commands [list]
-        set exported [list]
-        set imported [list]
-        set aliases  [list]
-        set procs    [list]
-        set ensembles [list]
-        set ooclasses [list]
-        set ooobjects [list]
-
-        if {$opt_nsdict eq ""} {
-            set nsmatches [get_ns_dicts $fq_glob -allbelow 0] 
-            set itemcount 0
-            set matches_with_results [list]
-            foreach nsinfo $nsmatches {
-                set itemcount [dict get $nsinfo itemcount] 
-                if {$itemcount > 0} {
-                    lappend matches_with_results $nsinfo
-                } 
-            }
-            if {[llength $matches_with_results] == 1} {
-               set contents [lindex $matches_with_results 0]
-            } elseif {[llength $matches_with_results] > 1} {
-               puts stderr "get_nslist WARNING: more than one ([llength $matches_with_results]) namespace had results for the pattern '$fq_glob'. Displaying only first. Consider calling get_ns_dicts and passing results to get_nslist one at a time using -nsdict option" 
-               set contents [lindex $matches_with_results 0]
-            } else {
-                return "- no results -"
-            }
-        } else {
-            set contents $opt_nsdict
-            if {[dict get $opt_nsdict itemcount] == 0} {
-                return "- no results -"
-            }
-        }
-        set ns       [dict get $contents location] 
-
-        package require overtype
-        if {"children" in $types} {
-            set children [dict get $contents children]
-        }
-        if {"commands" in $types} {
-            set commands [dict get $contents commands]
-            if {"exported" in $types} {
-                set exported [dict get $contents exported]
-            }
-            if {"imported" in $types} {
-                set imported [dict get $contents imported]
-            }
-            if {"aliases" in $types} {
-                set aliases  [dict get $contents aliases]
-            }
-            if {"procs" in $types} {
-                set procs    [dict get $contents procs]
-            }
-            if {"ensembles" in $types} {
-                set ensembles [dict get $contents ensembles]
-            }
-            if {"ooclasses" in $types} {
-                set ooclasses [dict get $contents ooclasses]
-            }
-            if {"ooobjects" in $types} {
-               set ooobjects [dict get $contents ooobjects]
-            }
-        }
-
-        set numchildren [llength $children]
-        if {$numchildren} {
-           set mid [expr {int(ceil($numchildren/2.0))}]
-           set children1 [lrange $children 0 $mid-1]
-           set children2 [lrange $children $mid end]
-        } else {
-            set children1 [list]
-            set children2 [list]
-        }
-
-        #elements are commands and possibly renamed aliases which may or may not have been renamed into the current namespace
-        #a command could be an empty string or something else weird. 
-        #Primarily just to handle empty string command - we will wrap each command as a 2-part element here
-        #(our foreach loop needs to ignore missing commands - but not empty string)
-        set elements [lmap v $commands {list c $v}]
-
-        set seencmds [list]
-        set masked [list] ;# 
-        foreach a $aliases {
-            if {[list c $a] in $elements} {
-                #possibly an ordinary alias - or a renamed alias that is masked by a proc/ensemble/oo 
-                #we can detect masking by proc/ensemble/oo - but not by a binary extension loaded after the rename:  REVIEW
-                if {$a in [concat $procs $ensembles $ooclasses $ooobjects]} {
-                    #we have an alias that is also a known other command-type
-                    lappend elements [list c $a] ;#add in twice so we can display both.
-                    lappend  masked $a
-                }
-            } else {
-                #a renamed-alias
-                lappend elements [list c $a]
-            }
-        }
-        set elements [lsort -index 1 $elements]
-        
-        
-        set numelements [llength $elements]
-        if {$numelements} {
-            set split1 [expr {int(ceil($numelements/4.0))}]
-            set elements1 [lrange $elements 0 $split1-1]
-            set remaining3 [lrange $elements $split1 end]
-
-            set numremaining3 [llength $remaining3] 
-            set split2 [expr {int(ceil($numremaining3/3.0))}]
-            set elements2 [lrange $remaining3 0 $split2-1]
-            set remaining2 [lrange $remaining3 $split2 end]
-
-            set numremaining2 [llength $remaining2]
-            set mid [expr {int(ceil($numremaining2/2.0))}]
-            set elements3 [lrange $remaining2 0 $mid-1]
-            set elements4 [lrange $remaining2 $mid end]
-
-        } else {
-            set elements1 [list]
-            set elements2 [list]
-            set elements3 [list]
-            set elements4 [list]
-        }
-
-
-
-        set chwidest1 [pipedata [list {*}$children1 ""] {lmap v $data {string length $v}}  {tcl::mathfunc::max {*}$data}]
-        set chwidest2 [pipedata [list {*}$children2 ""] {lmap v $data {string length $v}}  {tcl::mathfunc::max {*}$data}]
-
-        #wrap the cmd in [list] (just for the width calc) to get a proper length for what will actually be displayed
-        set cmdwidest1 [pipedata [list {*}$elements1 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-        set cmdwidest2 [pipedata [list {*}$elements2 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-        set cmdwidest3 [pipedata [list {*}$elements3 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-        set cmdwidest4 [pipedata [list {*}$elements4 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-
-        set displaylist [list]
-        set col1 [string repeat " " [expr {$chwidest1 + 8}]]
-        set col2 [string repeat " " [expr {$chwidest2 + 8}]]
-        set col3 [string repeat " " [expr {$cmdwidest1 + 8}]]
-        set col4 [string repeat " " [expr {$cmdwidest2 + 8}]]
-        set col5 [string repeat " " [expr {$cmdwidest3 + 8}]]
-        set a [a+ purple bold]
-        set e [a+ yellow bold]
-        set o [a+ cyan bold]
-        set p [a+ white bold]
-        foreach ch1 $children1 ch2 $children2 cmd1 $elements1 cmd2 $elements2 cmd3 $elements3 cmd4 $elements4 {
-            set a1 [a+ cyan]
-            set c1 [a+ white]
-            set c2 [a+ white]
-            set c3 [a+ white]
-            set c4 [a+ white]
-
-            for {set i 1} {$i <= 4} {incr i} {
-                if {[llength [set cmd$i]]} {
-                    set c [a+ white]
-                    set prefix "     "
-                    set element [set cmd$i]
-                    set cmd [lindex $element 1]
-                    set cmd_display [list $cmd] ;#wrap in list so empty command is visible (and distinguishable from for example a double-curly command)
-                    if {$cmd ni $commands && $cmd in $aliases } {
-                        #ordinary un-masked commandless-alias
-                        set c [a+ red bold]
-                        set prefix "${a}als  "
-                        set prefix [overtype::right $prefix "-R"]
-                    } else {
-                        if {$cmd in $exported} {
-                            set c [a+ green bold]
-                        }
-                        if {$cmd in $aliases && $cmd in $seencmds} {
-                            #masked commandless-alias
-                            #assert member of masked - but we use seencmds instead to detect.
-                            set c [a+ yellow bold]
-                            set prefix "${a}als  "
-                            set prefix [overtype::right $prefix "-R"]
-                        } elseif {$cmd in $procs} {
-                            set prefix "${p}prc  "
-                        } elseif {$cmd in $ensembles} {
-                            set prefix "${e}ens  "
-                        } elseif {$cmd in $ooclasses} {
-                            set prefix "${o}ooc  "
-                        } elseif {$cmd in $ooobjects} {
-                            set prefix "${o}ooo  "
-                        } elseif {$cmd in $aliases} {
-                            set prefix "${a}als  "
-                        } else {
-                        }
-                        if {$cmd in $imported} {
-                            set prefix [overtype::right $prefix "-[a+ yellow bold]I[a+]"]
-                        }
-                    }
-                    set cmd$i "${prefix} $c$cmd_display"
-                    set c$i $c 
-                    lappend seencmds $cmd
-                }
-            }
-
-            lappend displaylist $a1[overtype::left $col1 $ch1][a+]$a1[overtype::left $col2 $ch2][a+]$c1[overtype::left $col3 $cmd1][a+]$c2[overtype::left $col4 $cmd2][a+]$c3[overtype::left $col5 $cmd3][a+]$c4$cmd4[a+]
-        }
-    
-        return [list_as_lines $displaylist]
-    }
-    proc nspath_here_absolute {{nspath "\uFFFF"}} {
-        set path_is_absolute [expr {[string match ::* $nspath]}]
-        if {$path_is_absolute} {
-            return $nspath
-        }
-        set ns_caller [uplevel 1 {::namespace current}] ;#must qualify. Needs to be called from arbitrary namespaces where 'namespace' command may exist (e.g tdom::schema)
-        if {$nspath eq "\uFFFF"} {
-            return $ns_caller
-        }
-        #nsjoin will join nscaller with empty nspath to form nscaller::  - which is correct way to represent command named with empty string
-        return [nsjoin $ns_caller $nspath]
-    }
-
-    proc nspath_to_absolute {nspath base} {
-        set path_is_absolute [expr {[string match ::* $nspath]}]
-        if {$path_is_absolute} {
-            return $nspath
-        }
-        if {![string length $nspath]} {
-            return $base
-        }
-        return [nsjoin $base $nspath]
-    }
-
-    proc nslist {{glob "*"} args} {
-        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $glob]]
-        if {[dict exists $args -match]} {
-           #review -  presumably this is due to get_nslist taking -match? 
-           error "nslist requires positional argument 'glob' instead of -match option" 
-        }
-        set defaults [dict create\
-            -match $ns_absolute\
-            -nspathcommands 0\
-        ]
-
-        package require textblock
-        set opts [dict merge $defaults $args]
-        # -- --- ---
-        set opt_nspathcommands          [dict get $opts -nspathcommands]
-        # -- --- ---
-
-
-        set ns_matches [get_ns_dicts $ns_absolute -nspathcommands $opt_nspathcommands] 
-        set with_results [list]
-        foreach nsdict $ns_matches {
-            if {[dict get $nsdict itemcount]>0} {
-                lappend with_results $nsdict
-            }
-        }
-
-        #special case when glob is for * - we should also consider existence of item(s) namespacepath as a 'result' 
-
-        set count_with_results [llength $with_results]
-        set output ""
-        foreach nsdict $with_results {
-            dict set opts -nsdict $nsdict
-            set block [get_nslist {*}$opts]
-            if {[string first \n $block] < 0} {
-                #single line
-                set width [textblock::width [list $block]]
-            } else {
-                set width [textblock::width $block]
-            }
-            #if multiple results or if there is only 1 result - but we are path-globbing - then we need to show location 
-            if {$count_with_results > 1 || [regexp {[*?]} [nsprefix $ns_absolute]]} {
-                append output \n [dict get $nsdict location]
-            }
-            if {[string length $block]} {
-                append output \n $block
-            }
-            if {[dict size [dict get $nsdict namespacepath]]} {
-                set path_text ""
-                if {!$opt_nspathcommands} {
-                    append path_text \n "  also resolving cmds in namespace paths: [dict keys [dict get $nsdict namespacepath]]"
-                } else {
-                    append path_text \n "  also resolving cmds in namespace paths:"
-                    set nspathdict [dict get $nsdict namespacepath]
-                    dict for {k v} $nspathdict {
-                        set cmds [dict get $v commands]
-                        append path_text \n "    path: $k"
-                        append path_text \n "    cmds: $cmds"
-                    }
-                }
-                append output $path_text
-                set path_text_width [textblock::width $path_text]
-                append output \n [string repeat - [expr {max($width,$path_text_width)}]] 
-            } elseif {$count_with_results > 1 && $width > 0 } {
-                append output \n [string repeat - $width] 
-            }
-        }
-        return $output
-    }
-    #cli command - impure - relies on caller/ns_current
-    proc nslist_dict {{glob "*"} args} {
-        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $glob]]
-        return [get_ns_dicts $ns_absolute {*}$args]
-    }
-
-    #non-contextual - but impure due to state-retrieval from the passed-in namespace part of the fq_glob
-    #returns a list of dicts even if only one ns matched
-    #glob chars at last segment match contents/children of namespaces
-    #glob chars in the path will result in multiple namespaces being matched
-    #e.g  ::tcl::*::d* will match commands beginning with d and child namespaces beginning with d in any namespaces 1 below ::tcl
-    proc get_ns_dicts {fq_glob args} {
-        #JMN
-        #puts stderr "get_ns_dicts $fq_glob"
-        set glob_is_absolute [expr {[string match ::* $fq_glob]}]
-        if {!$glob_is_absolute} {
-            error "get_ns_dicts requires fully-qualified namespace glob e.g ::*"
-        }
-        set has_globchars [regexp {[*?]} $fq_glob]
-
-        set defaults [dict create\
-            -allbelow 0\
-            -nspathcommands 1\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-        set allbelow            [dict get $opts -allbelow]
-        set nspathcommands      [dict get $opts -nspathcommands]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-
-        #set location [nsprefix $fq_glob]
-        set commands [list]
-
-        set nsglob [nsprefix $fq_glob]
-        set glob [nstail $fq_glob]
-        set matched_namespaces [nstree_list $nsglob -allbelow $allbelow]
-
-        set report_namespaces [list] 
-        #special case trailing ** in last segment
-        if {[regexp {[*]{2}$} $glob]} {
-            lappend report_namespaces {*}$matched_namespaces 
-            foreach ns $matched_namespaces {
-                lappend report_namespaces {*}[nstree_list [nsjoin $ns $glob]]
-            }
-        } else {
-           set report_namespaces $matched_namespaces 
-        }
-
-        set nsdict_list [list]
-        foreach ch $report_namespaces {
-            #puts "get_ns_dicts>>> $ch  glob:'$glob'"
-            if {$allbelow == 0 && !$has_globchars} {
-                set allchildren [list]
-            } else {
-                set allchildren [nschildren $ch] ; #sorted, only returns 1 level deeper
-            }
-            
-            #nscommands returns exactly one line per entry + a trailing newline. If there is an empty line other than at the end - that is because there is a command named as the empty string.
-            # By default 'linelist'  trims 1st and last empty line. Turn off all block trimming with -block {}
-            #set  commands [.= nscommands -raw [nsjoin $ch $glob] |> linelist -block {}]
-            set commands [linelist -block {} [nscommands -raw [nsjoin $ch $glob]]]
-
-            #by convention - returning just \n represents a single result of the empty string whereas no results  
-            #after passing through linelist this becomes {} {} which appears as a list of two empty strings.
-            #this is because there isn't a way to represent unambiguously all 3 cases of: empty-list, list of single empty string, list of two empty strings just using \n separated lines 
-            #unless we always return a newline at the tail if there is a result
-            #For this reason nscommands returns a trailing newline - so the last entry should always be empty string - and is a bogus entry
-            #We double-check it here to avoid regressions/mistakes - as nscommands is also a user-level command so there exists the temptation to make it not return the extra newline. 
-            if {[lindex $commands end] eq ""} {
-                set commands [lrange $commands 0 end-1]
-            } else {
-                puts stderr "get_ns_dicts WARNING nscommands didn't return a trailing newline - unexpected"
-            }
-            
-            
-#JMN
-            set location $ch 
-            set exportpatterns [namespace eval $location {::namespace export}]
-            set nspathlist     [namespace eval $location {::namespace path}]
-            set nspathdict [dict create]
-            if {$nspathcommands} {
-                foreach pathns $nspathlist {
-                    set pathcommands [lmap v [info commands ${pathns}::*] {namespace tail $v}]
-                    set matched [lsearch -all -inline $pathcommands $glob]
-                    dict set nspathdict $pathns [dict create commands $matched]
-                }
-            } else {
-                foreach pathns $nspathlist {
-                    dict set nspathdict $pathns [dict create] ;#use consistent structure when nspathcommands false
-                }
-            }
-            #set exportpatterns [nseval $location {::namespace export}]
-            set allexported [list]
-            set matched [list]
-            foreach p $exportpatterns {
-                if {[regexp {[*?]} $p]} {
-                    #lappend matched {*}[nseval $location [list ::info commands [nsjoin ${location} $p]]]
-                    lappend matched {*}[namespace eval $location [list ::info commands [nsjoin ${location} $p]]]
-                    foreach m $matched {
-                        lappend allexported [nstail $m]
-                    }
-                } else {
-                    lappend allexported $p
-                }
-            }
-            set allexported [lsort -unique $allexported]
-            #NOTE: info procs within namespace eval is different to 'info commands' within namespace eval (info procs doesn't look outside of namespace)
-            set allprocs [namespace eval $location {::info procs}] 
-            #set allprocs    [nseval $location {::info procs}]
-            set childtails [lmap v $allchildren {nstail $v}]
-            set allaliases [list]
-            set allensembles [list]
-            set allooobjects [list]
-            set allooclasses [list]
-            set allimported [list]
-            set allundetermined [list]
-            set interp_aliases [interp aliases ""]
-            #use aliases glob - because aliases can be present with or without leading ::
-            #NOTE: alias may not have matching command in the relevant namespce (renamed alias) so we can't just start with commands and check if it's an alias if we want to show all aliases
-            set raw_aliases [namespace eval $location [list ::aliases $glob]] ;#'aliases $glob' must be passed as list, not separate args to namespace eval. 
-            #set raw_aliases [nseval $location [list ::aliases $glob]] ;#'aliases $glob' must be passed as list, not separate args to namespace eval. 
-            set aliases [list]
-            foreach a $raw_aliases {
-                if {[string match *:: $a]} {
-                    #exception for alias such as ::p::2::  so that it doesn't show up as empty string
-                    #lappend aliases ::
-                    #JMN - 2023 - better to display an empty string somehow
-                    lappend aliases "" 
-                } else {
-                    lappend aliases [nstail $a]
-                }
-            }
-
-            foreach cmd $commands {
-                #if {"${location}::$cmd" in $interp_aliases || [string trimleft "${location}::$cmd" ":"] in $interp_aliases} {
-                #    #NOTE: doesn't cater for renamed aliases - Tcl 8.x doesn't seem to have any introspection capabilities to match command to a renamed alias
-                #    #which_alias hack from wiki relies on trace and executing the command - which we don't want to do.
-                #    lappend allaliases $cmd
-                #}
-
-                if {![catch {namespace ensemble configure ${location}::$cmd} ensemble_info]} {
-                    lappend allensembles $cmd 
-                } elseif {[info object isa object ${location}::$cmd]} {
-                    lappend allooobjects $cmd
-                    if {[info object isa class ${location}::$cmd]} {
-                        lappend allooclasses $cmd
-                    }
-                }
-
-                if {[catch {
-                    if {$cmd eq ""} {
-                        #empty command was previously marked as "::" - too confusing - nslist updated to properly display empty string.
-                        set nsorigin [namespace origin ${location}::]
-                    } elseif {[string match :* $cmd]} {
-                        set nsorigin [nseval $location "::namespace origin $cmd"] 
-                    } else {
-                        set nsorigin [namespace origin [nsjoin $location $cmd]]
-                    }
-                } errM]} {
-                    puts stderr "get_ns_dicts failed to determine origin of command '$cmd' adding to 'undetermined'"
-                    puts stderr "error message: $errM"
-                    lappend allundetermined $cmd
-                } else {
-                    if {[nsprefix $nsorigin] ne $location} {
-                        lappend allimported $cmd
-                    }
-                }
-            }
-            if {$glob ne "*"} {
-                set childtailmatches [lsearch -all -inline $childtails $glob]
-                #set fqchildren [lmap v $childtailmatches {lindex ${location}::$v}]  ;#lindex without indices is fast equivalent of 'val' or string cat
-
-                set exported [lsearch -all -inline $allexported $glob]
-                set procs [lsearch -all -inline $allprocs $glob]
-                #set aliases [lsearch -all -inline $allaliases $glob]
-                set ensembles [lsearch -all -inline $allensembles $glob]
-                set ooobjects [lsearch -all -inline $allooobjects $glob]
-                set ooclasses [lsearch -all -inline $allooclasses $glob]
-                set imported [lsearch -all -inline $allimported $glob]
-                set undetermined [lsearch -all -inline $allundetermined $glob]
-            } else {
-                set childtailmatches $childtails
-                #set fqchildren $allchildren
-                set exported $allexported
-                set procs $allprocs
-                #set aliases $allaliases
-                set ensembles $allensembles
-                set ooobjects $allooobjects
-                set ooclasses $allooclasses
-                set imported $allimported
-                set undetermined $allundetermined
-            }
-            
-            #itemcount will overcount if we are including commands as well as procs/exported etc - 
-            set itemcount 0
-            incr itemcount [llength $childtailmatches]
-            incr itemcount [llength $commands]
-            
-
-            #incr itemcount [llength $procs]
-            #incr itemcount [llength $exported]
-            #incr itemcount [llength $imported]
-            #incr itemcount [llength $aliases]
-            #incr itemcount [llength $ensembles]
-            #incr itemcount [llength $ooobjects]
-            #incr itemcount [llength $ooclasses]
-            #definitely don't count exportpatterns
-            incr itemcount [llength $undetermined]
-
-
-            set nsdict [dict create\
-                location $location\
-                children [lsort $childtailmatches]\
-                commands $commands\
-                procs $procs\
-                exported $exported\
-                imported $imported\
-                aliases $aliases\
-                ensembles $ensembles\
-                ooobjects $ooobjects\
-                ooclasses $ooclasses\
-                namespacexport $exportpatterns\
-                undetermined $undetermined\
-                namespacepath $nspathdict\
-                glob $glob\
-                itemcount $itemcount\
-            ]
-            lappend nsdict_list $nsdict
-        }
-        return $nsdict_list 
-    }
-    #Must be no ansi when only single arg used.
-    #review - ansi codes will be very confusing in some scenarios! 
-    #todo - only output color when requested (how?) or via repltelemetry ?
-    interp alias {} nscommands2 {} .= ,'ok'@0.= {
-            #Note: namespace argument to apply doesn't accept namespace segments with leading colon - so pipelines won't work fully in dodgily-named namespaces such as :::x
-            #inspect -label namespace_current [namespace current]
-            #inspect -label info_procs [info procs]
-
-            ::set commandns [::namespace current]
-            ::set commandlist [::list]
-            #color code multiple args? - not very practical if many ns args supplied, but then... common case will only be 1 or 2 anyway
-            #colors can be stripped by caller with ansistrip - but we'll make the default case easier by using no ansi codes if a single arg is passed 
-            ::set colors [::list none cyan yellow green]
-            ::set ci 0 ;#colourindex
-            ::set do_raw 0
-            ::if {[::set posn [::lsearch $searchlist -raw]] >= 0} {
-                ::set searchlist [::lreplace $searchlist $posn $posn]
-                ::set do_raw 1 
-            }
-            ::if {![::llength $searchlist]} {
-                ::lappend searchlist *
-            }
-            ::foreach search $searchlist {
-                ::if {$ci > [::llength $colors]-1} {
-                    ::set ci 0
-                }
-                #by using pipeswitch instead of pipeswitchc - we give the ability* for the switch script block to affect vars in the calling scope
-                # (*not a desirable feature from a functional point of view - but useful for debugging, and also potentially faster )
-                ::if {$ci == 0 || $do_raw} {
-                    ::set col ""
-                    ::set rst ""
-                } else {
-                    ::set col [a+ [::lindex $colors $ci] bold]
-                    ::set rst [a+]
-                }
-                ::incr ci ;#colourindex
-                #inspect -label search $search
-                
-                ::if {![::llength $search]} {
-                    ::set base $commandns
-                    ::set what "*"
-                } else {
-                    ::if {[::string match ::* $search]} {
-                        ::set base [::punk::ns::nsprefix $search]
-                        ::set what [::punk::ns::nstail $search]
-                    } else {
-                        ::set base $commandns
-                        ::set what $search
-                    }
-                }
-
-                ::set all_ns_commands [::info commands [::punk::ns::nsjoin $base $what]]
-                #important not to call namespace eval (or punk::ns::nseval) on non-existant base - or it will be created
-                ::if {![::namespace exists $base]} {
-                   ::continue 
-                }
-
-                if 0 {
-                    #NOTE - matched commands will return commands from global ns due to 'namespace eval' - also any commands from namespaces in the 'namespace path' list
-                    #We don't simply do info commands ${base}::$what  because it misses some oddly named things (JMN 2023 - like what?)
-                    #this was to support weird namespaces with leading/trailing colons - not an important usecase for the cost
-                    ::set matchedcommands [::pipeswitch {
-                        ::pipecase \
-                            caseresult.= ::list $base $what |,basens/0,g/1>  {namespace eval $basens [::list ::info commands $g]}
-                    }]
-                    #lappend commandlist {*}[@@ok/result= $matchedcommands]
-                    #need to pull result from matchedcommands dict
-                    #set cmd_tails [@@ok/result= $matchedcommands |> {::lmap v $data {punk::ns::nstail $v}}]
-                    ::set cmd_tails [::lmap v [::dict get $matchedcommands ok result] {::punk::ns::nstail $v}]
-                    ::set all_ns_tails [::lmap v $all_ns_commands {::punk::ns::nstail $v}]
-                    ::foreach c $cmd_tails {
-                        ::if {$c in $all_ns_tails} {
-                            ::if {$do_raw} {
-                                ::lappend commandlist [::list $c $c]
-                            } else {
-                                ::lappend commandlist [::list $c $col[::list $c]$rst]
-                            }
-                        }
-                    }
-                } else {
-
-                    ::set all_ns_tails [::lmap v $all_ns_commands {::punk::ns::nstail $v}]
-                    foreach c $all_ns_tails {
-                        ::if {$do_raw} {
-                            ::lappend commandlist [::list $c $c]
-                        } else {
-                            ::lappend commandlist [::list $c $col[::list $c]$rst]
-                        }
-                    }
-                }
-            }
-            ::list ok [::list result $commandlist]
-            #unless we always return trailing \n - it's impossible to represent a list containing only the empty string using \n (cannot disambiguate between empty list and/or list of 2 empty strings)
-            #we use the convention that a result of just \n represents a list of just the empty string - as we don't require duplicates anyway - so it shouldn't mean two empty strings.
-    }  |data@@ok/result> ::lsort -index 0  |> {::lmap v $data {::lindex $v 1}} |> {::if {![::llength $data]} {::return {}} else {::return [::join $data \n]\n}} <searchlist|  
-
-    proc nscommands {args} {
-            set commandns [uplevel 1 [list ::namespace current]]
-            set commandlist [::list]
-            #color code multiple args? - not very practical if many ns args supplied, but then... common case will only be 1 or 2 anyway
-            #colors can be stripped by caller with ansistrip - but we'll make the default case easier by using no ansi codes if a single arg is passed 
-            set colors [::list none cyan yellow green]
-            set ci 0 ;#colourindex
-            set do_raw 0
-            if {[::set posn [::lsearch $args -raw]] >= 0} {
-                ::set args [::lreplace $args $posn $posn]
-                ::set do_raw 1 
-            }
-            if {![llength $args]} {
-                lappend args *
-            }
-            ::foreach search $args {
-                ::if {$ci > [::llength $colors]-1} {
-                    ::set ci 0
-                }
-                ::if {$ci == 0 || $do_raw} {
-                    ::set col ""
-                    ::set rst ""
-                } else {
-                    ::set col [a+ [::lindex $colors $ci] bold]
-                    ::set rst [a+]
-                }
-                ::incr ci ;#colourindex
-                #inspect -label search $search
-                
-                ::if {![::llength $search]} {
-                    ::set base $commandns
-                    ::set what "*"
-                } else {
-                    ::if {[::string match ::* $search]} {
-                        ::set base [::punk::ns::nsprefix $search]
-                        ::set what [::punk::ns::nstail $search]
-                    } else {
-                        ::set base $commandns
-                        ::set what $search
-                    }
-                }
-
-                ::set all_ns_commands [::info commands [::punk::ns::nsjoin $base $what]]
-                #important not to call namespace eval (or punk::ns::nseval) on non-existant base - or it will be created
-                ::if {![::namespace exists $base]} {
-                   ::continue 
-                }
-                ::set all_ns_tails [::lmap v $all_ns_commands {::punk::ns::nstail $v}]
-                foreach c $all_ns_tails {
-                    ::if {$do_raw} {
-                        ::lappend commandlist [::list $c $c]
-                    } else {
-                        ::lappend commandlist [::list $c $col[::list $c]$rst]
-                    }
-                }
-            }
-            set commandlist [lsort -index 0 $commandlist]
-            set results [list]
-            foreach pair $commandlist  {
-                lappend results [lindex $pair 1]
-            }
-            #unless we always return trailing \n - it's impossible to represent a list containing only the empty string using \n (cannot disambiguate between empty list and/or list of 2 empty strings)
-            #we use the convention that a result of just \n represents a list of just the empty string - as we don't require duplicates anyway - so it shouldn't mean two empty strings.
-            if {![llength $results]} {
-                return {}
-            } else {
-                return [join $results \n]\n
-            }
-    }
-    interp alias {} nscommands {} punk::ns::nscommands
-
-
-
-    interp alias {} nscommands1 {} .= ,'ok'@0.= {
-            set commandns [namespace current]
-            #upvar caseresult caseresult
-            inspect -label namespace_current [namespace current]
-            inspect -label nsthis [nsthis]
-            inspect -label nsthis2 [nsthis2]
-            inspect -label commandns $commandns
-            inspect -label info_procs [info procs]
-            #by using pipeswitch instead of pipeswitchc - we give the ability* for the switch script block to affect vars in the calling scope
-            # (*not a desirable feature from a functional point of view - but useful for debugging, and also potentially faster )
-            pipeswitch {
-                #no glob chars present
-                if {![llength $ns]} {
-                    set ns $commandns
-                } else {
-                    if {![string match ::* $ns]} {
-                        if {$commandns eq "::"} {set commandns ""}
-                        set ns ${commandns}::$ns
-                    }
-                }
-                inspect '$ns'
-                pipecase \
-                    caseresult= $ns |input> \
-                    1.= {expr {[string length [string map [list * "" ? ""] $data]] == [string length $data]}} |>  {
-                        #uplevel 1 [list info commands ${input}::*]
-                        info commands ${input}::*
-                    }
-
-                #pipecase1 ns has one or more of glob chars * or ?
-                pipecase \
-                    caseresult= $ns |input>  {
-                        #uplevel 1 [list info commands ${input}]
-                        info commands ${input}
-                    }
-            }
-    } |data@@ok/result>  {lmap v $data {punk::ns::nstail $v}} |> lsort |> {join $data \n} <ns/0| 
-
-    #todo - package up as navns
-    proc corp {path} {
-        #thanks to Richard Suchenwirth for the original - wiki.tcl-lang.org/page/corp 
-        #Note: modified here to support aliases and relative/absolute name (with respect to namespace .ie ::name vs name)
-        if {[info exists ::auto_index($path)]} {
-            set body "# $::auto_index($path)\n"
-        } else {
-            set body ""
-        }
-
-        if {[string match ::* $path]} {
-            set targetns [nsprefix $path]
-            set name [nstail $path]
-        } else {
-            set thispath [uplevel 1 [list ::nsthis $path]]
-            set targetns [nsprefix $thispath]
-            set name [nstail $thispath]
-        }
-        #puts stderr "corp upns:$upns"
-
-        #set name [string trim $name :]        
-        #set origin [namespace origin ${upns}::$name]
-        set origin [nseval $targetns [list ::namespace origin $name]]
-
-        #An renamed alias may exist that is the same name as a proc that was created later.. so we must check for the proc before looking into aliases!
-        if {$origin ni [info procs $origin]} {
-
-            #It seems an interp alias of "::x""  behaves the same as "x" 
-            #But we can't create both at the same time - and they have to be queried by the exact name.
-            #So we query for alias with and without leading ::
-            set alias_qualified [interp alias {} [string trim $origin :]]
-            set alias_unqualified [interp alias {} $origin]
-            if {[string length $alias_qualified] && [string length $alias_unqualified]} {
-                #our assumptions are wrong.. change in tcl version?
-                puts stderr "corp: Found alias for unqualified name:'[string trim $origin :]' and qualified name: '$origin' - unexpected (assumed impossible as at Tcl 8.6)"
-                if {$alias_qualified ne $alias_unqalified} {
-
-                } else {
-                    set alias $alias_unqualified
-                }
-            } else {
-                set alias ${alias_qualified}${alias_unqualified} ;#concatenate - as at least one should be empty
-            }
-
-            if {[string length $alias]} {
-                #todo - consider following alias-chain to ultimate proc?
-                #it can always be manually done with:
-                #.= corp $name |/1> corp |/1> corp ..
-                #depending on number of aliases in the chain
-                return [list alias {*}$alias]
-            }
-        } 
-        if {[nsprefix $origin] ne [nsprefix [nsjoin ${targetns} $name]]} {
-            append body "# namespace origin $origin" \n
-        }
-
-        append body [info body $origin]
-        set argl {}
-        foreach a [info args $origin] {
-            if {[info default $origin $a def]} {
-                lappend a $def
-            }
-            lappend argl $a
-        }
-        list proc [nsjoin ${targetns} $name] $argl $body
-    }
-
-
-    #review ???
-    proc ns_relative_to_location {name} {
-        if {[string match ::* $name]} {
-            error "ns_relative_to_location accepts a relative namespace name only ie one without leading ::"
-        }
-
-    }
-    proc ns_absolute_to_location {name} {
-
-    }
-
-
-    namespace eval internal {
-
-
-        #maintenance: similar in punk::winrun
-        proc get_run_opts {options alias_dict arglist} {
-            if {[catch {
-                set callerinfo [info level -1]
-            } errM]} {
-                set caller ""
-            } else {
-                set caller [lindex $callerinfo 0]
-            }
-
-            #update alias dict mapping shortnames to longnames - longnames to self
-            foreach o $options {
-                dict set alias_dict $o $o
-            }
-            set known_runopts [dict keys $alias_dict]
-            set runopts [list]
-            set cmdargs [list]
-
-            set first_eopt_posn [lsearch $arglist --]
-            if {$first_eopt_posn >=0} {
-                set pre_eopts [lrange $arglist 0 $first_eopt_posn-1]
-                set is_eopt_for_runopts 1 ;#default assumption that it is for this function rather than part of user's commandline - cycle through previous args to disprove.
-                foreach pre $pre_eopts {
-                    if {$pre ni $known_runopts} {
-                        set is_eopt_for_runopts 0; #the first -- isn't for us.
-                    }
-                }
-            } else {
-                set is_eopt_for_runopts 0
-            }
-            #split on first -- if only known opts preceding (or nothing preceeding) - otherwise split on first arg that doesn't look like an option and bomb if unrecognised flags before it.
-            if {$is_eopt_for_runopts} {
-                set idx_first_cmdarg [expr $first_eopt_posn + 1]
-                set runopts [lrange $arglist 0 $idx_first_cmdarg-2] ;#exclude -- from runopts - it's just a separator.
-            } else {
-                set idx_first_cmdarg [lsearch -not $arglist "-*"]
-                set runopts [lrange $arglist 0 $idx_first_cmdarg-1]
-            }
-            set cmdargs [lrange $arglist $idx_first_cmdarg end]
-            foreach o $runopts {
-                if {$o ni $known_runopts} {
-                    error "$caller: Unknown runoption $o - known options $known_runopts"
-                }
-            }
-            set runopts [lmap o $runopts {dict get $alias_dict $o}]
-            #todo - get these out of here. Should be supplied by caller.
-            if {"-allowvars" in $runopts && "-disallowvars" in $runopts} {
-                puts stderr "Warning - conflicting options -allowvars & -disallowvars specified: $arglist"
-            }
-
-            #maintain order: runopts $runopts cmdargs $cmdargs as first 4 args (don't break 'lassign [get_runopts $args] _ runopts _ cmdargs')
-            #todo - add new keys after these indicating type of commandline etc.
-            return [list runopts $runopts cmdargs $cmdargs]
-        }
-
-        proc _pkguse_vars {varnames} {
-            while {"pkguse_vars_[incr n]" in $varnames} {}
-            return [concat $varnames pkguse_vars_$n]
-        }
-        proc tracehandler_nowrite {args} {
-            error "readonly in use block"
-        }
-
-    }
-
-
-    #load package and move to namespace of same name if run interactively with only pkg/namespace argument.
-    #if args is supplied - first word is script to run in the namespace remaining args are args passed to scriptblock
-    #if no newline or $args in the script - treat as one-liner and supply {*}$args automatically
-    proc pkguse {pkg_or_existing_ns args} {
-        lassign [internal::get_run_opts {-vars -nowarnings} {} $args] _r runopts _c cmdargs
-        set use_vars    [expr {"-vars" in $runopts}]
-        set no_warnings [expr {"-nowarnings" in $runopts}]
-
-
-        #todo support leading solo flags such as -capture to control whether we do a static capture of local vars in the ns
-        if {[string tolower $pkg_or_existing_ns] in [list :: global]} {
-            set ns ::
-            set ver "";# tcl version?
-        } else {
-            if {[string match ::* $pkg_or_existing_ns]} {
-                if {![namespace exists $pkg_or_existing_ns]} {
-                    set ver [package require [string range $pkg_or_existing_ns 2 end]]
-                } else {
-                    set ver ""
-                }
-                set ns $pkg_or_existing_ns
-            } else {
-                set ver [package require $pkg_or_existing_ns]
-                set ns ::$pkg_or_existing_ns
-            }
-        }
-        if {[namespace exists $ns]} {
-            if {[llength $cmdargs]} {
-                set binding {}
-                #if {[info level] == 1} {
-                #    #up 1 is global 
-                #    set get_vars [list info vars]
-                #} else {
-                #    set get_vars [list info locals]
-                #}
-                #set vars [uplevel 1 {*}$get_vars]
-
-                #set vars [namespace eval $ns {info vars}]
-
-                #review - upvar in apply within ns eval vs direct access of ${ns}::varname
-                set capture [namespace eval $ns {
-                    apply { varnames  {
-                        while {"prev_args_[incr n]" in $varnames} {}
-                        set capturevars [dict create]
-                        set capturearrs [dict create]
-                        foreach fullv $varnames {
-                            set  v [namespace tail $fullv]
-                            upvar 1 $v var
-                            if {[info exists var]} {
-                                if {$v eq "args"} {
-                                    dict set capturevars "prev_args$n" [list var $var]
-                                } else {
-                                    if {(![array exists var])} {
-                                        dict set capturevars $v $var
-                                    } else {
-                                        dict set capturearrs $v [array get var]
-                                    }
-                                }
-                            } else {
-                                #A variable can show in the results for 'info vars' (or nsvars) but still not exist. e.g a 'variable x' declaration in the namespace where the variable has never been set
-                            }
-                        }                        
-                        return [dict create vars $capturevars arrs $capturearrs]
-                    } } [info vars [namespace current]::*]  ;#we are relying on info vars ::::* returning same as info vars ::*  - a bit hacky (don't want to set any extra vars in the ns)
-                } ]
-
-
-                set arglist [lassign $cmdargs scriptblock]
-                if {[string first "\n" $scriptblock] <0 && [string first {$args} $scriptblock] <0} {
-                    #one liner without use of $args  
-                    append scriptblock { {*}$args}
-                    #tailcall apply [list args [string cat $scriptblock { {*}$args}] $ns] {*}$arglist
-                }
-                if {!$no_warnings & $use_vars} {
-                    set script ""
-                    foreach v [dict keys [dict get $capture vars]] {
-                        append script [string map [list <v> $v] {
-                            trace add variable <v> write ::punk::ns::internal::tracehandler_nowrite
-                            #unset?
-                        }]
-                    }
-                    append script \n $scriptblock
-                } else {
-                    set script $scriptblock
-                }
-                if {$use_vars} {
-                    tailcall apply [list [concat [dict keys [dict get $capture vars]] args] $script $ns] {*}[concat [dict values [dict get $capture vars]] $arglist]
-                } else {
-                    tailcall apply [list args $scriptblock $ns] {*}$arglist
-                }
-            } else {
-                set out [punk::ns::ns/ / $ns]
-                append out \n  $ver
-                return $out
-            }
-        } else {
-            error "Namespace $ns not found."
-        }
-        return $out
-    }
-    interp alias "" use "" punk::ns::pkguse
-
-    proc nsimport_noclobber {pattern {ns ""}} {
-        set source_ns [namespace qualifiers $pattern]
-        if {![namespace exists $source_ns]} {
-            error "nsimport_noclobber error namespace $source_ns not found"
-        }
-        if {$ns eq ""} {
-            set ns [uplevel 1 {namespace current}]
-        } elseif {![string match ::* $ns]} {
-            set nscaller [uplevel 1 {namespace current}]
-            set ns [punk::nsjoin $nscaller $ns]
-        }
-        set a_export_patterns [namespace eval $source_ns {namespace export}] 
-        set a_commands [info commands $pattern]
-        set a_tails [lmap v $a_commands {namespace tail $v}]
-        set a_exported_tails [list]
-        foreach pattern $a_export_patterns {
-            set matches [lsearch -all -inline $a_tails $pattern]
-            foreach m $matches {
-                if {$m ni $a_exported_tails} {
-                    lappend a_exported_tails $m
-                }
-            }
-        }
-        set imported_commands [list]
-        foreach e $a_exported_tails {
-            set imported [namespace eval $ns [string map [list <func> $e <a> $source_ns] {
-                set cmd ""
-                if {![catch {namespace import <a>::<func>}]} {
-                    set cmd <func>
-                }
-                set cmd
-            }]]
-            if {[string length $imported]} {
-                lappend imported_commands $imported
-            }
-        }
-        return $imported_commands
-    }
-
-    #todo - use ns::nsimport_noclobber instead
-
-    interp alias {} nsthis    {} punk::ns::nspath_here_absolute
-    interp alias {} nsorigin {} apply {ns {namespace origin [uplevel 1 ::punk::ns::nspath_here_absolute $ns]} ::}
-    interp alias {} nsvars {} punk::ns::nsvars
-    interp alias {} nsjoin {} punk::ns::nsjoin
-    interp alias {} nsprefix {} punk::ns::nsprefix
-    interp alias {} nstail {} punk::ns::nstail
-    interp alias {} nsparts {} punk::ns::nsparts
-    interp alias {} nstree  {} punk::ns::nstree
-    #namespace/command/proc query
-    interp alias {} nslist {} punk::ns::nslist
-    interp alias {} nslist_dict {} punk::ns::nslist_dict
-
-    #extra slash implies more verbosity (ie display commands instead of just nschildren)
-    interp alias {} n/ {} punk::ns::ns/ /
-    interp alias {} n// {} punk::ns::ns/ //
-    interp alias {} n/// {} punk::ns::ns/ ///
-    interp alias {} n/new {} punk::ns::n/new
-    interp alias {} nn/ {} punk::ns::nsup/ /
-    interp alias {} nn// {} punk::ns::nsup/ //
-    if 0 {
-    #we can't have ::/ without just plain / which is confusing.
-    interp alias {} :/ {} punk::ns::ns/ /
-    interp alias {} :// {} punk::ns::ns/ //
-    interp alias {} :/new {} punk::ns::n/new
-    interp alias {} ::/ {} punk::ns::nsup/ /
-    interp alias {} ::// {} punk::ns::nsup/ //
-    }
-
-
-    interp alias {} corp       {} punk::ns::corp
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::ns [namespace eval punk::ns {
-    variable version
-    set version 0.1.0 
-}]
-return
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/overlay-0.1.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/overlay-0.1.tm
deleted file mode 100644
index eebf0e1e..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/overlay-0.1.tm
+++ /dev/null
@@ -1,159 +0,0 @@
-
-
-package require punk::mix::util
-
-namespace eval ::punk::overlay {
-    #based *loosely* on: wiki.tcl-lang.org/page/ensemble+extend
-    # extend an ensemble-like routine with the routines in some namespace
-    #
-    # e.g custom_from_base ::punk::mix::cli ::punk::mix::base
-    #
-    proc custom_from_base {routine base} {
-        if {![string match ::* $routine]} {
-            set resolved [uplevel 1 [list ::namespace which $routine]]
-            if {$resolved eq {}} {
-                error [list {no such routine} $routine]
-            }
-            set routine $resolved
-        }
-        set routinens [namespace qualifiers $routine]
-        if {$routinens eq {::}} {
-            set routinens {}
-        }
-        set routinetail [namespace tail $routine]
-
-        if {![string match ::* $base]} {
-            set base [uplevel 1 [
-                list [namespace which namespace] current]]::$base
-        }
-
-        if {![namespace exists $base]} {
-            error [list {no such namespace} $base]
-        }
-
-        set base [namespace eval $base [
-            list [namespace which namespace] current]]
-
-
-        #while 1 {
-        #    set renamed ${routinens}::${routinetail}_[info cmdcount]
-        #    if {[namespace which $renamed] eq {}} break
-        #}
-
-        namespace eval $routine [
-            list namespace ensemble configure  $routine -unknown [
-                list apply {{base ensemble subcommand args} {
-                    list ${base}::_redirected $ensemble $subcommand 
-                }} $base
-            ]
-        ]
-
-        punk::mix::util::namespace_import_pattern_to_namespace_noclobber ::punk::mix::util::* ${routine}::util
-        #namespace eval ${routine}::util {
-            #namespace import ::punk::mix::util::*
-        #}
-        punk::mix::util::namespace_import_pattern_to_namespace_noclobber ${base}::lib::* ${routine}::lib
-        #namespace eval ${routine}::lib [string map [list <base> $base] {
-        #    namespace import <base>::lib::*
-        #}]
-
-        namespace eval ${routine}::lib [string map [list <base> $base <routine> $routine] {
-            if {[namespace exists <base>::lib]} {
-                set current_paths [namespace path]
-                if {"<routine>" ni $current_paths} {
-                    lappend current_paths <routine>
-                }
-                namespace path $current_paths
-            }
-        }]
-
-        namespace eval $routine {
-            set exportlist [list]
-            foreach cmd [info commands [namespace current]::*] {
-                set c [namespace tail $cmd]
-                if {![string match _* $c]} {
-                    lappend exportlist $c
-                }
-            }
-            namespace export {*}$exportlist
-        }
-
-        return $routine
-    }
-    #load *exported* commands from cmdnamespace into caller's namespace - prefixing each command with $prefix
-    #Note: commandset may be imported by different CLIs with different bases *at the same time*
-    #so we don't make commands from the cli or its base available automatically (will generally require fully-qualified commands to use code from cli/base) 
-    #we do load punk::mix::util::*  into the util subnamespace even though the commandset might not be loaded in a cli using punk::mix::base  i.e punk::mix::util is a common dependency for CLIs.
-    #commandsets designed to be used with a specific cli/base may choose to do their own import e.g with util::namespace_import_pattern_to_namespace_noclobber and/or set namespace path if they 
-    #want the convenience of using lib:xxx with commands coming from those packages.
-    #This won't stop the commandset being used with other cli/bases unless the import is done by looking up the callers namespace.
-    #The basic principle is that the commandset is loaded into the caller(s) with a prefix 
-    #- but commandsets should explicitly package require if they have any backwards dependencies on cli/base (which they may or may not be loaded into)
-    proc import_commandset {prefix separator cmdnamespace} {
-        set bad_seps [list "::"]
-        if {$separator in $bad_seps} {
-            error "import_commandset invalid separator '$separator'"
-        }
-        #namespace may or may not be a package
-        # allow with or without leading ::
-        if {[string range $cmdnamespace 0 1] eq "::"} {
-            set cmdpackage [string range $cmdnamespace 2 end]
-        } else {
-            set cmdpackage $cmdnamespace
-            set cmdnamespace ::$cmdnamespace
-        }
-
-        if {![namespace exists $cmdnamespace]} {
-            #only do package require if the namespace not already present
-            catch {package require $cmdpackage} pkg_load_info 
-            #recheck
-            if {![namespace exists $cmdnamespace]} {
-                set prov [package provide $cmdpackage]
-                if {[string length $prov]} {
-                    set provinfo "(package $cmdpackage is present with version $prov)"
-                } else {
-                    set provinfo "(package $cmdpackage not present)"
-                }
-                error "punk::overlay::import_commandset supplied namespace '$cmdnamespace' doesn't exist. $provinfo  Pkg_load_result: $pkg_load_info  Usage: import_commandset prefix separator namespace"
-            }
-        }
-     
-        punk::mix::util::namespace_import_pattern_to_namespace_noclobber ::punk::mix::util::* ${cmdnamespace}::util
-
-        #let child namespace 'lib' resolve parent namespace and thus util::xxx
-        namespace eval ${cmdnamespace}::lib [string map [list <cmdns> $cmdnamespace] {
-            set nspaths [namespace path]
-            if {"<cmdns>" ni $nspaths} {
-                lappend nspaths <cmdns>
-            }
-            namespace path $nspaths
-        }]
-
-        set imported_commands [list]
-        set nscaller [uplevel 1 [list namespace current]]
-        if {[catch {
-            #review - noclobber?
-            namespace eval ${nscaller}::temp_import [list namespace import ${cmdnamespace}::*]
-            foreach cmd [info commands ${nscaller}::temp_import::*] {
-                set cmdtail [namespace tail $cmd]
-                if {$cmdtail eq "_default"} {
-                    set import_as ${nscaller}::${prefix}
-                } else {
-                    set import_as ${nscaller}::${prefix}${separator}${cmdtail}
-                }
-                rename $cmd  $import_as
-                lappend imported_commands $import_as
-            }
-        } errM]} {
-            puts stderr "Error loading commandset $prefix $separator $cmdnamespace"
-            puts stderr "err: $errM"
-        }
-        return $imported_commands
-    }
-}
-
-
-package provide punk::overlay [namespace eval punk::overlay {
-    variable version
-    set version 0.1 
-}]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/path-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/path-0.1.0.tm
deleted file mode 100644
index f877417a..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/path-0.1.0.tm
+++ /dev/null
@@ -1,397 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::path 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin punkshell_module_punk::path 0 0.1.0]
-#[copyright "2023"]
-#[titledesc {Filesystem path utilities}]  [comment {-- Name section and table of contents description --}]
-#[moddesc {punk path filesystem utils}]             [comment {-- Description at end of page heading --}] 
-#[require punk::path]
-#[description]
-#[keywords module path filesystem]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section Overview]
-#[para] overview of punk::path
-#[para] Filesystem path utility functions
-#[subsection Concepts]
-#[para] -
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[subsection dependencies]
-#[para] packages used by punk::path
-#[list_begin itemized]
-
-package require Tcl 8.6
-#*** !doctools
-#[item] [package {Tcl 8.6}]
-
-# #package require frobz
-# #*** !doctools
-# #[item] [package {frobz}]
-
-#*** !doctools
-#[list_end]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section API]
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# oo::class namespace
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::path::class {
-    #*** !doctools
-    #[subsection {Namespace punk::path::class}]
-    #[para] class definitions
-    if {[info commands [namespace current]::interface_sample1] eq ""} {
-        #*** !doctools
-        #[list_begin enumerated]
-
-        # oo::class create interface_sample1 {
-        #     #*** !doctools
-        #     #[enum] CLASS [class interface_sample1]
-        #     #[list_begin definitions]
-
-        #     method test {arg1} {
-        #         #*** !doctools
-        #         #[call class::interface_sample1    [method test] [arg arg1]]
-        #         #[para] test method
-        #         puts "test: $arg1"
-        #     }
-
-        #     #*** !doctools
-        #     #[list_end] [comment {-- end definitions interface_sample1}]
-        # }
-
-        #*** !doctools
-        #[list_end] [comment {--- end class enumeration ---}]
-    }
-}
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# Base namespace
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::path {
-    namespace export *
-    #variable xyz
-
-    #*** !doctools
-    #[subsection {Namespace punk::path}]
-    #[para] Core API functions for punk::path 
-    #[list_begin definitions]
-
-
-    proc pathglob_as_re {pathglob} {
-        #*** !doctools
-        #[call [fun pathglob_as_re] [arg pathglob]]
-        #[para] Returns a regular expression for matching a path to a glob pattern which can contain glob chars *|? in any segment of the path structure
-        #[para] ** matches any number of subdirectories. 
-        #[para] e.g /etc/**/*.txt will match any .txt files at any depth below /etc  (except directly within /etc itself)
-        #[para] e.g /etc/**.txt will match any .txt files at any depth below /etc
-        #[para] any segment that does not contain ** must match exactly one segment in the path
-        #[para] e.g the glob /etc/*/*.doc  - will match any .doc files that are exactly one tree level below /etc 
-        #[para] The pathglob doesn't have to contain glob characters, in which case the returned regex will match the pathglob exactly as specified.
-        #[para] Regular expression syntax is deliberateley not supported within the pathglob string so that supplied regex characters will be treated as literals 
-
-
-        #todo - consider whether a way to escape the glob chars ? * is practical - to allow literals ? *
-        # - would require counting immediately-preceding backslashes
-        set pats [list]
-        foreach seg [file split $pathglob] {
-            if {[string range $seg end end] eq "/"} {
-                set seg [string range $seg 0 end-1] ;# e.g c:/ -> c:   / -> ""  so that join at end doesn't double up
-            }
-            if {$seg eq "*"} {
-                lappend pats {[^/]*}
-            } elseif {$seg eq "**"} {
-                lappend pats {.*}
-            } else {
-                set seg [string map [list {^ {\^} $ {\$} [} {\[} ( {\(} \{ \\\{ \\ {\\}] $seg] ;#treat regex characters in the input as literals 
-                set seg [string map [list  . {[.]}] $seg]
-                if {[regexp {[*?]} $seg]} {
-                    set pat [string map [list ** {.*} * {[^/]*} ? {[^/]}] $seg]
-                    lappend pats "$pat"
-                } else {
-                    lappend pats "$seg"
-                }
-            }
-        }
-        return  "^[join $pats /]\$"
-    }
-    proc globmatchpath {pathglob path args} {
-        #*** !doctools
-        #[call [fun globmatchpath] [arg pathglob] [arg path] [opt {option value...}]]
-        #[para] Return true if the pathglob matches the path
-        #[para] see [fun pathglob_as_re] for pathglob description
-        #[para] Caller must ensure that file separator is forward slash. (e.g use file normalize on windows)
-        #[para]
-        #[para] Known options:
-        #[para]     -nocase 0|1  (default 0 - case sensitive)
-        #[para] If -nocase is not supplied - default to case sensitive *except for driveletter*
-        #[para] ie - the driveletter alone in paths such as c:/etc will still be case insensitive. (ie c:/ETC/* will match C:/ETC/blah but not C:/etc/blah)
-        #[para] Explicitly specifying -nocase 0 will require the entire case to match including the driveletter.
-
-        set defaults [dict create\
-            -nocase \uFFFF\
-        ]
-        set known_opts [dict keys $defaults]
-        set opts [dict merge $defaults $args]
-        dict for {k v} $args {
-            if {$k ni $known_opts} {
-                error "Unrecognised options $k - known options: $known_opts"
-            }
-        }
-        # -- --- --- --- --- --- 
-        set opt_nocase [dict get $opts -nocase]
-        set explicit_nocase 1 ;#default to disprove 
-        if {$opt_nocase eq "\uFFFF"} {
-            set opt_nocase 0
-            set explicit_nocase 0
-        } 
-        # -- --- --- --- --- --- 
-        if {$opt_nocase} {
-            return [regexp -nocase [pathglob_as_re $pathglob] $path]
-        } else {
-            set re [pathglob_as_re $pathglob]
-            if {$explicit_nocase} {
-                set ismatch [regexp $re $path] ;#explicit -nocase 0  - require exact match of path literals including driveletter
-            } else {
-                #caller is using default for -nocase - which indicates case sensitivity - but we have an exception for the driveletter.
-                set re_segments [file split $re] ;#Note that file split c:/etc gives {c:/ etc}  but file split ^c:/etc gives {^c: etc}
-                set first_seg [lindex $re_segments 0]
-                if {[regexp {^\^(.{1}):$} $first_seg _match driveletter]} {
-                    #first part of re is like "^c:" i.e a drive letter
-                    set chars [string tolower $driveletter][string toupper $driveletter]
-                    set re [join [concat "^\[$chars\]:" [lrange $re_segments 1 end]] /] ;#rebuild re with case insensitive driveletter only - use join - not file join. file join will misinterpret leading re segment.
-                }
-                #puts stderr "-->re: $re"
-                set ismatch [regexp $re $path]
-            }
-        }
-        return $ismatch
-    }
-
-    #todo - implement treefiles which acts like dirfiles but allows path globbing in the same way as punk::ns::ns/ 
-    #then review if treefiles can replace dirfiles or if both should exist (dirfiles can have literal glob chars in path segments - but that is a rare usecase)
-    proc treefilenames {basepath tailglob args} {
-        #*** !doctools
-        #[call [fun treefilenames] [arg basepath] [arg tailglob] [opt {option value...}]]
-        #basic (glob based) list of filenames matching tailglob - recursive
-        #no natsorting - so order is dependent on filesystem
-        set defaults [dict create\
-            -call-depth-internal 0\
-            -antiglob_paths {}\
-        ]
-        set opts [dict merge $defaults $args]
-        set opt_antiglob_paths [dict get $opts -antiglob_paths]
-        set CALLDEPTH [dict get $opts -call-depth-internal]
-
-        set files [list]
-        if {$CALLDEPTH == 0} {
-            if {![file isdirectory $basepath]} {
-                return [list] 
-            }
-        }
-
-        set skip 0
-        foreach anti $opt_antiglob_paths {
-            if {[globmatchpath $anti $basepath]} {
-                set skip 1
-                break
-            }
-        }
-        if {$skip} {
-            return [list]
-        }
-
-        #todo - account for vfs where matched path could appear to be a directory but is mounted so could be a desired match?
-        set dirfiles [glob -nocomplain -dir $basepath -type f $tailglob] 
-        lappend files  {*}$dirfiles
-        set dirdirs [glob -nocomplain -dir $basepath -type d *]
-        foreach dir $dirdirs {
-            set skip 0
-            foreach anti $opt_antiglob_paths {
-                if {[globmatchpath $anti $dir]} {
-                    set skip 1
-                    break 
-                }
-            }
-            if {$skip} {
-                continue
-            }
-            set nextargs [dict merge $args [list -call-depth-internal [incr CALLDEPTH]]]
-            lappend files {*}[treefilenames $dir $tailglob {*}$nextargs]
-        }
-        return $files
-    }
-
-    #maint warning - also in punkcheck
-    proc relative {reference location} {
-        #*** !doctools
-        #[call [fun relative] [arg reference] [arg location]]
-        #[para]    Taking two directory paths, a reference and a location, computes the path
-        #    of the location relative to the reference.
-        #[list_begin itemized]
-        #[item]
-        #[para] Arguments:
-        #       [list_begin arguments]
-        #       [arg_def string reference]       The path from which the relative path to location is determined. 
-        #       [arg_def string location]        The location path which may be above or below the reference path 
-        #       [list_end]
-        #[item]
-        #[para] Results:
-        #[para]    The relative path of the location to the reference path.
-        #[para]    Will return a single dot "." if the paths are the same
-        #[item]
-        #[para] Notes:
-        #[para]    Both paths must be the same type - ie both absolute or both relative
-        #[para]    Case sensitive.  ie  relative /etc /etC 
-        #      will return ../etC
-        #[para]    On windows, the drive-letter component (only) is not case sensitive
-        #[para]    ie relative c:/etc  C:/etc  returns .  
-        #[para]    but relative c:/etc C:/Etc returns ../Etc
-        #[para]    On windows, if the paths are absolute and specifiy different volumes, only the location will be returned.
-        #    ie  relative c:/etc d:/etc/blah
-        #    returns d:/etc/blah
-        #[list_end]
-
-        #see also kettle
-        # Modified copy of ::fileutil::relative (tcllib)
-        # Adapted to 8.5 ({*}).
-
-        #review - check volume info on windows.. UNC paths?
-        if {[file pathtype $reference] ne [file pathtype $location]} {
-            return -code error "Unable to compute relation for paths of different pathtypes: [file pathtype $reference] vs. [file pathtype $location], ($reference vs. $location)"
-        }
-
-        #avoid normalizing if possible (file normalize *very* expensive on windows)
-        set do_normalize 0
-        if {[file pathtype $reference] eq "relative"} {
-            #if reference is relative so is location 
-            if {[regexp {[.]{2}} [list $reference $location]]} {
-                set do_normalize 1
-            }
-            if {[regexp {[.]/} [list $reference $location]]} {
-                set do_normalize 1
-            }
-        } else {
-            set do_normalize 1
-        }
-        if {$do_normalize} {
-            set reference [file normalize $reference]
-            set location  [file normalize $location]
-        }
-
-        set save $location
-        set reference [file split $reference]
-        set location  [file split $location]
-
-        while {[lindex $location 0] eq [lindex $reference 0]} {
-            set location  [lrange $location  1 end]
-            set reference [lrange $reference 1 end]
-            if {![llength $location]} {break}
-        }
-
-        set location_len  [llength $location]
-        set reference_len [llength $reference]
-
-        if {($location_len == 0) && ($reference_len == 0)} {
-            # Cases:
-            # (a) reference == location
-
-            set location .
-        } else {
-            # Cases:
-            # (b) ref is: ref/sub = sub
-            #     loc is: ref     = {}
-
-            # (c) ref is: ref     = {}
-            #     loc is: ref/sub = sub
-
-            while {$reference_len > 0} {
-                set location [linsert $location 0 ..]
-                incr reference_len -1
-            }
-            set location [file join {*}$location]
-        }
-        return $location
-    }
-
-
-
-    #*** !doctools
-    #[list_end] [comment {--- end definitions namespace punk::path ---}]
-}
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# Secondary API namespace
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::path::lib {
-        namespace export *
-        namespace path [namespace parent]
-        #*** !doctools
-        #[subsection {Namespace punk::path::lib}]
-        #[para] Secondary functions that are part of the API 
-        #[list_begin definitions]
-
-
-
-
-
-        #*** !doctools
-        #[list_end] [comment {--- end definitions namespace punk::path::lib ---}]
-}
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[section Internal]
-namespace eval punk::path::system {
-        #*** !doctools
-        #[subsection {Namespace punk::path::system}]
-        #[para] Internal functions that are not part of the API 
-
-
-
-}
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::path [namespace eval punk::path {
-    variable pkg punk::path
-    variable version
-    set version 0.1.0 
-}]
-return
-
-#*** !doctools
-#[manpage_end]
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/repo-0.1.1.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/repo-0.1.1.tm
deleted file mode 100644
index d2aaf9fc..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/repo-0.1.1.tm
+++ /dev/null
@@ -1,1267 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#Copyright (c) 2023 Julian Noble
-#Copyright (c) 2012-2018 Andreas Kupries
-# - code from A.K's 'kettle' project used in this module
-#
-# @@ Meta Begin
-# Application punk::repo 0.1.1
-# Meta platform     tcl
-# Meta license      BSD
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#
-# path/repo functions
-#
-if {$::tcl_platform(platform) eq "windows"} {
-    package require punk::winpath
-} else {
-    catch {package require punk::winpath}
-}
-package require fileutil; #tcllib
-package require punk::path
-package require punk::mix::base ;#uses core functions from punk::mix::base::lib namespace e.g cksum_path 
-package require punk::mix::util ;#do_in_path
-
-
-# -- --- --- --- --- --- --- --- --- --- ---
-# For performance/efficiency reasons - use file functions on paths in preference to string operations
-# e.g use file join 
-# branch to avoid unnecessary calls to 'pwd' or 'file normalize' - which can be surprisingly expensive operations (as at tcl 8.7 2023)
-# pwd is only expensive if we treat it as a string instead of a list/path
-# e.g 
-# > time {set x [pwd]}
-# 5 microsoeconds..  no problem
-# > time {set x [pwd]}
-# 4 microsoeconds..  still no problem
-# > string length $x
-# 45
-# > time {set x [pwd]}
-# 1372 microseconds per iteration   ;#!!   values above 0.5ms common.. and that's a potential problem in loops that trawl filesystem
-# The same sorts of timings occur with file normalize
-# also.. even if we build up a path with file join from a base value that has already been normalized - the subsequent normalize will be expensive
-# -- --- --- --- --- --- --- --- --- --- ---
-
-namespace eval punk::repo {
-
-    #Todo - investigate proper way to install a client-side commit hook in the fossil project 
-    #Then we may still use this proxy to check the hook - but the required checks will occur when another shell used
-    proc fossil_proxy {args} {
-        set start_dir [pwd]
-        set fosroot [find_fossil $start_dir] 
-        set fossilcmd [lindex $args 0]
-
-        set no_warning_commands [list "help"  "dbstat" "grep" "diff" "xdiff" "cat" "version"]
-        if {$fossilcmd ni $no_warning_commands } {
-            set repostate [find_repos $start_dir] 
-        }
-
-        set no_prompt_commands [list "status" "info" {*}$no_warning_commands]
-
-
-        if {$fossilcmd ni $no_prompt_commands} {
-            set fossilrepos [dict get $repostate fossil]
-            if {[llength $fossilrepos] > 1} {
-                puts stdout [dict get $repostate warnings]
-                puts stdout "Operating on inner fossil repository: [lindex $fossilrepos 0]"
-                puts stdout "Use FOSSIL instead of fossil to avoid this prompt and warning"
-                set answer [askuser "Are you sure you want to perform the operation on this repo? Y/N"]
-                if {[string tolower $answer] ne "y"} {
-                    return
-                }
-            }
-        }
-        if {$fossilcmd eq "init"} {
-            #check if the path to .fossil is within an outer repo area.. offer to locate it somewhere else
-            set repos [dict get $repostate repos]
-            if {[llength $repos]} {
-                set chosenfossil [lindex $args end]
-                #if the user is naming it other than .fossil - assume they know what they're doing.
-                if {[string match *.fossil $chosenfossil]} {
-                    set norm_chosen [file normalize $chosenfossil]
-                    set fdir [file dirname $norm_chosen]
-                    set toprepo_info [lindex $repos end] ;#choose shortest path ie topmost
-                    set toprepo [lindex $toprepo_info 0]
-                    if {[punk::mix::base::lib::path_a_atorbelow_b $fdir $toprepo]} {
-                        set fproj [file rootname [file tail $norm_chosen]]
-                        puts stdout "Chosen .fossil location is within outer repository at $toprepo"
-                        set answer [askuser "Would you like the opportunity to choose a different location for the .fossil file from a menu? Y/N"]
-                        if {[string tolower $answer] eq "y"} {
-                            set repodir [fossil_get_repository_folder_for_project $fproj -extrachoice $fdir]
-                            if {[string length $repodir]} {
-                                puts stdout "LOCATION: $repodir/$fproj.fossil"
-                                set args [lrange $args 0 end-1]
-                                lappend args $repodir/$fproj.fossil
-                            } else {
-                                puts stderr "No directory found/selected - aborting"
-                                return
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if {$fossilcmd eq "commit"} {
-            if {[llength [file split $fosroot]]} {
-                if {[file exists [file join $fosroot src/buildsuites]]} {
-                    puts stderr "Todo - check buildsites/suite/projects for current branch/tag and update download_and_build_config"
-                }
-            }
-        } elseif {$fossilcmd in [list "info" "status"]} {
-            #emit warning whether or not multiple fossil repos
-            puts stdout [dict get $repostate warnings]
-        }
-        set fossil_prog [auto_execok fossil]
-        if {$fossil_prog ne ""} {
-            {*}$fossil_prog {*}$args
-        } else {
-            puts stderr "fossil command not found. Please install fossil"
-        }
-    }
-    interp alias "" fossil "" punk::repo::fossil_proxy
-
-    if {[auto_execok fossil] ne ""} { 
-        interp alias "" FOSSIL "" {*}[auto_execok fossil]
-    }
-
-    proc askuser {question} {
-        puts stdout $question
-        flush stdout
-        set stdin_state [fconfigure stdin]
-        try {
-            fconfigure stdin -blocking 1
-            set answer [gets stdin]
-        } finally {
-            fconfigure stdin -blocking [dict get $stdin_state -blocking]
-        }
-        return $answer
-    }
-    proc is_fossil {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[find_fossil $path] ne {}}]
-    }
-    proc is_git {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[find_git $path] ne {}}]
-    }
-    #tracked repo - but may not be a project
-    proc is_repo {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[isfossil] || [is_git]}]
-    }
-    proc is_candidate {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[find_candidate $path] ne {}}]
-    }
-    proc is_project {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        return [expr {[find_project $path] ne {}}]
-    }
-
-
-    proc find_fossil {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        scanup $path is_fossil_root
-    }
-    
-    proc find_git {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        scanup $path is_git_root
-    }
-    proc find_candidate {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        scanup $path is_candidate_root
-    }
-    proc find_repo {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        #find the closest (lowest in dirtree) repository
-        set f_root [find_fossil $path]
-        set g_root [find_git $path]
-        if {[string length $f_root]} {
-            if {[string length $g_root]} {
-                if {[punk::mix::base::lib::path_a_below_b $f_root $g_root]} {
-                    return $f_root
-                } else {
-                    return $g_root
-                }
-            } else {
-                return $f_root
-            }
-        } else {
-            if {[string length $g_root]} {
-                return $g_root
-            } else {
-                return ""
-            }
-        }
-    }
-    proc find_project {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        scanup $path is_project_root 
-    }
-
-    proc is_fossil_root {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        #from kettle::path::is.fossil
-        foreach control {
-            _FOSSIL_
-            .fslckout
-            .fos
-        } {
-            set control $path/$control
-            if {[file exists $control] && [file isfile $control]} {return 1}
-        }
-        return 0
-    }
-    
-    #review - is a .git folder sufficient?
-    #consider git rev-parse --git-dir ?
-    proc is_git_root {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        set control [file join $path .git]
-        expr {[file exists $control] && [file isdirectory $control]}
-    }
-    proc is_repo_root {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        expr {[is_fossil_root $path] || [is_git_root $path]}
-    }
-    #require a minimum of /src and /modules|lib|scriptapps|*.vfs - and that it's otherwise sensible
-    proc is_candidate_root {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        if {[file pathtype $path] eq "relative"} {
-            set normpath [punk::repo::norm $path]
-        } else {
-            set normpath $path
-        }
-        set unwise_paths [list "/" "/usr/local" "/usr/local/bin" "/usr/local/lib" "c:/windows"]
-        if {[string tolower $normpath] in $unwise_paths} {
-            return 0
-        }
-        if {[file pathtype [string trimright $normpath /]] eq "volumerelative"} {
-            #tcl 8.6/8.7 cd command doesn't preserve the windows "ProviderPath"  (per drive current working directory)
-            return 0
-        }
-
-        #review - adjust to allow symlinks to folders?
-        foreach required {
-            src
-        } {
-            set req $path/$required
-            if {(![file exists $req]) || ([file type $req] ne "directory") } {return 0}
-        }
-
-        set src_subs [glob -nocomplain -dir $path/src -types d -tail *]
-        if {"modules" in $src_subs || "lib" in $src_subs || "scriptapps" in $src_subs} {
-            return 1
-        }
-        foreach sub $src_subs {
-            if {[string match *.vfs $sub]} {
-                return 1
-            }
-        }
-
-        #todo - breadth first search with depth limit (say depth 3?) for *.tm or *.tcl as another positive qualifier for this dir to be a project-root
-        #we probably don't want to deep search a src folder in case the user is accidentally in some other type of project's tree
-        #such a src tree could be very large, so if we don't find tcl indicators near the root it's a good bet this isn't a candidate
-
-        return 0
-    }
-    #keep this message in sync with the programmed requirements of is_candidate_root
-    #message is not titled - it is intended to be output along with more contextual information from the calling site.
-    proc is_candidate_root_requirements_msg {} {
-        set msg ""
-        append msg "./src directory must exist." \n
-        append msg "At least one of ./src/lib ./src/modules ./src/scriptapps or a ./src/<something>.vfs folder should exist." \n
-        #append msg "Alternatively - the presence of any .tm or .tcl files within the top few levels of ./src will suffice." \n
-        return $msg
-    }
-
-    proc is_project_root {path} {
-        #review - find a reliable simple mechanism. Noting we have projects based on different templates. 
-        #Should there be a specific required 'project' file of some sort?
-
-        #test for file/folder items indicating fossil or git workdir base
-        if {(![punk::repo::is_fossil_root $path]) && (![punk::repo::is_git_root $path])} {
-            return 0
-        }
-        #exclude some known places we wouldn't want to put a project 
-        if {![is_candidate_root $path]} {
-            return 0
-        }
-        return 1
-    }
-
-    #review/tests
-    #todo - deleted items (e.g for git 1 .D ... )
-    #punkcheck uses this to check when copying a source-file to a repo-external location that the file can be tied to a revision.
-    #we are primarily concerned with the status of existent files (caller should check existence) and whether they belong to the revision that currently applies to the folder being examined.
-    #we are not concerned with git's staging facility - other than that it needs to be looked at to work out whether the file on disk is currently in a state matching the revision.
-    #
-    # -repotypes is an ordered list - if the closest repo is multi-typed the order will determine which is used.
-    # This deliberately doesn't allow bypassing a sub-repo to look for a higher-level repo in a repo-nest.
-    # The theory is that sub-repos shouldn't have their contents directly tracked directly by higher-level repos anyway
-    #REVIEW - if closest repo is both fossil and git - we only return info for one, with fossil being preferenced
-    #This may not make sense if we want to allow fossil tracking of projects where git is the primary repotype and fossil is just used to enable us to enumerate projects?
-    #does a dual git/fossil repo make sense if both are committing??
-    # see: https://fossil-scm.org/home/doc/trunk/www/inout.wiki for bidirectional sync info
-    proc workingdir_state {{abspath {}} args} {
-        set defaults [list\
-            -repotypes [list fossil git]\
-            -repopaths ""\
-        ]
-        #prefer fossil if first repo is dual git/fossil
-        if {$abspath in [dict keys $defaults]} {
-           set args [list $abspath {*}$args] 
-           set abspath ""
-        } 
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_repotypes [dict get $opts -repotypes]
-        set opt_repopaths [dict get $opts -repopaths]
-        if {"$opt_repopaths" ne ""} {
-            if {([llength $opt_repopaths] % 2 != 0) || ![dict exists $opt_repopaths closest]} {
-                error "workingdir_state error: -repopaths argument invalid. Expected a dict as retrieved using punk::repo::find_repos"
-            }
-            set repopaths $opt_repopaths
-        } else {
-            set repopaths [find_repos $abspath]
-        }
-        # -- --- --- --- --- --- --- --- --- --- --- ---
-
-        if {$abspath eq ""} {set abspath [pwd]}
-        if {[file pathtype $abspath] ne "absolute"} {
-            error "workingdir_state error: absolute path required. Got '$abspath'"
-        }
-        if {![file isdirectory $abspath]} {
-            #shouldn't be passed a file.. but just use containing folder if we were
-            set abspath [file dirname $abspath]
-        }
-        set repodir [dict get $repopaths closest]
-        set ondisk_repotypes [dict get $repopaths closest_types]
-        set repotypes_to_query [list]
-        foreach r $opt_repotypes {
-            if {$r in $ondisk_repotypes} {
-                lappend repotypes_to_query $r              
-            }
-        }
-
-        if {$repodir eq ""} {
-            error "workingdir_state error: No repository found at or above path '$abspath'" 
-        }
-        set subpath [punk::path::relative $repodir $abspath]
-        if {$subpath eq "."} {
-            set subpath ""
-        }
-
-        set resultdict [dict create repodir $repodir subpath $subpath]
-        #set defaults in case no supported repotype found
-        set revision ""
-        set revision_iso8601 ""
-        set pathdict [dict create]
-
-        if {![llength $repotypes_to_query]} {
-            error "No tracking information available for project at $repodir with the chosen repotypes '$opt_repotypes'. Ensure project workingdir is a fossil (or git) checkout"
-        }
-        foreach rt $repotypes_to_query {
-            #We need entire list of files in the revision because there is no easy way to get the list of files configured to be ignored 
-            #(aside from attempting to calculate from .fossil-settings ignore-glob or .gitignore)
-            #This means we can't just use fossil extras or the list of git untracked files 
-            #i.e a file not showing as EDITED/MISSING/EXTRA can't be assumed to be in the revision as it may match an ignore-glob or .gitignore entry
-            #For this reason we will store 'unchanged' records for both git and fossil so that the combined dict should represent all files in the revision
-            if {$rt eq "fossil"} {
-                dict set resultdict repotype fossil
-                set fossil_cmd [auto_execok fossil]
-                if {$fossil_cmd eq ""} {
-                    error "workingdir_state error: fossil executable doesn't seem to be available"
-                }
-                if {[catch {punk::mix::util::do_in_path $repodir [list exec {*}$fossil_cmd status --all --differ --merge $abspath]} fossilstate]} {
-                    error "workingdir_state error: Unable to retrieve workingdir state using fossil. Errormsg: $fossilstate"
-                }
-                # line: checkout: fb971... Y-m-d H:M:S TZ
-                set checkout_info [lindex [grep {checkout:*} $fossilstate] 0] ;#grep returns a list - but it should always be a single match in this case
-                set revision [lindex $checkout_info 0 1]
-                #set checkrevision [fossil_revision $abspath]
-                lassign $checkout_info _key revision revision_ymd revision_hms revision_tz
-                if {$revision_tz eq "UTC"} {
-                    set revision_tz "+0000" ;#normalize UTC for consistency with git tz output - review - should do date-math if necessary on git and fossil to bring all to +0000 (is fossil always UTC? git )
-                }
-                set revision_iso8601 "${revision_ymd}T${revision_hms}${revision_tz}"
-
-
-                dict set resultdict ahead ""
-                dict set resultdict behind ""
-
-                foreach ln [split $fossilstate \n] {
-                    if {[string trim $ln] eq ""} {continue}
-                    set space1 [string first " " $ln]
-                    if {$space1 > 1} {
-                       set word1 [string range $ln 0 $space1-1] 
-                       if {[string index $word1 end] eq ":"} {
-                           #we've already examined any xxx: header lines we're interested in.
-                           continue
-                       }
-                    }
-                    if {[string match "EDITED *" $ln]} {
-                        set path [string trim [string range $ln [string length "EDITED "] end]] ;#should handle spaced paths
-                        dict set pathdict $path "changed"
-                    } elseif {[string match "ADDED *" $ln]} {
-                        set path [string trim [string range $ln [string length "ADDED "] end]]
-                        dict set pathdict $path "new"
-                    } elseif {[string match "DELETED *" $ln]} {
-                        set path [string trim [string range $ln [string length "DELETED "] end]]
-                        dict set pathdict $path "missing"
-                    } elseif {[string match "MISSING *" $ln]} {
-                        set path [string trim [string range $ln [string length "MISSING "] end]]
-                        dict set pathdict $path "missing"
-                    } elseif {[string match "EXTRA *" $ln]} {
-                        #fossil will explicitly list files in a new folder - as opposed to git which shows just the folder
-                        set path [string trim [string range $ln [string length "EXTRA "] end]]
-                        dict set pathdict $path "extra"
-                    } elseif {[string match "UNCHANGED *" $ln]} {
-                        set path [string trim [string range $ln [string length "UNCHANGED "] end]]
-                        dict set pathdict $path "unchanged"
-                    } else {
-                        #emit for now 
-                        puts stderr "unprocessed fossilstate line: $ln" 
-                    }
-                    #other entries??
-                }
-                break
-            } elseif {$rt eq "git"} {
-                dict set resultdict repotype git 
-                set git_cmd [auto_execok git]
-                # -uno =  suppress ? lines.
-                # -b = show ranch and tracking info
-                if {[catch {punk::mix::util::do_in_path $repodir [list exec {*}$git_cmd status --porcelain=2 -b -- $abspath]} gitstate]} {
-                    error "workingdir_state error: Unable to retrieve workingdir state using git. Errormsg: $gitstate"
-                }
-                # line: # branch.oid f2d2a...
-                set revision [lindex [grep {# branch.oid *} $gitstate] 0 2]
-                if {$revision eq "(initial)"} {
-                    puts stderr "workingdir_state: git revision is (initial) - no file state to gather"
-                    break
-                }
-
-                # -- --- --- --- --- 
-                #could use %ci for ISO8601 data - see git-show manpage, but this will be in timezone of developer's machine - we need it in UTC for comparison to fossil outputs and other devs
-                set had_TZ 0
-                if {[info exists ::env(TZ)]} {
-                    set TZ_prev $::env(TZ)
-                    set had_TZ 1
-                }
-                set ::env(TZ) "UTC0"
-                if {[catch {punk::mix::util::do_in_path $repodir [list exec {*}$git_cmd show -s --date=format-local:%Y:%m:%dT%H:%M:%S+0000 --format=format:%cd -- $abspath]} revision_iso8601]} {
-                    puts stderr "workingdir_state warning: Unable to retrieve workingdir state using git. Errormsg: $gitstate"
-                }
-                if {$had_TZ} {
-                    set ::env(TZ) $TZ_prev
-                } else {
-                    unset ::env(TZ)
-                }
-                # -- --- --- --- --- 
-
-                dict set resultdict ahead ""
-                dict set resultdict behind ""
-                set aheadbehind [lindex [grep {# branch.ab *} $gitstate] 0]
-                if {[llength $aheadbehind] > 0} {
-                    lassign [lrange $aheadbehind 2 3] a b
-                    if {$a > 0} {
-                        dict set resultdict ahead [expr {abs($a)}]
-                    }
-                    if {$b < 0} {
-                        dict set resultdict behind [expr {abs($b)}]
-                    }
-                }
-                #set checkrevision [git_revision $abspath]
-                if {[catch {punk::mix::util::do_in_path $repodir [list exec {*}$git_cmd ls-tree -r $revision $abspath]} gitfiles]} {
-                    error "workingdir_state error: Unable to retrieve files for revision '$revision' using git. Errormsg: $gitfiles"
-                }
-
-                #paths will be relative to $repodir/$subpath
-                foreach ln [split $gitfiles \n] {
-                    if {[string trim $ln] eq ""} {continue}
-                    #review - spaced paths?
-                    set path [lindex $ln end] 
-                    dict set pathdict $path "unchanged" ;#default only - to be overridden with info from gitstate
-                }
-
-                foreach ln [split $gitstate \n] {
-                    if {[string trim $ln] eq ""} {continue}
-                    if {[string match "#*" $ln]} {continue}
-                    if {[string match "1 *" $ln]} {
-                        # ordinary changed entries
-                        # format:  1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>
-                        #review - what does git do for spaced paths? 
-                        #for now we will risk treating as a list
-                        set path [lindex $ln end]
-                        set xy [lindex $ln 1]
-                        lassign [split $xy ""] staged unstaged
-                        if {[string match "*M*" $xy]} { 
-                            #e.g .M when unstaged M. when staged
-                            dict set pathdict $path "changed"
-                        } elseif {[string match "*D*" $xy]} {
-                            dict set pathdict $path "missing"
-                        } elseif {[string match "*A*" $xy]} {
-                            #e.g A. for new file that has been staged
-                            dict set pathdict $path "new"
-                        } else {
-                            dict set pathdict $path "UNKNOWN" ;#review - fix
-                        }
-                    } elseif {[string match "? *" $ln]} {
-                        #note that git will list a folder entry without going deeper to list contents
-                        set path [string trim [string range $ln [string length "? "] end]] ;#should handle spaced paths
-                        dict set pathdict $path "extra"
-                    } elseif {[string match "2 *" $ln]} {
-                        # renamed or copied entries
-                        # as we don't supply -z option - <sep> is tab char.
-                        # format: 2 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <X><score> <path><sep><origPath>
-                        #we should mark target of rename as 'new' - consistent with fossil - and stops caller from seeing no entry for an existent file and assuming it already belongs to the revision checkout
-                        lassign [split $ln \t] pretab posttab
-                        set path [lindex $pretab end]
-                        dict set pathdict $path "new" ;#review - if file was first deleted then renamed - is it more appropriately flagged as 'changed' - possibly doesn't matter for revision-membership detection new or changed should be ok
-
-                        set pathorig [string trim $posttab]
-                        dict set pathdict $pathorig "missing"
-                    } elseif {[string match "u *" $ln]} {
-                        #Unmerged entries
-                        # format: u <XY> <sub> <m1> <m2> <m3> <mW> <h1> <h2> <h3> <path>
-                        #
-                        #presume file on disk not as per revision - treat as changed (?review)
-                        set path [lindex $ln end]
-                        dict set pathdict $path "changed"
-                    } elseif {[string match "! *" $ln]} {
-                        #ignored files - not part of revision
-
-                    } else {
-                        #emit for now
-                        puts stderr "unprocessed gitstat line $ln"
-                    }
-                }
-                break
-            } else {
-                puts stderr "workingdir_state - repotype $rt not supported"
-            }
-        }
-        dict set resultdict revision $revision
-        dict set resultdict revision_iso8601 $revision_iso8601
-        dict set resultdict paths $pathdict
-        return $resultdict
-    }
-    proc workingdir_state_summary {repostate args} {
-        if {![dict exists $repostate repotype] || ![dict exists $repostate paths]} {
-            error "workingdir_state_summary error repostate doesn't appear to be a repostate dict. (use workingdir_state <path> to create)"
-        }
-        package require overtype
-        set defaults [dict create\
-            -fields {ahead behind unchanged changed new missing extra}\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- ---
-        set opt_fields [dict get $opts -fields]
-        # -- --- --- --- --- --- --- --- --- ---
-
-        set summary_dict [workingdir_state_summary_dict $repostate]
-        set repotype [dict get $summary_dict repotype]
-        set fieldnames [dict create\
-            repodir     repodir\
-            subpath     subpath\
-            revision    revision\
-            revision_iso8601    revision_iso8601\
-            ahead       ahead\
-            behind      behind\
-            repotype    repotype\
-            unchanged   unchanged\
-            changed     changed\
-            new         new\
-            missing     missing\
-            extra       extra\ 
-        ]
-        foreach f $opt_fields {
-            if {$f ni [dict keys $fieldnames]} {
-                error "workingdir_state_summary error: unknown field $f. known-values: [dict keys $fieldnames]"
-            }
-        }
-        if {$repotype eq "git"} {
-           dict set fieldnames extra "extra (files/folders)" 
-        }
-        set col1_fields [list]
-        set col2_values [list]
-        foreach f $opt_fields {
-            lappend col1_fields [dict get $fieldnames $f]
-            lappend col2_values [dict get $summary_dict $f]
-        }
-        set title1 ""
-        set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1_fields] {string length $v}]]
-        set col1 [string repeat " " $widest1]
-        set title2 ""
-        set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2_values] {string length $v}]]
-        set col2 [string repeat " " $widest2]
-
-        set result ""
-        foreach f $col1_fields v $col2_values {
-            append result "[overtype::left $col1 $f]: [overtype::right $col2 $v]" \n
-        }
-        set result [string trimright $result \n]
-        return $result
-    }
-    proc workingdir_state_summary_dict {repostate} {
-        if {![dict exists $repostate repotype] || ![dict exists $repostate paths]} {
-            error "workingdir_state_summary_dict error repostate doesn't appear to be a repostate dict. (use workingdir_state <path> to create)"
-        }
-        set filestates [dict values [dict get $repostate paths]]
-        set path_count_fields [list unchanged changed new missing extra]
-        set state_fields [list ahead behind repodir subpath repotype revision revision_iso8601]
-        set dresult [dict create]
-        foreach f $state_fields {
-           dict set dresult $f [dict get $repostate $f]
-        }
-        foreach f $path_count_fields {
-            dict set dresult $f [llength [lsearch -all $filestates $f]]
-        }
-        return $dresult
-    }
-    #determine nature of possibly-nested repositories (of various types) at and above this path
-    #Treat an untracked 'candidate' folder as a sort of repository
-    proc find_repos {path} {
-        set start_dir $path
-
-        #root is a 'project' if it it meets the candidate requrements and is under repo control
-        #therefore if project is in the closest_types list - candidate will always be there too - and at least one of git or fossil
-        #ie 'project' is a derived repo-type
-        set root_dict [list closest {} closest_types {} fossil {} git {} candidate {} project {} warnings {}]
-        set msg ""
-
-        #we're only searching in a straight path up the tree looking for a few specific marker files/folder
-        set fos_search_from $start_dir
-        set fossils_bottom_to_top [list]
-        while {[string length [set fosroot                  [punk::repo::find_fossil $fos_search_from]]]} {
-            lappend fossils_bottom_to_top $fosroot
-            set fos_search_from [file dirname $fosroot]
-        }
-        dict set root_dict fossil    $fossils_bottom_to_top
-
-        set git_search_from $start_dir
-        set gits_bottom_to_top [list]
-        while {[string length [set gitroot                  [punk::repo::find_git $git_search_from]]]} {
-            lappend gits_bottom_to_top $gitroot
-            set git_search_from [file dirname $gitroot]
-        }
-        dict set root_dict git       $gits_bottom_to_top
-
-        set cand_search_from $start_dir
-        set candidates_bottom_to_top [list]
-        while {[string length [set candroot                 [punk::repo::find_candidate $cand_search_from]]]} {
-            lappend candidates_bottom_to_top $candroot
-            set cand_search_from [file dirname $candroot]
-        }
-        dict set root_dict candidate $candidates_bottom_to_top
-
-
-        set projects_bottom_to_top [list]
-        set pathinfo [list] ;#list of {path plen} elements - for sorting on plen
-        set path_dict [dict create] ;#key on path - store repo-types as list
-        foreach repotype [list fossil git candidate] {
-            set repos [dict get $root_dict $repotype]
-            if {[llength $repos]} {
-                foreach p $repos {
-                    if {![dict exists $path_dict $p]} {
-                        dict set path_dict $p $repotype
-                    } else {
-                        if {$repotype eq "candidate"} {
-                            #path exists so this path is tracked and a candidate - therefore a punk 'project'
-                            dict lappend path_dict $p "candidate" "project"
-                            lappend projects_bottom_to_top $p
-                        } else {
-                            dict lappend path_dict $p $repotype
-                        }
-                    }
-                    set plen [llength [file split $p]]
-                }
-            }
-        }
-        dict set root_dict project $projects_bottom_to_top
-
-        dict for {path repotypes} $path_dict {
-            lappend pathinfo [list $repotypes $path [llength [file split $path]]]
-        }
-        #these root are all inline towards root of drive - so anything of same length should be same path - shorter path must be above another
-        #we will check equal depth paths are equal strings and raise an error just in case there are problems with the coding for the various path functions used here
-        #longest path is 'closest' to start_dir
-        set longest_first [lsort -decreasing -index 2 $pathinfo]
-        set repos [list]
-        foreach pinfo $longest_first {
-            lassign $pinfo types p len
-            lappend repos [list $p $types]
-        }
-        dict set root_dict repos $repos
-
-        set is_fossil_and_project 0; #fossil repo *and* candidate
-        foreach fos [dict get $root_dict fossil] {
-            if {$fos in [dict get $root_dict candidate]} {
-                set is_fossil_and_project 1
-                break
-            }
-        }
-        if {(!$is_fossil_and_project)} {
-            append msg "Not a punk fossil project" \n
-        }
-
-        if {![llength $longest_first]} {
-            #no repos or candidate
-            append msg "No fossil or git tracking found - No candidate project root found" \n
-        } else {
-            dict set root_dict closest [lindex $longest_first 0 1] ;#the *path* of the closest to start_dir
-            dict set root_dict closest_types [lindex $longest_first 0 0]
-        }
-        
-
-        set closest_fossil [lindex [dict get $root_dict fossil] 0]
-        set closest_fossil_len [llength [file split $closest_fossil]]
-        set closest_git [lindex [dict get $root_dict git] 0]
-        set closest_git_len [llength [file split $closest_git]]
-        set closest_candidate [lindex [dict get $root_dict candidate] 0]
-        set closest_candidate_len [llength [file split $closest_candidate]]
-
-        if {$closest_candidate_len > $closest_fossil_len && $closest_candidate_len > $closest_git_len} {
-                #only warn if this candidate is *within* a found repo root
-                append msg "**" \n
-                append msg "** found folder with /src at or above starting folder - that is below a fossil and/or git repo" \n
-                append msg "** starting folder : $start_dir" \n
-                append msg "** untracked       : $candroot" \n
-                if {$closest_fossil_len} {
-                    append msg "** fossil root     : $closest_fossil    ([punk::path::relative $start_dir $closest_fossil])" \n
-                }
-                if {$closest_git_len} {
-                    append msg "** git root        : $closest_git    ([punk::path::relative $start_dir $closest_git])" \n
-                }
-                append msg "**" \n
-        }
-
-
-        #don't warn if not git - unless also not fossil
-        if {(![llength [dict get $root_dict fossil]]) && (![llength [dict get $root_dict git]])} {
-            append msg "No repository located at or above starting folder $start_dir" \n
-            if {![llength [dict get $root_dict candidate]]} {
-                append msg "No candidate project root found. " \n
-                append msg "Searched upwards from '$start_dir' expecting a folder with the following requirements: " \n
-                append msg [punk::repo::is_candidate_root_requirements_msg] \n
-            } else {
-                append msg "Candidate project root found at : $closest_candidate" \n
-                append msg " - consider putting this folder under fossil control (and/or git)" \n
-            }
-        }
-
-        set nestinfo [list]
-        if {[llength $longest_first] > 1} {
-            foreach pinfo $longest_first {
-                lassign $pinfo types p len
-                lappend nestinfo [list $p [join $types -]]
-            }
-        }
-        if {[string length $nestinfo]} {
-            set rnestinfo [lreverse $nestinfo]
-            set col1items [lsearch -all -inline -index 0 -subindices $rnestinfo *]
-            set col2items [lsearch -all -inline -index 1 -subindices $rnestinfo *]
-
-            package require overtype
-            set title1 "Path"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {punk::strlen $v}]]
-            set col1 [string repeat " " $widest1]
-            set title2 "Repo-type(s)"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
-            set col2 [string repeat " " $widest2]
-            set tablewidth [expr {$widest1 + 1 + $widest2}]
-
-            append msg [string repeat "=" $tablewidth] \n
-            append msg "Found nested repository structure" \n
-            append msg "[overtype::left $col1 $title1] [overtype::left $col2 $title2]" \n
-
-            append msg "[string repeat - $widest1] [string repeat - $widest2]" \n
-
-            foreach p $col1items tp $col2items {
-                append msg "[overtype::left $col1 $p] [overtype::left $col2 $tp]" \n
-            }
-            append msg [string repeat "=" $tablewidth] \n
-        }
-
-        dict set root_dict warnings $msg
-
-        return $root_dict
-    }
-    proc fossil_get_repository_file {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        set fossilcmd [auto_execok fossil]
-        if {[llength $fossilcmd]} {
-            do_in_path $path {
-                set fossilinfo [::exec {*}$fossilcmd info]
-            }
-            set matching_lines [punk::repo::grep {repository:*} $fossilinfo]
-            if {![llength $matching_lines]} {
-                return ""
-            }
-            set trimmedline [string trim [lindex $matching_lines 0]]
-            set firstcolon [string first : $trimmedline]
-            set repofile_path [string trim [string range $trimmedline $firstcolon+1 end]]
-            if {![file exists $repofile_path]} {
-                puts stderr "Repository file pointed to by fossil configdb doesn't exist: $repofile_path"
-                return ""
-            }
-            return $repofile_path
-        } else {
-            puts stderr "fossil_get_repository_file: fossil command unavailable"
-            return "" 
-        }
-    }
-    proc fossil_get_repository_folder_for_project {projectname args} {
-
-        set defaults [list -parentfolder \uFFFF -extrachoice \uFFFF] 
-        set opts            [dict merge $defaults $args]
-
-        set opt_parentfolder [dict get $opts -parentfolder]
-        if {$opt_parentfolder eq "\uFFFF"} {
-            set opt_parentfolder [pwd]
-        }
-        set opt_extrachoice [dict get $opts -extrachoice]
-        set extrachoice ""
-        if {$opt_extrachoice ne "\uFFFF"} {
-            set extrachoice $opt_extrachoice
-        }
-
-        set startdir $opt_parentfolder
-
-        set fossil_prog [auto_execok fossil]
-        if {$fossil_prog eq ""} {
-            puts stderr "Fossil not found. Please install fossil"
-            return
-        }
-
-        set fossilinfo [exec {*}$fossil_prog info] ;#will give us the necessary config-db info whether in a project folder or not
-        set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
-        if {[llength $matching_lines] != 1} {
-            puts stderr "Unable to find config-db info from fossil. Check your fossil installation."
-            puts stderr "Fossil output was:"
-            puts stderr "-------------"
-            puts stderr "$fossilinfo"
-            puts stderr "-------------"
-            puts stderr "config-db info:"
-            puts stderr "$matching_lines"
-            return
-        }
-        set trimmedline [string trim [lindex $matching_lines 0]]
-        set firstcolon [string first : $trimmedline]
-        set config_db_path [string trim [string range $trimmedline $firstcolon+1 end]]
-        if {![file exists $config_db_path]} {
-            puts stderr "Unable to verify fossil global configuration info at path: $config_db_path"
-            return
-        }
-        set config_db_folder [file dirname $config_db_path]
-
-        #NOTE: we could use fossil all info to detect all locations of .fossil files - but there may be many that are specific to projects if the user wasn't in the habit of using a default location
-        #Whilst it might detect a central repo folder in a non-standard location - it might also be annoying.
-        #Todo - a separate environment variable for users to declare one or more locations where they would like to store project .fossil repositories?
-
-        set candidate_repo_folder_locations [list] 
-        #- choose a sensible default based on where fossil put the global config dir - or on the existence of a .fossils folder in a 'standard' location
-        #verify with user before creating a .fossils folder
-        #always check env(FOSSIL_HOME) first - but this is designed to locate the global .fossil (or _fossil) file - .fossils repository folder doesn't have to be at the same location
-        set usable_repo_folder_locations [list]
-        #If we find one, but it's not writable - add it to another list 
-        set readonly_repo_folder_locations [list]
-
-        #Examine a few possible locations for .fossils folder set 
-        #if containing folder is writable add to candidate list
-        set testpaths [list]
-
-        if {[info exists ::env(FOSSIL_HOME)]} {
-            set fossilhome_raw [string trim $::env(FOSSIL_HOME)]
-            if {![catch {package require Tcl 8.7-}]} {
-                set fossilhome [file normalize [file tildeexpand $fossilhome_raw]]
-            } else {
-                #8.6 
-                set fossilhome [file normalize $fossilhome_raw] 
-            }
-
-            lappend testpaths [file join $fossilhome .fossils]
-        }
-
-        if {[info exists ::env(HOME)]} {
-            set homedir $::env(HOME) ;#use capital for cross-platform
-            set tp [file join $homedir .fossils]
-            if {$tp ni $testpaths} {
-                lappend testpaths $tp
-            }
-        }
-        set tp  [file join $config_db_folder .fossils]
-        if {$tp ni $testpaths} {
-            lappend testpaths $tp
-        }
-        #test our current startdir too in case the user likes to keep their fossils closer to the projects
-        set tp [file join $startdir .fossils]
-        if {$tp ni $testpaths} {
-            lappend testpaths $tp
-        }
-        if {[string length $extrachoice]} {
-            set tp $extrachoice
-            if {$tp ni $testpaths} {
-                lappend testpaths $tp
-            }
-        }
-
-
-        foreach testrepodir $testpaths {
-            if {[file isdirectory $testrepodir]} {
-                if {[file writable $testrepodir]} {
-                    lappend usable_repo_folder_locations $testrepodir
-                } else {
-                    lappend readonly_repo_folder_locations $testrepodir
-                }
-            } else {
-                set repo_parent [file dirname $testrepodir]
-                if {[file writable $repo_parent]} {
-                    lappend candidate_repo_folder_locations $testrepodir
-                }
-            }
-        }
-      
-        set startdir_fossils [glob -nocomplain -dir $startdir -type f *.fossil]
-        if {[llength $startdir_fossils]} {
-            #user is already keeping .fossil files directly in curent dir - give them the option to easily keep doing this
-            #(we don't add it if no .fossil files there already - as it is probably a niche requirement - or a sign the user hasn't thought about a better/central location)
-            if {$startdir ni $usable_repo_folder_locations} {
-                lappend usable_repo_folder_locations $startdir 
-            }
-        }
-        set choice_folders [list]
-        set i 1
-        foreach fld $usable_repo_folder_locations {
-            set existing_fossils [glob -nocomplain -dir $fld -type f -tails *.fossil]
-            if {[set ecount [llength $existing_fossils]]} {
-                if {$ecount ==1} {set s ""} else {set s "s"}
-                set existingfossils "( $ecount existing .fossil$s )"
-            } else {
-                set existingfossils "( no existing .fossil files found )"
-            }
-            if {"$projectname.fossil" in $existing_fossils} {
-                set conflict "CONFLICT - $projectname.fossil already exists in this folder"
-            } else {
-                set conflict ""
-            }
-            lappend choice_folders [list index $i folder $fld folderexists 1 existingfossils $existingfossils conflict $conflict]
-            incr i
-        }
-
-        if {![llength $choice_folders]} {
-            #no existing writable .fossil folders (and no existing .fossil files in startdir)
-            #offer the (writable) candidate_repo_folder_locations
-            foreach fld $candidate_repo_folder_locations {
-                lappend choice_folders [list index $i folder $fld folderexists 0 existingfossils "" conflict ""] 
-                incr i
-            }
-        }
-
-        set menu_message ""
-        if {[llength $choice_folders]} {
-            append menu_message "Select the number of the folder to use to store the .fossil repository file" \n
-        } else {
-            append menu_message "--- NO suitable writable folders or locations found for .fossil file. Consider setting FOSSIL_HOME environment variable and check that folders are writable.--" \n
-        }
-
-        set conflicted_options [list]
-        foreach option $choice_folders {
-            set i [dict get $option index] ;# 1-based
-            set fld [dict get $option folder]
-            set existingfossils [dict get $option existingfossils]
-            set conflict [dict get $option conflict]
-            if {[string length $conflict]} {
-                lappend conflicted_options $i ;#1+
-            }
-            set folderexists [dict get $option folderexists]
-            if {$folderexists} {
-                set folderstatus "(existing folder)" 
-            } else {
-                set folderstatus "(CREATE folder for .fossil repository files)"
-            }
-            append menu_message "$i  $folderstatus $fld $existingfossils $conflict" \n
-        }
-
-
-        #append the readonly_repo_folder_locations so that user is aware of them as it may affect their choice 
-        if {[llength $readonly_repo_folder_locations]} {
-            append menu_message "--------------------------------------------------" \n
-            foreach readonly $readonly_repo_folder_locations {
-                append menu_message "<unavailable not writable> $readonly" \n
-            }
-            append menu_message "--------------------------------------------------" \n
-        }
-
-        #see if we can reasonably use the only available option and not bug the user
-        #Todo - option to always prompt?
-        #we will not auto-select if there is even one conflicted_option - as that seems like something you should know about
-        if {![llength $conflicted_options] && ([llength $choice_folders] == 1)} {
-            set repo_folder_choice [lindex $choice_folders 0]
-            set repository_folder [dict get $repo_folder_choice folder]
-        } else {
-            if {[llength $choice_folders]} {
-                puts stdout $menu_message
-                set max [llength $choice_folders] 
-                if {$max == 1} {
-                    set rangemsg "the number 1"
-                } else {
-                    set rangemsg "a number from 1 to $max" 
-                }
-                set answer [askuser "Enter $rangemsg to select location. (or N to abort)"]
-                if {![string is integer -strict $answer]} {
-                    puts stderr "Aborting"
-                    return
-                }
-
-                set index [expr {int($answer) -1}]
-                if {$index >= 0 && $index <= $max-1} {
-                    set repo_folder_choice [lindex $choice_folders $index]
-                    set repository_folder [dict get $repo_folder_choice folder]
-                    puts stdout "Selected fossil location $repository_folder" 
-                } else {
-                    puts stderr " No menu number matched - aborting."
-                    return
-                }
-            } else {
-                puts stdout $menu_message
-                set answer [askuser "Hit enter to exit"]
-                return
-            }
-        }
-        return $repository_folder
-    }
-
-    #------------------------------------
-    #limit to exec so full punk shell not required in scripts
-    proc git_revision {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        # ::kettle::path::revision.git
-        do_in_path $path {
-        try {
-            #git describe will error with 'No names found' if repo has no tags
-            #set v [::exec {*}[auto_execok git] describe]
-            set v [::exec {*}[auto_execok git] rev-parse HEAD] ;# consider 'git rev-parse --short HEAD'
-        } on error {e o} {
-            set v [lindex [split [dict get $o -errorinfo] \n] 0]
-        }
-        }
-        return [string trim $v]
-    }
-    proc git_remote {{path {{}}}} {
-        if {$path eq {}} { set path [pwd] }
-        do_in_path $path {
-        try {
-            #git describe will error with 'No names found' if repo has no tags
-            #set v [::exec {*}[auto_execok git] describe]
-            set v [::exec {*}[auto_execok git] -remote -v] ;# consider 'git rev-parse --short HEAD'
-        } on error {e o} {
-            set v [lindex [split [dict get $o -errorinfo] \n] 0]
-        }
-        }
-        return [string trim $v]
-    }
-
-    proc fossil_revision {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        # ::kettle::path::revision.fossil 
-        set fossilcmd [auto_execok fossil]
-        if {[llength $fossilcmd]} {
-            do_in_path $path {
-                set info [::exec {*}$fossilcmd info]
-            }
-            return [lindex [grep {checkout:*} $info] 0 1]
-        } else {
-            return Unknown
-        }
-    }
-
-    proc fossil_remote {{path {}}} {
-        if {$path eq {}} { set path [pwd] }
-        # ::kettle::path::revision.fossil 
-        set fossilcmd [auto_execok fossil]
-        if {[llength $fossilcmd]} {
-            do_in_path $path {
-                set info [::exec {*}$fossilcmd remote ls]
-            }
-            return [string trim $info]
-        } else {
-            return Unknown
-        }
-    }
-    #------------------------------------
-    
-    #temporarily cd to workpath to run script - return to correct path even on failure
-    proc do_in_path {path script} {
-        #from ::kettle::path::in
-        set here [pwd]
-        try {
-            cd $path
-            uplevel 1 $script
-        } finally {
-            cd $here
-        }
-    }
-    proc scanup {path cmd} {
-        if {$path eq {}} { set path [pwd] }
-        #based on kettle::path::scanup
-        if {[file pathtype $path] eq "relative"} {
-            set path [file normalize $path]
-        }
-        while {1} {
-            # Found the proper directory, per the predicate.
-            if {[{*}$cmd $path]} { return $path }
-
-            # Not found, walk to parent
-            set new [file dirname $path]
-
-            # Stop when reaching the root.
-            if {$new eq $path} { return {} }
-            if {$new eq {}} { return {} }
-
-            # Ok, truly walk up.
-            set path $new
-        }
-        return {}
-    }
-    #get content part of content/zip delimited by special \x1a (ctrl-z) char as used in tarjr and kettle::path::c/z
-    proc c/z {content} {
-        return [lindex [split $content \x1A] 0]
-    }
-    proc grep {pattern data} {
-        set data [string map [list \r\n \n] $data]
-        return [lsearch -all -inline -glob [split $data \n] $pattern]
-    }
-
-    proc rgrep {pattern data} {
-        set data [string map [list \r\n \n] $data]
-        return [lsearch -all -inline -regexp [split $data \n] $pattern]
-    }
-
-
-    #todo - review
-    proc ensure-cleanup {path} {
-        #::atexit [lambda {path} {
-        #file delete -force $path
-        #} [norm $path]]
-
-        file delete -force $path
-    }
-
-
-    #whether path is at and/or below one of the vfs mount points
-    #The design should facilitate nested vfs mountpoints
-    proc path_vfs_info {filepath} {
-        error "unimplmented"
-    }
-
-    #file normalize is expensive so this is too
-    proc norm {path {platform env}} {
-        #kettle::path::norm
-        #see also wiki
-        #full path normalization
-
-        set platform [string tolower $platform]
-        if {$platform eq "env"} {
-            set platform $::tcl_platform(platform)
-        }
-
-        #No - don't do this sort of path translation here - leave as option for specific utils only such as ./ 
-        #Windows volume-relative syntax with specific volume specified is somewhat broken in Tcl - but leading slash volume-relative does work 
-        #We shouldn't break it totally just because accessing WSL/mingw paths is slightly more useful
-        #if {$platform eq "windows"} {
-            #return [file dirname [file normalize [punk::unixywindows::towinpath $path]/__]]
-        #}
-
-        return [file dirname [file normalize $path/__]]
-    }
-
-    #This taken from kettle::path::strip
-    #It doesn't compare the prefix contents presumably for speed when used in kettle::path::scan
-    #renamed to better indicate its behaviour
-    
-    proc path_strip_prefixdepth {path prefix} {
-        if {$prefix eq ""} {
-            return [norm $path]
-        }
-        return [file join \
-            {*}[lrange \
-                [file split [norm $path]] \
-                [llength [file split [norm $prefix]]] \
-                end]]
-    }
-
-    #Must accept empty prefix - which is effectively noop.
-    #MUCH faster version for absolute path prefix (pre-normalized)
-    proc path_strip_alreadynormalized_prefixdepth {path prefix} {
-        if {$prefix eq ""} {
-            return $path
-        }
-        return [file join \
-            {*}[lrange \
-                [file split $path] \
-                [llength [file split $prefix]] \
-                end]]
-    }
-    #fs agnostic - so file normalize must be done by caller
-    proc strip_if_prefix {prefix path args} {
-        set known_opts [list -nocase]
-        set opts [list]
-        foreach a $args {
-            lappend opts [tcl::prefix match -message "option" $known_opts $a]
-        }
-        if {"-nocase" in $opts} {
-            set lp [tcl::prefix longest [string tolower $path] [string tolower $prefix]]
-        } else {
-            set lp [tcl::prefix longest $path $prefix]
-        }
-        #return in original casing whether or not -nocase specified. -nocase only applies to the comparison
-        if {![llength $lp]} {
-            return $path
-        } else {
-            return  [string range $path [string length $prefix] end]
-        }
-    }
-
-
-    interp alias {} is_fossil   {} ::punk::repo::is_fossil
-    interp alias {} is_fossil_root   {} ::punk::repo::is_fossil_root
-    interp alias {} find_fossil   {} ::punk::repo::find_fossil
-    interp alias {} fossil_revision   {} ::punk::repo::fossil_revision
-    interp alias {} is_git      {} ::punk::repo::is_git
-    interp alias {} is_git_root      {} ::punk::repo::is_git_root
-    interp alias {} find_git   {} ::punk::repo::find_git
-    interp alias {} git_revision   {} ::punk::repo::git_revision
-
-
-    interp alias {} gs {} git status -sb
-    interp alias {} gr {} ::punk::repo::git_revision
-    interp alias {} gl {} git log --oneline --decorate ;#decorate so stdout consistent with what we see on console
-    interp alias {} glast {} git log -1 HEAD --stat
-    interp alias {} gconf {} git config --global -l
-
-}
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::repo [namespace eval punk::repo {
-    variable version
-    set version 0.1.1 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/tdl-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/tdl-0.1.0.tm
deleted file mode 100644
index 7f034c18..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/tdl-0.1.0.tm
+++ /dev/null
@@ -1,104 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::tdl 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::tdl {
-    # https://wiki.tcl-lang.org/page/Config+file+using+slave+interp
-
-    variable sample_script {
-        server -name bsd1 -os FreeBSD
-        server -name p1 -os linux
-        server -name trillion -os windows
-
-        server -name vmhost1 -os FreeBSD {
-            guest -name bsd1 -vmmanager iocage
-            guest -name p1 -vmmanager bhyve
-        }
-
-    }
-
-
-    proc prettyparse {script} {
-        set i [interp create -safe]
-        try {
-    #       $i eval {unset {*}[info vars]}
-    #       foreach command [$i eval {info commands}] {$i hide $command}
-    #       $i invokehidden namespace delete {*}[$i invokehidden namespace children]
-            $i alias unknown apply {{i tag args} {
-                upvar 1 result result
-                set e [concat [list tag $tag]\
-                            [lrange $args 0 [expr {([llength $args] & ~1) - 1}]]]
-                if {[llength $args] % 2} {
-                    set saved $result
-                    set result {}
-                    $i eval [lindex $args end]
-                    lappend e body $result
-                    set result $saved
-                }
-                lappend result $e
-                list
-            }} $i
-            set result {}
-            $i eval $script
-            return $result
-        } finally {
-            interp delete $i
-        }
-    }
-    proc prettyprint {data {level 0}} {
-        set ind [string repeat "    " $level]
-        incr level
-        set result {}
-        foreach e $data {
-            set line $ind[concat [list [dict get $e tag]] [dict remove $e tag body]]
-            if {[dict exists $e body] && [llength [dict get $e body]]} {
-                append line " {\n[prettyprint [dict get $e body] $level]\n$ind}"
-            }
-            lappend result $line
-        }
-        join $result \n
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::tdl [namespace eval punk::tdl {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/winpath-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/winpath-0.1.0.tm
deleted file mode 100644
index a21e91ef..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punk/winpath-0.1.0.tm
+++ /dev/null
@@ -1,266 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punk::winpath 0.1.0
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::winpath {
-    namespace export winpath windir cdwin cdwindir illegalname_fix illegalname_test
-
-
-
-
-    #\\servername\share etc  or \\?\UNC\servername\share  etc.
-    proc is_unc_path {path} {
-        set strcopy_path [punk::objclone $path]
-        set strcopy_path [string map [list \\ /] $strcopy_path] ;#normalize to forward slashes for testing purposes (and forward slashes seem to be auto-translated by windows anyway)
-        if {[string first "//" $strcopy_path] == 0} {
-            #check for "Dos device path" syntax
-            if {[string range $strcopy_path 0 3] in [list "//?/" "//./"]} {
-                #Note that //./ doesn't appear to be supported in Tcl as at 2023-08 - but //?/ works  (except for //?/UNC/Server/share)
-                if {[string range $strcopy_path 4 6] eq "UNC"} {
-                    return 1
-                } else {
-                    #some other Dos device path. Could be a drive which is mapped to a UNC path - but the path itself isn't a unc path
-                    return 0
-                }
-            } else {
-                #leading double slash and not dos device path syntax
-                return 1
-            }
-        }
-        return 0
-    }
-
-    #ordinary \\Servername   or \\servername\share or \\servername\share\path  (or forward-slash equivalent) with no dos device syntax //?/ //./ etc.
-    proc is_unc_path_plain {path} {
-        if {[is_unc_path $path]} {
-            if {![is_dos_device_path $path]} {
-                return 1
-            } else {
-                return 0
-            }
-        } else {
-            return 0
-        }
-    }
-
-    #int-rep path preserved - but 'file attributes', and therefor this operation, is expensive (on windows at least)
-    proc pwdshortname {{path {}}} {
-        if {$path eq ""} {
-           set path [pwd]
-        } else {
-            if {[file pathtype $path] eq "relative"} {
-                set path [file normalize $path]
-            }
-        }
-        return [dict get [file attributes $path] -shortname]
-    }
-    #dos device path syntax allows windows api to acces extended-length paths and filenames with illegal path characters such as trailing dots or whitespace
-    #(can exist on server shares and on NTFS - but standard apps can't access without dos device syntax)
-    proc is_dos_device_path {path} {
-        set strcopy_path [punk::objclone $path]
-        set strcopy_path [string map [list \\ /] $strcopy_path] ;#normalize to forward slashes for testing purposes (and forward slashes seem to be auto-translated by windows anyway)
-        if {[string range $strcopy_path 0 3] in [list "//?/" "//./"]} {
-            return 1
-        } else {
-            return 0
-        }
-    }
-    proc strip_dos_device_prefix {path} {
-        #it's unlikely to be valid to strip only //?/ from a //?/UNC  path so check for it here and diver to strip that.
-        #(review.. or raise error because a //?/UNC path isn't *strictly* a UNC path? )
-        if {[is_unc_path $path]} {
-            return [strip_unc_path_prefix $path]
-        }
-        if {[is_dos_device_path $path]} {
-            return [string range $path 4 end]
-        } else {
-            return $path
-        }
-    }
-    proc strip_unc_path_prefix {path} {
-        if {[is_unc_path $path]} {
-            #//?/UNC/server/etc
-            set strcopy_path [punk::objclone $path]
-            set trimmedpath [string range $strcopy_path 7 end]
-            file pathtype $trimmedpath ;#shimmer it to path rep
-            return $trimmedpath
-        } elseif {is_unc_path_plain $path} {
-            #plain unc //server
-            set strcopy_path [punk::objclone $path]
-            set trimmedpath [string range $strcopy_path 2 end]
-            file pathtype $trimmedpath
-            return $trimmedpath
-        } else {
-            return $path
-        }
-    }
-    #we don't validate that path is actually illegal because we don't know the full range of such names.
-    #The caller can apply this to any path.
-    #don't test for platform here - needs to be callable from any platform for potential passing to windows (what usecase? 8.3 name is not always calculable independently)
-    #The utility of this is questionable. prepending a dos-device path won't make a filename with illegal characters readable by windows.
-    #It will need the 'shortname' at least for the illegal segment - if not the whole path
-    #Whilst the 8.3 name algorithm - including undocumented hash function has been reverse engineered 
-    #- it depends on the content of the directory - as collisions cause a different name (e.g incremented number) 
-    #- it also depends on the history of the folder
-    #- you can't take the current dir contents and a particular *existing* longname and determine the shortname algorithmically...
-    #- the shortname may have been generated during a different directory state.
-    #- It is then stored on disk (where?) - so access to reading the existing shortname is required.
-    #- An implementation of the 8.3 algorithm would only be potentially useful in determining the name that will result from adding a new file 
-    #  and would be subject to potential collisions if there are race-conditions in file creation
-    #- Using an 8.3 algorithm externally would be dangerous in that it could appear to work a lot of the time - but return a different file entirely sometimes.
-    #- Conclusion is that the 8.3 name must be retrieved rathern than calclated
-    proc illegalname_fix {path} {
-        #don't add extra dos device path syntax protection-prefix if already done
-        if {[is_unc_path $path]} {
-            error "illegalname_fix called on UNC path $path - unable to process"
-        }
-        if {[is_dos_device_path $path]} {
-            #we may have appended 
-            return $path
-        }
-
-
-
-        #\\servername\share theoretically maps to: \\?\UNC\servername\share  in protected form. https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
-        #NOTE: 2023-08 on windows 10 at least  \\?\UNC\Server\share  doesn't work - ie we can't use illegalname_fix on UNC paths such as \\Server\share 
-        #(but mapped drive to same path will work)
-        #Note that test-path cmdlet in powershell is also flaky with regards to \\?\UNC\Server paths.
-        #It seems prudent for now to disallow \\?\ protection for UNC paths such as \\server\etc
-        if {[is_unc_path $path]} {
-            set err ""
-            append err      "illegalname_fix doesn't currently support UNC paths (non dos device leading double slash or //?/UNC/...)"
-            append err \n   " - because //?/UNC/Servername/share is not supported in Tcl (and only minimally even in powershell) as at 2023. (on windows use mapped drive instead)"
-            error $err
-        }
-
-        set strcopy_path [punk::objclone $path]
-
-
-        #Note: path could still have leading double slash if it is a Dos device path: e.g. //?/c:/etc
-        if {[file pathtype $path] eq "absolute"} {
-            if {$path eq "~"} {
-                # non-normalized ~ is classified as absolute
-                # tilde special meaning is a bit of a nuisance..  but as it's the entire path in this case.. presumably it should be kept that way
-                # leave for caller to interpret it - but it's not an illegal name whether it's interpreted with special meaning or not
-                # unlikely this fix will be called on a plain tilde anyway
-                return $path
-            } else {
-                set fullpath $path
-            }
-        } else {
-            #set fullpath [file normalize $path] ;#very slow on windows
-            #set fullpath [pwd]/$path ;#will keep ./ in middle of path - not valid for dos-device paths
-            if {[string range $strcopy_path 0 1] eq "./"} {
-                set strcopy_path [string range $strcopy_path 2 end]
-            }
-            set fullpath [file join [pwd] $strcopy_path]
-        }
-        #For file I/O, the "\\?\" prefix to a path string tells the Windows APIs to disable all string parsing
-        # and to send the string that follows it straight to the file system.
-        set protect "\\\\?\\"  ;# value is: \\?\ prefix   
-        set protect2 "//?/" ;#file normalize may do this - it still works 
-        #don't use "//./" - not currently supported in Tcl - seems to work in powershell though.
-
-
-        #choose //?/  as normalized version - since likely 'file normalize' will do it anyway, and experimentall, the windows API accepts both  REVIEW
-        set result ${protect2}$fullpath
-        file pathtype $result ;#make it return a path rep
-        return $result
-    }
-
-    #don't test for platform here - needs to be callable from any platform for potential passing to windows
-    #we can create files with windows illegal names by using //?/ dos device path syntax - but we need to detect when that is required.
-    #
-    # path int-rep preserving
-    proc illegalname_test {path} {
-        #https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
-        #according to the above: Use any character in the current code page for a name, including Unicode characters and characters in the extended character set (128–255), except for the following:
-        set reserved [list  < > : \" / \\ | ? *]
-
-
-        #we need to exclude things like path/..   path/.
-        foreach seg [file split $path] {
-            if {$seg in [list . ..]} {
-                #review - what if there is a folder or file that actually has a name such as . or .. ? 
-                #unlikely in normal use - but could done deliberately for bad reasons?
-                #We are unable to check for it here anyway - as this command is intended for checking the path string - not the actual path on a filesystem.
-                #
-                #/./  /../  segments don't require protection - keep checking.
-                continue
-            }
-
-            #only check for actual space as other whitespace seems to work without being stripped
-            #trailing tab and trailing \n or \r seem to be creatable in windows with Tcl - map to some glyph
-            if {[string index $seg end] in [list " " "."]} {
-                #windows API doesn't handle trailing dots or spaces (silently strips) - even though such files can be created on NTFS systems (or seen via samba etc)
-                return 1
-            }
-        }
-        #glob chars '* ?' are probably illegal.. but although x*y.txt and x?y.txt don't display properly (* ? replaced with some other glyph)
-        #- they seem to be readable from cmd and tclsh as is.
-        # pipe symbol also has glyph substitution and behaves the same  e.g a|b.txt
-        #(at least with encoding system utf-8)
-
-        #todo - determine what else constitutes an illegal name according to windows APIs and requires protection with dos device syntax
-        return 0
-    }
-
-    proc test_ntfs_tunneling {f1 f2 args} {
-        file mkdir $f1
-        puts stderr  "waiting 15secs..."
-        after 5000 {puts -nonewline stderr .}
-        after 5000 {puts -nonewline stderr .}
-        after 5000 {puts -nonewline stderr .}
-        after 500 {puts stderr \n}
-        file mkdir $f2
-        puts stdout "$f1   [file stat $f1]"
-        puts stdout "$f2   [file stat $f2]"
-        file delete $f1
-        puts stdout "renaming $f2 to $f1"
-        file rename $f2 $f1
-        puts stdout "$f1   [file stat $f1]"
-
-    }
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punk::winpath [namespace eval punk::winpath {
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punkcheck-0.1.0.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punkcheck-0.1.0.tm
deleted file mode 100644
index 4582ac50..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/punkcheck-0.1.0.tm
+++ /dev/null
@@ -1,1962 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) 2023
-#
-# @@ Meta Begin
-# Application punkcheck 0.1.0
-# Meta platform     tcl
-# Meta license      <unspecified>
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-
-package require punk::tdl
-package require punk::path
-package require punk::repo
-package require punk::mix::util
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# Punkcheck uses the TDL format which is a list of lists in Tcl format
-# It is intended primarily for source build/distribution tracking within a punk project or single filesystem - with relative paths.
-#
-#see following article regarding the many problems with using mtime for build-decisions:  https://apenwarr.ca/log/20181113
-#
-namespace eval punkcheck {
-        namespace export\
-            uuid\
-            start_installer_event  installfile_*
-
-        variable default_antiglob_dir_core  [list "#*" "_aside" ".git" ".fossil*"]
-        variable default_antiglob_file_core ""
-        proc uuid {} {
-            set has_twapi 0
-            if {"windows" eq $::tcl_platform(platform)} {
-                if {![catch {package require twapi}]} {
-                    set has_twapi 1
-                }
-            }
-            if {!$has_twapi} {
-                if {[catch {package require uuid} errM]} {
-                    error "Unable to load a package for uuid on this platform. Try tcllib's uuid (any platform) - twapi for windows"
-                }
-                return [uuid::uuid generate]
-            } else {
-                return [twapi::new_uuid]
-            }
-        }
-
-        proc default_antiglob_dir_core {} {
-            variable default_antiglob_dir_core
-            return $default_antiglob_dir_core
-        }
-        proc default_antiglob_file_core {} {
-            variable default_antiglob_file_core
-            if {$default_antiglob_file_core eq ""} {
-                set default_antiglob_file_core [list "*.swp" "*[punk::mix::util::magic_tm_version]*" "*-buildversion.txt" ".punkcheck"]
-            }
-            return $default_antiglob_file_core
-        }
-
-
-        proc load_records_from_file {punkcheck_file} { 
-            set record_list [list]
-            if {[file exists $punkcheck_file]} {
-                set tdlscript [punk::mix::util::fcat $punkcheck_file]
-                set record_list [punk::tdl::prettyparse $tdlscript]
-            }
-            return $record_list
-        }
-        proc save_records_to_file {recordlist punkcheck_file} {
-            set newtdl [punk::tdl::prettyprint $recordlist]
-            set linecount [llength [split $newtdl \n]]
-            #puts stdout $newtdl
-            set fd [open $punkcheck_file w]
-            fconfigure $fd -translation binary
-            puts -nonewline $fd $newtdl
-            close $fd
-            return [list recordcount [llength $recordlist] linecount $linecount]
-        }
-
-
-        #todo - work out way to use same punkcheck file for multiple installers running concurrently. Thread?
-        #an installtrack objects represents an installation path from sourceroot to targetroot 
-        #The source and target folders should be as specific as possible but it is valid to specify for example c:/ -> c:/  (or / -> /)  if source and targets within the installation operation are spread around.
-        #
-        set objname [namespace current]::installtrack
-        if {$objname ni [info commands $objname]} {
-            package require oolib
-
-            #FILEINFO record - target fileset with body records: INSTALL-RECORD,INSTALL-INPROGRESS,INSTALL-SKIPPED,DELETE-RECORD,DELETE-INPROGRESS,MODIFY-INPROGRESS,MODIFY-RECORD
-            #each FILEINFO body being a list of SOURCE records
-            oo::class create targetset {
-                variable o_targets 
-                variable o_keep_installrecords
-                variable o_keep_skipped
-                variable o_keep_inprogress
-                variable o_records
-                constructor {args} {
-                    #set o_records [oolib::collection create [namespace current]::recordcollection]
-                    set o_records [list]
-
-                }
-
-                method as_record {} {
-
-                    set fields [list\
-                        -targets $o_targets\
-                        -keep_installrecords $o_keep_installrecords\
-                        -keep_skipped $o_keep_skipped\
-                        -keep_inprogress $o_keep_inprogress\
-                        body $o_records\
-                    ]
-
-                    set record [dict create tag FILEINFO {*}$fields]
-                }
-                
-                #retrieve last completed record for the fileset ie exclude SKIPPED,INSTALL-INPROGRESS,DELETE-INPROGRESS,MODIFY-INPROGRESS
-                method get_last_record {fileset_record} {
-                    set body [dict_getwithdefault $fileset_record body [list]]
-                    set previous_records [lrange $body 0 end-1]
-                    #get last previous that is tagged INSTALL-RECORD,MODIFY-RECORD,DELETE-RECORD
-                    set revlist [lreverse $previous_records]
-                    foreach rec $revlist {
-                        if {[dict get $rec tag] in [list "INSTALL-RECORD" "MODIFY-RECORD" "DELETE-RECORD" "VIRTUAL-RECORD"]} {
-                            return $rec
-                        }
-                    }
-                    return [list]
-                }
-            }
-
-            oo::class create installevent {
-                variable o_id
-                variable o_rel_sourceroot
-                variable o_rel_targetroot
-                variable o_ts_begin
-                variable o_ts_end
-                variable o_types
-                variable o_configdict
-                variable o_targets
-                variable o_operation
-                variable o_operation_start_ts
-                variable o_fileset_record
-                variable o_installer ;#parent object
-                constructor {installer rel_sourceroot rel_targetroot args} {
-                    set o_installer $installer
-                    set o_operation_start_ts ""
-                    set o_operation ""
-                    set defaults [dict create\
-                        -id ""\
-                        -tsbegin ""\
-                        -config [list]\
-                        -tsend ""\
-                        -types [list]\
-                    ]
-                    set opts [dict merge $defaults $args]
-                    if {[dict get $opts -id] eq ""} {
-                        set o_id [punkcheck::uuid]
-                    } else {
-                        set o_id [dict get $opts -id]
-                    }
-                    if {[dict get $opts -tsbegin] eq ""} {
-                        set o_ts_begin [clock microseconds]
-                    } else {
-                        set o_ts_begin [dict get $opts -tsbegin]
-                    }
-                    set o_ts_end    [dict get $opts -tsend]
-                    set o_types     [dict get $opts -types]
-                    set o_configdict [dict get $opts -config] 
-
-                    set o_rel_sourceroot $rel_sourceroot
-                    set o_rel_targetroot $rel_targetroot
-                }                
-                destructor {
-                    #puts "[self] destructor called"
-                }
-                method as_record {} {
-                    set begin_seconds [expr {$o_ts_begin / 1000000}]
-                    set tsiso_begin [clock format $begin_seconds -format "%Y-%m-%dT%H:%M:%S"]
-                    if {$o_ts_end ne ""} {
-                        set end_seconds [expr {$o_ts_end / 1000000}]
-                        set tsiso_end [clock format $end_seconds -format "%Y-%m-%dT%H:%M:%S"]
-                    } else {
-                        set tsiso_end ""
-                    }
-                    set fields [list\
-                        -tsiso_begin $tsiso_begin\
-                        -ts_begin    $o_ts_begin\
-                        -tsiso_end   $tsiso_end\
-                        -ts_end      $o_ts_end\
-                        -id          $o_id\
-                        -source      $o_rel_sourceroot\
-                        -targets     $o_rel_targetroot\
-                        -types       $o_types\
-                        -config      $o_configdict\
-                    ]
-
-                    set record [dict create tag EVENT {*}$fields]
-                }
-                method get_id {} {
-                    return $o_id
-                }
-                method get_operation {} {
-                    return $o_operation
-                }
-                method get_targets {} {
-                    return $o_targets
-                }
-                method get_targets_exist {} {
-                    set punkcheck_folder [file dirname [$o_installer get_checkfile]]
-                    set existing [list]
-                    foreach t $o_targets {
-                        if {[file exists [file join $punkcheck_folder $t]]} {
-                            lappend existing $t
-                        }
-                    }
-                    return $existing
-                }
-                method end {} {
-                    set o_ts_end [clock microseconds]
-                }
-                method targetset_dict {} {
-                    punk::records_as_target_dict [$o_installer get_recordlist]
-                }
-
-                #related - installfile_begin
-                #call init before we know if we are going to run the operation vs skip
-                method targetset_init {operation targetset} {
-                    set known_ops [list QUERY INSTALL MODIFY DELETE VIRTUAL]
-                    if {[string toupper $operation] ni $known_ops} {
-                        error "[self] add_target unknown operation '$operation'. Known operations $known_ops"
-                    }
-                    set o_operation [string toupper $operation]
-
-                    if {$o_operation_start_ts ne ""} {
-                        error "[self] targetset_tart $o_operation operation already in progress. Use targetset_finished or targetset_complete to finish."
-                    }
-                    set o_operation_start_ts [clock microseconds]
-                    set seconds [expr {$o_operation_start_ts / 1000000}]
-                    set tsiso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-                    set punkcheck_file [$o_installer get_checkfile]
-                    set punkcheck_folder [file dirname $punkcheck_file]
-
-                    set relativepath_targetset [list]
-                    if {$o_operation eq "VIRTUAL"} {
-                        foreach p $targetset {
-                            lappend relativepath_targetset $p
-                        }
-                    } else {
-                        foreach p $targetset {
-                            if {[file pathtype $p] eq "absolute"} {
-                                lappend relativepath_targetset [punkcheck::lib::path_relative $punkcheck_folder $p]
-                            } else {
-                                lappend relativepath_targetset $p
-                            }
-                        }
-                    }
-
-
-                    set fields [list\
-                        -tsiso $tsiso\
-                        -ts $o_operation_start_ts\
-                        -installer [$o_installer get_name]\
-                        -eventid $o_id\
-                        ]
-
-                    set o_targets [lsort -dictionary -increasing $relativepath_targetset] ;#exact sort order not critical - but must be consistent
-
-                    #set targetdict [my targetset_dict]
-
-                    set record_list [punkcheck::load_records_from_file $punkcheck_file]
-                    set extractioninfo [punkcheck::recordlist::extract_or_create_fileset_record $o_targets $record_list]
-                    set o_fileset_record [dict get $extractioninfo record]
-                    set record_list [dict get $extractioninfo recordset]
-                    set isnew       [dict get $extractioninfo isnew]
-                    set oldposition [dict get $extractioninfo oldposition]
-                    unset extractioninfo
-
-                    #INSTALL-INPROGRESS will become INSTALL-RECORD or INSTALL-FAILED or INSTALL-SKIPPED upon finalisation
-                    #-installer and -eventid keys are added here
-                    set new_inprogress_record [dict create tag [string toupper $operation]-INPROGRESS {*}$fields -tempcontext [my as_record] body {}]
-                    #set existing_body [dict_getwithdefault $o_fileset_record body [list]]
-                    #todo - look for existing "-INPROGRESS" records - mark as failed or incomplete?
-                    dict lappend o_fileset_record body $new_inprogress_record
-
-                    if {$isnew} {
-                        lappend record_list $o_fileset_record
-                    } else {
-                        set record_list [linsert $record_list[unset record_list] $oldposition $o_fileset_record]
-                    }
-                    if {$o_operation ne "QUERY"} {
-                        punkcheck::save_records_to_file $record_list $punkcheck_file
-                    }
-                    return $o_fileset_record
-
-                }
-                #operation has been started
-                #todo - upgrade .punkcheck format to hold more than just list of SOURCE entries in each record.
-                # - allow arbitrary targetset_startphase <name> targetset_endphase <name> calls to store timestamps and calculate elapsed time
-                method targetset_started {} {
-                    set punkcheck_folder [file dirname [$o_installer get_checkfile]]
-                    if {$o_operation eq "QUERY"} {
-                        set fileinfo_body [dict get $o_fileset_record body] ;#body of FILEINFO record
-                        set installing_record [lindex $fileinfo_body end]
-
-                        set ts_start [dict get $installing_record -ts]
-                        set ts_now [clock microseconds] 
-                        set metadata_us [expr {$ts_now - $ts_start}]
-
-                        dict set installing_record -metadata_us $metadata_us
-                        dict set installing_record -ts_start_transfer $ts_now
-
-                        lset fileinfo_body end $installing_record
-                        
-                        return [dict set o_fileset_record body $fileinfo_body]
-                    } else {
-                        #legacy call
-                        #saves to .punkcheck file
-                        return [set o_fileset_record [punkcheck::installfile_started_install $punkcheck_folder $o_fileset_record]]
-                    }
-                }
-                method targetset_end {status args} {
-                    set defaults [dict create\
-                        -note \uFFFF\
-                    ]
-                    set known_opts [dict keys $defaults]
-                    if {[llength $args] % 2 != 0} {
-                        error "targetset_end arguments after status must be in the form of -flag value pairs. known flags: $known_opts"
-                    }
-                    set opts [dict merge $defaults $args]
-                    if {[dict get $opts -note] eq "\uFFFF"} {
-                        dict unset opts -note
-                    }
-
-                    set status [string toupper $status]
-                    set statusdict [dict create OK RECORD SKIPPED SKIPPED FAILED FAILED] 
-                    if {$o_operation_start_ts eq ""} {
-                        error "[self] targetset_end $status - no current operation - call targetset_started first"
-                    }
-                    if {$status ni [dict keys $statusdict]} {
-                        error "[self] targetset_end unrecognized status:$status known values: [dict keys $statusdict]"
-                    }
-                    if {![punkcheck::lib::is_file_record_inprogress $o_fileset_record]} {
-                        error "targetset_end $status error: bad fileset_record - expected FILEINFO with last body element *-INPROGRESS"
-                    }
-                    set targetlist [dict get $o_fileset_record -targets]
-                    if {$targetlist ne $o_targets} {
-                        error "targetset_end $status error. targetlist mismatch between file : $targetlist vs $o_targets"
-                    }
-                    set operation_end_ts [clock microseconds]
-                    set elapsed_us [expr {$operation_end_ts - $o_operation_start_ts}] 
-                    set file_record_body [dict get $o_fileset_record body]
-                    set installing_record [lindex $file_record_body end]
-                    set punkcheck_file [$o_installer get_checkfile]
-                    set punkcheck_folder [file dirname $punkcheck_file]
-                    set record_list [punkcheck::load_records_from_file $punkcheck_file]
-                    if {[dict exists $installing_record -ts_start_transfer]} {
-                        set ts_start_transfer [dict get $installing_record -ts_start_transfer]
-                        set transfer_us [expr {$operation_end_ts - $ts_start_transfer}]
-                        dict set installing_record  -transfer_us $transfer_us
-                    }
-                    if {[dict exists $opts -note]} {
-                        dict set installing_record -note [dict get $opts -note]
-                    }
-
-                    dict set installing_record -elapsed_us $elapsed_us
-                    dict unset installing_record -tempcontext
-                    dict set installing_record tag "${o_operation}-[dict get $statusdict $status]" ;# e.g INSTALL-RECORD, INSTALL-SKIPPED
-                    if {$o_operation in [list INSTALL MODIFY] && [dict get $statusdict $status] eq "RECORD"} {
-                        #only calculate and store post operation target cksums on successful INSTALL or MODIFY, doesn't make sense for DELETE or VIRTUAL operations
-                        set new_targets_cksums [list] ;#ordered list of cksums matching targetset order
-                        set cksum_all_opts "" ;#same cksum opts for each target so we store it once
-                        set ts_begin_cksum [clock microseconds]
-                        foreach p $o_targets {
-                            set tgt_cksum_info [punk::mix::base::lib::cksum_path [file join $punkcheck_folder $p]]
-                            lappend new_targets_cksums [dict get $tgt_cksum_info cksum]
-                            if {$cksum_all_opts eq ""} {
-                                set cksum_all_opts [dict get $tgt_cksum_info opts]
-                            }
-                        }
-                        set cksum_us [expr {[clock microseconds] - $ts_begin_cksum}]
-                        dict set installing_record -targets_cksums $new_targets_cksums 
-                        dict set installing_record -cksum_all_opts $cksum_all_opts
-                        dict set installing_record -cksum_us $cksum_us
-                    }
-                    lset file_record_body end $installing_record
-                    dict set o_fileset_record body $file_record_body 
-                    set o_fileset_record [punkcheck::recordlist::file_record_prune $o_fileset_record]
-
-                    set oldrecordinfo [punkcheck::recordlist::get_file_record $targetlist $record_list]
-                    set old_posn [dict get $oldrecordinfo position]
-                    if {$old_posn == -1} {
-                        lappend record_list $o_fileset_record
-                    } else {
-                        lset record_list $old_posn $o_fileset_record
-                    }
-                    if {$o_operation ne "QUERY"} {
-                        punkcheck::save_records_to_file $record_list $punkcheck_file
-                    }
-                    set o_operation_start_ts ""
-                    set o_operation ""
-                    return $o_fileset_record
-                }
-                method targetset_addsource {source_path} {
-                    set punkcheck_file [$o_installer get_checkfile]
-                    set punkcheck_folder [file dirname $punkcheck_file]
-                    if {[file pathtype $source_path] eq "absolute"} {
-                        set rel_source_path [punkcheck::lib::path_relative $punkcheck_folder $source_path]
-                    } else {
-                        set rel_source_path $source_path
-                    }
-
-                    set o_fileset_record [punkcheck::installfile_add_source_and_fetch_metadata $punkcheck_folder $rel_source_path $o_fileset_record]
-
-                }
-                method targetset_last_complete {} {
-                    #retrieve last completed record for the fileset ie exclude SKIPPED,INSTALL-INPROGRESS,DELETE-INPROGRESS,MODIFY-INPROGRESS
-                    set body [punkcheck::dict_getwithdefault $o_fileset_record body [list]]
-                    set previous_records [lrange $body 0 end]
-                    #get last that is tagged INSTALL-RECORD,MODIFY-RECORD,DELETE-RECORD
-                    set revlist [lreverse $previous_records]
-                    foreach rec $revlist {
-                        if {[dict get $rec tag] in [list "INSTALL-RECORD" "MODIFY-RECORD" "DELETE-RECORD" "VIRTUAL-RECORD"]} {
-                            return $rec
-                        }
-                    }
-                    return [list]
-
-                }
-                method targetset_source_changes {} {
-                    punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $o_fileset_record body] end]
-                }
-
-            }
-
-
-            oo::class create installtrack {
-                variable o_name
-                variable o_tsiso
-                variable o_ts
-                variable o_keep_events
-                variable o_checkfile
-                variable o_sourceroot 
-                variable o_rel_sourceroot
-                variable o_targetroot
-                variable o_rel_targetroot
-                variable o_record_list
-                variable o_active_event 
-                variable o_events
-                constructor {installername punkcheck_file} {
-                    set o_active_event ""
-                    set o_name $installername
-
-                    set o_checkfile [file normalize $punkcheck_file]
-                    set o_sourceroot ""
-                    set o_targetroot ""
-                    set o_rel_sourceroot ""
-                    set o_rel_targetroot ""
-                    #todo - validate punkcheck file location further??
-                    set punkcheck_folder [file dirname $o_checkfile]
-                    if {![file isdirectory $punkcheck_folder]} {
-                        error "[self] constructor error. Folder for punkcheck_file not found - $o_checkfile"
-                    }
-
-                    my load_all_records
-                    set resultinfo [punkcheck::recordlist::get_installer_record $o_name $o_record_list]
-                    set existing_header_posn [dict get $resultinfo position]
-                    if {$existing_header_posn == -1} {
-                        set this_installer_record [punkcheck::recordlist::new_installer_record $o_name]
-                        set o_record_list [linsert $o_record_list 0 $this_installer_record]
-                    } else {
-                        set this_installer_record [dict get $resultinfo record]
-                    }
-                    set o_tsiso [dict get $this_installer_record -tsiso]
-                    set o_ts [dict get $this_installer_record -ts]
-                    set o_keep_events [dict get $this_installer_record -keep_events]
-
-                    set o_events [oolib::collection create [namespace current]::eventcollection]
-                    set eventlist [punkcheck::dict_getwithdefault $this_installer_record body [list]]
-                    foreach e $eventlist {
-                        set eobj [punkcheck::installevent create [namespace current]::event_[my events count] [self] [dict get $e -source] [dict get $e -targets] {*}$e]
-                        #$o_events add $e [dict get $e -id]
-                        $o_events add $eobj [dict get $e -id]
-                    }
-                    
-                }
-                destructor {
-                    #puts "[self] destructor called"
-                }
-                method test {} {
-                    return [self]
-                }
-                method get_name {} {
-                    return $o_name
-                }
-                method get_checkfile {} {
-                    return $o_checkfile
-                }
-
-                #call set_source_target before calling start_event/end_event
-                #each event can have different source->target pairs - but may often have same, so set on installtrack as defaults. Only persisted in event records. 
-                method set_source_target {sourceroot targetroot} {
-                    if {[file pathtype $sourceroot] ne "absolute"} {
-                        error "[self] set_source_target error: sourceroot must be absolute path. Received '$sourceroot'"
-                    }
-                    if {[file pathtype $targetroot] ne "absolute"} {
-                        error "[self] set_source_target error: targetroot must be absolute path. Received '$targetroot'"
-                    }
-                    set punkcheck_folder [file dirname $o_checkfile]
-                    set o_sourceroot $sourceroot
-                    set o_targetroot $targetroot
-                    set o_rel_sourceroot [punkcheck::lib::path_relative $punkcheck_folder $sourceroot]
-                    set o_rel_targetroot [punkcheck::lib::path_relative $punkcheck_folder $targetroot]
-                    return [list $o_rel_sourceroot $o_rel_targetroot]
-                }
-                #review/fix to allow multiple installtrack objects on same punkcheck file.
-                method load_all_records {} {
-                    set o_record_list [punkcheck::load_records_from_file $o_checkfile]
-                }
-
-                #does not include associated FILEINFO records - as a targetset (FILEINFO record) can be associated with events from multiple installers over time.
-                #e.g a logfile common to installers, or a separate installer that updates a previous output.
-                method as_record {} {
-                    set eventrecords [list]
-                    foreach eobj [my events items] {
-                        lappend eventrecords [$eobj as_record]
-                    }
-                    set fields [list\
-                        -tsiso       $o_tsiso\
-                        -ts          $o_ts\
-                        -name        $o_name\
-                        -keep_events $o_keep_events\
-                        body $eventrecords\
-                    ]
-                    set record [dict create tag INSTALLER {*}$fields]
-                }
-                #open file and save only own records
-                method save_all_records {} {
-                    my save_installer_record
-                    #todo - save FILEINFO targetset records
-                }
-                method save_installer_record {} {
-                    set file_records [punkcheck::load_records_from_file $o_checkfile]
-                    
-                    set this_installer_record [my as_record]
-
-                    set persistedinfo [punkcheck::recordlist::get_installer_record $o_name $file_records]
-                    set existing_header_posn [dict get $persistedinfo position]
-                    if {$existing_header_posn == -1} {
-                        set file_records [linsert $file_records 0 $this_installer_record]
-                    } else {
-                        lset file_records $existing_header_posn $this_installer_record
-                    }
-                    punkcheck::save_records_to_file $file_records $o_checkfile
-                }
-                method events {args} {
-                    tailcall $o_events {*}$args
-                }
-                method start_event {configdict} {
-                    if {$o_active_event ne ""} {
-                        error "[self] start_event error - event already started:   $o_active_event"
-                    }
-                    if {$o_rel_sourceroot eq "" || $o_rel_targetroot eq ""} {
-                        error "[self] No configured sourceroot or targetroot. Call [self] set_source_target <abspath_sourceroot> <abspath_targetroot> first"
-                    }
-
-                    if {[llength $configdict] %2 != 0} {
-                        error "[self] new_event configdict must have an even number of elements"
-                    }
-                    set resultinfo [punkcheck::recordlist::get_installer_record $o_name $o_record_list]
-                    set existing_header_posn [dict get $resultinfo position]
-                    if {$existing_header_posn == -1} {
-                        error "[self] start_event - installer record missing. installer: $o_name"
-                    } else {
-                        set this_installer_record [dict get $resultinfo record]
-                    }
-
-                    set eventobj [punkcheck::installevent create [namespace current]::event_[my events count] [self] $o_rel_sourceroot $o_rel_targetroot -config $configdict]
-                    set eventid [$eventobj get_id]
-                    set event_record [$eventobj as_record]
-
-                    set this_installer_record [punkcheck::recordlist::installer_record_add_event $this_installer_record $event_record]
-                    set this_installer_record [punkcheck::recordlist::installer_record_pruneevents $this_installer_record $o_record_list]
-
-                    #replace
-                    lset o_record_list $existing_header_posn $this_installer_record
-
-                    punkcheck::save_records_to_file $o_record_list $o_checkfile
-                    set o_active_event $eventobj
-                    my events add $eventobj $eventid
-                    return $eventobj
-                }
-                method installer_record_from_file {} {
-                    set resultinfo [punkcheck::recordlist::get_installer_record $o_name $o_record_list]
-                }
-                method get_recordlist {} {
-                    return $o_recordlist    
-                }
-                method end_event {} {
-                    if {$o_active_event eq ""} {
-                        error "[self] end_event error - no active event"
-                    }
-                    $o_active_event end 
-                }
-                method get_event {} {
-                    return $o_active_event
-                }
-            }
-        }
-        proc start_installer_event {punkcheck_file installername from_fullpath to_fullpath config} {
-            set eventid [punkcheck::uuid]
-            if {[file pathtype $from_fullpath] ne "absolute"} {
-                error "start_installer_event error: from_fullpath must be absolute path. Received '$from_fullpath'"
-            }
-            if {[file pathtype $to_fullpath] ne "absolute"} {
-                error "start_installer_event error: to_fullpath must be absolute path. Received '$to_fullpath'"
-            }
-            set punkcheck_folder [file dirname $punkcheck_file]
-            set rel_source [punkcheck::lib::path_relative $punkcheck_folder $from_fullpath]
-            set rel_target [punkcheck::lib::path_relative $punkcheck_folder $to_fullpath]
-
-
-            set record_list [punkcheck::load_records_from_file $punkcheck_file]
-            set resultinfo [punkcheck::recordlist::get_installer_record $installername $record_list]
-            set existing_header_posn [dict get $resultinfo position]
-            if {$existing_header_posn == -1} {
-                set this_installer_record [punkcheck::recordlist::new_installer_record $installername]
-            } else {
-                set this_installer_record [dict get $resultinfo record]
-            }
-
-            set event_record [punkcheck::recordlist::new_installer_event_record install\
-                -id $eventid\
-                -source $rel_source\
-                -targets $rel_target\
-                -config $config\
-            ]
-
-            set this_installer_record [punkcheck::recordlist::installer_record_add_event $this_installer_record $event_record]
-            set this_installer_record [punkcheck::recordlist::installer_record_pruneevents $this_installer_record $record_list]
-
-            if {$existing_header_posn == -1} {
-                #not found - prepend
-                set record_list [linsert $record_list 0 $this_installer_record]
-            } else {
-                #replace
-                lset record_list $existing_header_posn $this_installer_record
-            }
-
-            punkcheck::save_records_to_file $record_list $punkcheck_file
-            return [list eventid $eventid recordset $record_list]
-        }
-        #-----------------------------------------------
-        proc installfile_help {} {
-            set msg ""
-            append msg  "Call in order:" \n
-            append msg  "  start_installer_event (get dict with eventid and recordset keys)"
-            append msg  "  installfile_begin  (to return a new INSTALLING record) - must pass in a valid eventid"  \n
-            append msg  "  installfile_add_source_and_fetch_metadata (1+ times to update SOURCE record with checksum/timestamp info from source)" \n 
-            append msg  "     ( - possibly with same algorithm as previous installrecord)" \n
-            append msg  "     ( - todo - search/load metadata for this source from other FILEINFO records for same installer)" \n
-            append msg  "Finalize by calling:" \n
-            append msg  "  installfile_started_install" \n
-            append msg  "  (install the file e.g file copy)" \n
-            append msg  "  installfile_finished_install" \n
-            append msg  "  OR" \n
-            append msg  "  installfile_skipped_install" \n
-        }
-        proc installfile_begin {punkcheck_folder target_relpath installername args} {
-            if {[llength $args] %2 !=0} {
-                error "punkcheck installfile_begin args must be name-value pairs"
-            }
-            set target_relpath [lsort -dictionary -increasing $target_relpath] ;#exact sort order not critical - but must be consistent
-            set ts [clock microseconds]
-            set seconds [expr {$ts / 1000000}]
-            set tsiso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-            set defaults [list\
-                -tsiso $tsiso\
-                -ts $ts\
-                -installer $installername\
-                -eventid unspecified\
-                ]
-            set opts [dict merge $defaults $args]
-            set opt_eventid [dict get $opts -eventid]
-
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-            set record_list [load_records_from_file $punkcheck_file]
-           
-            set resultinfo [punkcheck::recordlist::get_installer_record $installername $record_list]
-            set installer_record_position [dict get $resultinfo position]
-            if {$installer_record_position == -1} {
-                error "installfile_begin error: Failed to retrieve installer record for installer name:'$installername' - ensure start_installer_event has been called with same installer, and -eventid is passed to installfile_begin"
-            }
-            set this_installer_record [dict get $resultinfo record]
-            set events [dict get $this_installer_record body]
-            set active_event [list]
-            foreach evt [lreverse $events] {
-                if {[dict get $evt -id] eq $opt_eventid} {
-                    set active_event $evt
-                    break
-                }
-            }
-            if {![llength $active_event]} {
-                error "installfile_begin error: eventid $opt_eventid not found for installer '$installername' - aborting"
-            }
-
-
-            set extractioninfo [punkcheck::recordlist::extract_or_create_fileset_record $target_relpath $record_list]
-            set file_record [dict get $extractioninfo record]
-            set record_list [dict get $extractioninfo recordset]
-            set isnew       [dict get $extractioninfo isnew]
-            set oldposition [dict get $extractioninfo oldposition]
-            unset extractioninfo
-
-            #INSTALL-INPROGRESS will become INSTALL-RECORD or INSTALL-FAILED or INSTALL-SKIPPED upon finalisation
-            #-installer and -eventid keys are added here
-            set new_installing_record [dict create tag INSTALL-INPROGRESS {*}$opts -tempcontext $active_event body {}]
-            #set existing_body [dict_getwithdefault $file_record body [list]]
-            #todo - look for existing "INSTALL-INPROGRESS" records - mark as failed?
-            dict lappend file_record body $new_installing_record
-
-            if {$isnew} {
-                lappend record_list $file_record
-            } else {
-                set record_list [linsert $record_list[unset record_list] $oldposition $file_record]
-            }
-
-            save_records_to_file $record_list $punkcheck_file
-            return $file_record
-        }
-
-        #todo - ensure that removing a dependency is noticed as a change
-        #e.g previous installrecord had 2 source records - but we now only depend on one.
-        #The files we depended on for the previous record haven't changed themselves - but the list of files has (reduced by one)
-        proc installfile_add_source_and_fetch_metadata {punkcheck_folder source_relpath file_record} {
-            if {![lib::is_file_record_inprogress $file_record]} {
-                error "installfile_add_source_and_fetch_metadata error: bad file_record - expected FILEINFO with last body element *-INPROGRESS ($file_record)"
-            }
-            set ts_start [clock microseconds]
-            set last_installrecord [lib::file_record_get_last_installrecord $file_record]
-            set prev_ftype ""
-            set prev_fsize ""
-            set prev_cksum ""
-            set prev_cksum_opts ""
-            if {[llength $last_installrecord]} {
-                set src [lib::install_record_get_matching_source_record $last_installrecord $source_relpath]
-                if {[llength $src]} {
-                    if {[dict_getwithdefault $src -path ""] eq $source_relpath} {
-                        set prev_ftype [dict_getwithdefault $src -type ""]
-                        set prev_fsize [dict_getwithdefault $src -size ""]
-                        set prev_cksum [dict_getwithdefault $src -cksum ""]
-                        set prev_cksum_opts [dict_getwithdefault $src -cksum_all_opts ""]
-                    }
-                }
-            }
-            #check that this relpath not already added as child of *-INPROGRESS 
-            set file_record_body [dict_getwithdefault $file_record body [list]] ;#new file_record may have no body
-            set installing_record [lindex $file_record_body end]
-            set already_present_record [lib::install_record_get_matching_source_record $installing_record $source_relpath]
-            if {[llength $already_present_record]} {
-                error "installfile_add_source_and_fetch_metadata error: source path $source_relpath already exists in the file_record - cannot add again"
-            }
-
-            if {$prev_cksum_opts ne ""} {
-                set cksum_opts $prev_cksum_opts
-            } else {
-                set cksum_opts ""
-            }
-
-            #todo - accept argument of cached source cksum info (for client calling multiple targets with same source in quick succession e.g when building .vfs kits with multiple runtimes)
-            #if same cksum_opts - then use cached data instead of checksumming here.
-
-            #allow nonexistant as a source 
-            set fpath [file join $punkcheck_folder $source_relpath]
-            if {![file exists $fpath]} {
-                set ftype "missing"
-                set fsize ""
-                #get_relativecksum_from_base will set cksum to <PATHNOTFOUND>
-                set source_cksum_info [punk::mix::base::lib::get_relativecksum_from_base $punkcheck_folder $source_relpath {*}$cksum_opts]
-            } else {
-                set ftype [file type $fpath]
-                if {$ftype eq "directory"} {
-                    set source_cksum_info [punk::mix::base::lib::get_relativecksum_from_base $punkcheck_folder $source_relpath {*}$cksum_opts]
-                    set fsize "NA"
-                } else {
-                    #todo - optionally use mtime instead of cksum (for files only)?
-                    #mtime is not reliable across platforms and filesystems though.. see article linked at toop.
-                    set source_cksum_info [punk::mix::base::lib::get_relativecksum_from_base $punkcheck_folder $source_relpath {*}$cksum_opts]
-                    set fsize [file size $fpath]
-                }
-            }
-
-
-            lassign $source_cksum_info pathkey ckinfo
-            if {$pathkey ne $source_relpath} {
-                error "installfile_add_source_and_fetch_metadata error: cksum returned wrong path info '$pathkey' expected '$source_relpath'"
-            }
-            set cksum [dict get $ckinfo cksum]
-            set cksum_all_opts [dict get $ckinfo cksum_all_opts]
-            if {$cksum ne $prev_cksum || $ftype ne $prev_ftype || $fsize ne $prev_fsize} {
-                set changed 1
-            } else {
-                set changed 0
-            }
-            set installing_record_sources [dict_getwithdefault $installing_record body [list]]
-            set ts_now [clock microseconds] ;#gathering metadata - especially checsums on folder can take some time - calc and store elapsed us for time taken to gather metadata
-            set metadata_us [expr {$ts_now - $ts_start}]
-            set this_source_record [dict create tag SOURCE -type $ftype -size $fsize -path $source_relpath -cksum $cksum -cksum_all_opts $cksum_all_opts -changed $changed -metadata_us $metadata_us]
-            lappend installing_record_sources $this_source_record
-            dict set installing_record body $installing_record_sources
-
-            lset file_record_body end $installing_record
-
-            dict set file_record body $file_record_body
-            return $file_record
-        }
-
-        #write back to punkcheck - don't accept recordset - invalid to update anything other than the installing_record at this time
-        proc installfile_started_install {punkcheck_folder file_record} {
-            if {![lib::is_file_record_inprogress $file_record]} {
-                error "installfile_started_install error: bad file_record - expected FILEINFO with last body element *-INPROGRESS"
-            }
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-            set record_list [load_records_from_file $punkcheck_file]
-
-            set file_record_body [dict get $file_record body]
-            set targetlist [dict get $file_record -targets]
-            set installing_record [lindex $file_record_body end]
-
-            set ts_start [dict get $installing_record -ts]
-            set ts_now [clock microseconds] 
-            set metadata_us [expr {$ts_now - $ts_start}]
-            
-            dict set installing_record -metadata_us $metadata_us
-            dict set installing_record -ts_start_transfer $ts_now
-
-            lset file_record_body end $installing_record
-            
-            dict set file_record body $file_record_body
-
-
-            set getresult [punkcheck::recordlist::get_file_record $targetlist $record_list]
-            set old_posn [dict get $getresult position]
-            if {$old_posn == -1} {
-                lappend record_list $file_record
-            } else {
-                lset record_list $old_posn $file_record
-            }
-
-            save_records_to_file $record_list $punkcheck_file
-            return $file_record
-        }
-        proc installfile_finished_install {punkcheck_folder file_record} {
-            if {![lib::is_file_record_inprogress $file_record]} {
-                error "installfile_finished_install error: bad file_record - expected FILEINFO with last body element *-INPROGRESS"
-            }
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-            set record_list [load_records_from_file $punkcheck_file]
-
-            set file_record_body [dict get $file_record body]
-            set targetlist [dict get $file_record -targets]
-            set installing_record [lindex $file_record_body end]
-
-            set ts_start [dict get $installing_record -ts]
-            set ts_start_transfer [dict get $installing_record -ts_start_transfer]
-            set ts_now [clock microseconds]
-            set elapsed_us [expr {$ts_now - $ts_start}]
-            set transfer_us [expr {$ts_now - $ts_start_transfer}]
-            dict set installing_record  -transfer_us $transfer_us
-            dict set installing_record -elapsed_us $elapsed_us
-            dict unset installing_record -tempcontext
-            dict set installing_record tag "INSTALL-RECORD"
-
-            lset file_record_body end $installing_record
-            dict set file_record body $file_record_body 
-
-            set file_record [punkcheck::recordlist::file_record_prune $file_record]
-
-            set oldrecordinfo [punkcheck::recordlist::get_file_record $targetlist $record_list]
-            set old_posn [dict get $oldrecordinfo position]
-            if {$old_posn == -1} {
-                lappend record_list $file_record
-            } else {
-                lset record_list $old_posn $file_record
-            }
-
-            save_records_to_file $record_list $punkcheck_file
-            return $file_record
-        }
-        proc installfile_skipped_install {punkcheck_folder file_record} {
-            if {![lib::is_file_record_inprogress $file_record]} {
-                set msg "installfile_skipped_install error: bad file_record - expected FILEINFO with last body element *-INPROGRESS"
-                append msg \n "received:"
-                append msg \n $file_record
-                error $msg
-            }
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-            set record_list [load_records_from_file $punkcheck_file]
-
-            set file_record_body [dict get $file_record body]
-            set targetlist [dict get $file_record -targets]
-            set installing_record [lindex $file_record_body end]
-
-            set ts_start [dict get $installing_record -ts]
-            set tsnow [clock microseconds]
-            set elapsed_us [expr {$tsnow - $ts_start}]
-            dict set installing_record -elapsed_us $elapsed_us
-            dict set installing_record tag "INSTALL-SKIPPED" 
-             
-            lset file_record_body end $installing_record
-            dict set file_record body $file_record_body
-
-            set file_record [punkcheck::recordlist::file_record_prune $file_record]
-
-            set getresult [punkcheck::recordlist::get_file_record $targetlist $record_list]
-            set old_posn [dict get $getresult position]
-            if {$old_posn == -1} {
-                lappend record_list $file_record
-            } else {
-                lset record_list $old_posn $file_record
-            }
-
-            save_records_to_file $record_list $punkcheck_file
-            return $file_record
-        }
-        #-----------------------------------------------
-        #then: file_record_add_installrecord
-
-        namespace eval lib {
-            set pkg punkcheck
-            namespace path ::punkcheck
-            proc is_file_record_inprogress {file_record} {
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    return 0
-                }
-                set installing_record [lindex [dict_getwithdefault $file_record body [list]] end]
-                if {[dict_getwithdefault $installing_record tag [list]] ni [list QUERY-INPROGRESS INSTALL-INPROGRESS MODIFY-INPROGRESS DELETE-INPROGRESS VIRTUAL-INPROGRESS]} {
-                    return 0
-                }
-                return 1
-            }
-            proc is_file_record_installing {file_record} {
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    return 0
-                }
-                set installing_record [lindex [dict_getwithdefault $file_record body [list]] end]
-                if {[dict_getwithdefault $installing_record tag [list]] ne "INSTALL-INPROGRESS"} {
-                    return 0
-                }
-                return 1
-            }
-            proc file_record_get_last_installrecord {file_record} {
-                set body [dict_getwithdefault $file_record body [list]]
-                set previous_install_records [lrange $body 0 end-1]
-                #get last previous that is tagged INSTALL-RECORD,MODIFY-RECORD,VIRTUAL-RECORD
-                #REVIEW DELETERECORD ???
-                set revlist [lreverse $previous_install_records]
-                foreach rec $revlist {
-                    if {[dict get $rec tag] in [list "INSTALL-RECORD" "MODIFY-RECORD" "VIRTUAL-RECORD"]} {
-                        return $rec
-                    }
-                }
-                return [list]
-            }
-
-            #should work on *-INPROGRESS or INSTALL(etc) record - don't restrict tag to INSTALL
-            proc install_record_get_matching_source_record {install_record source_relpath} {
-                set body [dict_getwithdefault $install_record body [list]] 
-                foreach src $body {
-                    if {[dict get $src tag] eq "SOURCE"} {
-                        if {[dict_getwithdefault $src -path ""] eq $source_relpath} {
-                            return $src
-                        }
-                    }
-                }
-                return [list]
-            }
-
-
-
-            #maint warning - also in punk::mix::util
-            proc path_relative {base dst} {
-                #see also kettle
-                # Modified copy of ::fileutil::relative (tcllib)
-                # Adapted to 8.5 ({*}).
-                #
-                #    Taking two _directory_ paths, a base and a destination, computes the path
-                #    of the destination relative to the base.
-                #
-                # Arguments:
-                #    base    The path to make the destination relative to.
-                #    dst     The destination path
-                #
-                # Results:
-                #    The path of the destination, relative to the base.
-
-                # Ensure that the link to directory 'dst' is properly done relative to
-                # the directory 'base'.
-
-                #review - check volume info on windows.. UNC paths?
-                if {[file pathtype $base] ne [file pathtype $dst]} {
-                    return -code error "Unable to compute relation for paths of different pathtypes: [file pathtype $base] vs. [file pathtype $dst], ($base vs. $dst)"
-                }
-
-                #avoid normalizing if possible - at least for relative paths which we are likely to loop on (file normalize *very* expensive on windows)
-                set do_normalize 0
-                if {[file pathtype $base] eq "relative"} {
-                    #if base is relative so is dst
-                    if {[regexp {[.]{2}} [list $base $dst]]} {
-                        set do_normalize 1
-                    }
-                    if {[regexp {[.]/} [list $base $dst]]} {
-                        set do_normalize 1
-                    }
-                } else {
-                    #case differences in volumes is common on windows 
-                    set do_normalize 1
-                }
-                if {$do_normalize} {
-                    set base [file normalize $base]
-                    set dst  [file normalize $dst]
-                }
-
-                set save $dst
-                set base [file split $base]
-                set dst  [file split $dst]
-
-                while {[lindex $dst 0] eq [lindex $base 0]} {
-                    set dst  [lrange $dst  1 end]
-                    set base [lrange $base 1 end]
-                    if {![llength $dst]} {break}
-                }
-
-                set dstlen  [llength $dst]
-                set baselen [llength $base]
-
-                if {($dstlen == 0) && ($baselen == 0)} {
-                    # Cases:
-                    # (a) base == dst
-
-                    set dst .
-                    } else {
-                    # Cases:
-                    # (b) base is: base/sub = sub
-                    #     dst  is: base     = {}
-
-                    # (c) base is: base     = {}
-                    #     dst  is: base/sub = sub
-
-                    while {$baselen > 0} {
-                        set dst [linsert $dst 0 ..]
-                        incr baselen -1
-                    }
-                    set dst [file join {*}$dst]
-                }
-
-                return $dst
-            }
-        }
-        #skip writing punkcheck during checksum/timestamp checks
-
-        proc install_tm_files {srcdir basedir args} {
-            set defaults [list\
-                -glob *.tm\
-                -antiglob_file [list "*[punk::mix::util::magic_tm_version]*"]\
-                -installer punkcheck::install_tm_files\
-                ]
-            set opts [dict merge $defaults $args]
-            punkcheck::install $srcdir $basedir {*}$opts
-        }
-        proc install_non_tm_files {srcdir basedir args} {
-            #set keys [dict keys $args]
-            #adjust the default antiglob_dir_core entries so that .fossil-custom, .fossil-settings are copied
-            set antiglob_dir_core [punkcheck::default_antiglob_dir_core]
-            set posn [lsearch $antiglob_dir_core ".fossil*"]
-            if {$posn >=0} {
-                set antiglob_dir_core [lreplace $antiglob_dir_core $posn $posn]
-            }
-            set defaults [list\
-                -glob *\
-                -antiglob_file [list "*.tm" "*-buildversion.txt" "*.exe"]\
-                -antiglob_dir_core $antiglob_dir_core\
-                -installer punkcheck::install_non_tm_files\
-                ]
-            set opts [dict merge $defaults $args]
-            punkcheck::install $srcdir $basedir {*}$opts
-        }
-
-        #for tcl8.6 - tcl8.7+ has dict getwithdefault (dict getdef)
-        proc dict_getwithdefault {dictValue args} {
-            if {[llength $args] < 2} {
-                error {wrong # args: should be "dict_getdef dictionary ?key ...? key default"}
-            }
-            set keys [lrange $args 0 end-1]
-            if {[dict exists $dictValue {*}$keys]} {
-                return [dict get $dictValue {*}$keys]
-            } else {
-                return [lindex $args end] 
-            }
-        }
-        ## unidirectional file transfer to possibly non empty folder
-        #default of -overwrite no-targets will only copy files that are missing at the target
-        #           -overwrite newer-targets will copy files with older source timestamp over newer target timestamp and those missing at the target (a form of 'restore' operation)
-        #           -overwrite older-targets will copy files with newer source timestamp over older target timestamp and those missing at the target
-        #           -overwrite all-targets will copy regardless of timestamp at target
-        #           -overwrite installedsourcechanged-targets will copy if the target doesn't exist or the source changed 
-        #           -overwrite synced-targets will copy if the target doesn't exist or the source changed and the target cksum is the same as the last INSTALL-RECORD targets_cksums entry
-        #           review - timestamps unreliable
-        #            - what about slightly mismatched system clocks and mounted filesystems? caller responsibility to verify first? 
-        #           if timestamp exactly equal -  should we check content-hash? This is presumably only likely to occur deliberately(maliciously?) 
-        #           e.g some process that digitally signs or otherwise modifies a file and preserves update timestmp?
-        #           if such a content-mismatch - what default behaviour and what options would make sense?
-        #           probably it's reasonable that only all-targets would overwrite such files.
-        #           consider -source_fudge_seconds  +-X  ?,  -source_override_timestamp ts  ???  etc which only adjust timestamp for calculation purposes? Define a specific need/usecase when reviewing.
-        #
-        # valid filetypes for src tgt
-        #  src dir      tgt dir
-        #  todo - review and consider enabling symlink src and dst
-        #  no need for src file  - as we use -glob with no glob characters to match one  source file file
-        #  no ability to target file with different name - keep it simpler and caller will have to use an intermediate folder/file if they need to rename something?
-        #
-        #  todo - determine what happens if mismatch between file type of a src vs target e.g target has dir matching filename at source
-        #  A pre-scan to determine no such conflict - before attempting to copy anything might provide the most integrity at slight cost in speed.
-        #  REVIEW  we should only expect dirs to be created as necessary to hold files? i.e target folder won't be created if no source file matches for that folder
-        #  -source_checksum  compare|store|comparestore|false|true  where true == comparestore
-        #  -punkcheck_folder target|source|project|<absolutepath>  target is default and is generally recommended
-        #  -punkcheck_records empty string | parsed TDL records ie {tag xxx k v}  structure
-        # install creates FILEINFO records with a single entry in the -targets field (it is legitimate to have a list of targets for an installation operation - the oo interface supports this)
-        proc install {srcdir tgtdir args} {
-            set defaults [list\
-                -call-depth-internal 0\
-                -max_depth 1000\
-                -subdirlist {}\
-                -createdir 0\
-                -glob *\
-                -antiglob_file_core "\uFFFF"\
-                -antiglob_file "" \
-                -antiglob_dir_core "\uFFFF"\
-                -antiglob_dir {}\
-                -antiglob_paths {}\
-                -overwrite no-targets\
-                -source_checksum comparestore\
-                -punkcheck_folder target\
-                -punkcheck_eventid "\uFFFF"\
-                -punkcheck_records ""\
-                -installer punkcheck::install\
-                ]
-
-            set opts [dict merge $defaults $args]
-            if {([llength $args] %2) != 0} {
-                error "punkcheck::install requires option-style arguments to be in pairs. Received args: $args"
-            }
-            foreach k [dict keys $args] {
-                if {$k ni [dict keys $defaults]} {
-                    error "punkcheck::install  unrecognised option '$k' known options: '[dict keys $defaults]'"
-                }
-            }
-
-            #The choice to recurse using the original values of srcdir & tgtdir, and passing the subpath down as a list in -subdirlist seems an odd one.
-            #(as opposed to a more 'standard' mechanism of adjusting srcdir & tgtdir as we move down the tree)
-            #It comes from build_modules_from_source_to_base where we need to keep track of position relative to our targetdir starting point to handle submodules e.g pkg::something::mypkg-0.1.tm
-            #It could have been handled with some other parameter such as -depth, but this -subdirlist mechanism, whilst perhaps not beautiful, is straightforward enough
-            #and may be less error prone than doing slightly more opaue path manipulations at each recursion level to determine where we started
-            #For consistency - we'll use the same mechanism in various recursive directory walking procedures such as this one.
-            set CALLDEPTH                               [dict get $opts -call-depth-internal] ;#added for extra debug/sanity checking - clearer test for initial function call ie CALLDPEPTH = 0
-            set max_depth                               [dict get $opts -max_depth]
-            set subdirlist                              [dict get $opts -subdirlist] ;# generally should be same length as CALLDEPTH - but user could prefill
-            set fileglob                                [dict get $opts -glob]
-            set createdir                               [dict get $opts -createdir] ;#defaults to zero to help avoid mistakes with initial target dir - required target subdirs are created regardless of this setting
-
-            if {$CALLDEPTH == 0} {
-                #expensive to normalize  but we need to do it at least once
-                set srcdir [file normalize $srcdir]
-                set tgtdir [file normalize $tgtdir]
-                if {$createdir} {
-                    file mkdir $tgtdir
-                }
-                #now the values we build from these will be properly cased
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_file_core                  [dict get $opts -antiglob_file_core]
-            if {$opt_antiglob_file_core eq "\uFFFF"} {
-                set opt_antiglob_file_core [default_antiglob_file_core]
-                dict set opts -antiglob_file_core $opt_antiglob_file_core
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_file                       [dict get $opts -antiglob_file]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_dir_core                   [dict get $opts -antiglob_dir_core]
-            if {$opt_antiglob_dir_core eq "\uFFFF"} {
-                set opt_antiglob_dir_core [default_antiglob_dir_core]
-                dict set opts -antiglob_dir_core $opt_antiglob_dir_core
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_dir                        [dict get $opts -antiglob_dir]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_antiglob_paths                     [dict get $opts -antiglob_paths] ;#todo - combine with config file in source tree .punkcheckpublish (?)
-            set antiglob_paths_matched [list]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set known_whats [list no-targets newer-targets older-targets all-targets installedsourcechanged-targets synced-targets]
-            set overwrite_what                          [string tolower [dict get $opts -overwrite]]; #accept any case for value to allow emphasis by caller e.g -overwrite NEWER-TARGETS
-            if {$overwrite_what ni $known_whats} {
-                error "punkcheck::install received unrecognised value for -overwrite. Received value '$overwrite_what' vs known values '$known_whats'"
-            }
-            if {$overwrite_what in [list newer-targets older-targets]} {
-                error "punkcheck::install newer-target, older-targets not implemented - sorry"
-                #TODO - check crossplatform availability of ctime  (on windows it still seems to be creation time, but on bsd/linux it's last attribute mod time)
-                # external pkg?  use twapi and ctime only on other platforms?
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_source_checksum                     [dict get $opts -source_checksum]
-            if {[string is boolean $opt_source_checksum]} {
-                if {$opt_source_checksum} {
-                    set opt_source_checksum "comparestore"
-                } else {
-                    set opt_source_checksum 0
-                }
-                dict set opts -source_checksum $opt_source_checksum
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_punkcheck_folder                    [dict get $opts -punkcheck_folder]
-            if {$opt_punkcheck_folder eq "target"} {
-                set punkcheck_folder $tgtdir
-            } elseif {$opt_punkcheck_folder eq "source"} {
-                set punkcheck_folder $srcdir
-            } elseif {$opt_punkcheck_folder eq "project"} {
-                set sourceprojectinfo [punk::repo::find_repos $srcdir]
-                set targetprojectinfo [punk::repo::find_repos $tgtdir]
-                set srcproj [lindex [dict get $sourceprojectinfo project] 0]
-                set tgtproj [lindex [dict get $targetprojectinfo project] 0]
-                if {$srcproj eq $tgtproj} {
-                    set punkcheck_folder $tgtproj
-                } else {
-                    error "copy_files_from_source_to_target error: Unable to find common project dir for source and target folder - use absolutepath for -punkcheck_folder if source and target are not within same project"
-                }
-            } else {
-                set punkcheck_folder $opt_punkcheck_folder
-            }
-            if {$punkcheck_folder ne ""} {
-                if {[file pathtype $punkcheck_folder] ne "absolute"} {
-                    error "copy_files_from_source_to_target error: -punkcheck_folder '$punkcheck_folder' must be an absolute path, or one of: target|source|project"
-                }
-                if {![file isdirectory $punkcheck_folder]} {
-                    error "copy_files_from_source_to_target error: -punkcheck_folder '$punkcheck_folder' not found"
-                }
-            } else {
-                #review - leave empty? use pwd?
-            }
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set punkcheck_records                       [dict get $opts -punkcheck_records]
-            set punkcheck_records_init $punkcheck_records ;#change-detection
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_installer                           [dict get $opts -installer]
-            # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-            set opt_punkcheck_eventid                             [dict get $opts -punkcheck_eventid]
-
-
-
-            set punkcheck_file [file join $punkcheck_folder/.punkcheck]
-
-            if {$CALLDEPTH == 0} {
-                set punkcheck_eventid "<invalid>"
-                if {$punkcheck_folder ne ""} {
-                    set config $opts
-                    dict unset config -call-depth-internal
-                    dict unset config -max_depth
-                    dict unset config -subdirlist
-                    dict for {k v} $config {
-                        if {$v eq "\uFFFF"} {
-                            dict unset config $k
-                        }
-                    }
-                    lassign [punkcheck::start_installer_event $punkcheck_file $opt_installer $srcdir $tgtdir $config] _eventid punkcheck_eventid _recordset punkcheck_records
-                }
-            } else {
-                set punkcheck_eventid $opt_punkcheck_eventid
-            }
-
-
-
-            if {$opt_source_checksum != 0} {
-                #we need to read the file even if only set to store (or we would overwrite entries)
-                set compare_cksums 1
-            } else {
-                set compare_cksums 0
-            }
-
-            if {[string match *store* $opt_source_checksum]} {
-                set store_source_cksums 1
-            } else {
-                set store_source_cksums 0
-            }
-            
-
-
-
-
-            if {[llength $subdirlist] == 0} {
-                set current_source_dir $srcdir
-                set current_target_dir $tgtdir
-            } else {
-                set current_source_dir $srcdir/[file join {*}$subdirlist]
-                set current_target_dir $tgtdir/[file join {*}$subdirlist]
-            }
-
-
-            set relative_target_dir [lib::path_relative $tgtdir $current_target_dir]
-            if {$relative_target_dir eq "."} {
-                set relative_target_dir ""
-            }
-            set relative_source_dir [lib::path_relative $srcdir $current_source_dir]
-            if {$relative_source_dir eq "."} {
-                set relative_source_dir ""
-            }
-            set target_relative_to_punkcheck_dir [lib::path_relative $punkcheck_folder $current_target_dir]
-            if {$target_relative_to_punkcheck_dir eq "."} {
-                set target_relative_to_punkcheck_dir ""
-            }
-            foreach unpub $opt_antiglob_paths {
-                #puts "testing folder - globmatchpath $unpub $relative_source_dir"
-                if {[punk::path::globmatchpath $unpub $relative_source_dir]} {
-                    lappend antiglob_paths_matched $current_source_dir
-                    return [list files_copied {} files_skipped {} sources_unchanged {} punkcheck_records $punkcheck_records antiglob_paths_matched $antiglob_paths_matched srcdir $srcdir tgtdir $tgtdir punkcheck_folder $punkcheck_folder]
-                }
-            }
-
-
-            if {![file exists $current_source_dir]} {
-                error "copy_files_from_source_to_target current source dir:'$current_source_dir' doesn't exist (srcdir:$srcdir tgtdir:$tgtdir args:'$args')"
-            }
-            if {![file exists $current_target_dir]} {
-                error "copy_files_from_source_to_target current target dir:'$current_target_dir' doesn't exist (srcdir:$srcdir tgtdir:$tgtdir args:'$args')"
-            }
-            if {([file type $current_source_dir] ni [list directory]) || ([file type $current_target_dir] ni [list directory])} {
-                error "copy_files_from_source_to_target requires source and target dirs to be of type 'directory' type current source: [file type $current_source_dir] type current target: [file type $current_target_dir]"
-            }
-
-            set files_copied [list]
-            set files_skipped [list]
-            set sources_unchanged [list]
-
-
-            set candidate_list [glob -nocomplain -dir $current_source_dir -type f -tail $fileglob]
-            set hidden_candidate_list [glob -nocomplain -dir $current_source_dir -types {hidden f} -tail $fileglob]
-            foreach h $hidden_candidate_list {
-                if {$h ni $candidate_list} {
-                    lappend candidate_list $h
-                }
-            }
-            set match_list [list]
-            foreach m $candidate_list {
-                set suppress 0
-                foreach anti [concat $opt_antiglob_file_core $opt_antiglob_file] {
-                    if {[string match $anti $m]} {
-                        #puts stderr "anti: $anti  vs m:$m"
-                        set suppress 1
-                        break
-                    }
-                }
-                if {$suppress == 0} {
-                    lappend match_list $m
-                } 
-            }
-
-            #sample .punkcheck file record (raw form) to make the code clearer
-            #punk::tdl converts to dict form e.g: tag FILEINFO -targets filename body sublist
-            #Valid installrecord types are INSTALL-RECORD SKIPPED INSTALL-INPROGRESS, MODIFY-RECORD MODIFY-INPROGRESS DELETE-RECORD DELETE-INPROGRESS 
-            #
-            #FILEINFO -targets jjjetc-0.1.0.tm -keep_installrecords 2 -keep_skipped 1 -keep_inprogress 2 {
-            #    INSTALL-RECORD -tsiso 2023-09-20T07:30:30 -ts 1695159030266610 -installer punk::mix::cli::build_modules_from_source_to_base -metadata_us 18426 -ts_start_transfer 1695159030285036 -transfer_us 10194 -elapsed_us 28620 {
-            #        SOURCE -type file -path ../src/modules/jjjetc-buildversion.txt -cksum c7c71839c36b3d21c8370fed106192fcd659eca9 -cksum_all_opts {-cksum_content 1 -cksum_meta 0 -cksum_acls 0 -cksum_usetar 0 -cksum_algorithm sha1} -changed 1 -metadata_us 3423
-            #        SOURCE -type file -path ../src/modules/jjjetc-999999.0a1.0.tm -cksum b646fc2ee88cbd068d2e946fe929b7aea96bd39d -cksum_all_opts {-cksum_content 1 -cksum_meta 0 -cksum_acls 0 -cksum_usetar 0 -cksum_algorithm sha1} -changed 1 -metadata_us 3413
-            #    }
-            #    INSTALL-SKIPPED -tsiso 2023-09-20T08:14:26 -ts 1695161666087880 -installer punk::mix::cli::build_modules_from_source_to_base -elapsed_us 18914 {
-            #        SOURCE -type file -path ../src/modules/jjjetc-buildversion.txt -cksum c7c71839c36b3d21c8370fed106192fcd659eca9 -cksum_all_opts {-cksum_content 1 -cksum_meta 0 -cksum_acls 0 -cksum_usetar 0 -cksum_algorithm sha1} -changed 0 -metadata_us 3435
-            #        SOURCE -type file -path ../src/modules/jjjetc-999999.0a1.0.tm -cksum b646fc2ee88cbd068d2e946fe929b7aea96bd39d -cksum_all_opts {-cksum_content 1 -cksum_meta 0 -cksum_acls 0 -cksum_usetar 0 -cksum_algorithm sha1} -changed 0 -metadata_us 3338
-            #    }
-            #}
-            
-            
-            #proc get_relativecksum_from_base_and_fullpath {base fullpath args}
-          
-
-            #puts stdout     "Current target dir: $current_target_dir"
-            foreach m $match_list {
-                set new_tgt_cksum_info [list]
-                set relative_target_path [file join $relative_target_dir $m]
-                set relative_source_path [file join $relative_source_dir $m]
-                set punkcheck_target_relpath [file join $target_relative_to_punkcheck_dir $m]
-                set is_antipath 0
-                foreach antipath $opt_antiglob_paths {
-                    #puts "testing file - globmatchpath $antipath  vs $relative_source_path" 
-                    if {[punk::path::globmatchpath $antipath $relative_source_path]} {
-                        lappend antiglob_paths_matched $current_source_dir
-                        set is_antipath 1
-                        break
-                    }
-                }
-                if {$is_antipath} {
-                    continue
-                }
-                #puts stdout "    checking file : $current_source_dir/$m"
-                set ts_start [clock microseconds]
-                set seconds [expr {$ts_start / 1000000}]
-                set ts_start_iso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-
-
-                #puts stdout "  rel_target: $punkcheck_target_relpath"
-                
-                set fetch_filerec_result [punkcheck::recordlist::get_file_record $punkcheck_target_relpath $punkcheck_records]
-                #change to use extract_or_create_fileset_record ?
-                set existing_filerec_posn [dict get $fetch_filerec_result position]
-                if {$existing_filerec_posn == -1} {
-                    puts stdout "NO existing record for $punkcheck_target_relpath"
-                    set has_filerec 0
-                    set new_filerec [dict create tag FILEINFO -targets $punkcheck_target_relpath]
-                    set filerec $new_filerec
-                } else {
-                    set has_filerec 1
-                    #puts stdout "  TDL existing FILEINFO record for $punkcheck_target_relpath"
-                    #puts stdout "  $existing_install_record"
-                    set filerec [dict get $fetch_filerec_result record]
-                }
-                set filerec [punkcheck::recordlist::file_record_set_defaults $filerec]
-             
-                #new INSTALLREC must be tagged as INSTALL-INPROGRESS to use recordlist::installfile_ method
-                set new_install_record   [dict create tag INSTALL-INPROGRESS -tsiso $ts_start_iso -ts $ts_start -installer $opt_installer -eventid $punkcheck_eventid]
-                dict lappend filerec body $new_install_record ;#can't use recordlist::file_record_add_installrecord as '*-INPROGRESS' isn't a final tag - so pruning would be mucked up. No need to prune now anyway.
-                unset new_install_record
-
-
-
-
-
-                set relative_source_path [lib::path_relative $punkcheck_folder $current_source_dir/$m]
-                #puts stdout "  rel_source: $relative_source_path"
-                if {[file pathtype $relative_source_path] ne "relative"} {
-                    #different volume or root
-                }
-                #Note this isn't a recordlist function - so it doesn't purely operate on the records
-                #this hits the filesystem for the sourcepath - gets checksums/timestamps depending on config. 
-                #It doesn't save to .punkcheck (the only punkcheck::installfile_ method which doesn't)
-                set filerec [punkcheck::installfile_add_source_and_fetch_metadata $punkcheck_folder $relative_source_path $filerec]
-
-
-
-                #changeinfo comes from last record in body - which is the record we are working on and so will always exist
-                set changeinfo [punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $filerec body] end]]
-                set changed [dict get $changeinfo changed]
-                set unchanged [dict get $changeinfo unchanged]
-
-                if {[llength $unchanged]} {
-                    lappend sources_unchanged $current_source_dir/$m
-                }
-
-                set is_skip 0
-                if {$overwrite_what eq "all-targets"} {
-                    file copy -force $current_source_dir/$m $current_target_dir
-                    lappend files_copied $current_source_dir/$m
-                } else {
-                    if {![file exists $current_target_dir/$m]} {
-                        file copy $current_source_dir/$m $current_target_dir
-                        set new_tgt_cksum_info [punk::mix::base::lib::cksum_path $current_target_dir/$m]
-                        lappend files_copied $current_source_dir/$m
-                        incr filecount_new
-                    } else {
-                        if {$overwrite_what eq "installedsourcechanged-targets"} {
-                            if {[llength $changed]} {
-                                #An unrecorded installation is considered a source change (from unknown/unrecorded source to recorded)
-                                file copy -force $current_source_dir/$m $current_target_dir
-                                set new_tgt_cksum_info [punk::mix::base::lib::cksum_path $current_target_dir/$m]
-                                lappend files_copied $current_source_dir/$m
-                            } else {
-                                set is_skip 1
-                                lappend files_skipped $current_source_dir/$m
-                            }
-                        } elseif {$overwrite_what eq "synced-targets"} {
-                            if {[llength $changed]} {
-                                #only overwrite if the target checksum equals the last installed checksum (ie target is in sync with source and so hasn't been customized)
-                                set existing_tgt_cksum_info [punk::mix::base::lib::cksum_path $current_target_dir/$m]
-                                set is_target_unmodified_since_install 0
-                                set target_cksum_compare "unknown"
-                                set latest_install_record [punkcheck::recordlist::file_record_latest_installrecord $filerec] ;#may be no such record - in which case we get an empty list
-                                if {[dict exists $latest_install_record -targets_cksums]} {
-                                set last_install_cksum [dict get $latest_install_record -targets_cksums] ;#in this case we know there is only one as 'install' always uses targetset size of 1. (FILEINFO record per file in source folder)
-                                    if {[dict get $existing_tgt_cksum_info cksum] eq $last_install_cksum} {
-                                        set is_target_unmodified_since_install 1
-                                        set target_cksum_compare "match"
-                                    } else {
-                                        set target_cksum_compare "nomatch"
-                                    }
-                                } else {
-                                    set target_cksum_compare "norecord"
-                                }
-                                if {$is_target_unmodified_since_install} {
-                                    file copy -force $current_source_dir/$m $current_target_dir
-                                    set new_tgt_cksum_info [punk::mix::base::lib::cksum_path $current_target_dir/$m]
-                                    lappend files_copied $current_source_dir/$m
-                                } else {
-                                    #either cksum is different or we were unable to verify the record. Either way we can't know if the target is in sync so we must skip it
-                                    set is_skip 1
-                                    puts stderr "Skipping file copy $m target $current_target_dir/$m - require synced_target to overwrite - current target cksum compared to previous install: $target_cksum_compare" 
-                                    lappend files_skipped $current_source_dir/$m
-                                }
-                            } else {
-                                set is_skip 1
-                                lappend files_skipped $current_source_dir/$m
-                            }
-                        } else {
-                            set is_skip 1
-                            puts stderr "Skipping file copy $m target $current_target_dir/$m already exists (use -overwrite all-targets  to overwrite)"
-                            #TODO! implement newer-targets older-targets? (note ctimes/mtimes are unreliable - may not be worth implementing)
-                            lappend files_skipped $current_source_dir/$m
-                        }
-                    }
-                }
-
-
-                set ts_now    [clock microseconds]
-                set elapsed_us [expr {$ts_now - $ts_start}]
-
-                #if {$store_source_cksums} {
-                #}
-
-                set install_records [dict get $filerec body] 
-                set current_install_record [lindex $install_records end]
-                #change the tag from *-INPROGRESS to INSTALL-RECORD/SKIPPED
-                if {$is_skip} {
-                    set tag INSTALL-SKIPPED
-                } else {
-                    set tag INSTALL-RECORD
-                }
-                dict set current_install_record tag $tag
-                dict set current_install_record -elapsed_us $elapsed_us
-                if {[llength $new_tgt_cksum_info]} {
-                    dict set current_install_record -targets_cksums [list [dict get $new_tgt_cksum_info cksum]]
-                    dict set current_install_record -cksum_all_opts [dict get $new_tgt_cksum_info opts]
-                }
-                lset install_records end $current_install_record
-                dict set filerec body $install_records
-                set filerec [punkcheck::recordlist::file_record_prune $filerec] ;#prune now that tag is finalized
-                if {!$has_filerec} {
-                    #not found in original recordlist - append
-                    lappend punkcheck_records $filerec
-                } else {
-                    lset punkcheck_records $existing_filerec_posn $filerec
-                }
-
-            }
-
-            if {$CALLDEPTH >= $max_depth} {
-                #don't process any more subdirs
-                set subdirs [list]
-            } else {
-                set subdirs [glob -nocomplain -dir $current_source_dir -type d -tail *]
-                set hiddensubdirs [glob -nocomplain -dir $current_source_dir -type {hidden d} -tail *]
-                foreach h $hiddensubdirs {
-                    if {$h in [list "." ".."]} {
-                        continue
-                    }
-                    if {$h ni $subdirs} {
-                        lappend subdirs $h
-                    }
-                }
-            }
-            #puts stderr "subdirs: $subdirs"
-            foreach d $subdirs {
-                set skipd 0
-                foreach dg [concat $opt_antiglob_dir_core $opt_antiglob_dir] {
-                    if {[string match $dg $d]} {
-                        puts stdout "SKIPPING FOLDER $d due to antiglob_dir-match: $dg "
-                        set skipd 1
-                        break
-                    }
-                }
-                if {$skipd} {
-                    continue
-                }
-
-
-                if {![file exists $current_target_dir/$d]} {
-                    file mkdir $current_target_dir/$d
-                }
-                
-
-                set sub_opts_1 [list\
-                    -call-depth-internal [expr {$CALLDEPTH + 1}]\
-                    -subdirlist [list {*}$subdirlist $d]\
-                    -glob $fileglob\
-                    -antiglob_file_core $opt_antiglob_file_core\
-                    -antiglob_file $opt_antiglob_file\
-                    -antiglob_dir_core  $opt_antiglob_dir_core\
-                    -antiglob_dir $opt_antiglob_dir\
-                    -overwrite $overwrite_what\
-                    -source_checksum $opt_source_checksum\
-                    -punkcheck_folder $punkcheck_folder\
-                    -punkcheck_eventid $punkcheck_eventid\
-                    -punkcheck_records $punkcheck_records\
-                    -installer $opt_installer\
-                    ]
-                set sub_opts [list\
-                    -call-depth-internal [expr {$CALLDEPTH + 1}]\
-                    -subdirlist [list {*}$subdirlist $d]\
-                    -punkcheck_folder $punkcheck_folder\
-                    -punkcheck_eventid $punkcheck_eventid\
-                    -punkcheck_records $punkcheck_records\
-                ]                
-                set sub_opts [dict merge $opts $sub_opts]
-                set sub_result [punkcheck::install $srcdir $tgtdir {*}$sub_opts]
-
-                lappend files_copied {*}[dict get $sub_result files_copied]
-                lappend files_skipped {*}[dict get $sub_result files_skipped]
-                lappend sources_unchanged {*}[dict get $sub_result sources_unchanged]
-                lappend antiglob_paths_matched {*}[dict get $sub_result antiglob_paths_matched]
-                set punkcheck_records [dict get $sub_result punkcheck_records]
-            }
-            
-            if {[string match *store* $opt_source_checksum]} {
-                #puts "subdirlist: $subdirlist"
-                if {$CALLDEPTH == 0} {
-                    if {[llength $files_copied] || [llength $files_skipped]} {
-                        #puts stdout ">>>>>>>>>>>>>>>>>>>"
-                        set saveresult [punkcheck::save_records_to_file $punkcheck_records $punkcheck_file]
-                        puts stdout "punkcheck::install [dict get $saveresult recordcount] records saved as [dict get $saveresult linecount] lines to $punkcheck_file copied: [llength $files_copied] skipped: [llength $files_skipped]"
-                        #puts stdout ">>>>>>>>>>>>>>>>>>>"
-                    } else {
-                        #todo - write db INSTALLER record if -debug true
-                        
-                    }
-                    #puts stdout "sources_unchanged"
-                    #puts stdout "$sources_unchanged"
-                    #puts stdout "- -- --- --- --- ---"
-                }
-            }
-
-            return [list files_copied $files_copied files_skipped $files_skipped sources_unchanged $sources_unchanged antiglob_paths_matched $antiglob_paths_matched punkcheck_records $punkcheck_records punkcheck_folder $punkcheck_folder srcdir $srcdir tgtdir $tgtdir]
-        }
-        proc summarize_install_resultdict {resultdict} {
-            set msg ""
-            if {[dict size $resultdict]} {
-                set copied [dict get $resultdict files_copied]
-                append msg "--------------------------" \n
-                append msg  "[dict keys $resultdict]" \n
-                set tgtdir [dict get $resultdict tgtdir]
-                set checkfolder [dict get $resultdict punkcheck_folder]
-                append msg "Copied [llength $copied] files from [dict get $resultdict srcdir] to [dict get $resultdict tgtdir]" \n
-                foreach f $copied {
-                    append msg "COPIED [punkcheck::lib::path_relative $checkfolder $f]" \n
-                    append msg "    TO $tgtdir" \n
-                }
-                append msg "[llength [dict get $resultdict sources_unchanged]] unchanged source files" \n
-                append msg "[llength [dict get $resultdict files_skipped]] skipped files" \n
-                append msg "--------------------------" \n
-            }
-            return $msg
-        }
-
-        namespace eval recordlist {
-            set pkg punkcheck
-            namespace path ::punkcheck
-
-            proc records_as_target_dict {record_list} {
-                set result [dict create]
-                foreach rec $record_list {
-                    if {[dict get $rec tag] eq "FILEINFO"} {
-                        set tgtlist [dict get $rec -targets]
-                        dict set result $tgtlist $rec
-                    }
-                }
-                return $result
-            }
-
-
-
-
-            #will only match if same base was used.. and same targetlist
-            proc get_file_record {targetlist record_list} {
-                set posn 0
-                set found_posn -1
-                set record ""
-                foreach rec $record_list {
-                    if {[dict get $rec tag] eq "FILEINFO"} {
-                        if {[dict get $rec -targets] eq $targetlist} {
-                            set found_posn $posn
-                            set record $rec
-                            break
-                        }
-                    }
-                    incr posn
-                }
-                return [list position $found_posn record $record]
-            }
-            proc file_install_record_source_changes {install_record} {
-                #reject INSTALLFAILED items ?
-                if {[dict get $install_record tag] ni [list "QUERY-INPROGRESS" "INSTALL-RECORD" "INSTALL-SKIPPED" "INSTALL-INPROGRESS" "MODIFY-INPROGRESS" "MODIFY-RECORD" "MODIFY-SKIPPED" "VIRTUAL-INPROGRESS" "VIRTUAL-RECORD" "VIRTUAL-SKIPPED" "DELETE-RECORD" "DELETE-INPROGRESS" "DELETE-SKIPPED"]} {
-                    error "file_install_record_source_changes bad install record: tag '[dict get $install_record tag]' not INSTALL-RECORD|SKIPPED|INSTALL-INPROGRESS|MODIFY-RECORD|MODIFY-INPROGRESS|VIRTUAL-RECORD|VIRTUAL-INPROGRESS|DELETE-RECORD|DELETE-INPROGRESS"
-                }
-                set source_list [dict_getwithdefault $install_record body [list]]
-                set changed [list]
-                set unchanged [list]
-                foreach src $source_list {
-                    if {[dict exists $src -changed]} {
-                        if {[dict get $src -changed] !=0} {
-                            lappend changed [dict get $src -path]
-                        } else {
-                            lappend unchanged [dict get $src -path]
-                        }
-                    } else {
-                        lappend changed [dict get $src -path]
-                    }
-                }
-                return [dict create changed $changed unchanged $unchanged]
-            }
-
-            #assume only one for name - use first encountered
-            proc get_installer_record {name record_list} {
-                set posn 0
-                set found_posn -1
-                set record ""
-                #puts ">>>> checking [llength $record_list] punkcheck records"
-                foreach rec $record_list {
-                    if {[dict get $rec tag] eq "INSTALLER"} {
-                        if {[dict get $rec -name] eq $name} {
-                            set found_posn $posn
-                            set record $rec
-                            break
-                        }
-                    }
-                    incr posn
-                }
-                return [list position $found_posn record $record]
-            }
-
-            proc new_installer_record {name args} {
-                if {[llength $args] %2 !=0} {
-                    error "punkcheck new_installer_record args must be name-value pairs"
-                }
-                set ts [clock microseconds]
-                set seconds [expr {$ts / 1000000}]
-                set tsiso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-
-                #put -tsiso first so it lines up with -tsiso in event records
-                set defaults [list\
-                    -tsiso $tsiso\
-                    -ts $ts\
-                    -name $name\
-                    -keep_events 5\
-                    ]
-                set opts [dict merge $defaults $args]
-
-                #set this_installer_record_list [punk::tdl::prettyparse [list INSTALLER name $opt_installer ts $ts tsiso $tsiso keep_events 5 {}]]
-                #set this_installer_record [lindex $this_installer_record_list 0]
-
-                set record [dict create tag INSTALLER {*}$opts body {}]
-
-
-                return $record
-            }
-            proc new_installer_event_record {type args} {
-                if {[llength $args] %2 !=0} {
-                    error "punkcheck new_installer_event_record args must be name-value pairs"
-                }
-                set ts [clock microseconds]
-                set seconds [expr {$ts / 1000000}]
-                set tsiso [clock format $seconds -format "%Y-%m-%dT%H:%M:%S"]
-                set defaults [list\
-                    -tsiso $tsiso\
-                    -ts $ts\
-                    -type $type\
-                    ]
-                set opts [dict merge $defaults $args]
-
-                set record [dict create tag EVENT {*}$opts]
-            }
-            #need to scan entire set if filerecords to check if event is still referenced
-            proc installer_record_pruneevents {installer_record record_list} {
-                set keep 5
-                if {[dict exists $installer_record -keep_events]} {
-                    set keep [dict get $installer_record -keep_events]
-                }
-
-                if {[dict exists $installer_record body]} {
-                    set body_items [dict get $installer_record body]
-                } else {
-                    set body_items [list]
-                }
-                set kept_body_items [list]
-                set kcount 0
-                foreach item [lreverse $body_items] {
-                    if {[dict get $item tag] eq "EVENT"} {
-                        incr kcount
-                        if {$keep < 0 || $kcount <= $keep} {
-                            lappend kept_body_items $item
-                        } else {
-                            set eventid ""
-                            if {[dict exists $item -id]} {
-                                set eventid [dict get $item -id]
-                            }
-                            if {$eventid ne "" && $eventid ne "unspecified"} {
-                                #keep if referenced, discard if not, or if eventid empty/unspecified
-                                set is_referenced 0
-                                foreach rec $record_list {
-                                    if {[dict get $rec tag] eq "FILEINFO"} {
-                                        if {[dict exists $rec body]} {
-                                            foreach install [dict get $rec body] {
-                                                if {[dict exists $install -eventid] && [dict get $install -eventid] eq $eventid} {
-                                                    set is_referenced 1
-                                                    break
-                                                }
-                                            }
-                                        }
-                                    }
-                                    if {$is_referenced} {
-                                        break
-                                    }
-                                }
-                                if {$is_referenced} {
-                                    lappend kept_body_items $item
-                                }
-                            }
-                        }
-                    } else {
-                        lappend kept_body_items $item
-                    }
-                }
-                set kept_body_items [lreverse $kept_body_items]
-                dict set installer_record body $kept_body_items
-                return $installer_record
-            }
-            proc installer_record_add_event {installer_record event} {
-                if {[dict get $installer_record tag] ne "INSTALLER"} {
-                    error "installer_record_add_event bad installer record: tag not INSTALLER"
-                }
-                if {[dict get $event tag] ne "EVENT"} {
-                    error "installer_record_add_event bad event record: tag not EVENT"
-                }
-                if {[dict exists $installer_record body]} {
-                    set body_items [dict get $installer_record body]
-                } else {
-                    set body_items [list]
-                }
-                lappend body_items $event
-                dict set installer_record body $body_items
-                return $installer_record
-            }
-            proc file_record_latest_installrecord {file_record} {
-                tailcall file_record_latest_operationrecord INSTALL $file_record
-            }
-            proc file_record_latest_operationrecord {operation file_record} {
-                set operation [string toupper $operation]
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    error "file_record_latest_operationrecord bad file_record: tag not FILEINFO"
-                }
-                if {![dict exists $file_record body]} {
-                    return [list]
-                }
-                set body_items [dict get $file_record body]
-                foreach item [lreverse $body_items] {
-                    if {[dict get $item tag] eq "$operation-RECORD"} {
-                        return $item
-                    }
-                }
-                return [list]
-            }
-
-
-            proc file_record_set_defaults {file_record} {
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    error "file_record_set_defaults bad file_record: tag not FILEINFO"
-                }
-                set defaults [list -keep_installrecords 3 -keep_skipped 1 -keep_inprogress 2] 
-                dict for {k v} $defaults {
-                    if {![dict exists $file_record $k]} {
-                        dict set file_record $k $v
-                    }
-                }
-                return $file_record
-            }
-
-            #negative keep_ value will keep all
-            proc file_record_prune {file_record} {
-                if {[dict get $file_record tag] ne "FILEINFO"} {
-                    error "file_record_prune bad file_record: tag not FILEINFO"
-                }
-                set file_record [file_record_set_defaults $file_record]
-                set kmap [list -keep_installrecords *-RECORD -keep_skipped *-SKIPPED -keep_inprogress *-INPROGRESS]
-                foreach {key rtype} $kmap {
-                    set keep [dict get $file_record $key]
-                    if {[dict exists $file_record body]} {
-                        set body_items [dict get $file_record body]
-                    } else {
-                        set body_items [list]
-                    }
-                    set kept_body_items [list]
-                    set kcount 0
-                    foreach item [lreverse $body_items] {
-                        if {[string match $rtype [dict get $item tag]]} {
-                            incr kcount
-                            if {$keep < 0 || $kcount <= $keep} {
-                                lappend kept_body_items $item
-                            }
-                        } else {
-                            lappend kept_body_items $item
-                        }
-                    }
-                    set kept_body_items [lreverse $kept_body_items]
-                    dict set file_record body $kept_body_items
-                }
-                return $file_record
-            }
-
-            #extract new or existing filerecord for path given
-            #review - locking/concurrency
-            proc extract_or_create_fileset_record {relative_target_paths recordset} {
-                set fetch_record_result [punkcheck::recordlist::get_file_record $relative_target_paths $recordset]
-                set existing_posn [dict get $fetch_record_result position]
-                if {$existing_posn == -1} {
-                    #puts stdout "NO existing record for $relative_target_paths"
-                    set isnew 1
-                    set fileset_record [dict create tag FILEINFO -targets $relative_target_paths body {}]
-                } else {
-                    set recordset [lreplace $recordset[unset recordset] $existing_posn $existing_posn]
-                    set isnew 0
-                    set fileset_record [dict get $fetch_record_result record]
-                }
-                return [list record $fileset_record recordset $recordset isnew $isnew oldposition $existing_posn]
-            }
-
-        }
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide punkcheck [namespace eval punkcheck {
-    set pkg punkcheck
-    variable version
-    set version 0.1.0 
-}]
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/set-2.2.3.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/set-2.2.3.tm
deleted file mode 100644
index 2ed2c260..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/set-2.2.3.tm
+++ /dev/null
@@ -1,189 +0,0 @@
-#----------------------------------------------------------------------
-#
-# sets.tcl --
-#
-#	Definitions for the processing of sets.
-#
-# Copyright (c) 2004-2008 by Andreas Kupries.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: sets.tcl,v 1.17 2008/03/09 04:24:37 andreas_kupries Exp $
-#
-#----------------------------------------------------------------------
-
-# @mdgen EXCLUDE: sets_c.tcl
-
-package require Tcl 8.5-
-
-namespace eval ::struct::set {}
-
-# ### ### ### ######### ######### #########
-## Management of set implementations.
-
-# ::struct::set::LoadAccelerator --
-#
-#	Loads a named implementation, if possible.
-#
-# Arguments:
-#	key	Name of the implementation to load.
-#
-# Results:
-#	A boolean flag. True if the implementation
-#	was successfully loaded; and False otherwise.
-
-proc ::struct::set::LoadAccelerator {key} {
-    variable accel
-    set r 0
-    switch -exact -- $key {
-	critcl {
-	    # Critcl implementation of set requires Tcl 8.4.
-	    if {![package vsatisfies [package provide Tcl] 8.4]} {return 0}
-	    if {[catch {package require tcllibc}]} {return 0}
-	    set r [llength [info commands ::struct::set_critcl]]
-	}
-	tcl {
-	    variable selfdir
-	    source [file join $selfdir sets_tcl.tcl]
-	    set r 1
-	}
-        default {
-            return -code error "invalid accelerator/impl. package $key:\
-                must be one of [join [KnownImplementations] {, }]"
-        }
-    }
-    set accel($key) $r
-    return $r
-}
-
-# ::struct::set::SwitchTo --
-#
-#	Activates a loaded named implementation.
-#
-# Arguments:
-#	key	Name of the implementation to activate.
-#
-# Results:
-#	None.
-
-proc ::struct::set::SwitchTo {key} {
-    variable accel
-    variable loaded
-
-    if {[string equal $key $loaded]} {
-	# No change, nothing to do.
-	return
-    } elseif {![string equal $key ""]} {
-	# Validate the target implementation of the switch.
-
-	if {![info exists accel($key)]} {
-	    return -code error "Unable to activate unknown implementation \"$key\""
-	} elseif {![info exists accel($key)] || !$accel($key)} {
-	    return -code error "Unable to activate missing implementation \"$key\""
-	}
-    }
-
-    # Deactivate the previous implementation, if there was any.
-
-    if {![string equal $loaded ""]} {
-	rename ::struct::set ::struct::set_$loaded
-    }
-
-    # Activate the new implementation, if there is any.
-
-    if {![string equal $key ""]} {
-	rename ::struct::set_$key ::struct::set
-    }
-
-    # Remember the active implementation, for deactivation by future
-    # switches.
-
-    set loaded $key
-    return
-}
-
-proc ::struct::set::Loaded {} {
-    variable loaded
-    return  $loaded
-}
-
-# ::struct::set::Implementations --
-#
-#	Determines which implementations are
-#	present, i.e. loaded.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	A list of implementation keys.
-
-proc ::struct::set::Implementations {} {
-    variable accel
-    set res {}
-    foreach n [array names accel] {
-	if {!$accel($n)} continue
-	lappend res $n
-    }
-    return $res
-}
-
-# ::struct::set::KnownImplementations --
-#
-#	Determines which implementations are known
-#	as possible implementations.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	A list of implementation keys. In the order
-#	of preference, most prefered first.
-
-proc ::struct::set::KnownImplementations {} {
-    return {critcl tcl}
-}
-
-proc ::struct::set::Names {} {
-    return {
-	critcl {tcllibc based}
-	tcl    {pure Tcl}
-    }
-}
-
-# ### ### ### ######### ######### #########
-## Initialization: Data structures.
-
-namespace eval ::struct::set {
-    variable  selfdir [file dirname [info script]]
-    variable  accel
-    array set accel   {tcl 0 critcl 0}
-    variable  loaded  {}
-}
-
-# ### ### ### ######### ######### #########
-## Initialization: Choose an implementation,
-## most prefered first. Loads only one of the
-## possible implementations. And activates it.
-
-namespace eval ::struct::set {
-    variable e
-    foreach e [KnownImplementations] {
-	if {[LoadAccelerator $e]} {
-	    SwitchTo $e
-	    break
-	}
-    }
-    unset e
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-namespace eval ::struct {
-    # Export the constructor command.
-    namespace export set
-}
-
-package provide struct::set 2.2.3
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/sets.tcl b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/sets.tcl
deleted file mode 100644
index 2ed2c260..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/sets.tcl
+++ /dev/null
@@ -1,189 +0,0 @@
-#----------------------------------------------------------------------
-#
-# sets.tcl --
-#
-#	Definitions for the processing of sets.
-#
-# Copyright (c) 2004-2008 by Andreas Kupries.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: sets.tcl,v 1.17 2008/03/09 04:24:37 andreas_kupries Exp $
-#
-#----------------------------------------------------------------------
-
-# @mdgen EXCLUDE: sets_c.tcl
-
-package require Tcl 8.5-
-
-namespace eval ::struct::set {}
-
-# ### ### ### ######### ######### #########
-## Management of set implementations.
-
-# ::struct::set::LoadAccelerator --
-#
-#	Loads a named implementation, if possible.
-#
-# Arguments:
-#	key	Name of the implementation to load.
-#
-# Results:
-#	A boolean flag. True if the implementation
-#	was successfully loaded; and False otherwise.
-
-proc ::struct::set::LoadAccelerator {key} {
-    variable accel
-    set r 0
-    switch -exact -- $key {
-	critcl {
-	    # Critcl implementation of set requires Tcl 8.4.
-	    if {![package vsatisfies [package provide Tcl] 8.4]} {return 0}
-	    if {[catch {package require tcllibc}]} {return 0}
-	    set r [llength [info commands ::struct::set_critcl]]
-	}
-	tcl {
-	    variable selfdir
-	    source [file join $selfdir sets_tcl.tcl]
-	    set r 1
-	}
-        default {
-            return -code error "invalid accelerator/impl. package $key:\
-                must be one of [join [KnownImplementations] {, }]"
-        }
-    }
-    set accel($key) $r
-    return $r
-}
-
-# ::struct::set::SwitchTo --
-#
-#	Activates a loaded named implementation.
-#
-# Arguments:
-#	key	Name of the implementation to activate.
-#
-# Results:
-#	None.
-
-proc ::struct::set::SwitchTo {key} {
-    variable accel
-    variable loaded
-
-    if {[string equal $key $loaded]} {
-	# No change, nothing to do.
-	return
-    } elseif {![string equal $key ""]} {
-	# Validate the target implementation of the switch.
-
-	if {![info exists accel($key)]} {
-	    return -code error "Unable to activate unknown implementation \"$key\""
-	} elseif {![info exists accel($key)] || !$accel($key)} {
-	    return -code error "Unable to activate missing implementation \"$key\""
-	}
-    }
-
-    # Deactivate the previous implementation, if there was any.
-
-    if {![string equal $loaded ""]} {
-	rename ::struct::set ::struct::set_$loaded
-    }
-
-    # Activate the new implementation, if there is any.
-
-    if {![string equal $key ""]} {
-	rename ::struct::set_$key ::struct::set
-    }
-
-    # Remember the active implementation, for deactivation by future
-    # switches.
-
-    set loaded $key
-    return
-}
-
-proc ::struct::set::Loaded {} {
-    variable loaded
-    return  $loaded
-}
-
-# ::struct::set::Implementations --
-#
-#	Determines which implementations are
-#	present, i.e. loaded.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	A list of implementation keys.
-
-proc ::struct::set::Implementations {} {
-    variable accel
-    set res {}
-    foreach n [array names accel] {
-	if {!$accel($n)} continue
-	lappend res $n
-    }
-    return $res
-}
-
-# ::struct::set::KnownImplementations --
-#
-#	Determines which implementations are known
-#	as possible implementations.
-#
-# Arguments:
-#	None.
-#
-# Results:
-#	A list of implementation keys. In the order
-#	of preference, most prefered first.
-
-proc ::struct::set::KnownImplementations {} {
-    return {critcl tcl}
-}
-
-proc ::struct::set::Names {} {
-    return {
-	critcl {tcllibc based}
-	tcl    {pure Tcl}
-    }
-}
-
-# ### ### ### ######### ######### #########
-## Initialization: Data structures.
-
-namespace eval ::struct::set {
-    variable  selfdir [file dirname [info script]]
-    variable  accel
-    array set accel   {tcl 0 critcl 0}
-    variable  loaded  {}
-}
-
-# ### ### ### ######### ######### #########
-## Initialization: Choose an implementation,
-## most prefered first. Loads only one of the
-## possible implementations. And activates it.
-
-namespace eval ::struct::set {
-    variable e
-    foreach e [KnownImplementations] {
-	if {[LoadAccelerator $e]} {
-	    SwitchTo $e
-	    break
-	}
-    }
-    unset e
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-namespace eval ::struct {
-    # Export the constructor command.
-    namespace export set
-}
-
-package provide struct::set 2.2.3
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/sets_c.tcl b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/sets_c.tcl
deleted file mode 100644
index c9837e94..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/sets_c.tcl
+++ /dev/null
@@ -1,93 +0,0 @@
-#----------------------------------------------------------------------
-#
-# sets_tcl.tcl --
-#
-#       Definitions for the processing of sets. C implementation.
-#
-# Copyright (c) 2007 by Andreas Kupries.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: sets_c.tcl,v 1.3 2008/03/25 07:15:34 andreas_kupries Exp $
-#
-#----------------------------------------------------------------------
-
-package require critcl
-# @sak notprovided struct_setc
-package provide struct_setc 2.1.1
-package require Tcl 8.5-
-
-namespace eval ::struct {
-    # Supporting code for the main command.
-
-    catch {
-        #critcl::cheaders -g
-        #critcl::debug memory symbols
-    }
-
-    critcl::cheaders sets/*.h
-    critcl::csources sets/*.c
-
-    critcl::ccode {
-        /* -*- c -*- */
-
-        #include <m.h>
-    }
-
-    # Main command, set creation.
-
-    critcl::ccommand set_critcl {dummy interp objc objv} {
-	/* Syntax - dispatcher to the sub commands.
-	 */
-
-        static CONST char* methods [] = {
-            "add",      "contains",     "difference",   "empty",
-            "equal","exclude",  "include",      "intersect",
-            "intersect3",       "size", "subsetof",     "subtract",
-            "symdiff",  "union",
-            NULL
-        };
-        enum methods {
-            S_add,      S_contains,     S_difference,   S_empty,
-            S_equal,S_exclude,  S_include,      S_intersect,
-            S_intersect3,       S_size, S_subsetof,     S_subtract,
-            S_symdiff,  S_union
-        };
-
-	int m;
-
-        if (objc < 2) {
-            Tcl_WrongNumArgs (interp, objc, objv, "cmd ?arg ...?");
-            return TCL_ERROR;
-        } else if (Tcl_GetIndexFromObj (interp, objv [1], methods, "option",
-            0, &m) != TCL_OK) {
-            return TCL_ERROR;
-        }
-
-        /* Dispatch to methods. They check the #args in detail before performing
-         * the requested functionality
-         */
-
-        switch (m) {
-            case S_add:        return sm_ADD        (NULL, interp, objc, objv);
-            case S_contains:   return sm_CONTAINS   (NULL, interp, objc, objv);
-            case S_difference: return sm_DIFFERENCE (NULL, interp, objc, objv);
-            case S_empty:      return sm_EMPTY      (NULL, interp, objc, objv);
-            case S_equal:      return sm_EQUAL      (NULL, interp, objc, objv);
-            case S_exclude:    return sm_EXCLUDE    (NULL, interp, objc, objv);
-            case S_include:    return sm_INCLUDE    (NULL, interp, objc, objv);
-            case S_intersect:  return sm_INTERSECT  (NULL, interp, objc, objv);
-            case S_intersect3: return sm_INTERSECT3 (NULL, interp, objc, objv);
-            case S_size:       return sm_SIZE       (NULL, interp, objc, objv);
-            case S_subsetof:   return sm_SUBSETOF   (NULL, interp, objc, objv);
-            case S_subtract:   return sm_SUBTRACT   (NULL, interp, objc, objv);
-            case S_symdiff:    return sm_SYMDIFF    (NULL, interp, objc, objv);
-            case S_union:      return sm_UNION      (NULL, interp, objc, objv);
-        }
-        /* Not coming to this place */
-    }
-}
-
-# ### ### ### ######### ######### #########
-## Ready
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/sets_tcl.tcl b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/sets_tcl.tcl
deleted file mode 100644
index ad76704f..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/struct/sets_tcl.tcl
+++ /dev/null
@@ -1,452 +0,0 @@
-#----------------------------------------------------------------------
-#
-# sets_tcl.tcl --
-#
-#	Definitions for the processing of sets.
-#
-# Copyright (c) 2004-2008 by Andreas Kupries.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: sets_tcl.tcl,v 1.4 2008/03/09 04:38:47 andreas_kupries Exp $
-#
-#----------------------------------------------------------------------
-
-package require Tcl 8.5-
-
-namespace eval ::struct::set {
-    # Only export one command, the one used to instantiate a new tree
-    namespace export set_tcl
-}
-
-##########################
-# Public functions
-
-# ::struct::set::set --
-#
-#	Command that access all set commands.
-#
-# Arguments:
-#	cmd	Name of the subcommand to dispatch to.
-#	args	Arguments for the subcommand.
-#
-# Results:
-#	Whatever the result of the subcommand is.
-
-proc ::struct::set::set_tcl {cmd args} {
-    # Do minimal args checks here
-    if { [llength [info level 0]] == 1 } {
-	return -code error "wrong # args: should be \"$cmd ?arg arg ...?\""
-    }
-    ::set sub S_$cmd
-    if { [llength [info commands ::struct::set::$sub]] == 0 } {
-	::set optlist [info commands ::struct::set::S_*]
-	::set xlist {}
-	foreach p $optlist {
-	    lappend xlist [string range $p 17 end]
-	}
-	return -code error \
-		"bad option \"$cmd\": must be [linsert [join [lsort $xlist] ", "] "end-1" "or"]"
-    }
-    return [uplevel 1 [linsert $args 0 ::struct::set::$sub]]
-}
-
-##########################
-# Implementations of the functionality.
-#
-
-# ::struct::set::S_empty --
-#
-#       Determines emptiness of the set
-#
-# Parameters:
-#       set	-- The set to check for emptiness.
-#
-# Results:
-#       A boolean value. True indicates that the set is empty.
-#
-# Side effects:
-#       None.
-#
-# Notes:
-
-proc ::struct::set::S_empty {set} {
-    return [expr {[llength $set] == 0}]
-}
-
-# ::struct::set::S_size --
-#
-#	Computes the cardinality of the set.
-#
-# Parameters:
-#	set	-- The set to inspect.
-#
-# Results:
-#       An integer greater than or equal to zero.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_size {set} {
-    return [llength [Cleanup $set]]
-}
-
-# ::struct::set::S_contains --
-#
-#	Determines if the item is in the set.
-#
-# Parameters:
-#	set	-- The set to inspect.
-#	item	-- The element to look for.
-#
-# Results:
-#	A boolean value. True indicates that the element is present.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_contains {set item} {
-    return [expr {[lsearch -exact $set $item] >= 0}]
-}
-
-# ::struct::set::S_union --
-#
-#	Computes the union of the arguments.
-#
-# Parameters:
-#	args	-- List of sets to unify.
-#
-# Results:
-#	The union of the arguments.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_union {args} {
-    switch -exact -- [llength $args] {
-	0 {return {}}
-	1 {return [lindex $args 0]}
-    }
-    foreach setX $args {
-	foreach x $setX {::set ($x) {}}
-    }
-    return [array names {}]
-}
-
-
-# ::struct::set::S_intersect --
-#
-#	Computes the intersection of the arguments.
-#
-# Parameters:
-#	args	-- List of sets to intersect.
-#
-# Results:
-#	The intersection of the arguments
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_intersect {args} {
-    switch -exact -- [llength $args] {
-	0 {return {}}
-	1 {return [lindex $args 0]}
-    }
-    ::set res [lindex $args 0]
-    foreach set [lrange $args 1 end] {
-	if {[llength $res] && [llength $set]} {
-	    ::set res [Intersect $res $set]
-	} else {
-	    # Squash 'res'. Otherwise we get the wrong result if res
-	    # is not empty, but 'set' is.
-	    ::set res {}
-	    break
-	}
-    }
-    return $res
-}
-
-proc ::struct::set::Intersect {A B} {
-    if {[llength $A] == 0} {return {}}
-    if {[llength $B] == 0} {return {}}
-
-    # This is slower than local vars, but more robust
-    if {[llength $B] > [llength $A]} {
-	::set res $A
-	::set A $B
-	::set B $res
-    }
-    ::set res {}
-    foreach x $A {::set ($x) {}}
-    foreach x $B {
-	if {[info exists ($x)]} {
-	    lappend res $x
-	}
-    }
-    return $res
-}
-
-# ::struct::set::S_difference --
-#
-#	Compute difference of two sets.
-#
-# Parameters:
-#	A, B	-- Sets to compute the difference for.
-#
-# Results:
-#	A - B
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_difference {A B} {
-    if {[llength $A] == 0} {return {}}
-    if {[llength $B] == 0} {return $A}
-
-    array set tmp {}
-    foreach x $A {::set tmp($x) .}
-    foreach x $B {catch {unset tmp($x)}}
-    return [array names tmp]
-}
-
-if {0} {
-    # Tcllib SF Bug 1002143. We cannot use the implementation below.
-    # It will treat set elements containing '(' and ')' as array
-    # elements, and this screws up the storage of elements as the name
-    # of local vars something fierce. No way around this. Disabling
-    # this code and always using the other implementation (s.a.) is
-    # the only possible fix.
-
-    if {[package vcompare [package provide Tcl] 8.4] < 0} {
-	# Tcl 8.[23]. Use explicit array to perform the operation.
-    } else {
-	# Tcl 8.4+, has 'unset -nocomplain'
-
-	proc ::struct::set::S_difference {A B} {
-	    if {[llength $A] == 0} {return {}}
-	    if {[llength $B] == 0} {return $A}
-
-	    # Get the variable B out of the way, avoid collisions
-	    # prepare for "pure list optimization"
-	    ::set ::struct::set::tmp [lreplace $B -1 -1 unset -nocomplain]
-	    unset B
-
-	    # unset A early: no local variables left
-	    foreach [lindex [list $A [unset A]] 0] {.} {break}
-
-	    eval $::struct::set::tmp
-	    return [info locals]
-	}
-    }
-}
-
-# ::struct::set::S_symdiff --
-#
-#	Compute symmetric difference of two sets.
-#
-# Parameters:
-#	A, B	-- The sets to compute the s.difference for.
-#
-# Results:
-#	The symmetric difference of the two input sets.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_symdiff {A B} {
-    # symdiff == (A-B) + (B-A) == (A+B)-(A*B)
-    if {[llength $A] == 0} {return $B}
-    if {[llength $B] == 0} {return $A}
-    return [S_union \
-	    [S_difference $A $B] \
-	    [S_difference $B $A]]
-}
-
-# ::struct::set::S_intersect3 --
-#
-#	Return intersection and differences for two sets.
-#
-# Parameters:
-#	A, B	-- The sets to inspect.
-#
-# Results:
-#	List containing A*B, A-B, and B-A
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_intersect3 {A B} {
-    return [list \
-	    [S_intersect $A $B] \
-	    [S_difference $A $B] \
-	    [S_difference $B $A]]
-}
-
-# ::struct::set::S_equal --
-#
-#	Compares two sets for equality.
-#
-# Parameters:
-#	a	First set to compare.
-#	b	Second set to compare.
-#
-# Results:
-#	A boolean. True if the lists are equal.
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_equal {A B} {
-    ::set A [Cleanup $A]
-    ::set B [Cleanup $B]
-
-    # Equal if of same cardinality and difference is empty.
-
-    if {[::llength $A] != [::llength $B]} {return 0}
-    return [expr {[llength [S_difference $A $B]] == 0}]
-}
-
-
-proc ::struct::set::Cleanup {A} {
-    # unset A to avoid collisions
-    if {[llength $A] < 2} {return $A}
-    # We cannot use variables to avoid an explicit array. The set
-    # elements may look like namespace vars (i.e. contain ::), and
-    # such elements break that, cannot be proc-local variables.
-    array set S {}
-    foreach item $A {set S($item) .}
-    return [array names S]
-}
-
-# ::struct::set::S_include --
-#
-#	Add an element to a set.
-#
-# Parameters:
-#	Avar	-- Reference to the set variable to extend.
-#	element	-- The item to add to the set.
-#
-# Results:
-#	None.
-#
-# Side effects:
-#       The set in the variable referenced by Avar is extended
-#	by the element (if the element was not already present).
-
-proc ::struct::set::S_include {Avar element} {
-    # Avar = Avar + {element}
-    upvar 1 $Avar A
-    if {![info exists A] || ![S_contains $A $element]} {
-	lappend A $element
-    }
-    return
-}
-
-# ::struct::set::S_exclude --
-#
-#	Remove an element from a set.
-#
-# Parameters:
-#	Avar	-- Reference to the set variable to shrink.
-#	element	-- The item to remove from the set.
-#
-# Results:
-#	None.
-#
-# Side effects:
-#       The set in the variable referenced by Avar is shrunk,
-#	the element remove (if the element was actually present).
-
-proc ::struct::set::S_exclude {Avar element} {
-    # Avar = Avar - {element}
-    upvar 1 $Avar A
-    if {![info exists A]} {return -code error "can't read \"$Avar\": no such variable"}
-    while {[::set pos [lsearch -exact $A $element]] >= 0} {
-	::set A [lreplace [K $A [::set A {}]] $pos $pos]
-    }
-    return
-}
-
-# ::struct::set::S_add --
-#
-#	Add a set to a set. Similar to 'union', but the first argument
-#	is a variable.
-#
-# Parameters:
-#	Avar	-- Reference to the set variable to extend.
-#	B	-- The set to add to the set in Avar.
-#
-# Results:
-#	None.
-#
-# Side effects:
-#       The set in the variable referenced by Avar is extended
-#	by all the elements in B.
-
-proc ::struct::set::S_add {Avar B} {
-    # Avar = Avar + B
-    upvar 1 $Avar A
-    if {![info exists A]} {set A {}}
-    ::set A [S_union [K $A [::set A {}]] $B]
-    return
-}
-
-# ::struct::set::S_subtract --
-#
-#	Remove a set from a set. Similar to 'difference', but the first argument
-#	is a variable.
-#
-# Parameters:
-#	Avar	-- Reference to the set variable to shrink.
-#	B	-- The set to remove from the set in Avar.
-#
-# Results:
-#	None.
-#
-# Side effects:
-#       The set in the variable referenced by Avar is shrunk,
-#	all elements of B are removed.
-
-proc ::struct::set::S_subtract {Avar B} {
-    # Avar = Avar - B
-    upvar 1 $Avar A
-    if {![info exists A]} {return -code error "can't read \"$Avar\": no such variable"}
-    ::set A [S_difference [K $A [::set A {}]] $B]
-    return
-}
-
-# ::struct::set::S_subsetof --
-#
-#	A predicate checking if the first set is a subset
-#	or equal to the second set.
-#
-# Parameters:
-#	A	-- The possible subset.
-#	B	-- The set to compare to.
-#
-# Results:
-#	A boolean value, true if A is subset of or equal to B
-#
-# Side effects:
-#       None.
-
-proc ::struct::set::S_subsetof {A B} {
-    # A subset|== B <=> (A == A*B)
-    return [S_equal $A [S_intersect $A $B]]
-}
-
-# ::struct::set::K --
-# Performance helper command.
-
-proc ::struct::set::K {x y} {::set x}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-namespace eval ::struct {
-    # Put 'set::set' into the general structure namespace
-    # for pickup by the main management.
-
-    namespace import -force set::set_tcl
-}
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil-0.9.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil-0.9.tm
deleted file mode 100644
index 59258514..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil-0.9.tm
+++ /dev/null
@@ -1,80 +0,0 @@
-# textutil.tcl --
-#
-#	Utilities for manipulating strings, words, single lines,
-#	paragraphs, ...
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2002      by Joe English <jenglish@users.sourceforge.net>
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: textutil.tcl,v 1.17 2006/09/21 06:46:24 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-## All through sub-packages imported here.
-
-package require textutil::string
-package require textutil::repeat
-package require textutil::adjust
-package require textutil::split
-package require textutil::tabify
-package require textutil::trim
-package require textutil::wcswidth
-
-namespace eval ::textutil {
-    # Import the miscellaneous string command for public export
-
-    namespace import -force string::chop string::tail
-    namespace import -force string::cap string::uncap string::capEachWord
-    namespace import -force string::longestCommonPrefix
-    namespace import -force string::longestCommonPrefixList
-
-    # Import the repeat commands for public export
-
-    namespace import -force repeat::strRepeat repeat::blank
-
-    # Import the adjust commands for public export
-
-    namespace import -force adjust::adjust adjust::indent adjust::undent
-
-    # Import the split commands for public export
-
-    namespace import -force split::splitx split::splitn
-
-    # Import the trim commands for public export
-
-    namespace import -force trim::trim trim::trimleft trim::trimright
-    namespace import -force trim::trimPrefix trim::trimEmptyHeading
-
-    # Import the tabify commands for public export
-
-    namespace import -force tabify::tabify tabify::untabify
-    namespace import -force tabify::tabify2 tabify::untabify2
-
-    # Re-export all the imported commands
-
-    namespace export chop tail cap uncap capEachWord
-    namespace export longestCommonPrefix longestCommonPrefixList
-    namespace export strRepeat blank
-    namespace export adjust indent undent
-    namespace export splitx splitn
-    namespace export trim trimleft trimright trimPrefix trimEmptyHeading
-    namespace export tabify untabify tabify2 untabify2
-}
-
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil 0.9
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/adjust-0.7.3.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/adjust-0.7.3.tm
deleted file mode 100644
index d47c82f8..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/adjust-0.7.3.tm
+++ /dev/null
@@ -1,761 +0,0 @@
-# trim.tcl --
-#
-#	Various ways of trimming a string.
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2002-2004 by Johannes-Heinrich Vogeler <vogeler@users.sourceforge.net>
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: adjust.tcl,v 1.16 2011/12/13 18:12:56 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-package require textutil::repeat
-package require textutil::string
-
-namespace eval ::textutil::adjust {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-
-namespace eval ::textutil::adjust {
-    namespace import -force ::textutil::repeat::strRepeat
-}
-
-proc ::textutil::adjust::adjust {text args} {
-    if {[string length [string trim $text]] == 0} {
-        return ""
-    }
-
-    Configure $args
-    Adjust text newtext
-
-    return $newtext
-}
-
-proc ::textutil::adjust::Configure {args} {
-    variable Justify      left
-    variable Length       72
-    variable FullLine     0
-    variable StrictLength 0
-    variable Hyphenate    0
-    variable HyphPatterns    ; # hyphenation patterns (TeX)
-
-    set args [ lindex $args 0 ]
-    foreach { option value } $args {
-	switch -exact -- $option {
-	    -full {
-		if { ![ string is boolean -strict $value ] } then {
-		    error "expected boolean but got \"$value\""
-		}
-		set FullLine [ string is true $value ]
-	    }
-	    -hyphenate {
-		# the word exceeding the length of line is tried to be
-		# hyphenated; if a word cannot be hyphenated to fit into
-		# the line processing stops! The length of the line should
-		# be set to a reasonable value!
-
-		if { ![ string is boolean -strict $value ] } then {
-		    error "expected boolean but got \"$value\""
-		}
-		set Hyphenate [string is true $value]
-		if { $Hyphenate && ![info exists HyphPatterns(_LOADED_)]} {
-		    error "hyphenation patterns not loaded!"
-		}
-	    }
-	    -justify {
-		set lovalue [ string tolower $value ]
-		switch -exact -- $lovalue {
-		    left -
-		    right -
-		    center -
-		    plain {
-			set Justify $lovalue
-		    }
-		    default {
-			error "bad value \"$value\": should be center, left, plain or right"
-		    }
-		}
-	    }
-	    -length {
-		if { ![ string is integer $value ] } then {
-		    error "expected positive integer but got \"$value\""
-		}
-		if { $value < 1 } then {
-		    error "expected positive integer but got \"$value\""
-		}
-		set Length $value
-	    }
-	    -strictlength {
-		# the word exceeding the length of line is moved to the
-		# next line without hyphenation; words longer than given
-		# line length are cut into smaller pieces
-
-		if { ![ string is boolean -strict $value ] } then {
-		    error "expected boolean but got \"$value\""
-		}
-		set StrictLength [ string is true $value ]
-	    }
-	    default {
-		error "bad option \"$option\": must be -full, -hyphenate, \
-			-justify, -length, or -strictlength"
-	    }
-	}
-    }
-
-    return ""
-}
-
-# ::textutil::adjust::Adjust
-#
-# History:
-#      rewritten on 2004-04-13 for bugfix tcllib-bugs-882402 (jhv)
-
-proc ::textutil::adjust::Adjust { varOrigName varNewName } {
-    variable Length
-    variable FullLine
-    variable StrictLength
-    variable Hyphenate
-
-    upvar $varOrigName orig
-    upvar $varNewName  text
-
-    set pos 0;                                   # Cursor after writing
-    set line ""
-    set text ""
-
-
-    if {!$FullLine} {
-	regsub -all -- "(\n)|(\t)"     $orig   " "  orig
-	regsub -all -- " +"            $orig  " "   orig
-	regsub -all -- "(^ *)|( *\$)"  $orig  ""    orig
-    }
-
-    set words [split $orig]
-    set numWords [llength $words]
-    set numline 0
-
-    for {set cnt 0} {$cnt < $numWords} {incr cnt} {
-
-	set w [lindex $words $cnt]
-	set wLen [string length $w]
-
-	# the word $w doesn't fit into the present line
-	# case #1: we try to hyphenate
-
-	if {$Hyphenate && ($pos+$wLen >= $Length)} {
-	    # Hyphenation instructions
-	    set w2 [textutil::adjust::Hyphenation $w]
-
-	    set iMax [llength $w2]
-	    if {$iMax == 1 && [string length $w] > $Length} {
-		# word cannot be hyphenated and exceeds linesize
-
-		error "Word \"$w2\" can\'t be hyphenated\
-			and exceeds linesize $Length!"
-	    } else {
-		# hyphenating of $w was successfull, but we have to look
-		# that every sylable would fit into the line
-
-		foreach x $w2 {
-		    if {[string length $x] >= $Length} {
-			error "Word \"$w\" can\'t be hyphenated\
-				to fit into linesize $Length!"
-		    }
-		}
-	    }
-
-	    for {set i 0; set w3 ""} {$i < $iMax} {incr i} {
-		set syl [lindex $w2 $i]
-		if {($pos+[string length " $w3$syl-"]) > $Length} {break}
-		append w3 $syl
-	    }
-	    for {set w4 ""} {$i < $iMax} {incr i} {
-		set syl [lindex $w2 $i]
-		append w4 $syl
-	    }
-
-	    if {[string length $w3] && [string length $w4]} {
-		# hyphenation was successfull: redefine
-		# list of words w => {"$w3-" "$w4"}
-
-		set x [lreplace $words $cnt $cnt "$w4"]
-		set words [linsert $x $cnt "$w3-"]
-		set w [lindex $words $cnt]
-		set wLen [string length $w]
-		incr numWords
-	    }
-	}
-
-	# the word $w doesn't fit into the present line
-	# case #2: we try to cut the word into pieces
-
-	if {$StrictLength && ([string length $w] > $Length)} {
-	    # cut word into two pieces
-	    set w2 $w
-
-	    set over [expr {$pos+2+$wLen-$Length}]
-
-	    incr Length -1
-	    set w3   [string range $w2 0 $Length]
-	    incr Length
-	    set w4   [string range $w2 $Length end]
-
-	    set x [lreplace $words $cnt $cnt $w4]
-	    set words [linsert $x $cnt $w3 ]
-	    set w [lindex $words $cnt]
-	    set wLen [string length $w]
-	    incr numWords
-	}
-
-	# continuing with the normal procedure
-
-	if {($pos+$wLen < $Length)} {
-	    # append word to current line
-
-	    if {$pos} {append line " "; incr pos}
-	    append line $w
-	    incr pos $wLen
-	} else {
-	    # line full => write buffer and  begin a new line
-
-	    if {[string length $text]} {append text "\n"}
-	    append text [Justification $line [incr numline]]
-	    set line $w
-	    set pos $wLen
-	}
-    }
-
-    # write buffer and return!
-
-    if {[string length $text]} {append text "\n"}
-    append text [Justification $line end]
-    return $text
-}
-
-# ::textutil::adjust::Justification
-#
-# justify a given line
-#
-# Parameters:
-#      line    text for justification
-#      index   index for line in text
-#
-# Returns:
-#      the justified line
-#
-# Remarks:
-#      Only lines with size not exceeding the max. linesize provided
-#      for text formatting are justified!!!
-
-proc ::textutil::adjust::Justification { line index } {
-    variable Justify
-    variable Length
-    variable FullLine
-
-    set len [string length $line];               # length of current line
-
-    if { $Length <= $len } then {
-	# the length of current line ($len) is equal as or greater than
-	# the value provided for text formatting ($Length) => to avoid
-	# inifinite loops we leave $line unchanged and return!
-
-	return $line
-    }
-
-    # Special case:
-    # for the last line, and if the justification is set to 'plain'
-    # the real justification is 'left' if the length of the line
-    # is less than 90% (rounded) of the max length allowed. This is
-    # to avoid expansion of this line when it is too small: without
-    # it, the added spaces will 'unbeautify' the result.
-    #
-
-    set justify $Justify
-    if { ( "$index" == "end" ) && \
-	    ( "$Justify" == "plain" ) && \
-	    ( $len < round($Length * 0.90) ) } then {
-	set justify left
-    }
-
-    # For a left justification, nothing to do, but to
-    # add some spaces at the end of the line if requested
-
-    if { "$justify" == "left" } then {
-	set jus ""
-	if { $FullLine } then {
-	    set jus [strRepeat " " [ expr { $Length - $len } ]]
-	}
-	return "${line}${jus}"
-    }
-
-    # For a right justification, just add enough spaces
-    # at the beginning of the line
-
-    if { "$justify" == "right" } then {
-	set jus [strRepeat " " [ expr { $Length - $len } ]]
-	return "${jus}${line}"
-    }
-
-    # For a center justification, add half of the needed spaces
-    # at the beginning of the line, and the rest at the end
-    # only if needed.
-
-    if { "$justify" == "center" } then {
-	set mr [ expr { ( $Length - $len ) / 2 } ]
-	set ml [ expr { $Length - $len - $mr } ]
-	set jusl [strRepeat " " $ml]
-	set jusr [strRepeat " " $mr]
-	if { $FullLine } then {
-	    return "${jusl}${line}${jusr}"
-	} else {
-	    return "${jusl}${line}"
-	}
-    }
-
-    # For a plain justification, it's a little bit complex:
-    #
-    # if some spaces are missing, then
-    #
-    # 1) sort the list of words in the current line by decreasing size
-    # 2) foreach word, add one space before it, except if it's the
-    #    first word, until enough spaces are added
-    # 3) rebuild the line
-
-    if { "$justify" == "plain" } then {
-	set miss [ expr { $Length - [ string length $line ] } ]
-
-	# Bugfix tcllib-bugs-860753 (jhv)
-
-	set words [split $line]
-	set numWords [llength $words]
-
-	if {$numWords < 2} {
-	    # current line consists of less than two words - we can't
-	    # insert blanks to achieve a plain justification => leave
-	    # $line unchanged and return!
-
-	    return $line
-	}
-
-	for {set i 0; set totalLen 0} {$i < $numWords} {incr i} {
-	    set w($i) [lindex $words $i]
-	    if {$i > 0} {set w($i) " $w($i)"}
-	    set wLen($i) [string length $w($i)]
-	    set totalLen [expr {$totalLen+$wLen($i)}]
-	}
-
-	set miss [expr {$Length - $totalLen}]
-
-	# len walks through all lengths of words of the line under
-	# consideration
-
-	for {set len 1} {$miss > 0} {incr len} {
-	    for {set i 1} {($i < $numWords) && ($miss > 0)} {incr i} {
-		if {$wLen($i) == $len} {
-		    set w($i) " $w($i)"
-		    incr wLen($i)
-		    incr miss -1
-		}
-	    }
-	}
-
-	set line ""
-	for {set i 0} {$i < $numWords} {incr i} {
-	    set line "$line$w($i)"
-	}
-
-	# End of bugfix
-
-	return "${line}"
-    }
-
-    error "Illegal justification key \"$justify\""
-}
-
-proc ::textutil::adjust::SortList { list dir index } {
-
-    if { [ catch { lsort -integer -$dir -index $index $list } sl ] != 0 } then {
-        error "$sl"
-    }
-
-    return $sl
-}
-
-# Hyphenation utilities based on Knuth's algorithm
-#
-# Copyright (C) 2001-2003 by Dr.Johannes-Heinrich Vogeler (jhv)
-# These procedures may be used as part of the tcllib
-
-# textutil::adjust::Hyphenation
-#
-#      Hyphenate a string using Knuth's algorithm
-#
-# Parameters:
-#      str     string to be hyphenated
-#
-# Returns:
-#      the hyphenated string
-
-proc ::textutil::adjust::Hyphenation { str } {
-
-    # if there are manual set hyphenation marks e.g. "Recht\-schrei\-bung"
-    # use these for hyphenation and return
-
-    if {[regexp {[^\\-]*[\\-][.]*} $str]} {
-	regsub -all {(\\)(-)} $str {-} tmp
-	return [split $tmp -]
-    }
-
-    # Don't hyphenate very short words! Minimum length for hyphenation
-    # is set to 3 characters!
-
-    if { [string length $str] < 4 } then { return $str }
-
-    # otherwise follow Knuth's algorithm
-
-    variable HyphPatterns;                       # hyphenation patterns (TeX)
-
-    set w ".[string tolower $str].";             # transform to lower case
-    set wLen [string length $w];                 # and add delimiters
-
-    # Initialize hyphenation weights
-
-    set s {}
-    for {set i 0} {$i < $wLen} {incr i} {
-	lappend s 0
-    }
-
-    for {set i 0} {$i < $wLen} {incr i} {
-	set kmax [expr {$wLen-$i}]
-	for {set k 1} {$k < $kmax} {incr k} {
-	    set sw [string range $w $i [expr {$i+$k}]]
-	    if {[info exists HyphPatterns($sw)]} {
-		set hw $HyphPatterns($sw)
-		set hwLen [string length $hw]
-		for {set l1 0; set l2 0} {$l1 < $hwLen} {incr l1} {
-		    set c [string index $hw $l1]
-		    if {[string is digit $c]} {
-			set sPos [expr {$i+$l2}]
-			if {$c > [lindex $s $sPos]} {
-			    set s [lreplace $s $sPos $sPos $c]
-			}
-		    } else {
-			incr l2
-		    }
-		}
-	    }
-	}
-    }
-
-    # Replace all even hyphenation weigths by zero
-
-    for {set i 0} {$i < [llength $s]} {incr i} {
-	set c [lindex $s $i]
-	if {!($c%2)} { set s [lreplace $s $i $i 0] }
-    }
-
-    # Don't start with a hyphen! Take also care of words enclosed in quotes
-    # or that someone has forgotten to put a blank between a punctuation
-    # character and the following word etc.
-
-    for {set i 1} {$i < ($wLen-1)} {incr i} {
-	set c [string range $w $i end]
-	if {[regexp {^[:alpha:][.]*} $c]} {
-	    for {set k 1} {$k < ($i+1)} {incr k} {
-		set s [lreplace $s $k $k 0]
-	    }
-	    break
-	}
-    }
-
-    # Don't separate the last character of a word with a hyphen
-
-    set max [expr {[llength $s]-2}]
-    if {$max} {set s [lreplace $s $max end 0]}
-
-    # return the syllabels of the hyphenated word as a list!
-
-    set ret ""
-    set w ".$str."
-    for {set i 1} {$i < ($wLen-1)} {incr i} {
-	if {[lindex $s $i]} { append ret - }
-	append ret [string index $w $i]
-    }
-    return [split $ret -]
-}
-
-# textutil::adjust::listPredefined
-#
-#      Return the names of the hyphenation files coming with the package.
-#
-# Parameters:
-#      None.
-#
-# Result:
-#       List of filenames (without directory)
-
-proc ::textutil::adjust::listPredefined {} {
-    variable here
-    return [glob -type f -directory $here -tails *.tex]
-}
-
-# textutil::adjust::getPredefined
-#
-#      Retrieve the full path for a predefined hyphenation file
-#       coming with the package.
-#
-# Parameters:
-#      name     Name of the predefined file.
-#
-# Results:
-#       Full path to the file, or an error if it doesn't
-#       exist or is matching the pattern *.tex.
-
-proc ::textutil::adjust::getPredefined {name} {
-    variable here
-
-    if {![string match *.tex $name]} {
-        return -code error \
-                "Illegal hyphenation file \"$name\""
-    }
-    set path [file join $here $name]
-    if {![file exists $path]} {
-        return -code error \
-                "Unknown hyphenation file \"$path\""
-    }
-    return $path
-}
-
-# textutil::adjust::readPatterns
-#
-#      Read hyphenation patterns from a file and store them in an array
-#
-# Parameters:
-#      filNam  name of the file containing the patterns
-
-proc ::textutil::adjust::readPatterns { filNam } {
-
-    variable HyphPatterns;                       # hyphenation patterns (TeX)
-
-    # HyphPatterns(_LOADED_) is used as flag for having loaded
-    # hyphenation patterns from the respective file (TeX format)
-
-    if {[info exists HyphPatterns(_LOADED_)]} {
-	unset HyphPatterns(_LOADED_)
-    }
-
-    # the array xlat provides translation from TeX encoded characters
-    # to those of the ISO-8859-1 character set
-
-    set xlat(\"s) \337;  # 223 := sharp s    "
-    set xlat(\`a) \340;  # 224 := a, grave
-    set xlat(\'a) \341;  # 225 := a, acute
-    set xlat(\^a) \342;  # 226 := a, circumflex
-    set xlat(\"a) \344;  # 228 := a, diaeresis "
-    set xlat(\`e) \350;  # 232 := e, grave
-    set xlat(\'e) \351;  # 233 := e, acute
-    set xlat(\^e) \352;  # 234 := e, circumflex
-    set xlat(\`i) \354;  # 236 := i, grave
-    set xlat(\'i) \355;  # 237 := i, acute
-    set xlat(\^i) \356;  # 238 := i, circumflex
-    set xlat(\~n) \361;  # 241 := n, tilde
-    set xlat(\`o) \362;  # 242 := o, grave
-    set xlat(\'o) \363;  # 243 := o, acute
-    set xlat(\^o) \364;  # 244 := o, circumflex
-    set xlat(\"o) \366;  # 246 := o, diaeresis "
-    set xlat(\`u) \371;  # 249 := u, grave
-    set xlat(\'u) \372;  # 250 := u, acute
-    set xlat(\^u) \373;  # 251 := u, circumflex
-    set xlat(\"u) \374;  # 252 := u, diaeresis "
-
-    set fd [open $filNam RDONLY]
-    set status 0
-
-    while {[gets $fd line] >= 0} {
-
-	switch -exact $status {
-	    PATTERNS {
-		if {[regexp {^\}[.]*} $line]} {
-		    # End of patterns encountered: set status
-		    # and ignore that line
-		    set status 0
-		    continue
-		} else {
-		    # This seems to be pattern definition line; to process it
-		    # we have first to do some editing
-		    #
-		    # 1) eat comments in a pattern definition line
-		    # 2) eat braces and coded linefeeds
-
-		    set z [string first "%" $line]
-		    if {$z > 0} { set line [string range $line 0 [expr {$z-1}]] }
-
-		    regsub -all {(\\n|\{|\})} $line {} tmp
-		    set line $tmp
-
-		    # Now $line should consist only of hyphenation patterns
-		    # separated by white space
-
-		    # Translate TeX encoded characters to ISO-8859-1 characters
-		    # using the array xlat defined above
-
-		    foreach x [array names xlat] {
-			regsub -all {$x} $line $xlat($x) tmp
-			set line $tmp
-		    }
-
-		    # split the line and create a lookup array for
-		    # the repective hyphenation patterns
-
-		    foreach item [split $line] {
-			if {[string length $item]} {
-			    if {![string match {\\} $item]} {
-				# create index for hyphenation patterns
-
-				set var $item
-				regsub -all {[0-9]} $var {} idx
-				# store hyphenation patterns as elements of an array
-
-				set HyphPatterns($idx) $item
-			    }
-			}
-		    }
-		}
-	    }
-	    EXCEPTIONS {
-		if {[regexp {^\}[.]*} $line]} {
-		    # End of patterns encountered: set status
-		    # and ignore that line
-		    set status 0
-		    continue
-		} else {
-		    # to be done in the future
-		}
-	    }
-	    default {
-		if {[regexp {^\\endinput[.]*} $line]} {
-		    # end of data encountered, stop processing and
-		    # ignore all the following text ..
-		    break
-		} elseif {[regexp {^\\patterns[.]*} $line]} {
-		    # begin of patterns encountered: set status
-		    # and ignore that line
-		    set status PATTERNS
-		    continue
-		} elseif {[regexp {^\\hyphenation[.]*} $line]} {
-		    # some particular cases to be treated separately
-		    set status EXCEPTIONS
-		    continue
-		} else {
-		    set status 0
-		}
-	    }
-	}
-    }
-
-    close $fd
-    set HyphPatterns(_LOADED_) 1
-
-    return
-}
-
-#######################################################
-
-# @c The specified <a text>block is indented
-# @c by <a prefix>ing each line. The first
-# @c <a hang> lines ares skipped.
-#
-# @a text:   The paragraph to indent.
-# @a prefix: The string to use as prefix for each line
-# @a prefix: of <a text> with.
-# @a skip:   The number of lines at the beginning to leave untouched.
-#
-# @r Basically <a text>, but indented a certain amount.
-#
-# @i indent
-# @n This procedure is not checked by the testsuite.
-
-proc ::textutil::adjust::indent {text prefix {skip 0}} {
-    set text [string trimright $text]
-
-    set res [list]
-    foreach line [split $text \n] {
-	if {[string compare "" [string trim $line]] == 0} {
-	    lappend res {}
-	} else {
-	    set line [string trimright $line]
-	    if {$skip <= 0} {
-		lappend res $prefix$line
-	    } else {
-		lappend res $line
-	    }
-	}
-	if {$skip > 0} {incr skip -1}
-    }
-    return [join $res \n]
-}
-
-# Undent the block of text: Compute LCP (restricted to whitespace!)
-# and remove that from each line. Note that this preverses the
-# shaping of the paragraph (i.e. hanging indent are _not_ flattened)
-# We ignore empty lines !!
-
-proc ::textutil::adjust::undent {text} {
-
-    if {$text == {}} {return {}}
-
-    set lines [split $text \n]
-    set ne [list]
-    foreach l $lines {
-	if {[string length [string trim $l]] == 0} continue
-	lappend ne $l
-    }
-    set lcp [::textutil::string::longestCommonPrefixList $ne]
-
-    if {[string length $lcp] == 0} {return $text}
-
-    regexp "^(\[\t \]*)" $lcp -> lcp
-
-    if {[string length $lcp] == 0} {return $text}
-
-    set len [string length $lcp]
-
-    set res [list]
-    foreach l $lines {
-	if {[string length [string trim $l]] == 0} {
-	    lappend res {}
-	} else {
-	    lappend res [string range $l $len end]
-	}
-    }
-    return [join $res \n]
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::adjust {
-    variable here [file dirname [info script]]
-
-    variable Justify      left
-    variable Length       72
-    variable FullLine     0
-    variable StrictLength 0
-    variable Hyphenate    0
-    variable HyphPatterns
-
-    namespace export adjust indent undent
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::adjust 0.7.3
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/dehypht.tex b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/dehypht.tex
deleted file mode 100644
index 8f1dfb04..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/dehypht.tex
+++ /dev/null
@@ -1,902 +0,0 @@
-% This is `dehypht.tex' as of 03 March 1999.
-%
-% Copyright (C) 1988,1991 Rechenzentrum der Ruhr-Universitaet Bochum
-%               [german hyphen patterns]
-% Copyright (C) 1993,1994,1999 Bernd Raichle/DANTE e.V.
-%               [macros, adaption for TeX 2]
-%
-% -----------------------------------------------------------------
-% IMPORTANT NOTICE:
-%
-% This program can be redistributed and/or modified under the terms
-% of the LaTeX Project Public License Distributed from CTAN
-% archives in directory macros/latex/base/lppl.txt; either
-% version 1 of the License, or any later version.
-% -----------------------------------------------------------------
-%
-%
-% This file contains german hyphen patterns following traditional
-% hyphenation rules and includes umlauts and sharp s, but without
-% `c-k' and triple consonants.  It is based on hyphen patterns
-% containing 5719 german hyphen patterns with umlauts in the
-% recommended version of September 27, 1990.
-%
-% For use with TeX generated by
-%
-%          Norbert Schwarz
-%          Rechenzentrum Ruhr-Universitaet Bochum
-%          Universitaetsstrasse 150
-%          D-44721 Bochum, FRG
-%
-%
-% Adaption of these patterns for TeX, Version 2.x and 3.x and
-% all fonts in T1/`Cork'/EC/DC and/or OT1/CM encoding by
-%
-%          Bernd Raichle
-%          Stettener Str. 73
-%          D-73732 Esslingen, FRG
-%   Email: raichle@Informatik.Uni-Stuttgart.DE
-%
-%
-% Error reports in case of UNCHANGED versions to
-%
-%          DANTE e.V., Koordinator `german.sty'
-%          Postfach 10 18 40
-%          D-69008 Heidelberg, FRG
-%   Email: german@Dante.DE
-%
-% or one of the addresses given above.
-%
-%
-% Changes:
-%  1990-09-27 First version of `ghyphen3.tex' (Norbert Schwarz)
-%  1991-02-13 PC umlauts changed to ^^xx  (Norbert Schwarz)
-%  1993-08-27 Umlauts/\ss changed to "a/\3 macros, added macro
-%             definitions and additional logic to select correct
-%             patterns/encoding  (Bernd Raichle)
-%  1994-02-13 Release of `ghyph31.tex' V3.1a (Bernd Raichle)
-%  1999-03-03 Renamed file to `dehypht.tex' according to the
-%             naming scheme using the ISO country code `de', the
-%             common part `hyph' for all hyphenation patterns files,
-%             and the additional postfix `t' for traditional,
-%             removed wrong catcode change of ^^e (the comment
-%             character %) and ^^f (the character &),
-%             do _not_ change \catcode, \lccode, \uccode to avoid
-%             problems with other hyphenation pattern files,
-%             changed code to distinguish TeX 2.x/3.x,
-%             changed license conditions to LPPL (Bernd Raichle)
-%
-%
-% For more information see the additional documentation
-% at the end of this file.
-%
-% -----------------------------------------------------------------
-%
-\message{German Traditional Hyphenation Patterns %
-         `dehypht' Version 3.2a <1999/03/03>}
-\message{(Formerly known under the name `ghyph31' and `ghyphen'.)}
-%
-%
-% Next we define some commands which are used inside the patterns.
-% To keep them local, we enclose the rest of the file in a group
-% (The \patterns command globally changes the hyphenation trie!).
-%
-\begingroup
-%
-%
-% Make sure that doublequote is not active:
-\catcode`\"=12
-%
-%
-% Because ^^e4 is used in the following macros which is read by
-% TeX 2.x as ^^e or %, the comment character of TeX, some trick
-% has to be found to avoid this problem.  The same is true for the
-% character ^^f or & in the TeX 2.x code.
-% Therefore in the code the exclamationmark ! is used instead of
-% the circumflex ^ and its \catcode is set appropriately
-% (normally \catcode`\!=12, in the code \catcode`\!=7).
-%
-% The following \catcode, \lccode assignments and macro definitions
-% are defined in such a way that the following \pattern{...} list
-% can be used for both, TeX 2.x and TeX 3.x.
-%
-% We first change the \lccode of ^^Y to make sure that we can
-% include this character in the hyphenation patterns.
-%
-\catcode`\^^Y=11 \lccode`\^^Y=`\^^Y
-%
-% Then we have to define some macros depending on the TeX version.
-% Therefore we have to distinguish TeX version 2.x and 3.x:
-%
-\ifnum`\@=`\^^40 % true => TeX 3.x
-  %
-  % For TeX 3:
-  % ----------
-  %
-  % Assign appropriate \catcode and \lccode values for all
-  % accented characters used in the patterns (\uccode changes are
-  % not used within \patterns{...} and thus not necessary):
-  %
-  \catcode"E4=11 \catcode"C4=11 % \"a \"A
-  \catcode"F6=11 \catcode"D6=11 % \"o \"O
-  \catcode"FC=11 \catcode"DC=11 % \"u \"U
-  \catcode"FF=11 \catcode"DF=11 % \ss  SS
-  %
-  \lccode"C4="E4 \uccode"C4="C4  \lccode"E4="E4 \uccode"E4="C4
-  \lccode"D6="F6 \uccode"D6="D6  \lccode"F6="F6 \uccode"F6="D6
-  \lccode"DC="FC \uccode"DC="DC  \lccode"FC="FC \uccode"FC="DC
-  \lccode"DF="FF \uccode"DF="DF  \lccode"FF="FF \uccode"FF="DF
-  %
-  % In the following definitions we use ??xy instead of ^^xy
-  % to avoid errors when reading the following macro definitions
-  % with TeX 2.x (remember ^^e(4) is the comment character):
-  %
-  \catcode`\?=7
-  %
-  % Define the accent macro " in such a way that it
-  % expands to single letters in font encoding T1.
-  \catcode`\"=13
-  \def"#1{\ifx#1a??e4\else \ifx#1o??f6\else \ifx#1u??fc\else
-      \errmessage{Hyphenation pattern file corrupted!}%
-    \fi\fi\fi}
-  %
-  %   - patterns with umlauts are ok
-  \def\n#1{#1}
-  %
-  % For \ss which exists in T1 _and_ OT1 encoded fonts but with
-  % different glyph codes, duplicated patterns for both encodings
-  % are included.  Thus you can use these hyphenation patterns for
-  % T1 and OT1 encoded fonts:
-  %   - define \3 to be code `\^^ff (\ss in font encoding T1)
-  %   - define \9 to be code `\^^Y  (\ss in font encoding OT1)
-  \def\3{??ff}
-  \def\9{??Y}
-  %   - duplicated patterns to support font encoding OT1 are ok
-  \def\c#1{#1}
-  %   >>>>>>  UNCOMMENT the next line, if you do not want
-  %   >>>>>>  to use fonts in font encoding OT1
-  %\def\c#1{}
-  %
-  \catcode`\?=12
-  %
-\else
-  %
-  % For TeX 2:
-  % ----------
-  %
-  % Define the accent macro " to throw an error message.
-  \catcode`\"=13
-  \def"#1{\errmessage{Hyphenation pattern file corrupted!}}
-  %
-  %   - ignore all patterns with umlauts
-  \def\n#1{}
-  %
-  % With TeX 2 fonts in encoding T1 can be used, but all glyphs
-  % in positions > 127 can not be used in hyphenation patterns.
-  % Thus only patterns with glyphs in OT1 positions are included:
-  %   - define \3 to be code ^^Y (\ss in CM font encoding)
-  %   - define \9 to throw an error message
-  \def\3{^^Y}
-  \def\9{\errmessage{Hyphenation pattern file corrupted!}}
-  %   - ignore all duplicated patterns with \ss in T1 encoding
-  \def\c#1{}
-  %
-\fi
-%
-%
-\patterns{%
-.aa6l .ab3a4s .ab3ei .abi2 .ab3it .ab1l .ab1r .ab3u .ad3o4r .alti6
-.ana3c .an5alg .an1e .ang8s .an1s .ap1p .ar6sc .ar6ta .ar6tei .as2z
-.au2f1 .au2s3 .be5erb .be3na .ber6t5r .bie6r5 .bim6s5t .brot3 .bru6s
-.ch6 .che6f5 .da8c .da2r .dar5in .dar5u .den6ka .de5r6en .des6pe
-.de8spo .de3sz .dia3s4 .dien4 .dy2s1 .ehren5 .eine6 .ei6n5eh .ei8nen
-.ein5sa .en6der .en6d5r .en3k4 .en8ta8 .en8tei .en4t3r .epo1 .er6ban
-.er6b5ei .er6bla .er6d5um .er3ei .er5er .er3in .er3o4b .erwi5s .es1p
-.es8t .ex1a2 .ex3em .fal6sc .fe6st5a .flu4g3 .furch8 .ga6ner .ge3n4a
-\n{.ge5r"o} .ges6 .halb5 .halbe6 .hal6br .haup4 .hau4t .heima6 .he4r3e
-.her6za .he5x .hin3 .hir8sc .ho4c .hu3sa .hy5o .ibe5 .ima6ge .in1
-.ini6 .is5chi .jagd5 .kal6k5o .ka6ph .ki4e .kop6f3 .kraf6 \n{.k"u5ra}
-.lab6br .liie6 .lo6s5k \n{.l"o4s3t} .ma5d .mi2t1 .no6th .no6top
-.obe8ri .ob1l .obs2 .ob6st5e .or3c .ort6s5e .ost3a .oste8r .pe4re
-.pe3ts .ph6 .po8str .rau4m3 .re5an .ro8q .ru5the \n{.r"u5be}
-\n{.r"u8stet} .sch8 .se6e .se5n6h .se5ra .si2e .spi6ke .st4 .sy2n
-.tages5 .tan6kl .ta8th .te6e .te8str .to6der .to8nin .to6we .um1
-.umpf4 .un1 .une6 .unge5n .ur1c .ur5en .ve6rin .vora8 .wah6l5 .we8ges
-.wo6r .wor3a .wun4s .zi4e .zuch8 \n{."ande8re} \n{."och8} aa1c aa2gr
-aal5e aa6r5a a5arti aa2s1t aat2s 6aba ab3art 1abdr 6abel aben6dr
-ab5erk ab5err ab5esse 1abf 1abg \n{1abh"a} ab1ir 1abko a1bl ab1la
-5ablag a6bla\3 \c{a6bla\9} ab4ler ab1lu \n{a8bl"a} \n{5a6bl"o} abma5c
-1abn ab1ra ab1re 5a6brec ab1ro ab1s ab8sk abs2z 3abtei ab1ur 1abw
-5abze 5abzu \n{ab1"an} \n{ab"au8} a4ce.  a5chal ach5art ach5au a1che
-a8chent ach6er.  a6ch5erf a1chi ach1l ach3m ach5n a1cho ach3re a1chu
-ach1w a1chy \n{ach5"af} ack1o acks6t ack5sta a1d 8ad.  a6d5ac ad3ant
-ad8ar 5addi a8dein ade5o8 adi5en 1adj 1adle ad1op a2dre 3adres adt1
-1adv \n{a6d"a} a1e2d ae1r a1er.  1aero 8afa a3fal af1an a5far a5fat
-af1au a6fentl a2f1ex af1fr af5rau af1re 1afri af6tent af6tra aft5re
-a6f5um \n{8af"a} ag5abe 5a4gent ag8er ages5e 1aggr ag5las ag1lo a1gn
-ag2ne 1agog a6g5und a1ha a1he ah5ein a4h3erh a1hi ahl1a ah1le ah4m3ar
-ahn1a a5ho ahra6 ahr5ab ah1re ah8rei ahren8s ahre4s3 ahr8ti ah1ru a1hu
-\n{ah8"o} ai3d2s ai1e aif6 a3inse ai4re.  a5isch.  ais8e a3ismu ais6n
-aiso6 a1j 1akad a4kade a1ke a1ki 1akko 5akro1 a5lal al5ans 3al8arm
-al8beb al8berw alb5la 3album al1c a1le a6l5e6be a4l3ein a8lel a8lerb
-a8lerh a6lert 5a6l5eth 1algi al4gli al3int al4lab al8lan al4l3ar
-alle3g a1lo a4l5ob al6schm al4the altist5 al4t3re 8a1lu alu5i a6lur
-alu3ta \n{a1l"a} a6mate 8ame.  5a6meise am6m5ei am6mum am2n ampf3a
-am6schw am2ta a1mu \n{a1m"a} a3nac a1nad anadi5e an3ako an3alp 3analy
-an3ame an3ara a1nas an5asti a1nat anat5s an8dent ande4s3 an1ec an5eis
-an1e2k 4aner.  a6n5erd a8nerf a6n5erke 1anfa 5anfert \n{1anf"a} 3angab
-5angebo an3gli ang6lis an2gn 3angri ang5t6 \n{5anh"a} ani5g ani4ka
-an5i8on an1kl an6kno an4kro 1anl anma5c anmar4 3annah anne4s3 a1no
-5a6n1o2d 5a6n3oma 5a6nord 1anr an1sa 5anschl an4soz an1st 5anstal
-an1s2z 5antenn an1th \n{5anw"a} a5ny an4z3ed 5anzeig 5anzieh 3anzug
-\n{an1"a} \n{5an"as} \n{a1n"o} \n{an"o8d} a1os a1pa 3apfel a2ph1t
-\n{aph5"a6} a1pi 8apl apo1c apo1s a6poste a6poth 1appa ap1pr a1pr
-\n{a5p"a} \n{a3p"u} a1ra a4r3af ar3all 3arbei 2arbt ar1c 2a1re ar3ein
-ar2gl 2a1ri ari5es ar8kers ar6les ar4nan ar5o6ch ar1o2d a1rol ar3ony
-a8ror a3ros ar5ox ar6schl 8artei ar6t5ri a1ru a1ry 1arzt arz1w
-\n{ar8z"a} \n{ar"a8m} \n{ar"o6} \n{ar5"om} \n{ar1"u2} a1sa a6schec
-asch5l asch3m a6schn a3s4hi as1pa asp5l a8steb as5tev 1asth a6stoc
-a1str ast3re 8a1ta ata5c ata3la a6tapf ata5pl a1te a6teli aten5a
-ate5ran 6atf 6atg a1th at3hal 1athl 2a1ti 5atlant 3atlas 8atmus 6atn
-a1to a6t5ops ato6ra a6t5ort.  4a1tr a6t5ru at2t1h \n{at5t6h"a} 6a1tu
-atz1w \n{a1t"a} \n{a1t"u} au1a au6bre auch3a au1e aue4l 5aufent
-\n{3auff"u} 3aufga 1aufn auf1t 3auftr 1aufw 3auge.  au4kle aule8s 6aum
-au8mar aum5p 1ausb 3ausd 1ausf 1ausg au8sin 3auss au4sta 1ausw 1ausz
-aut5eng au1th 1auto au\3e8 \c{au\9e8} a1v ave5r6a aver6i a1w a6wes a1x
-a2xia a6xio a1ya a1z azi5er.  8a\3 \c{8a\9} 1ba 8ba8del ba1la ba1na
-ban6k5r ba5ot bardi6n ba1ro basten6 bau3sp 2b1b bb6le b2bli 2b1c 2b1d
-1be be1a be8at.  be1ch 8becht 8becke.  be5el be1en bee8rei be5eta bef2
-8beff be1g2 \n{beh"o8} bei1s 6b5eisen bei3tr b8el bel8o belu3t be3nac
-bend6o be6ners be6nerw be4nor ben4se6 bens5el \n{be1n"a} \n{be1n"u}
-be1o2 b8er.  be1ra be8rac ber8gab.  ber1r \n{be1r"u} bes8c bes5erh
-bes2p be5tha bet5sc be1un be1ur 8bex be6zwec 2b1f8 bfe6st5e 2b1g2
-bga2s5 bge1 2b1h bhole6 1bi bi1bl b6ie bi1el bi1la \n{bil"a5} bi1na
-bi4nok bi5str bi6stu bi5tr bit4t5r b1j 2b1k2 \n{bk"u6} bl8 b6la.
-6b1lad 6blag 8blam 1blat b8latt 3blau.  b6lav 3ble.  b1leb b1led
-8b1leg 8b1leh 8bleid 8bleih 6b3lein blei3s ble4m3o 4blich b4lind
-8bling b2lio 5blit b4litz b1loh 8b1los 1blu 5blum 2blun blut3a blut5sc
-\n{3bl"a} \n{bl"as5c} \n{5bl"o} \n{3bl"u} \n{bl"u8sc} 2b1m 2b1n 1bo
-bo1ch bo5d6s boe5 8boff 8bonk bo1ra b1ort 2b1p2 b1q 1br brail6 brast8
-bre4a b5red 8bref 8b5riem b6riga bro1s b1rup b2ruz \n{8br"oh}
-\n{br"os5c} 8bs b1sa b8sang b2s1ar b1sc bs3erl bs3erz b8sof b1s2p
-bst1h b3stru \n{b5st"a} b6sun 2b1t b2t1h 1bu bu1ie bul6k b8ure bu6sin
-6b1v 2b1w 1by1 by6te.  8b1z bzi1s \n{1b"a} \n{b5"a6s5} \n{1b"u}
-\n{b6"u5bere} \n{b"uge6} \n{b"ugel5e} \n{b"ur6sc} 1ca cag6 ca5la ca6re
-ca5y c1c 1ce celi4c celich5 ce1ro c8h 2ch.  1chae ch1ah ch3akt cha6mer
-8chanz 5chara 3chari 5chato 6chb 1chef 6chei ch3eil ch3eis 6cherkl
-6chf 4chh 5chiad 5chias 6chins 8chj chl6 5chlor 6ch2m 2chn6 ch8nie
-5cho.  8chob choi8d 6chp ch3ren ch6res \n{ch3r"u} 2chs 2cht cht5ha
-cht3hi 5chthon ch6tin 6chuh chu4la 6ch3unt chut6t 8chw 1ci ci5tr c2k
-2ck.  ck1ei 4ckh ck3l ck3n ck5o8f ck1r 2cks ck5stra ck6s5u c2l 1c8o
-con6ne 8corb cos6t c3q 1c6r 8c1t 1cu 1cy \n{5c"a1} \n{c"o5} 1da.
-8daas 2dabg 8dabr 6dabt 6dabw 1dac da2gr 6d5alk 8d5amt dan6ce.
-dani5er dan8ker 2danl danla6 6dans 8danzi 6danzu d1ap da2r1a8 2d1arb
-d3arc dar6men 4d3art 8darz 1dat 8datm 2d1auf 2d1aus 2d1b 2d1c 2d1d
-d5de d3d2h \n{dd"amme8} 1de 2deal de5an de3cha de1e defe6 6deff 2d1ehr
-5d4eic de5isc de8lar del6s5e del6spr de4mag de8mun de8nep dene6r
-8denge.  8dengen de5o6d 2deol de5ram 8derdb der5ein de1ro der1r d8ers
-der5um de4s3am de4s3an de4sau de6sil de4sin de8sor de4spr de2su 8deul
-de5us.  2d1f df2l 2d1g 2d1h 1di dia5c di5ara dice5 di3chr di5ena di1gn
-di1la dil8s di1na 8dind 6dinf 4d3inh 2d1ins di5o6d di3p4t di8sen dis1p
-di5s8per di6s5to dis5tra di8tan di8tin d1j 6dje 2dju 2d1k 2d1l 2d1m
-2d1n6 dni6 dnje6 1do 6d5obe do6berf 6d5ony do3ran 6dord 2d1org dor4t3h
-do6ste 6doth dott8e 2d1p d5q dr4 1drah 8drak d5rand 6dre.  4drech
-d6reck 4d3reg 8d3reic d5reife 8drem 8d1ren 2drer 8dres.  6d5rh 1dria
-d1ric 8drind droi6 dro5x 1dru 8drut \n{dr"os5c} \n{1dr"u} \n{dr"u5b}
-\n{dr"u8sc} 2ds d1sa d6san dsat6 d1sc 5d6scha.  5dschik dse8e d8serg
-8dsl d1sp d4spak ds2po \n{d8sp"a} d1st \n{d1s"u} 2dt d1ta d1te d1ti
-d1to dt1s6 d1tu \n{d5t"a} 1du du5als du1b6 du1e duf4t3r 4d3uh du5ie
-8duml 8dumw 2d1und du8ni 6d5unt dur2c durch3 6durl 6dursa 8durt du1s
-du8schr 2d1v 2d1w dwa8l 2d1z \n{1d"a} \n{6d"ah} \n{8d"and} \n{d"a6r}
-\n{d"o8bl} \n{d5"ol} \n{d"or6fl} \n{d"o8sc} \n{d5"o4st} \n{d"os3te}
-\n{1d"u} ea4ben e1ac e1ah e1akt e1al.  e5alf e1alg e5a8lin e1alk e1all
-e5alp e1alt e5alw e1am e1and ea6nim e1ar.  e5arf e1ark e5arm e3art
-e5at.  e6ate e6a5t6l e8ats e5att e6au.  e1aus e1b e6b5am ebens5e
-eb4lie eb4ser eb4s3in e1che e8cherz e1chi ech3m 8ech3n ech1r ech8send
-ech4su e1chu eck5an e5cl e1d ee5a ee3e ee5g e1ei ee5isc eei4s3t
-ee6lend e1ell \n{ee5l"o} e1erd ee3r4e ee8reng eere6s5 \n{ee5r"a}
-ee6tat e1ex e1f e6fau e8fe8b 3effek ef3rom ege6ra eglo6si 1egy e1ha
-e6h5ach eh5ans e6hap eh5auf e1he e1hi ehl3a eh1le ehl5ein eh1mu ehn5ec
-e1ho ehr1a eh1re ehre6n eh1ri eh1ru ehr5um e1hu eh1w e1hy \n{e1h"a}
-\n{e1h"o} \n{e3h"ut} ei1a eia6s ei6bar eich3a eich5r ei4dar ei6d5ei
-ei8derf ei3d4sc ei1e 8eifen 3eifri 1eign eil1d ei6mab ei8mag ein1a4
-ei8nat ei8nerh ei8ness ei6nete ein1g e8ini ein1k ei6n5od ei8nok ei4nor
-\n{e3ins"a} ei1o e1irr ei5ru ei8sab ei5schn ei6s5ent ei8sol ei4t3al
-eit3ar eit1h ei6thi ei8tho eit8samt ei6t5um e1j 1ekd e1ke e1ki e1k2l
-e1kn ekni4 e1la e2l1al 6elan e6lanf e8lanl e6l5ans el3arb el3arm
-e6l3art 5e6lasti e6lauge elbst5a e1le 6elef ele6h e6l5ehe e8leif
-e6l5einh 1elek e8lel 3eleme e6lemen e6lente el5epi e4l3err e6l5ersc
-elf2l elg2 e6l5ins ell8er 4e1lo e4l3ofe el8soh el8tent 5eltern e1lu
-elut2 \n{e1l"a} \n{e1l"u} em8dei em8meis 4emo emo5s 1emp1f 1empt 1emto
-e1mu emurk4 emurks5 \n{e1m"a} en5a6ben en5achs en5ack e1nad en5af
-en5all en3alt en1am en3an.  en3ant en3anz en1a6p en1ar en1a6s 6e1nat
-en3auf en3aus en2ce enda6l end5erf end5erg en8dess 4ene.  en5eck
-e8neff e6n5ehr e6n5eim en3eis 6enem.  6enen e4nent 4ener.  e8nerd
-e6n3erf e4nerg 5energi e6n5erla en5ers e6nerst en5erw 6enes e6n5ess
-e2nex en3glo 2eni enni6s5 ennos4 enns8 e1no e6nober eno8f en5opf
-e4n3ord en8sers ens8kl en1sp ens6por en5t6ag enta5go en8terbu en6tid
-3entla ent5ric 5entwic 5entwu 1entz enu5i e3ny en8zan \n{en1"of}
-\n{e1n"os} \n{e1n"ug} eo1c e5o6fe e5okk e1on.  e3onf e5onk e5onl e5onr
-e5opf e5ops e5or.  e1ord e1org eo5r6h eo1t e1pa e8pee e6p5e6g ep5ent
-e1p2f e1pi 5epid e6pidem e1pl 5epos e6pos.  ep4p3a e1pr \n{e1p"a} e1q
-e1ra.  er5aal 8eraba e5rabel er5a6ben e5rabi er3abs er3ach era5e
-era5k6l er3all er3amt e3rand e3rane er3ans e5ranz.  e1rap er3arc
-e3rari er3a6si e1rat erat3s er3auf e3raum 3erbse er1c e1re 4e5re.
-er3eck er5egg er5e2h 2erei e3rei.  e8reine er5einr 6eren.  e4r3enm
-4erer.  e6r5erm er5ero er5erst e4r3erz er3ess \n{5erf"ul} er8gan.
-5ergebn er2g5h \n{5erg"anz} \n{5erh"ohu} 2e1ri eri5ak e6r5iat e4r3ind
-e6r5i6n5i6 er5ins e6r5int er5itio er1kl \n{3erkl"a} \n{5erl"os.}
-ermen6s er6nab 3ernst 6e1ro.  e1rod er1o2f e1rog 6e3roi ero8ide e3rol
-e1rom e1ron e3rop8 e2r1or e1ros e1rot er5ox ersch4 5erstat er6t5ein
-er2t1h er5t6her 2e1ru eruf4s3 e4r3uhr er3ums e5rus 5erwerb e1ry er5zwa
-er3zwu \n{er"a8m} \n{er5"as} \n{er"o8} \n{e3r"os.} \n{e6r1"u2b} e1sa
-esa8b e8sap e6s5a6v e1sc esch4l ese1a es5ebe eserve5 e8sh es5ill
-es3int es4kop e2sl eso8b e1sp espei6s5 es2po es2pu 5essenz e6stabs
-e6staf e6st5ak est3ar e8stob e1str est5res es3ur e2sz \n{e1s"u} e1ta
-et8ag etari5e eta8ta e1te eten6te et5hal e5thel e1ti 1etn e1to e1tr
-et3rec e8tscha et8se et6tei et2th et2t1r e1tu etu1s et8zent et8zw
-\n{e1t"a} \n{e1t"o} \n{e1t"u} eu1a2 eu1e eue8rei eu5fe euin5 euk2
-e1um.  eu6nio e5unter eu1o6 eu5p 3europ eu1sp eu5str eu8zo e1v eval6s
-eve5r6en ever4i e1w e2wig ex1or 1exp 1extr ey3er.  e1z \n{e1"a2}
-\n{e5"o8} \n{e1"u} e8\3es \c{e8\9es} fa6ch5i fade8 fa6del fa5el.
-fal6lo falt8e fa1na fan4gr 6fanl 6fap far6ba far4bl far6r5a 2f1art
-fa1sc fau8str fa3y 2f1b2 6f1c 2f1d 1fe 2f1eck fe6dr feh6lei f6eim
-8feins f5eis fel5en 8feltern 8femp fe5rant 4ferd.  ferri8 fe8stof
-fe6str fe6stum fe8tag fet6ta fex1 2ff f1fa f6f5arm f5fe ffe5in ffe6la
-ffe8ler ff1f f1fla ff3lei ff4lie ff8sa ff6s5ta 2f1g2 fgewen6 4f1h 1fi
-fid4 fi3ds fieb4 fi1la fi8lei fil4m5a f8in.  fi1na 8finf fi8scho fi6u
-6f1j 2f1k2 f8lanz fl8e 4f3lein 8flib 4fling f2lix 6f3lon 5flop 1flor
-\n{5f8l"ac} \n{3fl"ot} 2f1m 2f1n 1fo foh1 f2on fo6na 2f1op fo5ra
-for8mei for8str for8th for6t5r fo5ru 6f5otte 2f1p8 f1q fr6 f5ram
-1f8ran f8ra\3 \c{f8ra\9} f8re.  frei1 5frei.  f3reic f3rest f1rib
-8f1ric 6frig 1fris fro8na \n{fr"as5t} 2fs f1sc f2s1er f5str
-\n{fs3t"at} 2ft f1tak f1te ft5e6h ftere6 ft1h f1ti f5to f1tr ft5rad
-ft1sc ft2so f1tu ftwi3d4 ft1z 1fu 6f5ums 6funf fun4ka fu8\3end
-\c{fu8\9end} 6f1v 2f1w 2f1z \n{1f"a} \n{f"a1c} \n{8f"arm} \n{6f"aug}
-\n{f"a8\3} \n{\c{f"a8\9}} \n{f"ode3} \n{8f"of} \n{3f"or} \n{1f"u}
-\n{f"un4f3u} 1ga ga6bl 6gabw 8gabz g3a4der ga8ho ga5isc 4gak ga1la
-6g5amt ga1na gan5erb gan6g5a ga5nj 6ganl 8gansc 6garb 2g1arc 2g1arm
-ga5ro 6g3arti ga8sa ga8sc ga6stre 2g1atm 6g5auf gau5fr g5aus 2g1b g5c
-6gd g1da 1ge ge1a2 ge6an ge8at.  ge1e2 ge6es gef2 8geff ge1g2l ge1im
-4g3eise geist5r gel8bra gelt8s \n{ge5l"o} ge8nin gen3k 6g5entf
-\n{ge3n"a} ge1or ge1ra ge6rab ger8au \n{8gerh"o} ger8ins ge1ro 6g5erz.
-\n{ge1r"a} \n{ge1r"u} ge1s ges2p ge5unt 4g3ex3 2g1f8 2g1g g1ha 6g1hei
-5ghel.  g5henn 6g1hi g1ho 1ghr \n{g1h"o} 1gi gi5la gi8me.  gi1na
-4g3ins gi3str g1j 2g1k 8gl.  1glad g5lag glan4z3 1glas 6glass 5glaub
-g3lauf 1gle.  g5leb 3gleic g3lein 5gleis 1glem 2gler 8g3leu gli8a
-g2lie 3glied 1g2lik 1g2lim g6lio 1gloa 5glom 1glon 1glop g1los g4loss
-g5luf 1g2ly \n{1gl"u} 2g1m gn8 6gn.  1gna 8gnach 2gnah g1nas g8neu
-g2nie g3nis 1gno 8gnot 1go goe1 8gof 2gog 5gogr 6g5oh goni5e 6gonist
-go1ra 8gord 2g1p2 g1q 1gr4 g5rahm gra8m gra4s3t 6g1rec gre6ge 4g3reic
-g5reit 8grenn gri4e g5riem 5grif 2grig g5ring 6groh 2grot gro6\3
-\c{gro6\9} 4grut 2gs gs1ab g5sah gs1ak gs1an gs8and gs1ar gs1au g1sc
-gs1ef g5seil gs5ein g2s1er gs1in g2s1o gso2r gs1pr g2s1u 2g1t g3te
-g2t1h 1gu gu5as gu2e 2gue.  6gued 4g3uh 8gums 6g5unt gu1s gut3h gu2tu
-4g1v 2g1w gy1n g1z \n{1g"a} \n{8g"a8m} \n{6g"arm} \n{1g"o} \n{1g"u}
-\n{6g"ub} 1haa hab8r ha8del hade4n 8hae ha5el.  haf6tr 2hal.  ha1la
-hal4b5a 6hale 8han.  ha1na han6dr han6ge.  2hani h5anth 6hanz 6harb
-h3arbe h3arme ha5ro ha2t1h h1atm hau6san ha8\3 \c{ha8\9} h1b2 h1c h1d
-he2bl he3cho h3echt he5d6s 5heft h5e6he.  hei8ds h1eif 2hein he3ism
-he5ist.  heit8s3 hek6ta hel8lau 8helt he6mer 1hemm 6h1emp hen5end
-hen5klo hen6tri he2nu 8heo he8q her3ab he5rak her3an 4herap her3au
-h3erbi he1ro he8ro8b he4r3um her6z5er he4spe he1st heta6 het5am he5th
-heu3sc he1xa hey5e h1f2 h1g hgol8 h1h h1iat hie6r5i hi5kt hil1a2
-hil4fr hi5nak hin4ta hi2nu hi5ob hirn5e hir6ner hi1sp hi1th hi5tr
-5hitz h1j h6jo h1k2 hlabb4 hla4ga hla6gr h5lai hl8am h1las h1la\3
-\c{h1la\9} hl1c h1led h3lein h5ler.  h2lif h2lim h8linf hl5int h2lip
-h2lit h4lor h3lose \n{h1l"as} hme5e h2nee h2nei hn3eig h2nel hne8n
-hne4p3f hn8erz h6netz h2nip h2nit h1nol hn5sp h2nuc h2nud h2nul hoch1
-1hoh hoh8lei 2hoi ho4l3ar 1holz h2on ho1ra 6horg 5horn.  ho3sl hos1p
-ho4spi h1p hpi6 h1q 6hr h1rai h8rank h5raum hr1c hrcre8 h1red h3reg
-h8rei.  h4r3erb h8rert hrg2 h1ric hr5ins h2rom hr6t5erl hr2t1h hr6t5ra
-hr8tri h6rum hr1z hs3ach h6s5amt h1sc h6s5ec h6s5erl hs8erle h4sob
-h1sp h8spa\3 \c{h8spa\9} h8spel hs6po h4spun h1str h4s3tum hs3und
-\n{h1s"u} h5ta.  h5tab ht3ac ht1ak ht3ang h5tanz ht1ar ht1at h5taub
-h1te h2t1ec ht3eff ht3ehe h4t3eif h8teim h4t3ein ht3eis h6temp h8tentf
-hte8ren \n{h6terf"u} h8tergr h4t3erh h6t5ersc h8terst h8tese h8tess
-h2t1eu h4t3ex ht1he ht5hu h1ti ht5rak hts3ah ht1sc ht6sex ht8sk ht8so
-h1tu htz8 \n{h5t"um} hub5l hu6b5r huh1l h5uhr.  huld5a6 hu8lent
-\n{hu8l"a} h5up.  h1v h5weib h3weis h1z \n{h"a8kl} \n{h"al8s}
-\n{h"ama8tu8} \n{h"a8sche.} \n{h"at1s} \n{h"au4s3c} \n{2h"o.}
-\n{2h"oe} \n{8h"oi} \n{h"o6s} \n{h"os5c} \n{h"uhne6} \n{h"ul4s3t}
-\n{h"utte8re} i5adn i1af i5ak.  i1al.  i1al1a i1alb i1ald i5alei i1alf
-i1alg i3alh i1alk i1all i1alp i1alr i1als i1alt i1alv i5alw i3alz
-i1an.  ia5na i3and ian8e ia8ne8b i1ang i3ank i5ann i1ant i1anz i6apo
-i1ar.  ia6rab i5arr i1as.  i1asm i1ass i5ast.  i1at.  i5ats i1au i5azz
-i6b5eig i6b5eis ib2le i4blis i6brig i6b5unt \n{i6b"ub} i1che ich5ei
-i6cherb i1chi ich5ins ich1l ich3m ich1n i1cho icht5an icht3r i1chu
-ich1w ick6s5te ic5l i1d id3arm 3ideal ide8na 3ideol \n{ide5r"o} i6diot
-id5rec id1t ie1a ie6b5ar iebe4s3 ie2bl ieb1r ie8bra ie4bre \n{ie8b"a}
-ie2dr ie1e8 ie6f5ad ief5f ie2f1l ie4fro ief1t i1ei ie4l3ec ie8lei
-ie4lek i3ell i1en.  i1end ien6e i3enf i5enn ien6ne.  i1enp i1enr
-i5ensa ien8stal i5env i1enz ie5o ier3a4b ie4rap i2ere ie4rec ie6r5ein
-ie6r5eis ier8er i3ern.  ie8rum ie8rund ie6s5che ie6tau ie8tert ie5the
-ie6t5ri i1ett ie5un iex5 2if i1fa if5ang i6fau if1fr if5lac i5f6lie
-i1fre ift5a if6t5r ig3art 2ige i8gess ig5he i5gla ig2ni i5go ig3rot
-ig3s2p i1ha i8ham i8hans i1he i1hi ih1n ih1r i1hu i8hum ih1w 8i1i ii2s
-ii2t i1j i1k i6kak i8kerz i6kes ik4ler i6k5unt 2il i5lac i1lag il3ans
-i5las i1lau il6auf i1le ile8h i8lel il2fl il3ipp il6l5enn i1lo ilt8e
-i1lu \n{i1l"a} i8mart imb2 i8mele i8mid imme6l5a i1mu \n{i1m"a}
-\n{i5m"o} ina5he i1nat in1au inau8s 8ind.  in4d3an 5index ind2r 3indus
-i5nec i2n1ei i8nerw 3infek 1info 5ingeni ing5s6o 5inhab ini5er.  5inj
-\n{in8k"at} in8nan i1no inoi8d in3o4ku in5sau in1sp 5inspe 5instit
-5instru ins4ze 5intere 5interv in3the in5t2r i5ny \n{in"a2} \n{i1n"ar}
-\n{in1"as} \n{in"o8} \n{in5"od} \n{i1n"os} 2io io1a8 io1c iode4 io2di
-ioi8 i1ol.  i1om.  i1on.  i5onb ion2s1 i1ont i5ops i5o8pt i1or.
-i3oral io3rat i5orc i1os.  i1ot.  i1o8x 2ip i1pa i1pi i1p2l i1pr i1q
-i1ra ir6bl i1re i1ri ir8me8d ir2m1o2 ir8nak i1ro ir5rho ir6schl
-ir6sch5r i5rus i5ry \n{i5r"a} i1sa i8samt i6sar i2s1au i8scheh i8schei
-isch5m isch3r \n{isch"a8} is8ele ise3ra i4s3erh is3err isi6de i8sind
-is4kop ison5e is6por i8s5tum i5sty \n{i5s"o} i1ta it5ab.  i2t1a2m
-i8tax i1te i8tersc i1thi i1tho i5thr \n{it8h"a} i1ti i8ti8d iti6kl
-itmen4 i1to i8tof it3ran it3rau i1tri itri5o it1sc it2se it5spa it8tru
-i1tu it6z5erg it6z1w \n{i1t"a} \n{it"a6r5e} \n{it"at2} \n{it"ats5}
-\n{i1t"u} i1u iu6r 2i1v i6vad iva8tin i8vei i6v5ene i8verh i2vob i8vur
-i1w iwi2 i5xa i1xe i1z ize8n i8zir i6z5w \n{i"a8m} \n{i1"a6r}
-\n{i5"at.} \n{i5"av} \n{i1"o8} \n{i"u8} i6\35ers \c{i6\95ers} ja5la
-je2t3r 6jm 5jo jo5as jo1ra jou6l ju5cha jugen4 jugend5 jung5s6 ju1s
-\n{3j"a} 1ka 8kachs 8kakz ka1la kal5d kam5t ka1na 2kanl 8kapf ka6pl
-ka5r6a 6k3arbe ka1ro kar6p5f 4k3arti 8karz \n{ka1r"a} kasi5e ka6teb
-kat8ta kauf6s kau3t2 2k1b 2k1c 4k1d kehr6s kehrs5a 8keic 2k1eig 6k5ein
-6k5eis ke6lar ke8leis ke8lo 8kemp k5ente.  k3entf 8k5ents 6kentz ke1ra
-k5erlau 2k1f8 2k1g 2k1h ki5fl 8kik king6s5 6kinh ki5os ki5sp ki5th
-\n{8ki8"o} 2k1k2 kl8 1kla 8klac k5lager kle4br k3leib 3kleid kle5isc
-4k3leit k3lek 6k5ler.  5klet 2klic 8klig k2lim k2lin 5klip 5klop k3lor
-\n{1kl"a} 2k1m kmani5e kn8 6kner k2ni \n{kn"a8} 1k2o ko1a2 ko6de.
-ko1i koi8t ko6min ko1op ko1or ko6pht ko3ra kor6d5er ko5ru ko5t6sc k3ou
-3kow 6k5ox 2k1p2 k1q 1kr8 4k3rad 2k1rec 4k3reic kre5ie 2krib 6krig
-2krip 6kroba 2ks k1sa k6sab ksal8s k8samt k6san k1sc k2s1ex k5spat
-k5spe k8spil ks6por k1spr kst8 k2s1uf 2k1t kta8l kt5a6re k8tein kte8re
-k2t1h k8tinf kt3rec kt1s 1ku ku1ch kuck8 k3uhr ku5ie kum2s1 kunfts5
-kun2s kunst3 ku8rau ku4ro kurz1 ku1st 4kusti ku1ta ku8\3 \c{ku8\9}
-6k1v 2k1w ky5n 2k1z \n{1k"a} \n{k"a4m} \n{4k3"ami} \n{k"ase5} \n{1k"o}
-\n{k"o1c} \n{k"o1s} \n{1k"u} \n{k"u1c} \n{k"ur6sc} \n{k"u1s} 1la.
-8labf 8labh lab2r 2l1abs lach3r la8dr 5ladu 8ladv 6laff laf5t la2gn
-5laken 8lamb la6mer 5lampe.  2l1amt la1na 1land lan4d3a lan4d3r lan4gr
-8lanme 6lann 8lanw \n{6lan"a} 8lappa lap8pl lap6pr l8ar.  la5ra lar4af
-la8rag la8ran la6r5a6s l3arbe la8rei 6larm.  la8sa la1sc la8sta lat8i
-6l5atm 4lauss 4lauto 1law 2lb l8bab l8bauf l8bede l4b3ins l5blo
-lbst5an lbst3e 8lc l1che l8chert l1chi lch3m l5cho lch5w 6ld l4d3ei
-ld1re \n{l6d"ub} le2bl le8bre lecht6s5 led2r 6leff le4gas 1lehr lei6br
-le8inf 8leinn 5leistu 4lektr le6l5ers lemo2 8lemp l8en.  8lends
-6lendun le8nend len8erw 6l5ents 4l3entw 4lentz 8lenzy 8leoz 6lepi
-le6pip 8lepo 1ler l6er.  8lerbs 6l5erde le8reis le8rend le4r3er 4l3erg
-l8ergr 6lerkl 6l5erzie \n{8ler"o} 8lesel lesi5e le3sko le3tha let1s
-5leuc 4leuro leu4s3t le5xe 6lexp l1f 2l1g lgend8 l8gh lglie3 lglied6
-6l1h 1li li1ar li1as 2lick li8dr li1en lien6n li8ers li8ert 2lie\3
-\c{2lie\9} 3lig li8ga8b li1g6n li1l8a 8limb li1na 4l3indu lings5
-4l3inh 6linj link4s3 4linkt 2lint 8linv lion5s6t 4lipp 5lipt 4lisam
-livi5e 6l1j 6l1k l8keim l8kj lk2l lko8f lkor8 lk2sa lk2se 6ll l1la
-ll3a4be l8labt ll8anl ll1b ll1c ll1d6 l1le l4l3eim l6l5eise ller3a
-l4leti l5lip l1lo ll3ort ll5ov ll6spr llte8 l1lu ll3urg \n{l1l"a}
-\n{l5l"u} \n{l6l"ub} 2l1m l6m5o6d 6ln l1na l1no 8lobl lo6br 3loch.
-l5o4fen 5loge.  5lohn 4l3ohr 1lok l2on 4l3o4per lo1ra 2l1ord 6lorg
-4lort lo1ru 1los.  lo8sei 3losig lo6ve lowi5 6l1p lp2f l8pho l8pn
-lp4s3te l2pt l1q 8l1r 2ls l1sa l6sarm l1sc l8sec l6s5erg l4s3ers l8sh
-l5s6la l1sp ls4por ls2pu l1str l8suni \n{l1s"u} 2l1t lt5amp l4t3ein
-l5ten l6t5eng l6t5erp l4t3hei lt3her l2t1ho l6t5i6b lti1l \n{l8tr"o}
-lt1sc lt6ser lt4s3o lt5ums lu8br lu2dr lu1en8 8lu8fe luft3a luf8tr
-lu6g5r 2luh l1uhr lu5it 5luk 2l1umf 2l1umw 1lun 6l5u6nio 4l3unte lu5ol
-4lurg 6lurs l3urt lu4sto lu3str lu6st5re lu8su lu6tal lu6t5e6g lu8terg
-lu3the lu6t5or lu2t1r lu6\35 \c{lu6\95} l1v lve5r6u 2l1w 1ly lya6
-6lymp ly1no l8zess l8zo8f l3zwei lz5wu \n{3l"and} \n{l"a5on}
-\n{l"a6sc} \n{l"at1s} \n{5l"auf} \n{2l"aug} \n{l"au6s5c} \n{l"a5v}
-\n{l1"ol} \n{1l"os} \n{l"o1\36t} \n{\c{l"o1\96t}} \n{6l1"ube} 1ma
-8mabg ma5chan mad2 ma5el 4magg mag8n ma1la ma8lau mal5d 8malde mali5e
-malu8 ma8lut 2m1amp 3man mand2 man3ds 8mangr mani5o 8m5anst 6mappa
-4m3arbe mar8kr ma1r4o mar8schm 3mas ma1sc \n{ma1t"o} 4m5auf ma5yo 2m1b
-mb6r 2m1c 2m1d \n{md6s"a} 1me me1ch me5isc 5meld mel8sa 8memp me5nal
-men4dr men8schl men8schw 8mentsp me1ra mer4gl me1ro 3mes me6s5ei me1th
-me8\3 \c{me8\9} 2m1f6 2m1g 2m1h 1mi mi1a mi6ale mi1la 2m1imm mi1na
-\n{mi5n"u} mi4s3an mit1h mi5t6ra 3mitt mitta8 mi6\35 \c{mi6\95} 6mj
-2m1k8 2m1l 2m1m m6mad m6m5ak m8menth m8mentw mme6ra m2mn mm5sp mm5ums
-mmut5s \n{m8m"an} m1n8 m5ni 1mo mo5ar mo4dr 8mof mo8gal mo4kla mol5d
-m2on mon8do mo4n3od mont8a 6m5ony mopa6 mo1ra mor8d5a mo1sc mo1sp 5mot
-moy5 2mp m1pa mpfa6 mpf3l mphe6 m1pi mpin6 m1pl mp2li m2plu mpo8ste
-m1pr \n{mpr"a5} mp8th mput6 mpu5ts \n{m1p"o} 8m1q 2m1r 2ms ms5au m1sc
-msch4l ms6po m3spri m1str 2m1t mt1ar m8tein m2t1h mt6se \n{mt8s"a}
-mu5e 6m5uh mumi1 1mun mun6dr muse5e mu1ta 2m1v mvol2 mvoll3 2m1w 1my
-2m1z \n{m"a6kl} \n{1m"an} \n{m"a1s} \n{m"a5tr} \n{m"au4s3c} \n{3m"a\3}
-\n{\c{3m"a\9}} \n{m"ob2} \n{6m"ol} \n{1m"u} \n{5m"un} \n{3m"ut} 1na.
-n5ab.  8nabn n1abs n1abz \n{na6b"a} na2c nach3e 3nacht 1nae na5el
-n1afr 1nag 1n2ah na8ha na8ho 1nai 6nair na4kol n1akt nal1a 8naly 1nama
-na4mer na1mn n1amp 8n1amt 5nanc nan6ce n1and n6and.  2n1ang 1nani
-1nann n1ans 8nanw 5napf.  1n2ar.  na2ra 2n1arc n8ard 1nari n8ark
-6n1arm 5n6ars 2n1art n8arv 6natm nat6s5e 1naue 4nauf n3aug 5naui n5auk
-na5um 6nausb 6nauto 1nav 2nax 3naz 1na\3 \c{1na\9} n1b2 nbau5s n1c
-nche5e nch5m 2n1d nda8d n2d1ak nd5ans n2d1ei nde8lac ndel6sa n8derhi
-nde4se nde8stal n2dj ndnis5 n6d5or6t nd3rec nd3rot nd8samt nd6sau
-ndt1h n8dumd 1ne ne5as ne2bl 6n5ebn 2nec 5neei ne5en ne1g4l 2negy
-4n1ein 8neis 4n3e4lem 8nemb 2n1emp nen1a 6n5energ nen3k 8nentb
-4n3en3th 8nentl 8n5entn 8n5ents ne1ra ne5r8al ne8ras 8nerbi 6n5erde.
-nere5i6d nerfor6 \n{6n5erh"o} \n{8nerl"o} 2n1err n8ers.  6n5ertra
-2n1erz nesi3e net1h neu4ra neu5sc 8neu\3 \c{8neu\9} n1f nf5f nf2l
-nflei8 nf5lin nft8st n8g5ac ng5d ng8en nge8ram ngg2 ng1h n6glic ng3rip
-ng8ru ng2se4 ng2si n2g1um n1gy \n{n8g"al} n1h nhe6r5e 1ni ni1bl
-\n{ni5ch"a} ni8dee n6ie ni1en nie6s5te niet5h ni8etn 4n3i6gel n6ik
-ni1la 2n1imp ni5na 2n1ind 8ninf 6n5inh ni8nit 6n5inn 2n1ins 4n1int
-n6is ni3str ni1th ni1tr n1j n6ji n8kad nk5ans n1ke n8kerla n1ki nk5inh
-\n{n5kl"o} n1k2n n8k5not nk3rot \n{n8kr"u} nk5spo nk6t5r n8kuh
-\n{n6k"ub} n5l6 nli4mi n1m nmen4s n1na n8nerg nni5o n1no nn4t3ak nnt1h
-nnu1e n1ny \n{n1n"a} \n{n1n"o} \n{n1n"u} no5a no4b3la 4n3obs 2nobt
-noche8 no6die no4dis no8ia no5isc 6n5o6leu no4mal noni6er 2n1onk n1ony
-4n3o4per 6nopf 6nopti no3ra no4ram nor6da 4n1org 2n1ort n6os no1st
-8nost.  no8tan no8ter noty6pe 6n5ox n1p2 n1q n1r \n{nr"os3} 6ns n1sac
-ns3ang n1sc n8self n8s5erf n8serg n6serk ns5erw n8sint n1s2pe n1spr
-n6s5tat.  n5s6te.  n6stob n1str n1ta n4t3a4go nt5anh nt3ark nt3art
-n1te nt3eis nte5n6ar nte8nei nter3a nte6rei nt1ha nt6har n3ther nt5hie
-n3thus n1ti nti1c n8tinh nti1t ntlo6b ntmen8 n1to nt3o4ti n1tr ntra5f
-ntra5ut nt8rea nt3rec nt8rep n4t3rin nt8rop n4t3rot \n{n4tr"u} nt1s
-nts6an nt2sk n1tu nt1z \n{n1t"a} \n{n1t"o} \n{n8t"ol} \n{n1t"u} 1nu
-nu1a nu5el nu5en 4n1uhr nu5ie 8numl 6n5ums 6n5umw 2n1und 6nuni 6n5unr
-2n1unt 2nup 2nu6r n5uri nu3skr nu5ta n1v 8n1w 1nys n1za n6zab n2z1ar
-n6zaus nzi4ga n8zof n6z5unt n1zw n6zwir \n{1n"ac} \n{5n"ae} \n{5n"ai}
-\n{n8"al} \n{n"a6m} \n{n"a6re} \n{n5"arz} \n{5n"aus} \n{n1"ol}
-\n{1n"ot} \n{n5"oz} \n{5n"u.} \n{6n1"u2b} \n{5n"u\3} \n{\c{5n"u\9}}
-o5ab.  oa2l o8ala o1a2m o1an ob1ac obe4ra o6berh 5o4bers o4beru
-obe6ser 1obj o1bl o2bli ob5sk 3obst.  ob8sta obst5re ob5sz o1che
-oche8b o8chec o3chi och1l och3m ocho8f o3chro och3to o3chu och1w o1d
-o2d1ag od2dr ode5i ode6n5e od1tr o5e6b o5e6der.  oe8du o1ef o1e2l
-o1e2p o1er.  o5e8x o1fa of8fan 1offi of8fin of6f5la o5fla o1fr 8o1g
-og2n o1ha o1he o6h5eis o1hi ohl1a oh1le oh4l3er 5ohm.  oh2ni o1ho
-oh1re oh1ru o1hu oh1w o1hy \n{o1h"a} o5ia o1id.  o8idi oi8dr o5ids
-o5isch.  oiset6 o1ism o3ist.  o5i6tu o1j o1k ok2l ok3lau \n{o8kl"a}
-1okta o1la old5am old5r o1le ole5in ole1r ole3u ol6gl ol2kl olk4s1
-ol8lak ol8lauf.  ol6lel ol8less o1lo ol1s ol6sk o1lu oly1e2 5olym
-o2mab om6an o8mau ombe4 o8merz om5sp o1mu o8munt \n{o1m"a} \n{o1m"o}
-o1na ona8m on1ax on8ent o6n5erb 8oni oni5er.  on1k on6n5a6b o1no ono1c
-o4nokt 1ons onts8 \n{o1n"a} oo8f 1oog oo2pe oo2sa o1pa 3o4pera o3pfli
-opf3lo opf3r o1pi o1pl o2pli o5p6n op8pa op6pl o1pr o3p4ter 1opti
-\n{o1p"a} \n{o5p"o} o1q o1ra.  o3rad o8radd 1oram o6rang o5ras o8rauf
-or5cha or4d3a4m or8dei or8deu 1ordn or4dos o1re o5re.  ore2h o8r5ein
-ore5isc or6enn or8fla or8fli 1orga 5orgel.  or2gl o1ri 5o6rient or8nan
-\n{or8n"a} o1ro or1r2h or6t5an or8tau or8tere o1rus o1ry \n{o1r"a}
-\n{or1"u2} o1sa osa3i 6ose o8serk o1sk o6ske o6ski os2kl os2ko os2kr
-osni5e o2s1o2d o3s4per o4stam o6stau o3stra ost3re osu6 o6s5ur o5s6ze
-o1ta ot3auf o6taus o1te o6terw o1th othe5u o2th1r o1ti o1to oto1a
-ot1re o1tri o1tro ot1sc o3tsu ot6t5erg ot2t3h ot2t5r \n{ot8t"o} o1tu
-ou3e ouf1 ou5f6l o5u6gr ou5ie ou6rar ou1t6a o1v o1wa o1we o6wer.  o1wi
-owid6 o1wo o5wu o1xe oy5al.  oy1e oy1i o5yo o1z oza2r 1o2zea ozo3is
-\n{o"o8} o\35elt \c{o\95elt} o\31t \c{o\91t} 3paa pa6ce 5pad pag2 1pak
-pa1la pa8na8t pani5el pa4nor pan1s2 1pap pap8s pa8rei par8kr paro8n
-par5o6ti part8e 5partei 3partn pas6sep pa4tha 1pau 6paug pau3sc p1b
-8p5c 4p1d 1pe 4peic pe5isc 2pek pen3k pen8to8 p8er pe1ra pere6 per5ea
-per5eb pe4rem 2perr per8ran 3pers 4persi \n{pe3r"u} pe4sta pet2s
-p2f1ec p4fei pf1f pf2l 5pflanz pf8leg pf3lei 2pft pf3ta p1g 1ph 2ph.
-2p1haf 6phb 8phd 6p5heit ph5eme 6phg phi6e 8phk 6phn p5holl pht2
-ph3tha 4ph3the phu6 6phz pi1en pi5err pi1la pi1na 5pinse pioni8e 1pis
-pi1s2k pi1th p1k pl8 5pla p2lau 4plei p3lein 2pler 6p5les 2plig p6lik
-6p5ling p2liz plo8min 6p1m p1n 1p2o 8poh 5pol po8lan poly1 po3ny po1ra
-2porn por4t3h \n{po5r"o} 5poti p1pa p6p5ei ppe6la pp5f p2p1h p1pi pp1l
-ppp6 pp5ren pp1s \n{p5p"o} pr6 3preis 1pres 2p3rig 5prinz 1prob 1prod
-5prog pro8pt pro6t5a prote5i 8pro\3 \c{8pro\9} \n{pr"a3l} \n{1pr"as}
-\n{pr"ate4} \n{1pr"uf} p5schl 2pst 1p2sy p1t p8to8d pt1s 5p6ty 1pu
-pu1b2 2puc pu2dr puf8fr 6p5uh pun8s pu8rei pu5s6h pu1ta p1v p3w 5py
-py5l p1z \n{p"a6der} \n{p5"a6m} \n{p"a8nu} \n{8p"ar} \n{p"at5h}
-\n{p"at1s} qu6 1qui 8rabk ra6bla 3rable ra2br r1abt 6rabz ra4dan ra2dr
-5rafal ra4f3er ra5gla ra2g3n 6raha ral5am 5rald 4ralg ra8lins 2rall
-ral5t 8ramei r3anal r6and ran8der ran4dr 8ranf 6ranga 5rangi ran8gli
-r3angr rans5pa 8ranw r8anz.  ra5or 6rapf ra5pl rap6s5er 2r1arb 1rarh
-r1arm ra5ro 2r1art 6r1arz ra8tei ra6t5he 6ratl ra4t3ro r5atta raue4n
-6raus.  r5austa rau8tel raut5s ray1 r1b rb5lass r6bler rb4lie rbon6n
-r8brecht \n{rb6s5t"a} r8ces r1che rch1l rch3m rch3re rch3tr rch1w 8rd
-r1da r8dachs r8dap rda5ro rde5ins rdio5 r8dir rd3ost r1dr r8drau 1re.
-re1ak 3reakt re3als re6am.  re1as 4reben re6bl rech5a r8edi re3er
-8reff 3refl 2reh 5reha r4ei.  reich6s5 8reier 6reign re5imp 4r3eina
-6r3einb 6reing 6r5einn 6reinr 4r3eins r3eint reli3e 8r5elt 6rempf
-2remt ren5a6b ren8gl r3enni 1reno 5rente 4r3enth 8rentl 4r3entw 8rentz
-ren4zw re1on requi5 1rer rer4bl 6rerbs 4r3erd \n{8rerh"o} 8rerkl
-4r3erla \n{8rerl"o} 4r3erns \n{6r5ern"a} rer5o 6r5erreg r5ertr r5erwec
-\n{r5er"o} re2sa re8schm 2ress re5u8ni 6rewo 2r1ex r1f r8ferd rf4lie
-8r1g r8gah rge4bl rge5na rgest4 rg6ne r2gni2 r8gob r4g3ret rg8sel r1h8
-r2hy 5rhyt ri1ar ri5cha rid2g r2ie rieg4s5 ri8ei ri1el ri6ele ri1en
-ri3er.  ri5ers.  ri6fan ri8fer ri8fr 1r2ig ri8kn ri5la \n{rim"a8}
-ri1na r8inde rin4ga rin6gr 1rinn 6rinner rino1 r8insp 4rinst
-\n{ri1n"a} ri5o6ch ri1o2d ri3o6st 2r1ir r2is ri3sko ri8spr \n{ri8st"u}
-ri5sv r2it 6r5i6tal ri5tr ri6ve.  8r1j 6rk r1ke rkehrs5 r1ki r3klin
-r1k2n rk3str rk4t3an rk6to r6kuh \n{rk"a4s3t} r1l r5li rline5a 6r1m
-r6manl rma4p r4m3aph r8minf r8mob rm5sa 2rn r1na rna8be r5ne rn2ei
-r6neif r6nex r6nh rn1k r1no r6n5oc rn1sp \n{r1n"a} \n{r1n"u} ro6bern
-6robs ro1ch 3rock.  ro5de ro1e 4rofe ro8hert 1rohr ro5id ro1in ro5isc
-6rolym r2on 6roog ro6phan r3ort ro1s2p ro5s6w ro4tau ro1tr ro6ts 5rout
-r1p rpe8re rp2f r2ps r2pt r1q 2rr r1ra r1re rrer6 rr6hos \n{r5rh"o}
-r1ri r1ro rro8f rr8or rror5a r1ru r3ry \n{r1r"a} \n{r1r"o} \n{r1r"u}
-2r1s r6sab r4sanf rse6e rse5na r2sh r6ska r6ski rs2kl r8sko r2sl rs2p
-r6stauf r8sterw r8stran rswi3d4 r2sz 2r1t rt3art r8taut r5tei rt5eige
-r8tepe r4t3erh r8terla r4t3hei r5t6hu r4t3int rt5reif rt1sc rt6ser
-rt6s5o rt6s5u rt5und r8turt rube6 ru1en 1r4uf ruf4st ru1ie 2r1umg
-2r1uml 2rums run8der run4d5r 6rundz 6runf 8runs 2r1unt 2r1ur r6us
-ru6sta ru3str ru6tr 1ruts r1v rven1 rvi2c r1w r1x r1za rz5ac r6z5al
-r8z1ar r8zerd r6z5erf rz8erh rz4t3h r8zum \n{r"a4ste} \n{r"au8sc}
-\n{r1"of} \n{5r"ohr} \n{r"o5le} \n{3r"oll} \n{5r"omis} \n{r1"or}
-\n{r"o2sc} \n{3r"ump} 1sa.  1saa s3a4ben sa2bl 2s1abs 6s1abt 6sabw
-3sack.  6s3a4der 1saf sa1fa 4s1aff sa5fr 1sag 1sai sa1i2k1 4s1akt 1sal
-sa1la 4s3alpi 6salter salz3a 1sam s5anb san2c 1sand s5angeh 6sanl
-2s1ans 6s3antr 8s1anw s1ap s6aph 8sapo sap5p6 s8ar.  2s1arb 3sarg
-s1arm sa5ro 2s1art 6s1arz 1sas 1sat sat8a 2s1atl sa8tom 3s8aue s5auff
-sau5i s6aur 2s1aus 5s6ause 2s1b2 2sca s4ce 8sch.  3scha.  5schade
-3schaf 3schal sch5ame 8schanc 8schb 1sche 6schef 8schex 2schf 2schg
-2schh 1schi 2schk 5schlag 5schlu \n{6schm"a\3} \n{\c{6schm"a\9}}
-6schna\3 \c{6schna\9} 1scho 6schord 6schp 3schri 8schric 8schrig
-8schrou 6schs 2scht sch3ta sch3tr 1schu 8schunt 6schv 2schz \n{5sch"o}
-\n{5sch"u} 2sco scre6 6scu 2s1d 1se se5an se1ap se6ben se5ec see5i6g
-se3erl 8seff se6han se8hi \n{se8h"o} 6s5eid.  2s1eig s8eil 5sein.
-sei5n6e 6s5einh 3s8eit 3sel.  se4lar selb4 6s3e4lem se8lerl 2s1emp
-sen3ac se5nec 6s5ents 4sentz s8er.  se8reim ser5inn \n{8serm"a}
-8s5erzi \n{6ser"of} se1um 8sexa 6sexp 2s1f2 sfal8ler 2s3g2 sge5b2 s1h
-s8hew 5s6hip 5s4hop 1si 2siat si1b sicht6s 6s5i6dee siege6s5 si1en
-si5err si1f2 si1g2n si6g5r si8kau sik1i si4kin si2kl \n{si8k"u} si1la
-sil6br si1na 2s1inf sin5gh 2s1inh sinne6s5 2s1ins si5ru si5str 4s1j
-s1k2 6sk.  2skau skel6c skelch5 s6kele 1s2ki.  3s4kin.  s6kiz s8kj
-6skn 2skow 3skrib 3skrip 2sku \n{8sk"u} s1l s8lal slei3t s4low 2s1m
-s1n 6sna 6snot 1so so1ch 2s1odo so4dor 6s5o4fen solo3 s2on so5of 4sope
-so1ra 2s1ord 4sorga sou5c so3un 4s3ox sp2 8spaa 5spal 1span 2spap
-s2pec s4peis 1spek s6perg 4spers s6pes 2s1pf 8sphi \n{1s2ph"a} 1spi
-spi4e 6s5pig 6spinse 2spis 2spla 2spol 5s6pom 6s5pos 6spoti 1spra
-3s8prec 6spreis 5spring 6sprob 1spru s2pul 1s2pur 6spy \n{5sp"an}
-\n{1sp"u} s1q 2s1r 2s1s2 sse8nu ssini6s ssoi6r 2st.  1sta 4stafe 2stag
-sta3la 6stale 4stalg 8stalk 8stamt 6st5anf 4stans 6stanw 6starb sta4te
-6staus 2stb 6stc 6std 1ste 4steil 3s2tel st3elb 8stemb 6steppi 8stese
-8stesse 6stf 2stg 2sth st1ha st3hei s8t1hi st1ho st5hu 1sti sti4el
-4stigm sti3na 6stind 4stinf sti8r 2stk 2stl 2stm 1sto 6stoll.  4st3ope
-6stopf.  6stord 6stp 5stra.  4strai 3s4tral 6s5traum 3stra\3
-\c{3stra\9} 3strec 6s3tref 8streib 5streif 6streno 6stres 6strev
-5s6tria 6strig 5strik 8strisi 3s4troa s8troma st5rose 4struf 3strum
-\n{6str"ag} 2st1s6 2stt 1stu stu5a 4stuc 2stue 8stun.  2stv 2stw s2tyl
-6stz \n{1st"a} \n{8st"ag} \n{1st"o} \n{1st"u} \n{8st"uch} \n{4st"ur.}
-1su su2b1 3suc su1e su2fe su8mar 6sumfa 8sumk 2s1unt sup1p2 6s5u6ran
-6surte 2s1v 2s1w 1sy 8syl.  sy5la syn1 sy2na syne4 s1z s4zend 5s6zene.
-8szu \n{1s"a} \n{6s5"and} \n{6s"augi} \n{6s"au\3} \n{\c{6s"au\9}}
-\n{5s"om} \n{2s1"u2b} \n{1s"uc} \n{s"u8di} \n{1s"un} \n{5s"u\3}
-\n{\c{5s"u\9}} taats3 4tab.  taba6k ta8ban tab2l ta6bre 4tabs t3absc
-8tabz 6t3acht ta6der 6tadr tad6s tad2t 1tafe4 1tag ta6ga6 ta8gei
-tage4s tag6s5t tah8 tahl3 tai6ne.  ta5ir.  tak8ta tal3au 1tale ta8leng
-tal5ert 6t5a6mer 6tamp tampe6 2t1amt tan5d6a tan8dr tands5a tani5e
-6tanl 2tanr t3ans 8t5antr tanu6 t5anw 8tanwa tan8zw ta8rau 6tarbe
-1tari 2tark 2t1arm ta1ro 2tart t3arti 6tarz ta1sc ta6sien ta8stem
-ta8sto t5aufb 4taufn 8taus.  5tause 8tausf 6tausg t5ausl 2t1b2 2t1c
-t6chu 2t1d te2am tea4s te8ben 5techn 4teff te4g3re te6hau 2tehe te4hel
-2t1ehr te5id.  teig5l 6teign tei8gr 1teil 4teinh t5einhe 4teis t5eisen
-8teiw te8lam te4lar 4telek 8telem te6man te6n5ag ten8erw ten5k tens4p
-ten8tro 4t3entw 8tentz te6pli 5teppi ter5a6b te3ral ter5au 8terbar
-t5erbe.  6terben 8terbs 4t3erbt t5erde.  ter5ebe ter5ein te8rers terf4
-\n{8terh"o} \n{6terkl"a} ter8nor ter6re.  t8erscha t5e6sel te8stau
-t3euro te1xa tex3e 8texp tex6ta 2t1f2 2t1g2 2th.  th6a 5tha.  2thaa
-6t1hab 6t5haf t5hah 8thak 3thal.  6thals 6t3hand 2t1hau 1the.  3t4hea
-t1heb t5heil t3heit t3helf 1theo 5therap 5therf 6t5herz 1thes 1thet
-5thi.  2t1hil t3him 8thir 3this t5hj 2th1l 2th1m th1n t5hob t5hof
-4tholz 6thopti 1thr6 4ths t1hum 1thy \n{4t1h"a} \n{2t1h"o} \n{t1h"u}
-ti1a2m ti1b tie6fer ti1en ti8gerz tig3l ti8kin ti5lat 1tilg t1ind
-tin4k3l ti3spa ti5str 5tite ti5tr ti8vel ti8vr 2t1j 2t1k2 2t1l tl8a
-2t1m8 2t1n 3tobe 8tobj to3cha 5tocht 8tock tode4 to8del to8du to1e
-6t5o6fen to1in toi6r 5toll.  to8mene t2ons 2t1ony to4per 5topf.  6topt
-to1ra to1s to6ska tos2l 2toti to1tr t8ou 2t1p2 6t1q tr6 tra5cha
-tra8far traf5t 1trag tra6gl tra6gr t3rahm 1trai t6rans tra3sc tra6st
-3traue t4re.  2trec t3rech t8reck 6t1red t8ree 4t1reg 3treib 4treif
-8t3reis 8trepo tre6t5r t3rev 4t3rez 1trib t6rick tri6er 2trig t8rink
-tri6o5d trizi5 tro1a 3troc trocke6 troi8d tro8man.  tro3ny 5tropf
-6t5rosa t5ro\3 \c{t5ro\9} 5trub 5trup trut5 \n{1tr"ag} \n{6t1r"oh}
-\n{5tr"ub} \n{tr"u3bu} \n{t1r"uc} \n{t1r"us} 2ts ts1ab t1sac tsa8d
-ts1ak t6s5alt ts1an ts1ar ts3auf t3schr \n{t5sch"a} tse6e tsee5i
-tsein6s ts3ent ts1er t8serf t4serk t8sh 5t6sik t4s3int ts5ort.
-t5s6por t6sprei t1st t6s5tanz ts1th t6stit t4s3tor 1t2sua t2s1uf
-t8sum.  t2s1u8n t2s1ur 2t1t tt5eif tte6sa tt1ha tt8ret tt1sc tt8ser
-tt5s6z 1tuc tuch5a 1tu1e 6tuh t5uhr tu1i tu6it 1tumh 6t5umr 1tums
-8tumt 6tund 6tunf 2t1unt tu5ra tu6rau tu6re.  tu4r3er 2t1v 2t1w 1ty1
-ty6a ty8la 8tym 6ty6o 2tz tz5al tz1an tz1ar t8zec tzeh6 tzehn5 t6z5ei.
-t6zor t4z3um \n{t6z"au} \n{5t"ag} \n{6t"ah} \n{t5"alt} \n{t8"an}
-\n{t"are8} \n{8t"a8st} \n{6t"au\3} \n{\c{6t"au\9}} \n{t5"offen}
-\n{8t"o8k} \n{1t"on} \n{4t"ub} \n{t6"u5ber.} \n{5t"uch} \n{1t"ur.}
-u3al.  u5alb u5alf u3alh u5alk u3alp u3an.  ua5na u3and u5ans u5ar.
-ua6th u1au ua1y u2bab ubi5er.  u6b5rit ubs2k \n{u5b"o} \n{u8b"ub} 2uc
-u1che u6ch5ec u1chi uch1l uch3m uch5n uch1r uch5to ucht5re u1chu uch1w
-uck1a uck5in u1d ud4a u1ei u6ela uene8 u6ep u1er uer1a ue8rerl uer5o
-u8esc u2est u8ev u1fa u2f1ei u4f3ent u8ferh uf1fr uf1l uf1ra uf1re
-\n{uf1r"a} \n{uf1r"u} uf1s2p uf1st uft1s u8gabt u8gad u6gap ugeb8 u8gn
-ugo3s4 u1ha u1he u1hi uh1le u1ho uh1re u1hu uh1w \n{u1h"a} \n{u1h"o}
-6ui ui5en u1ig u3ins uin8tes u5isch.  u1j 6uk u1ke u1ki u1kl u8klu
-u1k6n u5ky u1la uld8se u1le ul8lac ul6lau ul6le6l ul6lo ulni8 u1lo
-ulo6i ult6a ult8e u1lu ul2vr \n{u1l"a} \n{u1l"o} 3umfan 5umlau umo8f
-um8pho u1mu umu8s \n{u5m"o} u1n1a un2al un6at unau2 6und.  5undein
-un4d3um 3undzw \n{und"u8} \n{un8d"ub} une2b un1ec une2h un3eis 3unfal
-\n{1unf"a} 5ungea \n{3ungl"u} ung2s1 \n{un8g"a} 1u2nif un4it un8kro
-unk5s u1no unpa2 uns2p unvol4 unvoll5 u5os.  u1pa u1pi u1p2l u1pr
-up4s3t up2t1a u1q u1ra ur5abs ura8d ur5ah u6rak ur3alt u6rana u6r5ans
-u8rap ur5a6ri u8ratt u1re ur3eig ur8gri u1ri ur5ins 3urlau urmen6
-ur8nan u1ro 3ursac ur8sau ur8sei ur4sk 3urtei u1ru uru5i6 uru6r u1ry
-ur2za \n{ur6z"a} \n{ur5"a6m} \n{u5r"o} \n{u1r"u} \n{ur"uck3} u1sa
-usa4gi u2s1ar u2s1au u8schec usch5wi u2s1ei use8kel u8sl u4st3a4b
-us3tau u3s4ter u2s1uf u8surn ut1ac u1tal uta8m u1tan ut1ar u1tas ut1au
-u1te u8teic u4tent u8terf u6terin u4t3hei ut5ho ut1hu u1ti utine5
-uti6q u1to uto5c u1tr ut1sa ut1s6p ut6stro u1tu utz5w u1u u1v uve5n
-\n{uve3r4"a} u1w u1xe u5ya uy5e6 u1yi u2z1eh u8zerh \n{u5"o} u\3e6n
-\c{u\9e6n} u\3en5e \c{u\9en5e} 8vanb 6vang 6varb var8d va6t5a va8tei
-va2t1r 2v1b 6v5c 6vd 1ve 6ve5g6 ver1 ver5b verb8l ve2re2 verg8 ve2ru8
-ve1s ve2s3p ve3xe 2v1f 2v1g 6v5h vi6el vie6w5 vi1g4 vi8leh vil6le.
-8vint vi1ru vi1tr 2v1k 2v1l 2v1m 4v5n 8vo8f voi6le vol8lend vol8li
-v2or1 vo2re vo8rin vo2ro 2v1p 8vra v6re 2v1s 2v1t 2v1v 4v3w 2v1z
-waffe8 wa6g5n 1wah wah8n wa5la wal8din wal6ta wan4dr 5ware wa8ru
-war4za 1was w5c w1d 5wech we6fl 1weg we8geng weg5h weg3l we2g1r
-weh6r5er 5weise weit3r wel2t welt3r we6rat 8werc 5werdu wer4fl 5werk.
-wer4ka wer8ku wer4ta wer8term we2sp we8stend we6steu we8str
-\n{we8st"o} wet8ta wich6s5t 1wid wi2dr wiede4 wieder5 wik6 wim6ma
-win4d3r 5wirt wisch5l 1wj 6wk 2w1l 8w1n wo1c woche6 wol6f wor6t5r 6ws2
-w1sk 6w5t 5wunde.  wun6gr wu1sc wu2t1 6w5w wy5a \n{w"arme5} \n{w"a1sc}
-1xag x1ak x3a4men 8xamt x1an 8x1b x1c 1xe.  x3e4g 1xen xe1ro x1erz
-1xes 8xf x1g 8x1h 1xi 8xid xi8so 4xiste x1k 6x1l x1m 8xn 1xo 8x5o6d
-8x3p2 x1r x1s6 8x1t x6tak x8terf x2t1h 1xu xu1e x5ul 6x3w x1z 5ya.
-y5an.  y5ank y1b y1c y6cha y4chia y1d yen6n y5ern y1g y5h y5in y1j
-y1k2 y1lak yl1al yla8m y5lax y1le y1lo y5lu y8mn ym1p2 y3mu y1na yno2d
-yn1t y1on.  y1o4p y5ou ypo1 y1pr y8ps y1r yri3e yr1r2 y1s ys5iat ys8ty
-y1t y3w y1z \n{y"a8m} z5a6b zab5l 8za6d 1zah za5is 4z3ak 6z1am 5zange.
-8zanl 2z1ara 6z5as z5auf 3zaun 2z1b 6z1c 6z1d 1ze ze4dik 4z3eff 8zein
-zei4ta zei8ters ze6la ze8lec zel8th 4zemp 6z5engel zen8zin \n{8zerg"a}
-zer8i ze1ro zers8 zerta8 zer8tab zer8tag 8zerz ze8ste zeu6gr 2z1ex
-2z1f8 z1g 4z1h 1zi zi1en zi5es.  4z3imp zi1na 6z5inf 6z5inni zin6s5er
-8zinsuf zist5r zi5th zi1tr 6z1j 2z1k 2z1l 2z1m 6z1n 1zo zo6gl 4z3oh
-zo1on zor6na8 4z1p z5q 6z1r 2z1s8 2z1t z4t3end z4t3hei z8thi 1zu zu3al
-zu1b4 zu1f2 6z5uhr zun2a 8zunem zunf8 8zungl zu1o zup8fi zu1s8 zu1z
-2z1v zw8 z1wal 5zweck zwei3s z1wel z1wer z6werg 8z5wes 1zwi zwi1s
-6z1wo 1zy 2z1z zz8a zzi1s \n{1z"a} \n{1z"o} \n{6z"ol.} \n{z"o1le}
-\n{1z"u} \n{2z1"u2b} \n{"a1a6} \n{"ab1l} \n{"a1che} \n{"a3chi}
-\n{"ach8sc} \n{"ach8sp} \n{"a5chu} \n{"ack5a} \n{"ad1a} \n{"ad5era}
-\n{"a6d5ia} \n{"a1e} \n{"a5fa} \n{"af1l} \n{"aft6s} \n{"ag1h}
-\n{"ag3le} \n{"a6g5nan} \n{"ag5str} \n{"a1he} \n{"a1hi} \n{"ah1le}
-\n{"ah5ne} \n{1"ahnl} \n{"ah1re} \n{"ah5ri} \n{"ah1ru} \n{"a1hu}
-\n{"ah1w} \n{6"ai} \n{"a1isc} \n{"a6ische} \n{"a5ism} \n{"a5j}
-\n{"a1k} \n{"al1c} \n{"a1le} \n{"a8lei} \n{"al6schl} \n{"ami1e}
-\n{"am8n} \n{"am8s} \n{"a5na} \n{5"anderu} \n{"ane5i8} \n{"ang3l}
-\n{"ank5l} \n{"a1no} \n{"an6s5c} \n{"a1pa} \n{"ap6s5c} \n{3"aq}
-\n{"ar1c} \n{"a1re} \n{"are8m} \n{5"argern} \n{"ar6gl} \n{"a1ri}
-\n{3"armel} \n{"a1ro} \n{"art6s5} \n{"a1ru} \n{3"arztl} \n{"a5r"o}
-\n{"a6s5chen} \n{"asen8s} \n{"as1th} \n{"ata8b} \n{"a1te} \n{"ateri4}
-\n{"ater5it} \n{"a6thy} \n{"a1ti} \n{3"atk} \n{"a1to} \n{"at8schl}
-\n{"ats1p} \n{"a5tu} \n{"aub1l} \n{"au1e} \n{1"aug} \n{"au8ga}
-\n{"au5i} \n{"a1um.} \n{"a1us.} \n{1"au\3} \n{\c{1"au\9}} \n{"a1z}
-\n{"o1b} \n{"o1che} \n{"o5chi} \n{"och8stei} \n{"och8str} \n{"ocht6}
-\n{5"o6dem} \n{5"offn} \n{"o1he} \n{"oh1l8} \n{"oh1re} \n{"o1hu}
-\n{"o1is} \n{"o1ke} \n{1"o2ko} \n{1"ol.} \n{"ol6k5l} \n{"ol8pl}
-\n{"o1mu} \n{"o5na} \n{"onig6s3} \n{"o1no} \n{"o5o6t} \n{"opf3l}
-\n{"op6s5c} \n{"o1re} \n{"or8gli} \n{"o1ri} \n{"or8tr} \n{"o1ru}
-\n{5"osterr} \n{"o1te} \n{"o5th} \n{"o1ti} \n{"o1tu} \n{"o1v} \n{"o1w}
-\n{"owe8} \n{"o2z} \n{"ub6e2} \n{3"u4ber1} \n{"ub1l} \n{"ub1r}
-\n{5"u2bu} \n{"u1che} \n{"u1chi} \n{"u8ch3l} \n{"uch6s5c} \n{"u8ck}
-\n{"uck1a} \n{"uck5ers} \n{"ud1a2} \n{"u6deu} \n{"udi8t} \n{"u2d1o4}
-\n{"ud5s6} \n{"uge4l5a} \n{"ug1l} \n{"uh5a} \n{"u1he} \n{"u8heh}
-\n{"u6h5erk} \n{"uh1le} \n{"uh1re} \n{"uh1ru} \n{"u1hu} \n{"uh1w}
-\n{"u3k} \n{"u1le} \n{"ul4l5a} \n{"ul8lo} \n{"ul4ps} \n{"ul6s5c}
-\n{"u1lu} \n{"un8da} \n{"un8fei} \n{"unk5l} \n{"un8za} \n{"un6zw}
-\n{"u5pi} \n{"u1re} \n{"u8rei} \n{"ur8fl} \n{"ur8fr} \n{"ur8geng}
-\n{"u1ri} \n{"u1ro} \n{"ur8sta} \n{"ur8ster} \n{"u1ru} \n{"use8n}
-\n{"u8sta} \n{"u8stes} \n{"u6s5tete} \n{"u3ta} \n{"u1te} \n{"u1ti}
-\n{"ut8tr} \n{"u1tu} \n{"ut8zei} \n{"u1v} \31a8 \c{\91a8} 5\3a.
-\c{5\9a.} \38as \c{\98as} \31b8 \c{\91b8} \31c \c{\91c} \31d \c{\91d}
-1\3e \c{1\9e} \35ec \c{\95ec} 8\3e8g \c{8\9e8g} 8\3e8h \c{8\9e8h}
-2\31ei \c{2\91ei} 8\3em \c{8\9em} \31f8 \c{\91f8} \31g \c{\91g} \31h
-\c{\91h} 1\3i \c{1\9i} \31k \c{\91k} \31l \c{\91l} \31m \c{\91m}
-\3mana8 \c{\9mana8} \31n \c{\91n} \31o \c{\91o} \31p8 \c{\91p8} \35q
-\c{\95q} \31r \c{\91r} \31s2 \c{\91s2} \3st8 \c{\9st8} \31ta \c{\91ta}
-\31te \c{\91te} \3t3hei \c{\9t3hei} \31ti \c{\91ti} \35to \c{\95to}
-\31tr \c{\91tr} 1\3u8 \c{1\9u8} 6\35um \c{6\95um} \31v \c{\91v} \31w
-\c{\91w} \31z \c{\91z}
-}%
-\endgroup
-\relax\endinput
-%
-% -----------------------------------------------------------------
-%
-% =============== Additional Documentation ===============
-%
-%
-% Older Versions of German Hyphenation Patterns:
-% ----------------------------------------------
-%
-% All older versions of `ghyphen.tex' distributed as
-%
-%       ghyphen.tex/germhyph.tex   as of 1986/11/01
-%       ghyphen.min/ghyphen.max    as of 1988/10/10
-%       ghyphen3.tex               as of 1990/09/27 & 1991/02/13
-%       ghyph31.tex                as of 1994/02/13
-%
-% are out of date and it is recommended to replace them
-% with the new version `dehypht.tex' as of 1999/03/03.
-%
-% If you are using `ghyphen.min' (a minor version of `ghyphen')
-% because of limited trie memory space, try this version and if
-% the space is exceeded get a newer TeX implementation with
-% larger or configurable trie memory sizes.
-%
-%
-%
-% Trie Memory Requirements/Space for Hyphenation Patterns:
-% --------------------------------------------------------
-%
-% To load this set of german hyphenation patterns the parameters
-% of TeX has to have at least these values:
-%
-% TeX 3.x:
-%    IniTeX:    trie_size >= 9733    trie_op_size >= 207
-%    VirTeX:    trie_size >= 8375    trie_op_size >= 207
-%
-% TeX 2.x:
-%    IniTeX:    trie_size >= 8675    trie_op_size >= 198
-%    VirTeX:    trie_size >= 7560    trie_op_size >= 198
-%
-% If you want to load more than one set of hyphenation patterns
-% (in TeX 3.x), the parameters have to be set to a value larger
-% than or equal to the sum of all required values for each set.
-%
-%
-% Setting Trie Memory Parameters:
-% -------------------------------
-%
-% Some implementations allow the user to change the default value
-% of a set of the internal TeX parameters including the trie memory
-% size parameter specifying the used memory for the hyphenation
-% patterns.
-% 
-% Web2c 7.x (Source), teTeX 0.9 (Unix, Amiga), fpTeX (Win32)
-% and newer:
-%   The used memory size of the true is usually set high enough.
-%   If needed set the size of the trie using the keyword `trie_size'
-%   in the configuration file `texmf/web2c/texmf.cnf'.  For details
-%   see the included documentation.
-%
-% emTeX (OS/2, MS-DOS, Windows 3.x/9x/NT):
-%   You can set the used memory size of the trie using the
-%   `-mt<number>' option on the command line or in the
-%   TEXOPTIONS environment variable.
-%
-% PasTeX (Amiga):
-%   The values for the parameters can be set using the keywords
-%   `triesize', `itriesize' and `trieopsize' in the configuration
-%   file.
-%
-% others (binaries only):
-%   See the documentation of the implementation if it is possible
-%   and how to change these values without recompilation.
-%
-% others (with sources)
-%   If the trie memory is too small, you have to recompile TeX
-%   using larger values for `trie_size' and `trie_op_size'.
-%   Modify the change file `tex.ch' and recompile TeX.
-%   For details see the documentation included in the sources.
-%
-%
-%
-% Necessary Settings in TeX macro files:
-% --------------------------------------
-%
-% \lefthyphenmin, \righthyphenmin:
-%   You can set both parameters to 2.
-%
-% \lccode <char>:
-%   To get correct hyphenation points within words containing
-%   umlauts or \ss, it's necessary to assign values > 0 to the
-%   appropriate \lccode <char> positions.
-%
-% These changes are _not_ done when reading this file and have to
-% be included in the language switching mechanism as is done in,
-% for example, `german.sty' (\lccode change for ^^Y = \ss in OT1,
-% \left-/\righthyphenmin settings).
-%
-%
-%% \CharacterTable
-%%  {Upper-case    \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z
-%%   Lower-case    \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z
-%%   Digits        \0\1\2\3\4\5\6\7\8\9
-%%   Exclamation   \!     Double quote  \"     Hash (number) \#
-%%   Dollar        \$     Percent       \%     Ampersand     \&
-%%   Acute accent  \'     Left paren    \(     Right paren   \)
-%%   Asterisk      \*     Plus          \+     Comma         \,
-%%   Minus         \-     Point         \.     Solidus       \/
-%%   Colon         \:     Semicolon     \;     Less than     \<
-%%   Equals        \=     Greater than  \>     Question mark \?
-%%   Commercial at \@     Left bracket  \[     Backslash     \\
-%%   Right bracket \]     Circumflex    \^     Underscore    \_
-%%   Grave accent  \`     Left brace    \{     Vertical bar  \|
-%%   Right brace   \}     Tilde         \~}
-%%
-\endinput
-%% 
-%% End of file `dehypht.tex'.
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/eshyph_vo.tex b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/eshyph_vo.tex
deleted file mode 100644
index e15bdc38..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/eshyph_vo.tex
+++ /dev/null
@@ -1,1104 +0,0 @@
-.\'a2
-.\'aa2
-.\'ae2
-.\'ai2
-.\'ao2
-.\'au2
-.\'e2
-.\'ea2
-.\'ee2
-.\'ei2
-.\'eo2
-.\'eu2
-.\'i2
-.\'ia2
-.\'ie2
-.\'ii2
-.\'io2
-.\'iu2
-.\'o2
-.\'oa2
-.\'oe2
-.\'oi2
-.\'oo2
-.\'ou2
-.\'u2
-.\'ua2
-.\'ue2
-.\'ui2
-.\'uo2
-.\'uu2
-.a2
-.a\'a2
-.a\'e2
-.a\'i2
-.a\'o2
-.a\'u2
-.aa2
-.ae2
-.ai2
-.ao2
-.au2
-.e2
-.e\'a2
-.e\'e2
-.e\'i2
-.e\'o2
-.e\'u2
-.ea2
-.ee2
-.ei2
-.eo2
-.eu2
-.i2
-.i\'a2
-.i\'e2
-.i\'i2
-.i\'o2
-.i\'u2
-.ia2
-.ie2
-.ii2
-.io2
-.iu2
-.o2
-.o\'a2
-.o\'e2
-.o\'i2
-.o\'o2
-.o\'u2
-.oa2
-.oe2
-.oi2
-.oo2
-.ou2
-.u2
-.u\'a2
-.u\'e2
-.u\'i2
-.u\'o2
-.u\'u2
-.ua2
-.ue2
-.ui2
-.uo2
-.uu2
-2\'a.
-2\'aa.
-2\'ae.
-2\'ai.
-2\'ao.
-2\'au.
-2\'e.
-2\'ea.
-2\'ee.
-2\'ei.
-2\'eo.
-2\'eu.
-2\'i.
-2\'ia.
-2\'ie.
-2\'ii.
-2\'io.
-2\'iu.
-2\'o.
-2\'oa.
-2\'oe.
-2\'oi.
-2\'oo.
-2\'ou.
-2\'u.
-2\'ua.
-2\'ue.
-2\'ui.
-2\'uo.
-2\'uu.
-2\~n1\~n
-2\~n1b
-2\~n1c
-2\~n1d
-2\~n1f
-2\~n1g
-2\~n1h
-2\~n1j
-2\~n1k
-2\~n1m
-2\~n1n
-2\~n1p
-2\~n1q
-2\~n1s
-2\~n1t
-2\~n1v
-2\~n1w
-2\~n1x
-2\~n1y
-2\~n1z
-2a.
-2a\'a.
-2a\'e.
-2a\'i.
-2a\'o.
-2a\'u.
-2aa.
-2ae.
-2ai.
-2ao.
-2au.
-2b1\~n
-2b1b
-2b1c
-2b1d
-2b1f
-2b1g
-2b1h
-2b1j
-2b1k
-2b1m
-2b1n
-2b1p
-2b1q
-2b1s
-2b1t
-2b1v
-2b1w
-2b1x
-2b1y
-2b1z
-2c1\~n
-2c1b
-2c1c
-2c1d
-2c1f
-2c1g
-2c1j
-2c1k
-2c1m
-2c1n
-2c1p
-2c1q
-2c1s
-2c1t
-2c1v
-2c1w
-2c1x
-2c1y
-2c1z
-2d1\~n
-2d1b
-2d1c
-2d1d
-2d1f
-2d1g
-2d1h
-2d1j
-2d1k
-2d1m
-2d1n
-2d1p
-2d1q
-2d1s
-2d1t
-2d1v
-2d1w
-2d1x
-2d1y
-2d1z
-2e.
-2e\'a.
-2e\'e.
-2e\'i.
-2e\'o.
-2e\'u.
-2ea.
-2ee.
-2ei.
-2eo.
-2eu.
-2f1\~n
-2f1b
-2f1c
-2f1d
-2f1f
-2f1g
-2f1h
-2f1j
-2f1k
-2f1m
-2f1n
-2f1p
-2f1q
-2f1s
-2f1t
-2f1v
-2f1w
-2f1x
-2f1y
-2f1z
-2g1\~n
-2g1b
-2g1c
-2g1d
-2g1f
-2g1g
-2g1h
-2g1j
-2g1k
-2g1m
-2g1n
-2g1p
-2g1q
-2g1s
-2g1t
-2g1v
-2g1w
-2g1x
-2g1y
-2g1z
-2h1\~n
-2h1b
-2h1c
-2h1d
-2h1f
-2h1g
-2h1h
-2h1j
-2h1k
-2h1m
-2h1n
-2h1p
-2h1q
-2h1s
-2h1t
-2h1v
-2h1w
-2h1x
-2h1y
-2h1z
-2i.
-2i\'a.
-2i\'e.
-2i\'i.
-2i\'o.
-2i\'u.
-2ia.
-2ie.
-2ii.
-2io.
-2iu.
-2j1\~n
-2j1b
-2j1c
-2j1d
-2j1f
-2j1g
-2j1h
-2j1j
-2j1k
-2j1m
-2j1n
-2j1p
-2j1q
-2j1s
-2j1t
-2j1v
-2j1w
-2j1x
-2j1y
-2j1z
-2k1\~n
-2k1b
-2k1c
-2k1d
-2k1f
-2k1g
-2k1h
-2k1j
-2k1k
-2k1m
-2k1n
-2k1p
-2k1q
-2k1s
-2k1t
-2k1v
-2k1w
-2k1x
-2k1y
-2k1z
-2l1\~n
-2l1b
-2l1c
-2l1d
-2l1f
-2l1g
-2l1h
-2l1j
-2l1k
-2l1m
-2l1n
-2l1p
-2l1q
-2l1s
-2l1t
-2l1v
-2l1w
-2l1x
-2l1y
-2l1z
-2m1\~n
-2m1b
-2m1c
-2m1d
-2m1f
-2m1g
-2m1h
-2m1j
-2m1k
-2m1l
-2m1m
-2m1n
-2m1p
-2m1q
-2m1r
-2m1s
-2m1t
-2m1v
-2m1w
-2m1x
-2m1y
-2m1z
-2n1\~n
-2n1b
-2n1c
-2n1d
-2n1f
-2n1g
-2n1h
-2n1j
-2n1k
-2n1l
-2n1m
-2n1n
-2n1p
-2n1q
-2n1r
-2n1s
-2n1t
-2n1v
-2n1w
-2n1x
-2n1y
-2n1z
-2o.
-2o\'a.
-2o\'e.
-2o\'i.
-2o\'o.
-2o\'u.
-2oa.
-2oe.
-2oi.
-2oo.
-2ou.
-2p1\~n
-2p1b
-2p1c
-2p1d
-2p1f
-2p1g
-2p1h
-2p1j
-2p1k
-2p1m
-2p1n
-2p1p
-2p1q
-2p1s
-2p1t
-2p1v
-2p1w
-2p1x
-2p1y
-2p1z
-2q1\~n
-2q1b
-2q1c
-2q1d
-2q1f
-2q1g
-2q1h
-2q1j
-2q1k
-2q1m
-2q1n
-2q1p
-2q1q
-2q1s
-2q1t
-2q1v
-2q1w
-2q1x
-2q1y
-2q1z
-2r1\~n
-2r1b
-2r1c
-2r1d
-2r1f
-2r1g
-2r1h
-2r1j
-2r1k
-2r1m
-2r1n
-2r1p
-2r1q
-2r1s
-2r1t
-2r1v
-2r1w
-2r1x
-2r1y
-2r1z
-2s1\~n
-2s1b
-2s1c
-2s1d
-2s1f
-2s1g
-2s1h
-2s1j
-2s1k
-2s1m
-2s1n
-2s1p
-2s1q
-2s1s
-2s1t
-2s1v
-2s1w
-2s1x
-2s1y
-2s1z
-2t1\~n
-2t1b
-2t1c
-2t1d
-2t1f
-2t1g
-2t1h
-2t1j
-2t1k
-2t1m
-2t1n
-2t1p
-2t1q
-2t1s
-2t1t
-2t1v
-2t1w
-2t1x
-2t1y
-2t1z
-2u.
-2u\'a.
-2u\'e.
-2u\'i.
-2u\'o.
-2u\'u.
-2ua.
-2ue.
-2ui.
-2uo.
-2uu.
-2v1\~n
-2v1b
-2v1c
-2v1d
-2v1f
-2v1g
-2v1h
-2v1j
-2v1k
-2v1m
-2v1n
-2v1p
-2v1q
-2v1s
-2v1t
-2v1v
-2v1w
-2v1x
-2v1y
-2v1z
-2w1\~n
-2w1b
-2w1c
-2w1d
-2w1f
-2w1g
-2w1h
-2w1j
-2w1k
-2w1m
-2w1n
-2w1p
-2w1q
-2w1s
-2w1t
-2w1v
-2w1w
-2w1x
-2w1y
-2w1z
-2x1\~n
-2x1b
-2x1c
-2x1d
-2x1f
-2x1g
-2x1h
-2x1j
-2x1k
-2x1m
-2x1n
-2x1p
-2x1q
-2x1s
-2x1t
-2x1v
-2x1w
-2x1x
-2x1y
-2x1z
-2y1\~n
-2y1b
-2y1c
-2y1d
-2y1f
-2y1g
-2y1h
-2y1j
-2y1k
-2y1m
-2y1n
-2y1p
-2y1q
-2y1s
-2y1t
-2y1v
-2y1w
-2y1x
-2y1y
-2y1z
-2z1\~n
-2z1b
-2z1c
-2z1d
-2z1f
-2z1g
-2z1h
-2z1j
-2z1k
-2z1m
-2z1n
-2z1p
-2z1q
-2z1s
-2z1t
-2z1v
-2z1w
-2z1x
-2z1y
-2z1z
-\'a1\'i
-\'a1\'u
-\'a1\~n
-\'a1a
-\'a1b
-\'a1c
-\'a1d
-\'a1e
-\'a1f
-\'a1g
-\'a1h
-\'a1j
-\'a1k
-\'a1l
-\'a1m
-\'a1n
-\'a1o
-\'a1p
-\'a1q
-\'a1r
-\'a1s
-\'a1t
-\'a1v
-\'a1w
-\'a1x
-\'a1y
-\'a1z
-\'a2\~n.
-\'a2b.
-\'a2c.
-\'a2d.
-\'a2f.
-\'a2g.
-\'a2h.
-\'a2j.
-\'a2k.
-\'a2l.
-\'a2m.
-\'a2n.
-\'a2p.
-\'a2q.
-\'a2r.
-\'a2s.
-\'a2t.
-\'a2v.
-\'a2w.
-\'a2x.
-\'a2y.
-\'a2z.
-\'e1\'i
-\'e1\'u
-\'e1\~n
-\'e1a
-\'e1b
-\'e1c
-\'e1d
-\'e1e
-\'e1f
-\'e1g
-\'e1h
-\'e1j
-\'e1k
-\'e1l
-\'e1m
-\'e1n
-\'e1o
-\'e1p
-\'e1q
-\'e1r
-\'e1s
-\'e1t
-\'e1v
-\'e1w
-\'e1x
-\'e1y
-\'e1z
-\'e2\~n.
-\'e2b.
-\'e2c.
-\'e2d.
-\'e2f.
-\'e2g.
-\'e2h.
-\'e2j.
-\'e2k.
-\'e2l.
-\'e2m.
-\'e2n.
-\'e2p.
-\'e2q.
-\'e2r.
-\'e2s.
-\'e2t.
-\'e2v.
-\'e2w.
-\'e2x.
-\'e2y.
-\'e2z.
-\'i1\'a
-\'i1\'e
-\'i1\'o
-\'i1\~n
-\'i1a
-\'i1b
-\'i1c
-\'i1d
-\'i1e
-\'i1f
-\'i1g
-\'i1h
-\'i1j
-\'i1k
-\'i1l
-\'i1m
-\'i1n
-\'i1o
-\'i1p
-\'i1q
-\'i1r
-\'i1s
-\'i1t
-\'i1v
-\'i1w
-\'i1x
-\'i1y
-\'i1z
-\'i2\~n.
-\'i2b.
-\'i2c.
-\'i2d.
-\'i2f.
-\'i2g.
-\'i2h.
-\'i2j.
-\'i2k.
-\'i2l.
-\'i2m.
-\'i2n.
-\'i2p.
-\'i2q.
-\'i2r.
-\'i2s.
-\'i2t.
-\'i2v.
-\'i2w.
-\'i2x.
-\'i2y.
-\'i2z.
-\'o1\'i
-\'o1\'u
-\'o1\~n
-\'o1a
-\'o1b
-\'o1c
-\'o1d
-\'o1e
-\'o1f
-\'o1g
-\'o1h
-\'o1j
-\'o1k
-\'o1l
-\'o1m
-\'o1n
-\'o1o
-\'o1p
-\'o1q
-\'o1r
-\'o1s
-\'o1t
-\'o1v
-\'o1w
-\'o1x
-\'o1y
-\'o1z
-\'o2\~n.
-\'o2b.
-\'o2c.
-\'o2d.
-\'o2f.
-\'o2g.
-\'o2h.
-\'o2j.
-\'o2k.
-\'o2l.
-\'o2m.
-\'o2n.
-\'o2p.
-\'o2q.
-\'o2r.
-\'o2s.
-\'o2t.
-\'o2v.
-\'o2w.
-\'o2x.
-\'o2y.
-\'o2z.
-\'u1\'a
-\'u1\'e
-\'u1\'o
-\'u1\~n
-\'u1a
-\'u1b
-\'u1c
-\'u1d
-\'u1e
-\'u1f
-\'u1g
-\'u1h
-\'u1j
-\'u1k
-\'u1l
-\'u1m
-\'u1n
-\'u1o
-\'u1p
-\'u1q
-\'u1r
-\'u1s
-\'u1t
-\'u1v
-\'u1w
-\'u1x
-\'u1y
-\'u1z
-\'u2\~n.
-\'u2b.
-\'u2c.
-\'u2d.
-\'u2f.
-\'u2g.
-\'u2h.
-\'u2j.
-\'u2k.
-\'u2l.
-\'u2m.
-\'u2n.
-\'u2p.
-\'u2q.
-\'u2r.
-\'u2s.
-\'u2t.
-\'u2v.
-\'u2w.
-\'u2x.
-\'u2y.
-\'u2z.
-a1\'a
-a1\'e
-a1\'i
-a1\'o
-a1\'u
-a1\~n
-a1a
-a1b
-a1c
-a1d
-a1e
-a1f
-a1g
-a1h
-a1j
-a1k
-a1l
-a1m
-a1n
-a1o
-a1p
-a1q
-a1r
-a1s
-a1t
-a1v
-a1w
-a1x
-a1y
-a1z
-a2\~n.
-a2b.
-a2c.
-a2d.
-a2f.
-a2g.
-a2h.
-a2j.
-a2k.
-a2l.
-a2m.
-a2n.
-a2p.
-a2q.
-a2r.
-a2s.
-a2t.
-a2v.
-a2w.
-a2x.
-a2y.
-a2z.
-e1\'a
-e1\'e
-e1\'i
-e1\'o
-e1\'u
-e1\~n
-e1a
-e1b
-e1c
-e1d
-e1e
-e1f
-e1g
-e1h
-e1j
-e1k
-e1l
-e1m
-e1n
-e1o
-e1p
-e1q
-e1r
-e1s
-e1t
-e1v
-e1w
-e1x
-e1y
-e1z
-e2\~n.
-e2b.
-e2c.
-e2d.
-e2f.
-e2g.
-e2h.
-e2j.
-e2k.
-e2l.
-e2m.
-e2n.
-e2p.
-e2q.
-e2r.
-e2s.
-e2t.
-e2v.
-e2w.
-e2x.
-e2y.
-e2z.
-i1\~n
-i1b
-i1c
-i1d
-i1f
-i1g
-i1h
-i1j
-i1k
-i1l
-i1m
-i1n
-i1p
-i1q
-i1r
-i1s
-i1t
-i1v
-i1w
-i1x
-i1y
-i1z
-i2\~n.
-i2b.
-i2c.
-i2d.
-i2f.
-i2g.
-i2h.
-i2j.
-i2k.
-i2l.
-i2m.
-i2n.
-i2p.
-i2q.
-i2r.
-i2s.
-i2t.
-i2v.
-i2w.
-i2x.
-i2y.
-i2z.
-o1\'a
-o1\'e
-o1\'i
-o1\'o
-o1\'u
-o1\~n
-o1a
-o1b
-o1c
-o1d
-o1e
-o1f
-o1g
-o1h
-o1j
-o1k
-o1l
-o1m
-o1n
-o1o
-o1p
-o1q
-o1r
-o1s
-o1t
-o1v
-o1w
-o1x
-o1y
-o1z
-o2\~n.
-o2b.
-o2c.
-o2d.
-o2f.
-o2g.
-o2h.
-o2j.
-o2k.
-o2l.
-o2m.
-o2n.
-o2p.
-o2q.
-o2r.
-o2s.
-o2t.
-o2v.
-o2w.
-o2x.
-o2y.
-o2z.
-u1\~n
-u1b
-u1c
-u1d
-u1f
-u1g
-u1h
-u1j
-u1k
-u1l
-u1m
-u1n
-u1p
-u1q
-u1r
-u1s
-u1t
-u1v
-u1w
-u1x
-u1y
-u1z
-u2\~n.
-u2b.
-u2c.
-u2d.
-u2f.
-u2g.
-u2h.
-u2j.
-u2k.
-u2l.
-u2m.
-u2n.
-u2p.
-u2q.
-u2r.
-u2s.
-u2t.
-u2v.
-u2w.
-u2x.
-u2y.
-u2z.
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/expander-1.3.1.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/expander-1.3.1.tm
deleted file mode 100644
index 9ce76d84..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/expander-1.3.1.tm
+++ /dev/null
@@ -1,1122 +0,0 @@
-#---------------------------------------------------------------------
-# TITLE:
-#	expander.tcl
-#
-# AUTHOR:
-#	Will Duquette
-#
-# DESCRIPTION:
-#
-# An expander is an object that takes as input text with embedded
-# Tcl code and returns text with the embedded code expanded.  The
-# text can be provided all at once or incrementally.
-#
-# See  expander.[e]html for usage info.
-# Also expander.n
-#
-# LICENSE:
-#       Copyright (C) 2001 by William H. Duquette.  See expander_license.txt,
-#       distributed with this file, for license information.
-#
-# CHANGE LOG:
-#
-#       10/31/01: V0.9 code is complete.
-#       11/23/01: Added "evalcmd"; V1.0 code is complete.
-
-# Provide the package.
-
-# Create the package's namespace.
-
-namespace eval ::textutil {
-    namespace eval expander {
-	# All indices are prefixed by "$exp-".
-	#
-	# lb		    The left bracket sequence
-	# rb		    The right bracket sequence
-	# errmode	    How to handle macro errors: 
-	#		    nothing, macro, error, fail.
-        # evalcmd           The evaluation command.
-	# textcmd           The plain text processing command.
-	# level		    The context level
-	# output-$level     The accumulated text at this context level.
-	# name-$level       The tag name of this context level
-	# data-$level-$var  A variable of this context level     
-	
-	variable Info
-    
-	# In methods, the current object:
-	variable This ""
-	
-	# Export public commands
-	namespace export expander
-    }
-
-    #namespace import expander::*
-    namespace export expander
-
-    proc expander {name} {uplevel ::textutil::expander::expander [list $name]}
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	expander name
-#
-# INPUTS:
-#	name		A proc name for the new object.  If not
-#                       fully-qualified, it is assumed to be relative
-#                       to the caller's namespace.
-#
-# RETURNS:
-#	nothing
-#
-# DESCRIPTION:
-#	Creates a new expander object.
-
-proc ::textutil::expander::expander {name} {
-    variable Info
-
-    # FIRST, qualify the name.
-    if {![string match "::*" $name]} {
-        # Get caller's namespace; append :: if not global namespace.
-        set ns [uplevel 1 namespace current]
-        if {"::" != $ns} {
-            append ns "::"
-        }
-        
-        set name "$ns$name"
-    }
-
-    # NEXT, Check the name
-    if {"" != [info commands $name]} {
-        return -code error "command name \"$name\" already exists"
-    }
-
-    # NEXT, Create the object.
-    proc $name {method args} [format {
-        if {[catch {::textutil::expander::Methods %s $method $args} result]} {
-            return -code error $result
-        } else {
-            return $result
-        }
-    } $name]
-
-    # NEXT, Initialize the object
-    Op_reset $name
-    
-    return $name
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Methods name method argList
-#
-# INPUTS:
-#	name		The object's fully qualified procedure name.
-#			This argument is provided by the object command
-#			itself.
-#	method		The method to call.
-#	argList		Arguments for the specific method.
-#
-# RETURNS:
-#	Depends on the method
-#
-# DESCRIPTION:
-#	Handles all method dispatch for a expander object.
-#       The expander's object command merely passes its arguments to
-#	this function, which dispatches the arguments to the
-#	appropriate method procedure.  If the method raises an error,
-#	the method procedure's name in the error message is replaced
-#	by the object and method names.
-
-proc ::textutil::expander::Methods {name method argList} {
-    variable Info
-    variable This
-
-    switch -exact -- $method {
-        expand -
-        lb -
-        rb -
-        setbrackets -
-        errmode -
-        evalcmd -
-	textcmd -
-        cpush -
-	ctopandclear -
-        cis -
-        cname -
-        cset -
-        cget -
-        cvar -
-        cpop -
-        cappend -
-	where -
-        reset {
-            # FIRST, execute the method, first setting This to the object
-            # name; then, after the method has been called, restore the
-            # old object name.
-            set oldThis $This
-            set This $name
-
-            set retval [catch "Op_$method $name $argList" result]
-
-            set This $oldThis
-
-            # NEXT, handle the result based on the retval.
-            if {$retval} {
-                regsub -- "Op_$method" $result "$name $method" result
-                return -code error $result
-            } else {
-                return $result
-            }
-        }
-        default {
-            return -code error "\"$name $method\" is not defined"
-        }
-    }
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Get key
-#
-# INPUTS:
-#	key		A key into the Info array, excluding the
-#	                object name.  E.g., "lb"
-#
-# RETURNS:
-#	The value from the array
-#
-# DESCRIPTION:
-#	Gets the value of an entry from Info for This.
-
-proc ::textutil::expander::Get {key} {
-    variable Info
-    variable This
-
-    return $Info($This-$key)
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Set key value
-#
-# INPUTS:
-#	key		A key into the Info array, excluding the
-#	                object name.  E.g., "lb"
-#
-#	value		A Tcl value
-#
-# RETURNS:
-#	The value
-#
-# DESCRIPTION:
-#	Sets the value of an entry in Info for This.
-
-proc ::textutil::expander::Set {key value} {
-    variable Info
-    variable This
-
-    return [set Info($This-$key) $value]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Var key
-#
-# INPUTS:
-#	key		A key into the Info array, excluding the
-#	                object name.  E.g., "lb"
-#
-# RETURNS:
-#	The full variable name, suitable for setting or lappending
-
-proc ::textutil::expander::Var {key} {
-    variable Info
-    variable This
-
-    return ::textutil::expander::Info($This-$key)
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Contains list value
-#
-# INPUTS:
-#       list		any list
-#	value		any value
-#
-# RETURNS:
-#	TRUE if the list contains the value, and false otherwise.
-
-proc ::textutil::expander::Contains {list value} {
-    if {[lsearch -exact $list $value] == -1} {
-        return 0
-    } else {
-        return 1
-    }
-}
-
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_lb ?newbracket?
-#
-# INPUTS:
-#	newbracket		If given, the new bracket token.
-#
-# RETURNS:
-#	The current left bracket
-#
-# DESCRIPTION:
-#	Returns the current left bracket token.
-
-proc ::textutil::expander::Op_lb {name {newbracket ""}} {
-    if {[string length $newbracket] != 0} {
-        Set lb $newbracket
-    }
-    return [Get lb]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_rb ?newbracket?
-#
-# INPUTS:
-#	newbracket		If given, the new bracket token.
-#
-# RETURNS:
-#	The current left bracket
-#
-# DESCRIPTION:
-#	Returns the current left bracket token.
-
-proc ::textutil::expander::Op_rb {name {newbracket ""}} {
-    if {[string length $newbracket] != 0} {
-        Set rb $newbracket
-    }
-    return [Get rb]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_setbrackets lbrack rbrack
-#
-# INPUTS:
-#	lbrack		The new left bracket
-#	rbrack		The new right bracket
-#
-# RETURNS:
-#	nothing
-#
-# DESCRIPTION:
-#	Sets the brackets as a pair.
-
-proc ::textutil::expander::Op_setbrackets {name lbrack rbrack} {
-    Set lb $lbrack
-    Set rb $rbrack
-    return
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_errmode ?newErrmode?
-#
-# INPUTS:
-#	newErrmode		If given, the new error mode.
-#
-# RETURNS:
-#	The current error mode
-#
-# DESCRIPTION:
-#	Returns the current error mode.
-
-proc ::textutil::expander::Op_errmode {name {newErrmode ""}} {
-    if {[string length $newErrmode] != 0} {
-        if {![Contains "macro nothing error fail" $newErrmode]} {
-            error "$name errmode: Invalid error mode: $newErrmode"
-        }
-
-        Set errmode $newErrmode
-    }
-    return [Get errmode]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_evalcmd ?newEvalCmd?
-#
-# INPUTS:
-#	newEvalCmd		If given, the new eval command.
-#
-# RETURNS:
-#	The current eval command
-#
-# DESCRIPTION:
-#	Returns the current eval command.  This is the command used to
-#	evaluate macros; it defaults to "uplevel #0".
-
-proc ::textutil::expander::Op_evalcmd {name {newEvalCmd ""}} {
-    if {[string length $newEvalCmd] != 0} {
-        Set evalcmd $newEvalCmd
-    }
-    return [Get evalcmd]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_textcmd ?newTextCmd?
-#
-# INPUTS:
-#	newTextCmd		If given, the new text command.
-#
-# RETURNS:
-#	The current text command
-#
-# DESCRIPTION:
-#	Returns the current text command.  This is the command used to
-#	process plain text. It defaults to {}, meaning identity.
-
-proc ::textutil::expander::Op_textcmd {name args} {
-    switch -exact [llength $args] {
-	0 {}
-	1 {Set textcmd [lindex $args 0]}
-	default {
-	    return -code error "wrong#args for textcmd: name ?newTextcmd?"
-	}
-    }
-    return [Get textcmd]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_reset
-#
-# INPUTS:
-#	none
-#
-# RETURNS:
-#	nothing
-#
-# DESCRIPTION:
-#	Resets all object values, as though it were brand new.
-
-proc ::textutil::expander::Op_reset {name} {
-    variable Info 
-
-    if {[info exists Info($name-lb)]} {
-        foreach elt [array names Info "$name-*"] {
-            unset Info($elt)
-        }
-    }
-
-    set Info($name-lb) "\["
-    set Info($name-rb) "\]"
-    set Info($name-errmode) "fail"
-    set Info($name-evalcmd) "uplevel #0"
-    set Info($name-textcmd) ""
-    set Info($name-level) 0
-    set Info($name-output-0) ""
-    set Info($name-name-0) ":0"
-
-    return
-}
-
-#-------------------------------------------------------------------------
-# Context: Every expansion takes place in its own context; however, 
-# a macro can push a new context, causing the text it returns and all
-# subsequent text to be saved separately.  Later, a matching macro can
-# pop the context, acquiring all text saved since the first command,
-# and use that in its own output.
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cpush cname
-#
-# INPUTS:
-#	cname		The context name
-#
-# RETURNS:
-#	nothing
-#
-# DESCRIPTION:
-#       Pushes an empty macro context onto the stack.  All expanded text
-#       will be added to this context until it is popped.
-
-proc ::textutil::expander::Op_cpush {name cname} {
-    # FRINK: nocheck
-    incr [Var level]
-    # FRINK: nocheck
-    set [Var output-[Get level]] {}
-    # FRINK: nocheck
-    set [Var name-[Get level]] $cname
-
-    # The first level is init'd elsewhere (Op_expand)
-    if {[set [Var level]] < 2} return
-
-    # Initialize the location information, inherit from the outer
-    # context.
-
-    LocInit $cname
-    catch {LocSet $cname [LocGet $name]}
-    return    
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cis cname
-#
-# INPUTS:
-#	cname		A context name
-#
-# RETURNS:
-#	true or false
-#
-# DESCRIPTION:
-#       Returns true if the current context has the specified name, and
-#	false otherwise.
-
-proc ::textutil::expander::Op_cis {name cname} {
-    return [expr {[string compare $cname [Op_cname $name]] == 0}]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cname
-#
-# INPUTS:
-#	none
-#
-# RETURNS:
-#	The context name
-#
-# DESCRIPTION:
-#       Returns the name of the current context.
-
-proc ::textutil::expander::Op_cname {name} {
-    return [Get name-[Get level]]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cset varname value
-#
-# INPUTS:
-#	varname		The name of a context variable
-#	value		The new value for the context variable
-#
-# RETURNS:
-#	The value
-#
-# DESCRIPTION:
-#       Sets a variable in the current context.
-
-proc ::textutil::expander::Op_cset {name varname value} {
-    Set data-[Get level]-$varname $value
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cget varname
-#
-# INPUTS:
-#	varname		The name of a context variable
-#
-# RETURNS:
-#	The value
-#
-# DESCRIPTION:
-#       Returns the value of a context variable.  It's an error if
-#	the variable doesn't exist.
-
-proc ::textutil::expander::Op_cget {name varname} {
-    if {![info exists [Var data-[Get level]-$varname]]} {
-        error "$name cget: $varname doesn't exist in this context ([Get level])"
-    }
-    return [Get data-[Get level]-$varname]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cvar varname
-#
-# INPUTS:
-#	varname		The name of a context variable
-#
-# RETURNS:
-#	The index to the variable
-#
-# DESCRIPTION:
-#       Returns the index to a context variable, for use with set, 
-#	lappend, etc.
-
-proc ::textutil::expander::Op_cvar {name varname} {
-    if {![info exists [Var data-[Get level]-$varname]]} {
-        error "$name cvar: $varname doesn't exist in this context"
-    }
-
-    return [Var data-[Get level]-$varname]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cpop cname
-#
-# INPUTS:
-#	cname		The expected context name.
-#
-# RETURNS:
-#	The accumulated output in this context
-#
-# DESCRIPTION:
-#       Returns the accumulated output for the current context, first
-#	popping the context from the stack.  The expected context name
-#	must match the real name, or an error occurs.
-
-proc ::textutil::expander::Op_cpop {name cname} {
-    variable Info
-
-    if {[Get level] == 0} {
-        error "$name cpop underflow on '$cname'"
-    }
-
-    if {[string compare [Op_cname $name] $cname] != 0} {
-        error "$name cpop context mismatch: expected [Op_cname $name], got $cname"
-    }
-
-    set result [Get output-[Get level]]
-    # FRINK: nocheck
-    set [Var output-[Get level]] ""
-    # FRINK: nocheck
-    set [Var name-[Get level]] ""
-
-    foreach elt [array names "Info data-[Get level]-*"] {
-        unset Info($elt)
-    }
-
-    # FRINK: nocheck
-    incr [Var level] -1
-    return $result
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_ctopandclear
-#
-# INPUTS:
-#	None.
-#
-# RETURNS:
-#	The accumulated output in the topmost context, clears the context,
-#	but does not pop it.
-#
-# DESCRIPTION:
-#       Returns the accumulated output for the current context, first
-#	popping the context from the stack.  The expected context name
-#	must match the real name, or an error occurs.
-
-proc ::textutil::expander::Op_ctopandclear {name} {
-    variable Info
-
-    if {[Get level] == 0} {
-        error "$name cpop underflow on '[Op_cname $name]'"
-    }
-
-    set result [Get output-[Get level]]
-    Set output-[Get level] ""
-    return $result
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_cappend text
-#
-# INPUTS:
-#	text		Text to add to the output
-#
-# RETURNS:
-#	The accumulated output
-#
-# DESCRIPTION:
-#       Appends the text to the accumulated output in the current context.
-
-proc ::textutil::expander::Op_cappend {name text} {
-    # FRINK: nocheck
-    append [Var output-[Get level]] $text
-}
-
-#-------------------------------------------------------------------------
-# Macro-expansion:  The following code is the heart of the module.
-# Given a text string, and the current variable settings, this code
-# returns an expanded string, with all macros replaced.
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_expand inputString ?brackets?
-#
-# INPUTS:
-#	inputString		The text to expand.
-#	brackets		A list of two bracket tokens.
-#
-# RETURNS:
-#	The expanded text.
-#
-# DESCRIPTION:
-#	Finds all embedded macros in the input string, and expands them.
-#	If ?brackets? is given, it must be list of length 2, containing
-#	replacement left and right macro brackets; otherwise the default
-#	brackets are used.
-
-proc ::textutil::expander::Op_expand {name inputString {brackets ""}} {
-    # FIRST, push a new context onto the stack, and save the current
-    # brackets.
-
-    Op_cpush $name expand
-    Op_cset $name lb [Get lb]
-    Op_cset $name rb [Get rb]
-
-    # Keep position information in context variables as well.
-    # Line we are in, counting from 1; column we are at,
-    # counting from 0, and index of character we are at,
-    # counting from 0. Tabs counts as '1' when computing
-    # the column.
-
-    LocInit $name
-
-    # SF Tcllib Bug #530056.
-    set start_level [Get level] ; # remember this for check at end
-
-    # NEXT, use the user's brackets, if given.
-    if {[llength $brackets] == 2} {
-        Set lb [lindex $brackets 0]
-        Set rb [lindex $brackets 1]
-    }
-
-    # NEXT, loop over the string, finding and expanding macros.
-    while {[string length $inputString] > 0} {
-        set plainText [ExtractToToken inputString [Get lb] exclude]
-
-        # FIRST, If there was plain text, append it to the output, and 
-        # continue.
-        if {$plainText != ""} {
-	    set input $plainText
-	    set tc [Get textcmd]
-	    if {[string length $tc] > 0} {
-		lappend tc $plainText
-
-		if {![catch "[Get evalcmd] [list $tc]" result]} {
-		    set plainText $result
-		} else {
-		    HandleError $name {plain text} $tc $result
-		}
-	    }
-            Op_cappend $name $plainText
-	    LocUpdate  $name $input
-
-            if {[string length $inputString] == 0} {
-                break
-            }
-        }
-
-        # NEXT, A macro is the next thing; process it.
-        if {[catch {GetMacro inputString} macro]} {
-	    # SF tcllib bug 781973 ... Do not throw a regular
-	    # error. Use HandleError to give the user control of the
-	    # situation, via the defined error mode. The continue
-	    # intercepts if the user allows the expansion to run on,
-	    # yet we must not try to run the non-existing macro.
-
-	    HandleError $name {reading macro} $inputString $macro
-	    continue
-        }
-
-        # Expand the macro, and output the result, or
-        # handle an error.
-        if {![catch "[Get evalcmd] [list $macro]" result]} {
-            Op_cappend $name $result 
-
-	    # We have to advance the location by the length of the
-	    # macro, plus the two brackets. They were stripped by
-	    # GetMacro, so we have to add them here again to make
-	    # computation correct.
-
-	    LocUpdate $name [Get lb]${macro}[Get rb]
-            continue
-        } 
-
-	HandleError $name macro $macro $result
-    }
-
-    # SF Tcllib Bug #530056.
-    if {[Get level] > $start_level} {
-	# The user macros pushed additional contexts, but forgot to
-	# pop them all. The main work here is to place all the still
-	# open contexts into the error message, and to produce
-	# syntactically correct english.
-
-	set c [list]
-	set n [expr {[Get level] - $start_level}]
-	if {$n == 1} {
-	    set ctx  context
-	    set verb was
-	} else {
-	    set ctx  contexts
-	    set verb were
-	}
-	for {incr n -1} {$n >= 0} {incr n -1} {
-	    lappend c [Get name-[expr {[Get level]-$n}]]
-	}
-	return -code error \
-		"The following $ctx pushed by the macros $verb not popped: [join $c ,]."
-    } elseif {[Get level] < $start_level} {
-	set n [expr {$start_level - [Get level]}]
-	if {$n == 1} {
-	    set ctx  context
-	} else {
-	    set ctx  contexts
-	}
-	return -code error \
-		"The macros popped $n more $ctx than they had pushed."
-    }
-
-    Op_lb $name [Op_cget $name lb]
-    Op_rb $name [Op_cget $name rb]
-
-    return [Op_cpop $name expand]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	Op_where
-#
-# INPUTS:
-#	None.
-#
-# RETURNS:
-#	The current location in the input.
-#
-# DESCRIPTION:
-#	Retrieves the current location the expander
-#	is at during processing.
-
-proc ::textutil::expander::Op_where {name} {
-    return [LocGet $name]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION
-#	HandleError name title command errmsg
-#
-# INPUTS:
-#	name		The name of the expander object in question.
-#	title		A title text
-#	command		The command which caused the error.
-#	errmsg		The error message to report
-#
-# RETURNS:
-#	Nothing
-#
-# DESCRIPTIONS
-#	Is executed when an error in a macro or the plain text handler
-#	occurs. Generates an error message according to the current
-#	error mode.
-
-proc ::textutil::expander::HandleError {name title command errmsg} {
-    switch [Get errmode] {
-	nothing { }
-	macro {
-	    # The location is irrelevant here.
-	    Op_cappend $name "[Get lb]$command[Get rb]" 
-	}
-	error {
-	    foreach {ch line col} [LocGet $name] break
-	    set display [DisplayOf $command]
-
-	    Op_cappend $name "\n=================================\n"
-	    Op_cappend $name "*** Error in $title at line $line, column $col:\n"
-	    Op_cappend $name "*** [Get lb]$display[Get rb]\n--> $errmsg\n"
-	    Op_cappend $name "=================================\n"
-	}
-	fail   { 
-	    foreach {ch line col} [LocGet $name] break
-	    set display [DisplayOf $command]
-
-	    return -code error "Error in $title at line $line,\
-		    column $col:\n[Get lb]$display[Get rb]\n-->\
-		    $errmsg"
-	}
-	default {
-	    return -code error "Unknown error mode: [Get errmode]"
-	}
-    }
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	ExtractToToken string token mode
-#
-# INPUTS:
-#	string		The text to process.
-#	token		The token to look for
-#	mode		include or exclude
-#
-# RETURNS:
-#	The extracted text
-#
-# DESCRIPTION:
-# 	Extract text from a string, up to or including a particular
-# 	token.  Remove the extracted text from the string.
-# 	mode determines whether the found token is removed;
-# 	it should be "include" or "exclude".  The string is
-# 	modified in place, and the extracted text is returned.
-
-proc ::textutil::expander::ExtractToToken {string token mode} {
-    upvar $string theString
-
-    # First, determine the offset
-    switch $mode {
-        include { set offset [expr {[string length $token] - 1}] }
-        exclude { set offset -1 }
-        default { error "::expander::ExtractToToken: unknown mode $mode" }
-    }
-
-    # Next, find the first occurrence of the token.
-    set tokenPos [string first $token $theString]
-
-    # Next, return the entire string if it wasn't found, or just
-    # the part upto or including the character.
-    if {$tokenPos == -1} {
-        set theText $theString
-        set theString ""
-    } else {
-        set newEnd    [expr {$tokenPos + $offset}]
-        set newBegin  [expr {$newEnd + 1}]
-        set theText   [string range $theString 0 $newEnd]
-        set theString [string range $theString $newBegin end]
-    }
-
-    return $theText
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	GetMacro string
-#
-# INPUTS:
-#	string		The text to process.
-#
-# RETURNS:
-#	The macro, stripped of its brackets.
-#
-# DESCRIPTION:
-
-proc ::textutil::expander::GetMacro {string} {
-    upvar $string theString
-
-    # FIRST, it's an error if the string doesn't begin with a
-    # bracket.
-    if {[string first [Get lb] $theString] != 0} {
-        error "::expander::GetMacro: assertion failure, next text isn't a command! '$theString'"
-    }
-
-    # NEXT, extract a full macro
-    set macro [ExtractToToken theString [Get lb] include]
-    while {[string length $theString] > 0} {
-        append macro [ExtractToToken theString [Get rb] include]
-
-        # Verify that the command really ends with the [rb] characters,
-        # whatever they are.  If not, break because of unexpected
-        # end of file.
-        if {![IsBracketed $macro]} {
-            break;
-        }
-
-        set strippedMacro [StripBrackets $macro]
-
-        if {[info complete "puts \[$strippedMacro\]"]} {
-            return $strippedMacro
-        }
-    }
-
-    if {[string length $macro] > 40} {
-        set macro "[string range $macro 0 39]...\n"
-    }
-    error "Unexpected EOF in macro:\n$macro"
-}
-
-# Strip left and right bracket tokens from the ends of a macro,
-# provided that it's properly bracketed.
-proc ::textutil::expander::StripBrackets {macro} {
-    set llen [string length [Get lb]]
-    set rlen [string length [Get rb]]
-    set tlen [string length $macro]
-
-    return [string range $macro $llen [expr {$tlen - $rlen - 1}]]
-}
-
-# Return 1 if the macro is properly bracketed, and 0 otherwise.
-proc ::textutil::expander::IsBracketed {macro} {
-    set llen [string length [Get lb]]
-    set rlen [string length [Get rb]]
-    set tlen [string length $macro]
-
-    set leftEnd  [string range $macro 0       [expr {$llen - 1}]]
-    set rightEnd [string range $macro [expr {$tlen - $rlen}] end]
-
-    if {$leftEnd != [Get lb]} {
-        return 0
-    } elseif {$rightEnd != [Get rb]} {
-        return 0
-    } else {
-        return 1
-    }
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocInit name
-#
-# INPUTS:
-#	name		The expander object to use.
-#
-# RETURNS:
-#	No result.
-#
-# DESCRIPTION:
-#	A convenience wrapper around LocSet. Initializes the location
-#	to the start of the input (char 0, line 1, column 0).
-
-proc ::textutil::expander::LocInit {name} {
-    LocSet $name {0 1 0}
-    return
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocSet name loc
-#
-# INPUTS:
-#	name		The expander object to use.
-#	loc		Location, list containing character position,
-#			line number and column, in this order.
-#
-# RETURNS:
-#	No result.
-#
-# DESCRIPTION:
-#	Sets the current location in the expander to 'loc'.
-
-proc ::textutil::expander::LocSet {name loc} {
-    foreach {ch line col} $loc break
-    Op_cset  $name char $ch
-    Op_cset  $name line $line
-    Op_cset  $name col  $col
-    return
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocGet name
-#
-# INPUTS:
-#	name		The expander object to use.
-#
-# RETURNS:
-#	A list containing the current character position, line number
-#	and column, in this order.
-#
-# DESCRIPTION:
-#	Returns the current location as stored in the expander.
-
-proc ::textutil::expander::LocGet {name} {
-    list [Op_cget $name char] [Op_cget $name line] [Op_cget $name col]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocUpdate name text
-#
-# INPUTS:
-#	name		The expander object to use.
-#	text		The text to process.
-#
-# RETURNS:
-#	No result.
-#
-# DESCRIPTION:
-#	Takes the current location as stored in the expander, computes
-#	a new location based on the string (its length and contents
-#	(number of lines)), and makes that new location the current
-#	location.
-
-proc ::textutil::expander::LocUpdate {name text} {
-    foreach {ch line col} [LocGet $name] break
-    set numchars [string length $text]
-    #8.4+ set numlines [regexp -all "\n" $text]
-    set numlines [expr {[llength [split $text \n]]-1}]
-
-    incr ch   $numchars
-    incr line $numlines
-    if {$numlines} {
-	set col [expr {$numchars - [string last \n $text] - 1}]
-    } else {
-	incr col $numchars
-    }
-
-    LocSet $name [list $ch $line $col]
-    return
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	LocRange name text
-#
-# INPUTS:
-#	name		The expander object to use.
-#	text		The text to process.
-#
-# RETURNS:
-#	A text range description, compatible with the 'location' data
-#	used in the tcl debugger/checker.
-#
-# DESCRIPTION:
-#	Takes the current location as stored in the expander object
-#	and the length of the text to generate a character range.
-
-proc ::textutil::expander::LocRange {name text} {
-    # Note that the structure is compatible with
-    # the ranges uses by tcl debugger and checker.
-    # {line {charpos length}}
-
-    foreach {ch line col} [LocGet $name] break
-    return [list $line [list $ch [string length $text]]]
-}
-
-#---------------------------------------------------------------------
-# FUNCTION:
-# 	DisplayOf text
-#
-# INPUTS:
-#	text		The text to process.
-#
-# RETURNS:
-#	The text, cut down to at most 30 bytes.
-#
-# DESCRIPTION:
-#	Cuts the incoming text down to contain no more than 30
-#	characters of the input. Adds an ellipsis (...) if characters
-#	were actually removed from the input.
-
-proc ::textutil::expander::DisplayOf {text} {
-    set ellip ""
-    while {[string bytelength $text] > 30} {
-	set ellip ...
-	set text [string range $text 0 end-1]
-    }
-    set display $text$ellip
-}
-
-#---------------------------------------------------------------------
-# Provide the package only if the code above was read and executed
-# without error.
-
-package provide textutil::expander 1.3.1
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/ithyph.tex b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/ithyph.tex
deleted file mode 100644
index 755e1085..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/ithyph.tex
+++ /dev/null
@@ -1,223 +0,0 @@
-
-%%%%%%%%%%%%%%%%%%%% file ithyph.tex
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%  file ithyph.tex  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% Prepared by Claudio Beccari   e-mail  beccari@polito.it
-%
-%                                       Dipartimento di Elettronica
-%                                       Politecnico di Torino
-%                                       Corso Duca degli Abruzzi, 24
-%                                       10129 TORINO
-%
-% Copyright  1998, 2001 Claudio Beccari
-%
-% This program can be redistributed and/or modified under the terms
-% of the LaTeX Project Public License Distributed from CTAN
-% archives in directory macros/latex/base/lppl.txt; either
-% version 1 of the License, or any later version.
-%
-% \versionnumber{4.8d}   \versiondate{2001/11/21}
-%
-% These hyphenation patterns for the Italian language are supposed to comply
-% with the Reccomendation UNI 6461 on hyphenation issued by the Italian
-% Standards Institution (Ente Nazionale di Unificazione UNI).  No guarantee
-% or declaration of fitness to any particular purpose is given and any
-% liability is disclaimed.
-%
-% See comments and loading instructions at the end of the file after the
-% \endinput line
-%
-{\lccode`\'=`\'      % Apostrophe has its own lccode so that it is treated
-                     % as a letter
-                     %>> 1998/04/14 inserted grouping
-                     %
-%\lccode23=23        % Compound word mark is a letter in encoding T1
-%\def\W{^^W}         % ^^W =\char23 = \char"17 =\char'27
-%
-\patterns{
-.a3p2n               % After the Garzanti dictionary: a-pnea, a-pnoi-co,...
-.anti1  .anti3m2n
-.bio1
-.ca4p3s
-.circu2m1
-.di2s3cine
-%.e2x
-.fran2k3
-.free3
-.narco1
-.opto1
-.orto3p2
-.para1
-.poli3p2
-.pre1
-.p2s
-%.ri1a2   .ri1e2    .re1i2  .ri1o2  .ri1u2
-.sha2re3
-.tran2s3c .tran2s3d .tran2s3f .tran2s3l .tran2s3n .tran2s3p .tran2s3r .tran2s3t
-.su2b3lu   .su2b3r
-.wa2g3n
-.wel2t1
-a1ia a1ie  a1io  a1iu a1uo a1ya 2at.
-e1iu e2w
-o1ia o1ie  o1io  o1iu
-%u1u
-%
-%1\W0a2 1\W0e2 1\W0i2 1\W0o2 1\W0u2
-'2
-1b   2bb   2bc   2bd  2bf  2bm  2bn  2bp  2bs  2bt  2bv
-     b2l   b2r   2b.  2b'. 2b''
-1c   2cb   2cc   2cd  2cf  2ck  2cm  2cn  2cq  2cs  2ct  2cz
-     2chh  c2h   2chb ch2r 2chn c2l  c2r  2c.  2c'. 2c'' .c2
-1d   2db   2dd   2dg  2dl  2dm  2dn  2dp  d2r  2ds  2dt  2dv  2dw
-     2d.   2d'.  2d'' .d2
-1f   2fb   2fg   2ff  2fn  f2l  f2r  2fs  2ft  2f.  2f'. 2f''
-1g   2gb   2gd   2gf  2gg  g2h  g2l  2gm  g2n  2gp  g2r  2gs  2gt
-     2gv   2gw   2gz  2gh2t     2g.  2g'. 2g''
-1h   2hb   2hd   2hh  hi3p2n    h2l  2hm  2hn  2hr  2hv  2h.  2h'.  2h''
-1j   2j.   2j'.  2j''
-1k   2kg   2kf   k2h  2kk  k2l  2km  k2r  2ks  2kt  2k.  2k'. 2k''
-1l   2lb   2lc   2ld  2l3f2     2lg  l2h  2lk  2ll  2lm  2ln  2lp
-     2lq   2lr   2ls  2lt  2lv  2lw  2lz  2l.  2l'. 2l''
-1m   2mb   2mc   2mf  2ml  2mm  2mn  2mp  2mq  2mr  2ms  2mt  2mv  2mw
-     2m.   2m'.  2m''
-1n   2nb   2nc   2nd  2nf  2ng  2nk  2nl  2nm  2nn  2np  2nq  2nr
-     2ns   2nt   2nv  2nz  n2g3n     2nheit.   2n.  2n'  2n''
-1p   2pd   p2h   p2l  2pn  3p2ne 2pp p2r  2ps  3p2sic 2pt  2pz  2p.  2p'. 2p''
-1q   2qq   2q.   2q'. 2q''
-1r   2rb   2rc   2rd  2rf  r2h  2rg  2rk  2rl  2rm  2rn  2rp
-     2rq   2rr   2rs  2rt  rt2s3 2rv 2rx  2rw  2rz  2r.  2r'. 2r''
-1s2  2shm  2s3s  s4s3m 2s3p2n   2stb 2stc 2std 2stf 2stg 2stm 2stn
-     2stp  2sts  2stt 2stv 2sz  4s.  4s'. 4s''
-1t   2tb   2tc   2td  2tf  2tg  t2h  t2l  2tm  2tn  2tp  t2r  2ts
-     3t2sch      2tt  2tv  2tw  t2z  2tzk 2tzs 2t.  2t'. 2t''
-1v   2vc   v2l   v2r  2vv  2v.  2v'. 2v''
-1w   w2h   wa2r  2w1y 2w.  2w'. 2w''
-1x   2xt   2xw   2x.   2x'. 2x''
-y1ou y1i
-1z   2zb   2zd   2zl  2zn  2zp  2zt  2zs  2zv  2zz  2z.  2z'. 2z''  .z2
-}}                          % Pattern end
-
-\endinput
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Information %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-
-                           LOADING THESE PATTERNS
-
-These patterns, as well  as  those  for  any  other  language, do not become
-effective until they are loaded in a special form into a format  file;  this
-task  is  performed  by  the  TeX  initializer;  any  TeX system has its own
-initializer with its special way  of  being activated.  Before loading these
-patterns, then, it is necessary to read very carefully the instructions that
-come with your TeX system.
-
-Here I describe how to load the  patterns with the freeware TeX system named
-MiKTeX version 2.x for Windows 9x, NT, 2000,  XP;  with  minor  changes  the
-whole  procedure  is applicable with other TeX systems, but the details must
-be deduced from your TeX system documentation at the section/chapter "How to
-build or to rebuild a format file".
-
-With MikTeX:
-
-a) copy this file and replace  the existing file ithyph.tex in the directory
-   \texmf\tex\generic\hyphen if the existing one has an older  version  date
-   and number.
-b) select Start|Programs|MiKTeX|MiKTeX options.
-c) in  the  Language tab add a check mark to the line concerning the Italian
-   language.
-d) in the Geneal tab click "Update format files".
-e) That's all!  
-
-For the activation of these  patterns  with the specific Italian typesetting
-features, use the babel package as this:
-
-\documentclass{article} % Or whatever other class
-\usepackage[italian]{babel}
-...
-\begin{document}
-...
-\end{document}
-
-
-                           ON ITALIAN HYPHENATION
-
-I have been working on patterns for the Italian language since 1987; in 1992
-I published
-
-C. Beccari, "Computer aided hyphenation for Italian and Modern
-      Latin", TUG vol. 13, n. 1, pp. 23-33 (1992)
-
-which contained a set of patterns that allowed hyphenation for both  Italian
-and  Latin;  a  slightly  modified  version of the patterns published in the
-above paper is contained in LAHYPH.TEX available on the CTAN archives.
-
-From  the  above  patterns  I  extracted  the  minimum  set  necessary   for
-hyphenating  Italian  that  was made available on the CTAN archives with the
-name ITHYPH.tex the version number  3.5  on  the  16th of August 1994.  
-
-The  original  pattern  set  required  37  ops;  being interested in a local
-version of TeX/LaTeX  capable  of  dealing  with  half  a dozen languages, I
-wanted to reduce memory occupation and therefore the number of ops.
-
-Th new version (4.0 released  in  1996)  of  ITHYPH.TEX is much simpler than
-version 3.5 and requires just 29 ops while  it  retains  all  the  power  of
-version  3.5;  it  contains  many  more new patterns that allow to hyphenate
-unusual words that generally have  a  root borrowed from a foreign language.
-Updated versions 4.x contain minor  additions  and  the  number  of  ops  is
-increased to 30 (version 4.7 of 1998/06/01).
-
-This new pattern set has been tested  with the same set of difficult Italian
-words that was used to test version 3.5 and it yields the  same  results  (a
-part  a  minor  change  that was deliberately introduced so as to reduce the
-typographical hyphenation  with  hyathi,  since  hyphenated  hyathi  are not
-appreciated by Italian readers).   A  new  enlarged  word  set  for  testing
-purposes  gets correct hyphen points that were missed or wrongly placed with
-version 3.5, although no error had  been reported, because such words are of
-very specialized nature and are seldom used.
-
-As the previous version, this new set  of  patterns  does  not  contain  any
-accented  character  so  that  the hyphenation algorithm behaves properly in
-both cases, that is with cm  and  with dc/ec fonts.  With LaTeXe terminology
-the difference is between OT1 and T1 encodings;  with  the  former  encoding
-fonts  do  not  contain  accented characters, while with the latter accented
-characters are present and sequences  such  as  \`a map directly to slot "E0
-that contains "agrave".
-
-Of course if you use dc/ec fonts (or any other real or virtual font with  T1
-encoding)  you get the full power of the hyphenation algorithm, while if you
-use cm fonts (or any other real or virtual font with OT1 encoding) you  miss
-some  possible  break  points;  this  is  not a big inconvenience in Italian
-because:
-
-1) The Regulation UNI 6015 on  accents  specifies  that  compulsory  accents
-   appear  only  on the ending vowel of oxitone words; this means that it is
-   almost indifferent to have or  to  miss  the dc/ec fonts because the only
-   difference consists in how TeX evaluates the end of the word; in practice
-   if you have these special facilities you get "qua-li-t\`a", while if  you
-   miss them, you get "qua-lit\`a" (assuming that \righthyphenmin > 1).
-
-2)  Optional  accents are so rare in Italian, that if you absolutely want to
-   use  them  in  those  rare  instances,  and  you  miss  the  T1  encoding
-   facilities, you should also provide  explicit discretionary hyphens as in
-   "s\'e\-gui\-to".
-
-There is no explicit  hyphenation  exception  list  because  these  patterns
-proved  to  hyphenate correctly a very large set of words suitably chosen in
-order to test them in the most heavy circumstances; these patterns were used
-in the preparation of a number of books and no errors were discovered.
-
-Nevertheless if you frequently use  technical terms that you want hyphenated
-differently  from  what  is  normally  done  (for  example  if  you   prefer
-etymological  hyphenation  of  prefixed  and/or  suffixed  words) you should
-insert a specific hyphenation  list  in  the  preamble of your document, for
-example:
-
-\hyphenation{su-per-in-dut-to-re su-per-in-dut-to-ri}
-
-Should you find any word that gets hyphenated in a wrong way, please, AFTER
-CHECKING ON A RELIABLE MODERN DICTIONARY, report to the author, preferably
-by e-mail.
-
-
-                       Happy multilingual typesetting !
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/patch-0.1.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/patch-0.1.tm
deleted file mode 100644
index cf68959d..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/patch-0.1.tm
+++ /dev/null
@@ -1,180 +0,0 @@
-# patch.tcl --
-#
-#	Application of a diff -ruN patch to a directory tree.
-#
-# Copyright (c) 2019 Christian Gollwitzer <auriocus@gmx.de>
-# with tweaks by Andreas Kupries
-# - Factored patch parsing into a helper
-# - Replaced `puts` with report callback.
-
-package require Tcl 8.5
-package provide textutil::patch 0.1
-
-# # ## ### ##### ######## ############# #####################
-
-namespace eval ::textutil::patch {
-    namespace export apply
-    namespace ensemble create
-}
-
-# # ## ### ##### ######## ############# #####################
-
-proc ::textutil::patch::apply {dir striplevel patch reportcmd} {
-    set patchdict [Parse $dir $striplevel $patch]
-
-    # Apply, now that we have parsed the patch.
-    dict for {fn hunks} $patchdict {
-	Report apply $fn
-	if {[catch {open $fn} fd]} {
-	    set orig {}
-	} else {
-	    set orig [split [read $fd] \n]
-	}
-	close $fd
-
-	set patched $orig
-
-	set fail false
-	set already_applied false
-	set hunknr 1
-	foreach hunk $hunks {
-	    dict with hunk {
-		set oldend [expr {$oldstart+[llength $oldcode]-1}]
-		set newend [expr {$newstart+[llength $newcode]-1}]
-		# check if the hunk matches
-		set origcode [lrange $orig $oldstart $oldend]
-		if {$origcode ne $oldcode} {
-		    set fail true
-		    # check if the patch is already applied
-		    set origcode_applied [lrange $orig $newstart $newend]
-		    if {$origcode_applied eq $newcode} {
-			set already_applied true
-			Report fail-already $fn $hunknr
-		    } else {
-			Report fail $fn $hunknr $oldcode $origcode
-		    }
-		    break
-		}
-		# apply patch
-		set patched [list \
-				 {*}[lrange $patched 0 $newstart-1] \
-				 {*}$newcode \
-				 {*}[lrange $orig $oldend+1 end]]
-	    }
-	    incr hunknr
-	}
-
-	if {!$fail} {
-	    # success - write the result back
-	    set fd [open $fn w]
-	    puts -nonewline $fd [join $patched \n]
-	    close $fd
-	}
-    }
-
-    return
-}
-
-# # ## ### ##### ######## ############# #####################
-
-proc ::textutil::patch::Report args {
-    upvar 1 reportcmd reportcmd
-    uplevel #0 [list {*}$reportcmd {*}$args]
-    ##
-    # apply        $fname
-    # fail-already $fname $hunkno
-    # fail         $fname $hunkno $expected $seen
-    ##
-}
-
-proc ::textutil::patch::Parse {dir striplevel patch} {
-    set patchlines [split $patch \n]
-    set inhunk false
-    set oldcode {}
-    set newcode {}
-    set n [llength $patchlines]
-
-    set patchdict {}
-    for {set lineidx 0} {$lineidx < $n} {incr lineidx} {
-	set line [lindex $patchlines $lineidx]
-	if {[string match ---* $line]} {
-	    # a diff block starts. Current line should be
-	    # --- oldfile date time TZ
-	    # Next line should be
-	    # +++ newfile date time TZ
-	    set in $line
-	    incr lineidx
-	    set out [lindex $patchlines $lineidx]
-
-	    if {![string match ---* $in] || ![string match +++* $out]} {
-		#puts $in
-		#puts $out
-		return -code error "Patch not in unified diff format, line $lineidx $in $out"
-	    }
-
-	    # the quoting is compatible with list
-	    lassign $in  -> oldfile
-	    lassign $out -> newfile
-
-	    set fntopatch [file join $dir {*}[lrange [file split $oldfile] $striplevel end]]
-	    set inhunk false
-	    #puts "Found diffline for $fntopatch"
-	    continue
-	}
-
-	# state machine for parsing the hunks
-	set typechar [string index $line 0]
-	set codeline [string range $line 1 end]
-	switch $typechar {
-	    @ {
-		if {![regexp {@@\s+\-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@} $line \
-			  -> oldstart oldlen newstart newlen]} {
-		    return code -error "Erroneous hunk in line $lindeidx, $line"
-		}
-		# adjust line numbers for 0-based indexing
-		incr oldstart -1
-		incr newstart -1
-		#puts "New hunk"
-		set newcode {}
-		set oldcode {}
-		set inhunk true
-	    }
-	    - { # line only in old code
-		if {$inhunk} {
-		    lappend oldcode $codeline
-		}
-	    }
-	    + { # line only in new code
-		if {$inhunk} {
-		    lappend newcode $codeline
-		}
-	    }
-	    " " { # common line
-		if {$inhunk} {
-		    lappend oldcode $codeline
-		    lappend newcode $codeline
-		}
-	    }
-	    default {
-		# puts "Junk: $codeline";
-		continue
-	    }
-	}
-	# test if the hunk is complete
-	if {[llength $oldcode]==$oldlen && [llength $newcode]==$newlen} {
-	    set hunk [dict create \
-			  oldcode $oldcode \
-			  newcode $newcode \
-			  oldstart $oldstart \
-			  newstart $newstart]
-	    #puts "hunk complete: $hunk"
-	    set inhunk false
-	    dict lappend patchdict $fntopatch $hunk
-	}
-    }
-
-    return $patchdict
-}
-
-# # ## ### ##### ######## ############# #####################
-return
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/repeat-0.7.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/repeat-0.7.tm
deleted file mode 100644
index 24f8693c..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/repeat-0.7.tm
+++ /dev/null
@@ -1,91 +0,0 @@
-# repeat.tcl --
-#
-#	Emulation of string repeat for older
-#	revisions of Tcl.
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: repeat.tcl,v 1.1 2006/04/21 04:42:28 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil::repeat {}
-
-# ### ### ### ######### ######### #########
-
-namespace eval ::textutil::repeat {
-    variable HaveBuiltin [expr {![catch {string repeat a 1}]}]
-}
-
-if {0} {
-    # Problems with the deactivated code:
-    # - Linear in 'num'.
-    # - Tests for 'string repeat' in every call!
-    #   (Ok, just the variable, still a test every call)
-    # - Fails for 'num == 0' because of undefined 'str'.
-
-    proc textutil::repeat::StrRepeat { char num } {
-	variable HaveBuiltin
-	if { $HaveBuiltin == 0 } then {
-	    for { set i 0 } { $i < $num } { incr i } {
-		append str $char
-	    }
-	} else {
-	    set str [ string repeat $char $num ]
-	}
-	return $str
-    }
-}
-
-if {$::textutil::repeat::HaveBuiltin} {
-    proc ::textutil::repeat::strRepeat {char num} {
-	return [string repeat $char $num]
-    }
-
-    proc ::textutil::repeat::blank {n} {
-	return [string repeat " " $n]
-    }
-} else {
-    proc ::textutil::repeat::strRepeat {char num} {
-	if {$num <= 0} {
-	    # No replication required
-	    return ""
-	} elseif {$num == 1} {
-	    # Quick exit for recursion
-	    return $char
-	} elseif {$num == 2} {
-	    # Another quick exit for recursion
-	    return $char$char
-	} elseif {0 == ($num % 2)} {
-	    # Halving the problem results in O (log n) complexity.
-	    set result [strRepeat $char [expr {$num / 2}]]
-	    return "$result$result"
-	} else {
-	    # Uneven length, reduce problem by one
-	    return "$char[strRepeat $char [incr num -1]]"
-	}
-    }
-
-    proc ::textutil::repeat::blank {n} {
-	return [strRepeat " " $n]
-    }
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::repeat {
-    namespace export strRepeat blank
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::repeat 0.7
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/split-0.8.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/split-0.8.tm
deleted file mode 100644
index 18ee13b5..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/split-0.8.tm
+++ /dev/null
@@ -1,176 +0,0 @@
-# split.tcl --
-#
-#	Various ways of splitting a string.
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2001      by Reinhard Max <max@suse.de>
-# Copyright (c) 2003      by Pat Thoyts <patthoyts@users.sourceforge.net>
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-# 
-# RCS: @(#) $Id: split.tcl,v 1.7 2006/04/21 04:42:28 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil::split {}
-
-########################################################################
-# This one was written by Bob Techentin (RWT in Tcl'ers Wiki):
-# http://www.techentin.net
-# mailto:techentin.robert@mayo.edu
-#
-# Later, he send me an email stated that I can use it anywhere, because
-# no copyright was added, so the code is defacto in the public domain.
-#
-# You can found it in the Tcl'ers Wiki here:
-# http://mini.net/cgi-bin/wikit/460.html
-#
-# Bob wrote:
-# If you need to split string into list using some more complicated rule
-# than builtin split command allows, use following function. It mimics
-# Perl split operator which allows regexp as element separator, but,
-# like builtin split, it expects string to split as first arg and regexp
-# as second (optional) By default, it splits by any amount of whitespace. 
-# Note that if you add parenthesis into regexp, parenthesed part of separator
-# would be added into list as additional element. Just like in Perl. -- cary 
-#
-# Speed improvement by Reinhard Max:
-# Instead of repeatedly copying around the not yet matched part of the
-# string, I use [regexp]'s -start option to restrict the match to that
-# part. This reduces the complexity from something like O(n^1.5) to
-# O(n). My test case for that was:
-# 
-# foreach i {1 10 100 1000 10000} {
-#     set s [string repeat x $i]
-#     puts [time {splitx $s .}]
-# }
-#
-
-if {[package vsatisfies [package provide Tcl] 8.3]} {
-
-    proc ::textutil::split::splitx {str {regexp {[\t \r\n]+}}} {
-        # Bugfix 476988
-        if {[string length $str] == 0} {
-            return {}
-        }
-        if {[string length $regexp] == 0} {
-            return [::split $str ""]
-        }
-	if {[regexp $regexp {}]} {
-	    return -code error \
-		"splitting on regexp \"$regexp\" would cause infinite loop"
-	}
-
-        set list  {}
-        set start 0
-        while {[regexp -start $start -indices -- $regexp $str match submatch]} {
-            foreach {subStart subEnd} $submatch break
-            foreach {matchStart matchEnd} $match break
-            incr matchStart -1
-            incr matchEnd
-            lappend list [string range $str $start $matchStart]
-            if {$subStart >= $start} {
-                lappend list [string range $str $subStart $subEnd]
-            }
-            set start $matchEnd
-        }
-        lappend list [string range $str $start end]
-        return $list
-    }
-
-} else {    
-    # For tcl <= 8.2 we do not have regexp -start...
-    proc ::textutil::split::splitx [list str [list regexp "\[\t \r\n\]+"]] {
-
-        if {[string length $str] == 0} {
-            return {}
-        }
-        if {[string length $regexp] == 0} {
-            return [::split $str {}]
-        }
-	if {[regexp $regexp {}]} {
-	    return -code error \
-		"splitting on regexp \"$regexp\" would cause infinite loop"
-	}
-
-        set list  {}
-        while {[regexp -indices -- $regexp $str match submatch]} {
-            lappend list [string range $str 0 [expr {[lindex $match 0] -1}]]
-            if {[lindex $submatch 0] >= 0} {
-                lappend list [string range $str [lindex $submatch 0] \
-                                  [lindex $submatch 1]]
-            }
-            set str [string range $str [expr {[lindex $match 1]+1}] end]
-        }
-        lappend list $str
-        return $list
-    }
-    
-}
-
-#
-# splitn --
-#
-# splitn splits the string $str into chunks of length $len.  These
-# chunks are returned as a list.
-#
-# If $str really contains a ByteArray object (as retrieved from binary
-# encoded channels) splitn must honor this by splitting the string
-# into chunks of $len bytes.
-#
-# It is an error to call splitn with a nonpositive $len.
-#
-# If splitn is called with an empty string, it returns the empty list.
-#
-# If the length of $str is not an entire multiple of the chunk length,
-# the last chunk in the generated list will be shorter than $len.
-#
-# The implementation presented here was given by Bryan Oakley, as
-# part of a ``contest'' I staged on c.l.t in July 2004.  I selected
-# this version, as it does not rely on runtime generated code, is
-# very fast for chunk size one, not too bad in all the other cases,
-# and uses [split] or [string range] which have been around for quite
-# some time.
-#
-# -- Robert Suetterlin (robert@mpe.mpg.de)
-#
-proc ::textutil::split::splitn {str {len 1}} {
-
-    if {$len <= 0} {
-        return -code error "len must be > 0"
-    }
-
-    if {$len == 1} {
-        return [split $str {}]
-    }
-
-    set result [list]
-    set max [string length $str]
-    set i 0
-    set j [expr {$len -1}]
-    while {$i < $max} {
-        lappend result [string range $str $i $j]
-        incr i $len
-        incr j $len
-    }
-
-    return $result
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::split {
-    namespace export splitx splitn
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::split 0.8
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/string-0.8.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/string-0.8.tm
deleted file mode 100644
index f1ad5a46..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/string-0.8.tm
+++ /dev/null
@@ -1,144 +0,0 @@
-# string.tcl --
-#
-#	Utilities for manipulating strings, words, single lines,
-#	paragraphs, ...
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2002      by Joe English <jenglish@users.sourceforge.net>
-# Copyright (c) 2001-2014 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-# 
-# RCS: @(#) $Id: string.tcl,v 1.2 2008/03/22 16:03:11 mic42 Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil::string {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-
-# @c Removes the last character from the given <a string>.
-#
-# @a string: The string to manipulate.
-#
-# @r The <a string> without its last character.
-#
-# @i chopping
-
-proc ::textutil::string::chop {string} {
-    return [string range $string 0 [expr {[string length $string]-2}]]
-}
-
-# @c Removes the first character from the given <a string>.
-# @c Convenience procedure.
-#
-# @a string: string to manipulate.
-#
-# @r The <a string> without its first character.
-#
-# @i tail
-
-proc ::textutil::string::tail {string} {
-    return [string range $string 1 end]
-}
-
-# @c Capitalizes first character of the given <a string>.
-# @c Complementary procedure to <p ::textutil::uncap>.
-#
-# @a string: string to manipulate.
-#
-# @r The <a string> with its first character capitalized.
-#
-# @i capitalize
-
-proc ::textutil::string::cap {string} {
-    return [string toupper [string index $string 0]][string range $string 1 end]
-}
-
-# @c unCapitalizes first character of the given <a string>.
-# @c Complementary procedure to <p ::textutil::cap>.
-#
-# @a string: string to manipulate.
-#
-# @r The <a string> with its first character uncapitalized.
-#
-# @i uncapitalize
-
-proc ::textutil::string::uncap {string} {
-    return [string tolower [string index $string 0]][string range $string 1 end]
-}
-
-# @c Capitalizes first character of each word of the given <a sentence>.
-#
-# @a sentence: string to manipulate.
-#
-# @r The <a sentence> with the first character of each word capitalized.
-#
-# @i capitalize
-
-proc ::textutil::string::capEachWord {sentence} {
-    regsub -all {\S+} [string map {\\ \\\\ \$ \\$} $sentence] {[string toupper [string index & 0]][string range & 1 end]} cmd
-    return [subst -nobackslashes -novariables $cmd]
-}
-
-# Compute the longest string which is common to all strings given to
-# the command, and at the beginning of said strings, i.e. a prefix. If
-# only one argument is specified it is treated as a list of the
-# strings to look at. If more than one argument is specified these
-# arguments are the strings to be looked at. If only one string is
-# given, in either form, the string is returned, as it is its own
-# longest common prefix.
-
-proc ::textutil::string::longestCommonPrefix {args} {
-    return [longestCommonPrefixList $args]
-}
-
-proc ::textutil::string::longestCommonPrefixList {list} {
-    if {[llength $list] <= 1} {
-	return [lindex $list 0]
-    }
-
-    set list [lsort $list]
-    set min [lindex $list 0]
-    set max [lindex $list end]
-
-    # Min and max are the two strings which are most different. If
-    # they have a common prefix, it will also be the common prefix for
-    # all of them.
-
-    # Fast bailouts for common cases.
-
-    set n [string length $min]
-    if {$n == 0} {return ""}
-    if {0 == [string compare $min $max]} {return $min}
-
-    set prefix ""
-    set i 0
-    while {[string index $min $i] == [string index $max $i]} {
-	append prefix [string index $min $i]
-	if {[incr i] > $n} {break}
-    }
-    set prefix
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::string {
-    # Export the imported commands
-
-    namespace export chop tail cap uncap capEachWord
-    namespace export longestCommonPrefix
-    namespace export longestCommonPrefixList
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::string 0.8
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/tabify-0.7.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/tabify-0.7.tm
deleted file mode 100644
index 543b96cc..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/tabify-0.7.tm
+++ /dev/null
@@ -1,289 +0,0 @@
-#
-# As the author of the procs 'tabify2' and 'untabify2' I suggest that the
-# comments explaining their behaviour be kept in this file.
-# 1) Beginners in any programming language (I am new to Tcl so I know what I
-#    am talking about) can profit enormously from studying 'correct' code.
-#    Of course comments will help a lot in this regard.
-# 2) Many problems newbies face can be solved by directing them towards
-#    available libraries - after all, libraries have been written to solve
-#    recurring problems. Then they can just use them, or have a closer look
-#    to see and to discover how things are done the 'Tcl way'.
-# 3) And if ever a proc from a library should be less than perfect, having
-#    comments explaining the behaviour of the code will surely help.
-#
-# This said, I will welcome any error reports or suggestions for improvements
-# (especially on the 'doing things the Tcl way' aspect).
-#
-# Use of these sources is licensed under the same conditions as is Tcl.
-#
-# June 2001, Helmut Giese (hgiese@ratiosoft.com)
-#
-# ----------------------------------------------------------------------------
-#
-# The original procs 'tabify' and 'untabify' each work with complete blocks
-# of $num spaces ('num' holding the tab size). While this is certainly useful
-# in some circumstances, it does not reflect the way an editor works:
-# 	Counting columns from 1, assuming a tab size of 8 and entering '12345'
-#   followed by a tab, you expect to advance to column 9. Your editor might
-#   put a tab into the file or 3 spaces, depending on its configuration.
-#	Now, on 'tabifying' you will expect to see those 3 spaces converted to a
-#	tab (and on the other hand expect the tab *at this position* to be
-#	converted to 3 spaces).
-#
-#	This behaviour is mimicked by the new procs 'tabify2' and 'untabify2'.
-#   Both have one feature in common: They accept multi-line strings (a whole
-#   file if you want to) but in order to make life simpler for the programmer,
-#   they split the incoming string into individual lines and hand each line to
-#   a proc that does the real work.
-#
-#   One design decision worth mentioning here:
-#      A single space is never converted to a tab even if its position would
-#      allow to do so.
-#   Single spaces occur very often, say in arithmetic expressions like
-#   [expr (($a + $b) * $c) < $d]. If we didn't follow the above rule we might
-#   need to replace one or more of them to tabs. However if the tab size gets
-#   changed, this expression would be formatted quite differently - which is
-#   probably not a good idea.
-#
-#   'untabifying' on the other hand might need to replace a tab with a single
-#   space: If the current position requires it, what else to do?
-#   As a consequence those two procs are unsymmetric in this aspect, but I
-#   couldn't think of a better solution. Could you?
-#
-# ----------------------------------------------------------------------------
-#
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-package require textutil::repeat
-
-namespace eval ::textutil::tabify {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-
-namespace eval ::textutil::tabify {
-    namespace import -force ::textutil::repeat::strRepeat
-}
-
-proc ::textutil::tabify::tabify { string { num 8 } } {
-    return [string map [list [MakeTabStr $num] \t] $string]
-}
-
-proc ::textutil::tabify::untabify { string { num 8 } } {
-    return [string map [list \t [MakeTabStr $num]] $string]
-}
-
-proc ::textutil::tabify::MakeTabStr { num } {
-    variable TabStr
-    variable TabLen
-
-    if { $TabLen != $num } then {
-	set TabLen $num
-	set TabStr [strRepeat " " $num]
-    }
-
-    return $TabStr
-}
-
-# ----------------------------------------------------------------------------
-#
-# tabifyLine: Works on a single line of text, replacing 'spaces at correct
-# 		positions' with tabs. $num is the requested tab size.
-#		Returns the (possibly modified) line.
-#
-# 'spaces at correct positions': Only spaces which 'fill the space' between
-# an arbitrary position and the next tab stop can be replaced. 
-# Example: With tab size 8, spaces at positions 11 - 13 will *not* be replaced,
-#          because an expansion of a tab at position 11 will jump up to 16.
-# See also the comment at the beginning of this file why single spaces are
-# *never* replaced by a tab.
-#
-# The proc works backwards, from the end of the string up to the beginning:
-#	- Set the position to start the search from ('lastPos') to 'end'.
-#	- Find the last occurrence of ' ' in 'line' with respect to 'lastPos'
-#         ('currPos' below). This is a candidate for replacement.
-#       - Find to 'currPos' the following tab stop using the expression
-#           set nextTab [expr ($currPos + $num) - ($currPos % $num)]
-#         and get the previous tab stop as well (this will be the starting 
-#         point for the next iteration).
-#	- The ' ' at 'currPos' is only a candidate for replacement if
-#	  1) it is just one position before a tab stop *and*
-#	  2) there is at least one space at its left (see comment above on not
-#	     touching an isolated space).
-#	  Continue, if any of these conditions is not met.
-#	- Determine where to put the tab (that is: how many spaces to replace?)
-#	  by stepping up to the beginning until
-#		-- you hit a non-space or
-#		-- you are at the previous tab position
-#	- Do the replacement and continue.
-#
-# This algorithm only works, if $line does not contain tabs. Otherwise our 
-# interpretation of any position beyond the tab will be wrong. (Imagine you 
-# find a ' ' at position 4 in $line. If you got 3 leading tabs, your *real*
-# position might be 25 (tab size of 8). Since in real life some strings might 
-# already contain tabs, we test for it (and eventually call untabifyLine).
-#
-
-proc ::textutil::tabify::tabifyLine { line num } {
-    if { [string first \t $line] != -1 } { 		
-	# assure array 'Spaces' is set up 'comme il faut'
-	checkArr $num
-	# remove existing tabs
-	set line [untabifyLine $line $num]
-    }
-
-    set lastPos end
-
-    while { $lastPos > 0 } {
-	set currPos [string last " " $line $lastPos]
-	if { $currPos == -1 } {
-	    # no more spaces
-	    break;
-	}
-
-	set nextTab [expr {($currPos + $num) - ($currPos % $num)}]
-	set prevTab [expr {$nextTab - $num}]
-
-	# prepare for next round: continue at 'previous tab stop - 1'
-	set lastPos [expr {$prevTab - 1}]
-
-	if { ($currPos + 1) != $nextTab } {
-	    continue			;# crit. (1)
-	}
-
-	if { [string index $line [expr {$currPos - 1}]] != " " } {
-	    continue			;# crit. (2)
-	}
-
-	# now step backwards while there are spaces
-	for {set pos [expr {$currPos - 2}]} {$pos >= $prevTab} {incr pos -1} {
-	    if { [string index $line $pos] != " " } {
-		break;
-	    }
-	}
-
-	# ... and replace them
-	set line [string replace $line [expr {$pos + 1}] $currPos \t]
-    }
-    return $line
-}
-
-#
-# Helper proc for 'untabifyLine': Checks if all needed elements of array
-# 'Spaces' exist and creates the missing ones if needed.
-#
-
-proc ::textutil::tabify::checkArr { num } {
-    variable TabLen2
-    variable Spaces
-
-    if { $num > $TabLen2 } {
-	for { set i [expr {$TabLen2 + 1}] } { $i <= $num } { incr i } {
-	    set Spaces($i) [strRepeat " " $i]
-	}
-	set TabLen2 $num
-    }
-}
-
-
-# untabifyLine: Works on a single line of text, replacing tabs with enough
-#		spaces to get to the next tab position.
-#		Returns the (possibly modified) line.
-#
-# The procedure is straight forward:
-#	- Find the next tab.
-#	- Calculate the next tab position following it.
-#	- Delete the tab and insert as many spaces as needed to get there.
-#
-
-proc ::textutil::tabify::untabifyLine { line num } {
-    variable Spaces
-
-    set currPos 0
-    while { 1 } {
-	set currPos [string first \t $line $currPos]
-	if { $currPos == -1 } {
-	    # no more tabs
-	    break
-	}
-
-	# how far is the next tab position ?
-	set dist [expr {$num - ($currPos % $num)}]
-	# replace '\t' at $currPos with $dist spaces
-	set line [string replace $line $currPos $currPos $Spaces($dist)]
-
-	# set up for next round (not absolutely necessary but maybe a trifle
-	# more efficient)
-	incr currPos $dist
-    }
-    return $line
-}
-
-# tabify2: Replace all 'appropriate' spaces as discussed above with tabs.
-#	'string' might hold any number of lines, 'num' is the requested tab size.
-#	Returns (possibly modified) 'string'.
-#
-proc ::textutil::tabify::tabify2 { string { num 8 } } {
-
-    # split string into individual lines
-    set inLst [split $string \n]
-
-    # now work on each line
-    set outLst [list]
-    foreach line $inLst {
-	lappend outLst [tabifyLine $line $num]
-    }
-
-    # return all as one string
-    return [join $outLst \n]
-}
-
-
-# untabify2: Replace all tabs with the appropriate number of spaces.
-#	'string' might hold any number of lines, 'num' is the requested tab size.
-#	Returns (possibly modified) 'string'.
-#
-proc ::textutil::tabify::untabify2 { string { num 8 } } {
-
-    # assure array 'Spaces' is set up 'comme il faut'
-    checkArr $num
-
-    set inLst [split $string \n]
-
-    set outLst [list]
-    foreach line $inLst {
-	lappend outLst [untabifyLine $line $num]
-    }
-
-    return [join $outLst \n]
-}
-
-
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::tabify {
-    variable TabLen  8
-    variable TabStr  [strRepeat " " $TabLen]
-
-    namespace export tabify untabify tabify2 untabify2
-    
-    # The proc 'untabify2' uses the following variables for efficiency.
-    # Since a tab can be replaced by one up to 'tab size' spaces, it is handy
-    # to have the appropriate 'space strings' available. This is the use of
-    # the array 'Spaces', where 'Spaces(n)' contains just 'n' spaces.
-    # The variable 'TabLen2' remembers the biggest tab size used.
-
-    variable  TabLen2 0
-    variable  Spaces
-    array set Spaces {0 ""}
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::tabify 0.7
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/trim-0.7.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/trim-0.7.tm
deleted file mode 100644
index 4aab0765..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/trim-0.7.tm
+++ /dev/null
@@ -1,112 +0,0 @@
-# trim.tcl --
-#
-#	Various ways of trimming a string.
-#
-# Copyright (c) 2000      by Ajuba Solutions.
-# Copyright (c) 2000      by Eric Melski <ericm@ajubasolutions.com>
-# Copyright (c) 2001-2006 by Andreas Kupries <andreas_kupries@users.sourceforge.net>
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-# 
-# RCS: @(#) $Id: trim.tcl,v 1.5 2006/04/21 04:42:28 andreas_kupries Exp $
-
-# ### ### ### ######### ######### #########
-## Requirements
-
-package require Tcl 8.2
-
-namespace eval ::textutil::trim {}
-
-# ### ### ### ######### ######### #########
-## API implementation
-
-proc ::textutil::trim::trimleft {text {trim "[ \t]+"}} {
-    regsub -line -all -- [MakeStr $trim left] $text {} text
-    return $text
-}
-
-proc ::textutil::trim::trimright {text {trim "[ \t]+"}} {
-    regsub -line -all -- [MakeStr $trim right] $text {} text
-    return $text
-}
-
-proc ::textutil::trim::trim {text {trim "[ \t]+"}} {
-    regsub -line -all -- [MakeStr $trim left]  $text {} text
-    regsub -line -all -- [MakeStr $trim right] $text {} text
-    return $text
-}
-
-
-
-# @c Strips <a prefix> from <a text>, if found at its start.
-#
-# @a text: The string to check for <a prefix>.
-# @a prefix: The string to remove from <a text>.
-#
-# @r The <a text>, but without <a prefix>.
-#
-# @i remove, prefix
-
-proc ::textutil::trim::trimPrefix {text prefix} {
-    if {[string first $prefix $text] == 0} {
-	return [string range $text [string length $prefix] end]
-    } else {
-	return $text
-    }
-}
-
-
-# @c Removes the Heading Empty Lines of <a text>.
-#
-# @a text: The text block to manipulate.
-#
-# @r The <a text>, but without heading empty lines.
-#
-# @i remove, empty lines
-
-proc ::textutil::trim::trimEmptyHeading {text} {
-    regsub -- "^(\[ \t\]*\n)*" $text {} text
-    return $text
-}
-
-# ### ### ### ######### ######### #########
-## Helper commands. Internal
-
-proc ::textutil::trim::MakeStr { string pos }  {
-    variable StrU
-    variable StrR
-    variable StrL
-
-    if { "$string" != "$StrU" } {
-        set StrU $string
-        set StrR "(${StrU})\$"
-        set StrL "^(${StrU})"
-    }
-    if { "$pos" == "left" } {
-        return $StrL
-    }
-    if { "$pos" == "right" } {
-        return $StrR
-    }
-
-    return -code error "Panic, illegal position key \"$pos\""
-}
-
-# ### ### ### ######### ######### #########
-## Data structures
-
-namespace eval ::textutil::trim {	    
-    variable StrU "\[ \t\]+"
-    variable StrR "(${StrU})\$"
-    variable StrL "^(${StrU})"
-
-    namespace export \
-	    trim trimright trimleft \
-	    trimPrefix trimEmptyHeading
-}
-
-# ### ### ### ######### ######### #########
-## Ready
-
-package provide textutil::trim 0.7
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/wcswidth-35.1.tm b/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/wcswidth-35.1.tm
deleted file mode 100644
index 080a8814..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/textutil/wcswidth-35.1.tm
+++ /dev/null
@@ -1,772 +0,0 @@
-###
-# This file is automatically generated by the build/build.tcl file
-# based on information in the following database:
-# http://www.unicode.org/Public/UCD/latest/ucd/EastAsianWidth.txt
-#
-# (This is the 35th edition, thus version 35 for our package)
-#
-# Author: Sean Woods <yoda@etoyoc.com>
-###
-package provide textutil::wcswidth 35.1
-proc ::textutil::wcswidth_type char {
-  if {$char == 161} { return A }
-  if {$char == 164} { return A }
-  if {$char == 167} { return A }
-  if {$char == 168} { return A }
-  if {$char == 170} { return A }
-  if {$char == 173} { return A }
-  if {$char == 174} { return A }
-  if {$char == 176} { return A }
-  if {$char == 177} { return A }
-  if {$char >= 178 && $char <= 179 } { return A }
-  if {$char == 180} { return A }
-  if {$char >= 182 && $char <= 183 } { return A }
-  if {$char == 184} { return A }
-  if {$char == 185} { return A }
-  if {$char == 186} { return A }
-  if {$char >= 188 && $char <= 190 } { return A }
-  if {$char == 191} { return A }
-  if {$char == 198} { return A }
-  if {$char == 208} { return A }
-  if {$char == 215} { return A }
-  if {$char == 216} { return A }
-  if {$char >= 222 && $char <= 225 } { return A }
-  if {$char == 230} { return A }
-  if {$char >= 232 && $char <= 234 } { return A }
-  if {$char >= 236 && $char <= 237 } { return A }
-  if {$char == 240} { return A }
-  if {$char >= 242 && $char <= 243 } { return A }
-  if {$char == 247} { return A }
-  if {$char >= 248 && $char <= 250 } { return A }
-  if {$char == 252} { return A }
-  if {$char == 254} { return A }
-  if {$char == 257} { return A }
-  if {$char == 273} { return A }
-  if {$char == 275} { return A }
-  if {$char == 283} { return A }
-  if {$char >= 294 && $char <= 295 } { return A }
-  if {$char == 299} { return A }
-  if {$char >= 305 && $char <= 307 } { return A }
-  if {$char == 312} { return A }
-  if {$char >= 319 && $char <= 322 } { return A }
-  if {$char == 324} { return A }
-  if {$char >= 328 && $char <= 331 } { return A }
-  if {$char == 333} { return A }
-  if {$char >= 338 && $char <= 339 } { return A }
-  if {$char >= 358 && $char <= 359 } { return A }
-  if {$char == 363} { return A }
-  if {$char == 462} { return A }
-  if {$char == 464} { return A }
-  if {$char == 466} { return A }
-  if {$char == 468} { return A }
-  if {$char == 470} { return A }
-  if {$char == 472} { return A }
-  if {$char == 474} { return A }
-  if {$char == 476} { return A }
-  if {$char == 593} { return A }
-  if {$char == 609} { return A }
-  if {$char == 708} { return A }
-  if {$char == 711} { return A }
-  if {$char >= 713 && $char <= 715 } { return A }
-  if {$char == 717} { return A }
-  if {$char == 720} { return A }
-  if {$char >= 728 && $char <= 731 } { return A }
-  if {$char == 733} { return A }
-  if {$char == 735} { return A }
-  if {$char >= 768 && $char <= 879 } { return A }
-  if {$char >= 913 && $char <= 929 } { return A }
-  if {$char >= 931 && $char <= 937 } { return A }
-  if {$char >= 945 && $char <= 961 } { return A }
-  if {$char >= 963 && $char <= 969 } { return A }
-  if {$char == 1025} { return A }
-  if {$char >= 1040 && $char <= 1103 } { return A }
-  if {$char == 1105} { return A }
-  if {$char >= 4352 && $char <= 4447 } { return W }
-  if {$char == 8208} { return A }
-  if {$char >= 8211 && $char <= 8213 } { return A }
-  if {$char == 8214} { return A }
-  if {$char == 8216} { return A }
-  if {$char == 8217} { return A }
-  if {$char == 8220} { return A }
-  if {$char == 8221} { return A }
-  if {$char >= 8224 && $char <= 8226 } { return A }
-  if {$char >= 8228 && $char <= 8231 } { return A }
-  if {$char == 8240} { return A }
-  if {$char >= 8242 && $char <= 8243 } { return A }
-  if {$char == 8245} { return A }
-  if {$char == 8251} { return A }
-  if {$char == 8254} { return A }
-  if {$char == 8308} { return A }
-  if {$char == 8319} { return A }
-  if {$char >= 8321 && $char <= 8324 } { return A }
-  if {$char == 8361} { return H }
-  if {$char == 8364} { return A }
-  if {$char == 8451} { return A }
-  if {$char == 8453} { return A }
-  if {$char == 8457} { return A }
-  if {$char == 8467} { return A }
-  if {$char == 8470} { return A }
-  if {$char >= 8481 && $char <= 8482 } { return A }
-  if {$char == 8486} { return A }
-  if {$char == 8491} { return A }
-  if {$char >= 8531 && $char <= 8532 } { return A }
-  if {$char >= 8539 && $char <= 8542 } { return A }
-  if {$char >= 8544 && $char <= 8555 } { return A }
-  if {$char >= 8560 && $char <= 8569 } { return A }
-  if {$char == 8585} { return A }
-  if {$char >= 8592 && $char <= 8596 } { return A }
-  if {$char >= 8597 && $char <= 8601 } { return A }
-  if {$char >= 8632 && $char <= 8633 } { return A }
-  if {$char == 8658} { return A }
-  if {$char == 8660} { return A }
-  if {$char == 8679} { return A }
-  if {$char == 8704} { return A }
-  if {$char >= 8706 && $char <= 8707 } { return A }
-  if {$char >= 8711 && $char <= 8712 } { return A }
-  if {$char == 8715} { return A }
-  if {$char == 8719} { return A }
-  if {$char == 8721} { return A }
-  if {$char == 8725} { return A }
-  if {$char == 8730} { return A }
-  if {$char >= 8733 && $char <= 8736 } { return A }
-  if {$char == 8739} { return A }
-  if {$char == 8741} { return A }
-  if {$char >= 8743 && $char <= 8748 } { return A }
-  if {$char == 8750} { return A }
-  if {$char >= 8756 && $char <= 8759 } { return A }
-  if {$char >= 8764 && $char <= 8765 } { return A }
-  if {$char == 8776} { return A }
-  if {$char == 8780} { return A }
-  if {$char == 8786} { return A }
-  if {$char >= 8800 && $char <= 8801 } { return A }
-  if {$char >= 8804 && $char <= 8807 } { return A }
-  if {$char >= 8810 && $char <= 8811 } { return A }
-  if {$char >= 8814 && $char <= 8815 } { return A }
-  if {$char >= 8834 && $char <= 8835 } { return A }
-  if {$char >= 8838 && $char <= 8839 } { return A }
-  if {$char == 8853} { return A }
-  if {$char == 8857} { return A }
-  if {$char == 8869} { return A }
-  if {$char == 8895} { return A }
-  if {$char == 8978} { return A }
-  if {$char >= 8986 && $char <= 8987 } { return W }
-  if {$char == 9001} { return W }
-  if {$char == 9002} { return W }
-  if {$char >= 9193 && $char <= 9196 } { return W }
-  if {$char == 9200} { return W }
-  if {$char == 9203} { return W }
-  if {$char >= 9312 && $char <= 9371 } { return A }
-  if {$char >= 9372 && $char <= 9449 } { return A }
-  if {$char >= 9451 && $char <= 9471 } { return A }
-  if {$char >= 9472 && $char <= 9547 } { return A }
-  if {$char >= 9552 && $char <= 9587 } { return A }
-  if {$char >= 9600 && $char <= 9615 } { return A }
-  if {$char >= 9618 && $char <= 9621 } { return A }
-  if {$char >= 9632 && $char <= 9633 } { return A }
-  if {$char >= 9635 && $char <= 9641 } { return A }
-  if {$char >= 9650 && $char <= 9651 } { return A }
-  if {$char == 9654} { return A }
-  if {$char == 9655} { return A }
-  if {$char >= 9660 && $char <= 9661 } { return A }
-  if {$char == 9664} { return A }
-  if {$char == 9665} { return A }
-  if {$char >= 9670 && $char <= 9672 } { return A }
-  if {$char == 9675} { return A }
-  if {$char >= 9678 && $char <= 9681 } { return A }
-  if {$char >= 9698 && $char <= 9701 } { return A }
-  if {$char == 9711} { return A }
-  if {$char >= 9725 && $char <= 9726 } { return W }
-  if {$char >= 9733 && $char <= 9734 } { return A }
-  if {$char == 9737} { return A }
-  if {$char >= 9742 && $char <= 9743 } { return A }
-  if {$char >= 9748 && $char <= 9749 } { return W }
-  if {$char == 9756} { return A }
-  if {$char == 9758} { return A }
-  if {$char == 9792} { return A }
-  if {$char == 9794} { return A }
-  if {$char >= 9800 && $char <= 9811 } { return W }
-  if {$char >= 9824 && $char <= 9825 } { return A }
-  if {$char >= 9827 && $char <= 9829 } { return A }
-  if {$char >= 9831 && $char <= 9834 } { return A }
-  if {$char >= 9836 && $char <= 9837 } { return A }
-  if {$char == 9839} { return A }
-  if {$char == 9855} { return W }
-  if {$char == 9875} { return W }
-  if {$char >= 9886 && $char <= 9887 } { return A }
-  if {$char == 9889} { return W }
-  if {$char >= 9898 && $char <= 9899 } { return W }
-  if {$char >= 9917 && $char <= 9918 } { return W }
-  if {$char == 9919} { return A }
-  if {$char >= 9924 && $char <= 9925 } { return W }
-  if {$char >= 9926 && $char <= 9933 } { return A }
-  if {$char == 9934} { return W }
-  if {$char >= 9935 && $char <= 9939 } { return A }
-  if {$char == 9940} { return W }
-  if {$char >= 9941 && $char <= 9953 } { return A }
-  if {$char == 9955} { return A }
-  if {$char >= 9960 && $char <= 9961 } { return A }
-  if {$char == 9962} { return W }
-  if {$char >= 9963 && $char <= 9969 } { return A }
-  if {$char >= 9970 && $char <= 9971 } { return W }
-  if {$char == 9972} { return A }
-  if {$char == 9973} { return W }
-  if {$char >= 9974 && $char <= 9977 } { return A }
-  if {$char == 9978} { return W }
-  if {$char >= 9979 && $char <= 9980 } { return A }
-  if {$char == 9981} { return W }
-  if {$char >= 9982 && $char <= 9983 } { return A }
-  if {$char == 9989} { return W }
-  if {$char >= 9994 && $char <= 9995 } { return W }
-  if {$char == 10024} { return W }
-  if {$char == 10045} { return A }
-  if {$char == 10060} { return W }
-  if {$char == 10062} { return W }
-  if {$char >= 10067 && $char <= 10069 } { return W }
-  if {$char == 10071} { return W }
-  if {$char >= 10102 && $char <= 10111 } { return A }
-  if {$char >= 10133 && $char <= 10135 } { return W }
-  if {$char == 10160} { return W }
-  if {$char == 10175} { return W }
-  if {$char >= 11035 && $char <= 11036 } { return W }
-  if {$char == 11088} { return W }
-  if {$char == 11093} { return W }
-  if {$char >= 11094 && $char <= 11097 } { return A }
-  if {$char >= 11904 && $char <= 11929 } { return W }
-  if {$char >= 11931 && $char <= 12019 } { return W }
-  if {$char >= 12032 && $char <= 12245 } { return W }
-  if {$char >= 12272 && $char <= 12283 } { return W }
-  if {$char == 12288} { return F }
-  if {$char >= 12289 && $char <= 12291 } { return W }
-  if {$char == 12292} { return W }
-  if {$char == 12293} { return W }
-  if {$char == 12294} { return W }
-  if {$char == 12295} { return W }
-  if {$char == 12296} { return W }
-  if {$char == 12297} { return W }
-  if {$char == 12298} { return W }
-  if {$char == 12299} { return W }
-  if {$char == 12300} { return W }
-  if {$char == 12301} { return W }
-  if {$char == 12302} { return W }
-  if {$char == 12303} { return W }
-  if {$char == 12304} { return W }
-  if {$char == 12305} { return W }
-  if {$char >= 12306 && $char <= 12307 } { return W }
-  if {$char == 12308} { return W }
-  if {$char == 12309} { return W }
-  if {$char == 12310} { return W }
-  if {$char == 12311} { return W }
-  if {$char == 12312} { return W }
-  if {$char == 12313} { return W }
-  if {$char == 12314} { return W }
-  if {$char == 12315} { return W }
-  if {$char == 12316} { return W }
-  if {$char == 12317} { return W }
-  if {$char >= 12318 && $char <= 12319 } { return W }
-  if {$char == 12320} { return W }
-  if {$char >= 12321 && $char <= 12329 } { return W }
-  if {$char >= 12330 && $char <= 12333 } { return W }
-  if {$char >= 12334 && $char <= 12335 } { return W }
-  if {$char == 12336} { return W }
-  if {$char >= 12337 && $char <= 12341 } { return W }
-  if {$char >= 12342 && $char <= 12343 } { return W }
-  if {$char >= 12344 && $char <= 12346 } { return W }
-  if {$char == 12347} { return W }
-  if {$char == 12348} { return W }
-  if {$char == 12349} { return W }
-  if {$char == 12350} { return W }
-  if {$char >= 12353 && $char <= 12438 } { return W }
-  if {$char >= 12441 && $char <= 12442 } { return W }
-  if {$char >= 12443 && $char <= 12444 } { return W }
-  if {$char >= 12445 && $char <= 12446 } { return W }
-  if {$char == 12447} { return W }
-  if {$char == 12448} { return W }
-  if {$char >= 12449 && $char <= 12538 } { return W }
-  if {$char == 12539} { return W }
-  if {$char >= 12540 && $char <= 12542 } { return W }
-  if {$char == 12543} { return W }
-  if {$char >= 12549 && $char <= 12591 } { return W }
-  if {$char >= 12593 && $char <= 12686 } { return W }
-  if {$char >= 12688 && $char <= 12689 } { return W }
-  if {$char >= 12690 && $char <= 12693 } { return W }
-  if {$char >= 12694 && $char <= 12703 } { return W }
-  if {$char >= 12704 && $char <= 12730 } { return W }
-  if {$char >= 12736 && $char <= 12771 } { return W }
-  if {$char >= 12784 && $char <= 12799 } { return W }
-  if {$char >= 12800 && $char <= 12830 } { return W }
-  if {$char >= 12832 && $char <= 12841 } { return W }
-  if {$char >= 12842 && $char <= 12871 } { return W }
-  if {$char >= 12872 && $char <= 12879 } { return A }
-  if {$char == 12880} { return W }
-  if {$char >= 12881 && $char <= 12895 } { return W }
-  if {$char >= 12896 && $char <= 12927 } { return W }
-  if {$char >= 12928 && $char <= 12937 } { return W }
-  if {$char >= 12938 && $char <= 12976 } { return W }
-  if {$char >= 12977 && $char <= 12991 } { return W }
-  if {$char >= 12992 && $char <= 13054 } { return W }
-  if {$char >= 13056 && $char <= 13311 } { return W }
-  if {$char >= 13312 && $char <= 19893 } { return W }
-  if {$char >= 19894 && $char <= 19903 } { return W }
-  if {$char >= 19968 && $char <= 40943 } { return W }
-  if {$char >= 40944 && $char <= 40959 } { return W }
-  if {$char >= 40960 && $char <= 40980 } { return W }
-  if {$char == 40981} { return W }
-  if {$char >= 40982 && $char <= 42124 } { return W }
-  if {$char >= 42128 && $char <= 42182 } { return W }
-  if {$char >= 43360 && $char <= 43388 } { return W }
-  if {$char >= 44032 && $char <= 55203 } { return W }
-  if {$char >= 57344 && $char <= 63743 } { return A }
-  if {$char >= 63744 && $char <= 64109 } { return W }
-  if {$char >= 64110 && $char <= 64111 } { return W }
-  if {$char >= 64112 && $char <= 64217 } { return W }
-  if {$char >= 64218 && $char <= 64255 } { return W }
-  if {$char >= 65024 && $char <= 65039 } { return A }
-  if {$char >= 65040 && $char <= 65046 } { return W }
-  if {$char == 65047} { return W }
-  if {$char == 65048} { return W }
-  if {$char == 65049} { return W }
-  if {$char == 65072} { return W }
-  if {$char >= 65073 && $char <= 65074 } { return W }
-  if {$char >= 65075 && $char <= 65076 } { return W }
-  if {$char == 65077} { return W }
-  if {$char == 65078} { return W }
-  if {$char == 65079} { return W }
-  if {$char == 65080} { return W }
-  if {$char == 65081} { return W }
-  if {$char == 65082} { return W }
-  if {$char == 65083} { return W }
-  if {$char == 65084} { return W }
-  if {$char == 65085} { return W }
-  if {$char == 65086} { return W }
-  if {$char == 65087} { return W }
-  if {$char == 65088} { return W }
-  if {$char == 65089} { return W }
-  if {$char == 65090} { return W }
-  if {$char == 65091} { return W }
-  if {$char == 65092} { return W }
-  if {$char >= 65093 && $char <= 65094 } { return W }
-  if {$char == 65095} { return W }
-  if {$char == 65096} { return W }
-  if {$char >= 65097 && $char <= 65100 } { return W }
-  if {$char >= 65101 && $char <= 65103 } { return W }
-  if {$char >= 65104 && $char <= 65106 } { return W }
-  if {$char >= 65108 && $char <= 65111 } { return W }
-  if {$char == 65112} { return W }
-  if {$char == 65113} { return W }
-  if {$char == 65114} { return W }
-  if {$char == 65115} { return W }
-  if {$char == 65116} { return W }
-  if {$char == 65117} { return W }
-  if {$char == 65118} { return W }
-  if {$char >= 65119 && $char <= 65121 } { return W }
-  if {$char == 65122} { return W }
-  if {$char == 65123} { return W }
-  if {$char >= 65124 && $char <= 65126 } { return W }
-  if {$char == 65128} { return W }
-  if {$char == 65129} { return W }
-  if {$char >= 65130 && $char <= 65131 } { return W }
-  if {$char >= 65281 && $char <= 65283 } { return F }
-  if {$char == 65284} { return F }
-  if {$char >= 65285 && $char <= 65287 } { return F }
-  if {$char == 65288} { return F }
-  if {$char == 65289} { return F }
-  if {$char == 65290} { return F }
-  if {$char == 65291} { return F }
-  if {$char == 65292} { return F }
-  if {$char == 65293} { return F }
-  if {$char >= 65294 && $char <= 65295 } { return F }
-  if {$char >= 65296 && $char <= 65305 } { return F }
-  if {$char >= 65306 && $char <= 65307 } { return F }
-  if {$char >= 65308 && $char <= 65310 } { return F }
-  if {$char >= 65311 && $char <= 65312 } { return F }
-  if {$char >= 65313 && $char <= 65338 } { return F }
-  if {$char == 65339} { return F }
-  if {$char == 65340} { return F }
-  if {$char == 65341} { return F }
-  if {$char == 65342} { return F }
-  if {$char == 65343} { return F }
-  if {$char == 65344} { return F }
-  if {$char >= 65345 && $char <= 65370 } { return F }
-  if {$char == 65371} { return F }
-  if {$char == 65372} { return F }
-  if {$char == 65373} { return F }
-  if {$char == 65374} { return F }
-  if {$char == 65375} { return F }
-  if {$char == 65376} { return F }
-  if {$char == 65377} { return H }
-  if {$char == 65378} { return H }
-  if {$char == 65379} { return H }
-  if {$char >= 65380 && $char <= 65381 } { return H }
-  if {$char >= 65382 && $char <= 65391 } { return H }
-  if {$char == 65392} { return H }
-  if {$char >= 65393 && $char <= 65437 } { return H }
-  if {$char >= 65438 && $char <= 65439 } { return H }
-  if {$char >= 65440 && $char <= 65470 } { return H }
-  if {$char >= 65474 && $char <= 65479 } { return H }
-  if {$char >= 65482 && $char <= 65487 } { return H }
-  if {$char >= 65490 && $char <= 65495 } { return H }
-  if {$char >= 65498 && $char <= 65500 } { return H }
-  if {$char >= 65504 && $char <= 65505 } { return F }
-  if {$char == 65506} { return F }
-  if {$char == 65507} { return F }
-  if {$char == 65508} { return F }
-  if {$char >= 65509 && $char <= 65510 } { return F }
-  if {$char == 65512} { return H }
-  if {$char >= 65513 && $char <= 65516 } { return H }
-  if {$char >= 65517 && $char <= 65518 } { return H }
-  if {$char == 65533} { return A }
-  if {$char >= 94176 && $char <= 94177 } { return W }
-  if {$char >= 94208 && $char <= 100337 } { return W }
-  if {$char >= 100352 && $char <= 101106 } { return W }
-  if {$char >= 110592 && $char <= 110847 } { return W }
-  if {$char >= 110848 && $char <= 110878 } { return W }
-  if {$char >= 110960 && $char <= 111355 } { return W }
-  if {$char == 126980} { return W }
-  if {$char == 127183} { return W }
-  if {$char >= 127232 && $char <= 127242 } { return A }
-  if {$char >= 127248 && $char <= 127277 } { return A }
-  if {$char >= 127280 && $char <= 127337 } { return A }
-  if {$char >= 127344 && $char <= 127373 } { return A }
-  if {$char == 127374} { return W }
-  if {$char >= 127375 && $char <= 127376 } { return A }
-  if {$char >= 127377 && $char <= 127386 } { return W }
-  if {$char >= 127387 && $char <= 127404 } { return A }
-  if {$char >= 127488 && $char <= 127490 } { return W }
-  if {$char >= 127504 && $char <= 127547 } { return W }
-  if {$char >= 127552 && $char <= 127560 } { return W }
-  if {$char >= 127568 && $char <= 127569 } { return W }
-  if {$char >= 127584 && $char <= 127589 } { return W }
-  if {$char >= 127744 && $char <= 127776 } { return W }
-  if {$char >= 127789 && $char <= 127797 } { return W }
-  if {$char >= 127799 && $char <= 127868 } { return W }
-  if {$char >= 127870 && $char <= 127891 } { return W }
-  if {$char >= 127904 && $char <= 127946 } { return W }
-  if {$char >= 127951 && $char <= 127955 } { return W }
-  if {$char >= 127968 && $char <= 127984 } { return W }
-  if {$char == 127988} { return W }
-  if {$char >= 127992 && $char <= 127994 } { return W }
-  if {$char >= 127995 && $char <= 127999 } { return W }
-  if {$char >= 128000 && $char <= 128062 } { return W }
-  if {$char == 128064} { return W }
-  if {$char >= 128066 && $char <= 128252 } { return W }
-  if {$char >= 128255 && $char <= 128317 } { return W }
-  if {$char >= 128331 && $char <= 128334 } { return W }
-  if {$char >= 128336 && $char <= 128359 } { return W }
-  if {$char == 128378} { return W }
-  if {$char >= 128405 && $char <= 128406 } { return W }
-  if {$char == 128420} { return W }
-  if {$char >= 128507 && $char <= 128511 } { return W }
-  if {$char >= 128512 && $char <= 128591 } { return W }
-  if {$char >= 128640 && $char <= 128709 } { return W }
-  if {$char == 128716} { return W }
-  if {$char >= 128720 && $char <= 128722 } { return W }
-  if {$char >= 128747 && $char <= 128748 } { return W }
-  if {$char >= 128756 && $char <= 128761 } { return W }
-  if {$char >= 129296 && $char <= 129342 } { return W }
-  if {$char >= 129344 && $char <= 129392 } { return W }
-  if {$char >= 129395 && $char <= 129398 } { return W }
-  if {$char == 129402} { return W }
-  if {$char >= 129404 && $char <= 129442 } { return W }
-  if {$char >= 129456 && $char <= 129465 } { return W }
-  if {$char >= 129472 && $char <= 129474 } { return W }
-  if {$char >= 129488 && $char <= 129535 } { return W }
-  if {$char >= 131072 && $char <= 173782 } { return W }
-  if {$char >= 173783 && $char <= 173823 } { return W }
-  if {$char >= 173824 && $char <= 177972 } { return W }
-  if {$char >= 177973 && $char <= 177983 } { return W }
-  if {$char >= 177984 && $char <= 178205 } { return W }
-  if {$char >= 178206 && $char <= 178207 } { return W }
-  if {$char >= 178208 && $char <= 183969 } { return W }
-  if {$char >= 183970 && $char <= 183983 } { return W }
-  if {$char >= 183984 && $char <= 191456 } { return W }
-  if {$char >= 191457 && $char <= 194559 } { return W }
-  if {$char >= 194560 && $char <= 195101 } { return W }
-  if {$char >= 195102 && $char <= 195103 } { return W }
-  if {$char >= 195104 && $char <= 196605 } { return W }
-  if {$char >= 196608 && $char <= 262141 } { return W }
-  if {$char >= 917760 && $char <= 917999 } { return A }
-  if {$char >= 983040 && $char <= 1048573 } { return A }
-  if {$char >= 1048576 && $char <= 1114109 } { return A }
-  return N
-}
-proc ::textutil::wcswidth_char char {
-  if {$char >= 4352 && $char <= 4447 } { return 2 }
-  if {$char >= 8986 && $char <= 8987 } { return 2 }
-  if {$char == 9001} { return 2 }
-  if {$char == 9002} { return 2 }
-  if {$char >= 9193 && $char <= 9196 } { return 2 }
-  if {$char == 9200} { return 2 }
-  if {$char == 9203} { return 2 }
-  if {$char >= 9725 && $char <= 9726 } { return 2 }
-  if {$char >= 9748 && $char <= 9749 } { return 2 }
-  if {$char >= 9800 && $char <= 9811 } { return 2 }
-  if {$char == 9855} { return 2 }
-  if {$char == 9875} { return 2 }
-  if {$char == 9889} { return 2 }
-  if {$char >= 9898 && $char <= 9899 } { return 2 }
-  if {$char >= 9917 && $char <= 9918 } { return 2 }
-  if {$char >= 9924 && $char <= 9925 } { return 2 }
-  if {$char == 9934} { return 2 }
-  if {$char == 9940} { return 2 }
-  if {$char == 9962} { return 2 }
-  if {$char >= 9970 && $char <= 9971 } { return 2 }
-  if {$char == 9973} { return 2 }
-  if {$char == 9978} { return 2 }
-  if {$char == 9981} { return 2 }
-  if {$char == 9989} { return 2 }
-  if {$char >= 9994 && $char <= 9995 } { return 2 }
-  if {$char == 10024} { return 2 }
-  if {$char == 10060} { return 2 }
-  if {$char == 10062} { return 2 }
-  if {$char >= 10067 && $char <= 10069 } { return 2 }
-  if {$char == 10071} { return 2 }
-  if {$char >= 10133 && $char <= 10135 } { return 2 }
-  if {$char == 10160} { return 2 }
-  if {$char == 10175} { return 2 }
-  if {$char >= 11035 && $char <= 11036 } { return 2 }
-  if {$char == 11088} { return 2 }
-  if {$char == 11093} { return 2 }
-  if {$char >= 11904 && $char <= 11929 } { return 2 }
-  if {$char >= 11931 && $char <= 12019 } { return 2 }
-  if {$char >= 12032 && $char <= 12245 } { return 2 }
-  if {$char >= 12272 && $char <= 12283 } { return 2 }
-  if {$char == 12288} { return 2 }
-  if {$char >= 12289 && $char <= 12291 } { return 2 }
-  if {$char == 12292} { return 2 }
-  if {$char == 12293} { return 2 }
-  if {$char == 12294} { return 2 }
-  if {$char == 12295} { return 2 }
-  if {$char == 12296} { return 2 }
-  if {$char == 12297} { return 2 }
-  if {$char == 12298} { return 2 }
-  if {$char == 12299} { return 2 }
-  if {$char == 12300} { return 2 }
-  if {$char == 12301} { return 2 }
-  if {$char == 12302} { return 2 }
-  if {$char == 12303} { return 2 }
-  if {$char == 12304} { return 2 }
-  if {$char == 12305} { return 2 }
-  if {$char >= 12306 && $char <= 12307 } { return 2 }
-  if {$char == 12308} { return 2 }
-  if {$char == 12309} { return 2 }
-  if {$char == 12310} { return 2 }
-  if {$char == 12311} { return 2 }
-  if {$char == 12312} { return 2 }
-  if {$char == 12313} { return 2 }
-  if {$char == 12314} { return 2 }
-  if {$char == 12315} { return 2 }
-  if {$char == 12316} { return 2 }
-  if {$char == 12317} { return 2 }
-  if {$char >= 12318 && $char <= 12319 } { return 2 }
-  if {$char == 12320} { return 2 }
-  if {$char >= 12321 && $char <= 12329 } { return 2 }
-  if {$char >= 12330 && $char <= 12333 } { return 2 }
-  if {$char >= 12334 && $char <= 12335 } { return 2 }
-  if {$char == 12336} { return 2 }
-  if {$char >= 12337 && $char <= 12341 } { return 2 }
-  if {$char >= 12342 && $char <= 12343 } { return 2 }
-  if {$char >= 12344 && $char <= 12346 } { return 2 }
-  if {$char == 12347} { return 2 }
-  if {$char == 12348} { return 2 }
-  if {$char == 12349} { return 2 }
-  if {$char == 12350} { return 2 }
-  if {$char >= 12353 && $char <= 12438 } { return 2 }
-  if {$char >= 12441 && $char <= 12442 } { return 2 }
-  if {$char >= 12443 && $char <= 12444 } { return 2 }
-  if {$char >= 12445 && $char <= 12446 } { return 2 }
-  if {$char == 12447} { return 2 }
-  if {$char == 12448} { return 2 }
-  if {$char >= 12449 && $char <= 12538 } { return 2 }
-  if {$char == 12539} { return 2 }
-  if {$char >= 12540 && $char <= 12542 } { return 2 }
-  if {$char == 12543} { return 2 }
-  if {$char >= 12549 && $char <= 12591 } { return 2 }
-  if {$char >= 12593 && $char <= 12686 } { return 2 }
-  if {$char >= 12688 && $char <= 12689 } { return 2 }
-  if {$char >= 12690 && $char <= 12693 } { return 2 }
-  if {$char >= 12694 && $char <= 12703 } { return 2 }
-  if {$char >= 12704 && $char <= 12730 } { return 2 }
-  if {$char >= 12736 && $char <= 12771 } { return 2 }
-  if {$char >= 12784 && $char <= 12799 } { return 2 }
-  if {$char >= 12800 && $char <= 12830 } { return 2 }
-  if {$char >= 12832 && $char <= 12841 } { return 2 }
-  if {$char >= 12842 && $char <= 12871 } { return 2 }
-  if {$char == 12880} { return 2 }
-  if {$char >= 12881 && $char <= 12895 } { return 2 }
-  if {$char >= 12896 && $char <= 12927 } { return 2 }
-  if {$char >= 12928 && $char <= 12937 } { return 2 }
-  if {$char >= 12938 && $char <= 12976 } { return 2 }
-  if {$char >= 12977 && $char <= 12991 } { return 2 }
-  if {$char >= 12992 && $char <= 13054 } { return 2 }
-  if {$char >= 13056 && $char <= 13311 } { return 2 }
-  if {$char >= 13312 && $char <= 19893 } { return 2 }
-  if {$char >= 19894 && $char <= 19903 } { return 2 }
-  if {$char >= 19968 && $char <= 40943 } { return 2 }
-  if {$char >= 40944 && $char <= 40959 } { return 2 }
-  if {$char >= 40960 && $char <= 40980 } { return 2 }
-  if {$char == 40981} { return 2 }
-  if {$char >= 40982 && $char <= 42124 } { return 2 }
-  if {$char >= 42128 && $char <= 42182 } { return 2 }
-  if {$char >= 43360 && $char <= 43388 } { return 2 }
-  if {$char >= 44032 && $char <= 55203 } { return 2 }
-  if {$char >= 63744 && $char <= 64109 } { return 2 }
-  if {$char >= 64110 && $char <= 64111 } { return 2 }
-  if {$char >= 64112 && $char <= 64217 } { return 2 }
-  if {$char >= 64218 && $char <= 64255 } { return 2 }
-  if {$char >= 65040 && $char <= 65046 } { return 2 }
-  if {$char == 65047} { return 2 }
-  if {$char == 65048} { return 2 }
-  if {$char == 65049} { return 2 }
-  if {$char == 65072} { return 2 }
-  if {$char >= 65073 && $char <= 65074 } { return 2 }
-  if {$char >= 65075 && $char <= 65076 } { return 2 }
-  if {$char == 65077} { return 2 }
-  if {$char == 65078} { return 2 }
-  if {$char == 65079} { return 2 }
-  if {$char == 65080} { return 2 }
-  if {$char == 65081} { return 2 }
-  if {$char == 65082} { return 2 }
-  if {$char == 65083} { return 2 }
-  if {$char == 65084} { return 2 }
-  if {$char == 65085} { return 2 }
-  if {$char == 65086} { return 2 }
-  if {$char == 65087} { return 2 }
-  if {$char == 65088} { return 2 }
-  if {$char == 65089} { return 2 }
-  if {$char == 65090} { return 2 }
-  if {$char == 65091} { return 2 }
-  if {$char == 65092} { return 2 }
-  if {$char >= 65093 && $char <= 65094 } { return 2 }
-  if {$char == 65095} { return 2 }
-  if {$char == 65096} { return 2 }
-  if {$char >= 65097 && $char <= 65100 } { return 2 }
-  if {$char >= 65101 && $char <= 65103 } { return 2 }
-  if {$char >= 65104 && $char <= 65106 } { return 2 }
-  if {$char >= 65108 && $char <= 65111 } { return 2 }
-  if {$char == 65112} { return 2 }
-  if {$char == 65113} { return 2 }
-  if {$char == 65114} { return 2 }
-  if {$char == 65115} { return 2 }
-  if {$char == 65116} { return 2 }
-  if {$char == 65117} { return 2 }
-  if {$char == 65118} { return 2 }
-  if {$char >= 65119 && $char <= 65121 } { return 2 }
-  if {$char == 65122} { return 2 }
-  if {$char == 65123} { return 2 }
-  if {$char >= 65124 && $char <= 65126 } { return 2 }
-  if {$char == 65128} { return 2 }
-  if {$char == 65129} { return 2 }
-  if {$char >= 65130 && $char <= 65131 } { return 2 }
-  if {$char >= 65281 && $char <= 65283 } { return 2 }
-  if {$char == 65284} { return 2 }
-  if {$char >= 65285 && $char <= 65287 } { return 2 }
-  if {$char == 65288} { return 2 }
-  if {$char == 65289} { return 2 }
-  if {$char == 65290} { return 2 }
-  if {$char == 65291} { return 2 }
-  if {$char == 65292} { return 2 }
-  if {$char == 65293} { return 2 }
-  if {$char >= 65294 && $char <= 65295 } { return 2 }
-  if {$char >= 65296 && $char <= 65305 } { return 2 }
-  if {$char >= 65306 && $char <= 65307 } { return 2 }
-  if {$char >= 65308 && $char <= 65310 } { return 2 }
-  if {$char >= 65311 && $char <= 65312 } { return 2 }
-  if {$char >= 65313 && $char <= 65338 } { return 2 }
-  if {$char == 65339} { return 2 }
-  if {$char == 65340} { return 2 }
-  if {$char == 65341} { return 2 }
-  if {$char == 65342} { return 2 }
-  if {$char == 65343} { return 2 }
-  if {$char == 65344} { return 2 }
-  if {$char >= 65345 && $char <= 65370 } { return 2 }
-  if {$char == 65371} { return 2 }
-  if {$char == 65372} { return 2 }
-  if {$char == 65373} { return 2 }
-  if {$char == 65374} { return 2 }
-  if {$char == 65375} { return 2 }
-  if {$char == 65376} { return 2 }
-  if {$char >= 65504 && $char <= 65505 } { return 2 }
-  if {$char == 65506} { return 2 }
-  if {$char == 65507} { return 2 }
-  if {$char == 65508} { return 2 }
-  if {$char >= 65509 && $char <= 65510 } { return 2 }
-  if {$char >= 94176 && $char <= 94177 } { return 2 }
-  if {$char >= 94208 && $char <= 100337 } { return 2 }
-  if {$char >= 100352 && $char <= 101106 } { return 2 }
-  if {$char >= 110592 && $char <= 110847 } { return 2 }
-  if {$char >= 110848 && $char <= 110878 } { return 2 }
-  if {$char >= 110960 && $char <= 111355 } { return 2 }
-  if {$char == 126980} { return 2 }
-  if {$char == 127183} { return 2 }
-  if {$char == 127374} { return 2 }
-  if {$char >= 127377 && $char <= 127386 } { return 2 }
-  if {$char >= 127488 && $char <= 127490 } { return 2 }
-  if {$char >= 127504 && $char <= 127547 } { return 2 }
-  if {$char >= 127552 && $char <= 127560 } { return 2 }
-  if {$char >= 127568 && $char <= 127569 } { return 2 }
-  if {$char >= 127584 && $char <= 127589 } { return 2 }
-  if {$char >= 127744 && $char <= 127776 } { return 2 }
-  if {$char >= 127789 && $char <= 127797 } { return 2 }
-  if {$char >= 127799 && $char <= 127868 } { return 2 }
-  if {$char >= 127870 && $char <= 127891 } { return 2 }
-  if {$char >= 127904 && $char <= 127946 } { return 2 }
-  if {$char >= 127951 && $char <= 127955 } { return 2 }
-  if {$char >= 127968 && $char <= 127984 } { return 2 }
-  if {$char == 127988} { return 2 }
-  if {$char >= 127992 && $char <= 127994 } { return 2 }
-  if {$char >= 127995 && $char <= 127999 } { return 2 }
-  if {$char >= 128000 && $char <= 128062 } { return 2 }
-  if {$char == 128064} { return 2 }
-  if {$char >= 128066 && $char <= 128252 } { return 2 }
-  if {$char >= 128255 && $char <= 128317 } { return 2 }
-  if {$char >= 128331 && $char <= 128334 } { return 2 }
-  if {$char >= 128336 && $char <= 128359 } { return 2 }
-  if {$char == 128378} { return 2 }
-  if {$char >= 128405 && $char <= 128406 } { return 2 }
-  if {$char == 128420} { return 2 }
-  if {$char >= 128507 && $char <= 128511 } { return 2 }
-  if {$char >= 128512 && $char <= 128591 } { return 2 }
-  if {$char >= 128640 && $char <= 128709 } { return 2 }
-  if {$char == 128716} { return 2 }
-  if {$char >= 128720 && $char <= 128722 } { return 2 }
-  if {$char >= 128747 && $char <= 128748 } { return 2 }
-  if {$char >= 128756 && $char <= 128761 } { return 2 }
-  if {$char >= 129296 && $char <= 129342 } { return 2 }
-  if {$char >= 129344 && $char <= 129392 } { return 2 }
-  if {$char >= 129395 && $char <= 129398 } { return 2 }
-  if {$char == 129402} { return 2 }
-  if {$char >= 129404 && $char <= 129442 } { return 2 }
-  if {$char >= 129456 && $char <= 129465 } { return 2 }
-  if {$char >= 129472 && $char <= 129474 } { return 2 }
-  if {$char >= 129488 && $char <= 129535 } { return 2 }
-  if {$char >= 131072 && $char <= 173782 } { return 2 }
-  if {$char >= 173783 && $char <= 173823 } { return 2 }
-  if {$char >= 173824 && $char <= 177972 } { return 2 }
-  if {$char >= 177973 && $char <= 177983 } { return 2 }
-  if {$char >= 177984 && $char <= 178205 } { return 2 }
-  if {$char >= 178206 && $char <= 178207 } { return 2 }
-  if {$char >= 178208 && $char <= 183969 } { return 2 }
-  if {$char >= 183970 && $char <= 183983 } { return 2 }
-  if {$char >= 183984 && $char <= 191456 } { return 2 }
-  if {$char >= 191457 && $char <= 194559 } { return 2 }
-  if {$char >= 194560 && $char <= 195101 } { return 2 }
-  if {$char >= 195102 && $char <= 195103 } { return 2 }
-  if {$char >= 195104 && $char <= 196605 } { return 2 }
-  if {$char >= 196608 && $char <= 262141 } { return 2 }
-  return 1
-}
-
-proc ::textutil::wcswidth {string} {
-  set width 0
-  set len [string length $string]
-  foreach c [split $string {}] {
-    scan $c %c char
-    set n [::textutil::wcswidth_char $char]
-    if {$n < 0} {
-      return -1
-    }
-    incr width $n
-  }
-  return $width
-}
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/build.tcl b/src/modules/punk/mix/templates/layouts/project/src/build.tcl
deleted file mode 100644
index ee541f5b..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/build.tcl
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/sh
-# -*- tcl -*- \
-# 'build.tcl' name as required by kettle
-# Can be run directly - but also using `pmix Kettle ...`  or `pmix KettleShell  ...`\
-exec ./kettle -f "$0" "${1+$@}"
-kettle doc
diff --git a/src/modules/punk/mix/templates/layouts/project/src/buildsuites/samplesuite1/download_and_build.config b/src/modules/punk/mix/templates/layouts/project/src/buildsuites/samplesuite1/download_and_build.config
deleted file mode 100644
index 1e9033d5..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/buildsuites/samplesuite1/download_and_build.config
+++ /dev/null
@@ -1,57 +0,0 @@
-#=======================================================
-#configuration data for download and build of buildsuite
-#=======================================================
-#windows build mechanism: mingw64 -ucrt64 gcc
-#other platforms build mechanism: gcc
-
-
-
-#-------------------------------------------------------
-set buildprefix <PROJECTDIR>/vendorbuild/samplesuite1
-set basemakeflags [list -j 2]
-set baseconfigflags [list --enable-64bit --prefix=$buildprefix]
-set repofolder ~/.fossils
-#-------------------------------------------------------
-
-
-
-
-
-SOURCEDOWNLOAD  -project tcl\
-                -mechanism fossil\
-                -localrepo tcl.fossil\
-                -branch core-8\
-                -remote https://core.tcl-lang.org/tcl
-
-#etc.
-#SOURCEDOWNLOAD tk...
-#SOURCEDOWNLOAD thread...
-
-#SOURCEDOWNLOAD -project critcl\
-                -mechanism git\
-                -branch master\
-                -remote http://github.com/andreas-kupries/critcl
-
-#SOURCEDOWNLOAD -project tclbench\
-                -mechanism fossil\
-                -remote https://core.tcl-lang.org/tclbench
-
-#CONFIGSTART tcl <SOURCEBASE>/win
-
-#CONFIGSTART tk <SOURCEBASE>/win
-#EXTRACONFIG tk --with-tcl=$buildprefix/lib --with-tclinclude=$buildprefix/include
-
-
-#CONFIGSTART thread ???
-#EXTRACONFIG thread --with-tcl=$buildprefix/lib --with-tclinclude=$buildprefix/include
-
-
-#SOURCEDOWNLOAD -project zint\
-                -mechanism git\
-                -branch master\
-                -remote  https://git.code.sf.net/p/zint/code
-
-
-
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/include/changes.inc b/src/modules/punk/mix/templates/layouts/project/src/doc/include/changes.inc
deleted file mode 100644
index 61b7abc5..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/include/changes.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-[section Changes]
-[include changes_0.1.inc]
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/include/changes_0.1.inc b/src/modules/punk/mix/templates/layouts/project/src/doc/include/changes_0.1.inc
deleted file mode 100644
index 258ec5bd..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/include/changes_0.1.inc
+++ /dev/null
@@ -1,28 +0,0 @@
-[subsection {Changes for version 0.1}]
-
-This release 0.1 of project %project%
-
-[para]	Summary
-[list_begin enumerated]
-    [enum] feature 1
-    [enum] feature 2
-[list_end]
-
-
-[para] In detail:
-[list_begin enumerated]
-    [comment {- - -- --- ----- -------- ------------- ---------------------}]
-
-    [enum] 	%project% requires Tcl 8.6 or higher. Tcl 8.5 or less is not
-        supported.
-
-    [comment {- - -- --- ----- -------- ------------- ---------------------}]
-
-    [enum]   
-
-    [comment {- - -- --- ----- -------- ------------- ---------------------}]
-[list_end]
-
-
-
-[comment {- - -- --- ----- -------- ------------- ---------------------}]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/include/feedback.inc b/src/modules/punk/mix/templates/layouts/project/src/doc/include/feedback.inc
deleted file mode 100644
index 20f3efa2..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/include/feedback.inc
+++ /dev/null
@@ -1,18 +0,0 @@
-[comment {-*- tcl -*- --- !doctools --- manpage}]
-[comment {- - -- --- ----- -------- ------------- ---------------------}]
-[section {Bugs, Ideas, Feedback}]
-[vset project_tracker https://example.com/tracker]
-[vset project_email dev@example.com]
-
-This document, and the package it describes, will undoubtedly contain
-bugs and other problems.
-
-Please report such at the
-[uri [vset project_tracker] {%project% tracker}].
-
-Please also report any ideas for enhancements you may have for either
-package and/or documentation.
-
-Contact: [uri [vset project_email] [vset project_email]]
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/include/general.inc b/src/modules/punk/mix/templates/layouts/project/src/doc/include/general.inc
deleted file mode 100644
index 58a24967..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/include/general.inc
+++ /dev/null
@@ -1,6 +0,0 @@
-[comment {-*- tcl -*- --- !doctools --- manpage}]
-[comment {- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---}]
-[moddesc   {%project% - a Tcl project}]
-[category  {unspecified}]
-[keywords  module %project%]
-[require Tcl 8.6]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/include/punkshell.inc b/src/modules/punk/mix/templates/layouts/project/src/doc/include/punkshell.inc
deleted file mode 100644
index 3cd21ba1..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/include/punkshell.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-[comment {Please consider retaining a link to PunkShell to support the project}]
-[vset punkshell_project https://www.gitea1.intx.com.au/jn/punkshell]
-[para]   This project uses [uri [vset punkshell_project] {PunkShell}] as a deployment management and documentation tool.
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/include/welcome.inc b/src/modules/punk/mix/templates/layouts/project/src/doc/include/welcome.inc
deleted file mode 100644
index ac429065..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/include/welcome.inc
+++ /dev/null
@@ -1,6 +0,0 @@
-[comment {-*- tcl -*- --- !doctools --- manpage}]
-[comment {- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---}]
-[include welcome_basic.inc]
-
-[para] Please read the document [term {Introduction to %project%}],
-if you have not done so already, to get an overview of the whole system.
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/include/welcome_basic.inc b/src/modules/punk/mix/templates/layouts/project/src/doc/include/welcome_basic.inc
deleted file mode 100644
index b8dc5f63..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/include/welcome_basic.inc
+++ /dev/null
@@ -1,5 +0,0 @@
-[comment {-*- tcl -*- --- !doctools --- manpage}]
-[comment {- - -- --- ----- -------- ------------- ---------------------}]
-[para]
-
-Welcome to the %project% project.
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/main.man b/src/modules/punk/mix/templates/layouts/project/src/doc/main.man
deleted file mode 100644
index cf2d528c..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/main.man
+++ /dev/null
@@ -1,16 +0,0 @@
-[comment {-*- tcl -*- --- doctools ---}]
-[manpage_begin %project% n 1]
-[include include/general.inc]
-[titledesc {%project% - Core}]
-[description]
-[para]
-[include include/welcome.inc]
-[para]
-
-This document is the reference to all commands provided by %project%
-
-[include include/feedback.inc]
-
-[comment {Please consider retaining a link to PunkShell to support the project}]
-[include include/punkshell.inc]
-[manpage_end]
\ No newline at end of file
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/project_changes.man b/src/modules/punk/mix/templates/layouts/project/src/doc/project_changes.man
deleted file mode 100644
index 2302c237..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/project_changes.man
+++ /dev/null
@@ -1,13 +0,0 @@
-[comment {-*- tcl -*- doctools manpage}]
-[manpage_begin %project%__project_changes n 8]
-[include include/general.inc]
-[titledesc {%project% Changes}]
-[description]
-[include include/welcome_basic.inc]
-[para]
-This document provides an overview of the changes [package %project%]
-underwent from version to version.
-
-[include include/changes.inc]
-[include include/feedback.inc]
-[manpage_end]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/doc/project_intro.man b/src/modules/punk/mix/templates/layouts/project/src/doc/project_intro.man
deleted file mode 100644
index c649c337..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/doc/project_intro.man
+++ /dev/null
@@ -1,15 +0,0 @@
-[comment {-*- tcl -*- doctools manpage}]
-[manpage_begin %project%__project_intro n 8]
-[include include/general.inc]
-[titledesc {Introduction to %project%}]
-[description]
-[include include/welcome_basic.inc]
-[para]
-Introduction to %project%
-
-[include include/feedback.inc]
-
-[comment {Please consider retaining a link to PunkShell to support the project}]
-[include include/punkshell.inc]
-[manpage_end]
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/embedded/README.md b/src/modules/punk/mix/templates/layouts/project/src/embedded/README.md
deleted file mode 100644
index 4f99e416..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/embedded/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Documents and help files  (for the repository website)
-These are html, markdown, manfiles etc which live within src/embedded and are intended to be checked into source control so they can form part of the online documentation available when browsing the repository.
-
-These files shouldn't be modified directly as they are built from the files in the src/doc folder 
-(Using the Kettle build system)
diff --git a/src/modules/punk/mix/templates/layouts/project/src/lib/README.md b/src/modules/punk/mix/templates/layouts/project/src/lib/README.md
deleted file mode 100644
index 143653c4..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/lib/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-Tcl Library Source files for the project.
-
-These are Tcl packages which use the pkgIndex system.
-
-The Kettle Build tool can be used to generate pkgIndex.tcl files and install these to appropriate locations.
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/make.tcl b/src/modules/punk/mix/templates/layouts/project/src/make.tcl
deleted file mode 100644
index c01c9775..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/make.tcl
+++ /dev/null
@@ -1,989 +0,0 @@
-# tcl
-#
-#make any tclkits and modules in src and place them and associated data files/scripts in the parent folder of src.
-#e.g in 'bin' and 'modules' folders at same level as 'src' folder.
-
-set hashline "# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###"
-puts $hashline
-puts "    punkshell make script " 
-puts $hashline\n
-namespace eval ::punkmake {
-    variable scriptfolder [file normalize [file dirname [info script]]]
-    variable foldername [file tail $scriptfolder]
-    variable pkg_requirements [list]; variable pkg_missing [list];variable pkg_loaded [list]
-    variable non_help_flags [list -k]
-    variable help_flags     [list -help --help /?]
-    variable known_commands [list project get-project-info shell bootsupport]
-}
-if {"::try" ni [info commands ::try]} {
-    puts stderr "Tcl interpreter possibly too old - 'try' command not found - aborting"
-    exit 1
-}
-
-#------------------------------------------------------------------------------
-#Module loading from /src/bootsupport or src/*.vfs if script is within a .vfs folder
-#------------------------------------------------------------------------------
-#If the there is a folder  under the current directory /src/bootsupport/modules which contains .tm files 
-# - then it will attempt to preference these modules
-# This allows a source update via 'fossil update' 'git pull' etc to pull in a minimal set of support modules for the make script
-# and load these in preference to ones that may have been in the interp's tcl::tm::list or auto_path due to environment variables
-set startdir [pwd]
-if {[file exists [file join $startdir src bootsupport]]} {
-    set bootsupport_mod [file join $startdir src bootsupport modules]
-    set bootsupport_lib [file join $startdir src bootsupport lib]
-} else {
-    set bootsupport_mod [file join $startdir bootsupport modules]
-    set bootsupport_lib [file join $startdir bootsupport lib]
-}
-if {[file exists $bootsupport_mod] || [file exists $bootsupport_lib]} {
-
-    set original_tm_list [tcl::tm::list]
-    tcl::tm::remove {*}$original_tm_list
-    set original_auto_path $::auto_path
-    set ::auto_path [list $bootsupport_lib]
-
-    set support_modules [glob -nocomplain -dir $bootsupport_mod -type f -tail *.tm]
-    set tcl_core_packages [list tcl::zlib zlib tcl::oo TclOO tcl::tommath tcl::zipfs Tcl Tk] ;#packages we 
-    if {[llength $support_modules] || [llength [glob -nocomplain -dir $bootsupport_lib  -tail *]]} {
-        #only forget all *unloaded* package names
-        foreach pkg [package names] {
-            if {$pkg in $tcl_core_packages} {
-                continue
-            }
-            if {![llength [package versions $pkg]]} {
-                #puts stderr "Got no versions for pkg $pkg"
-                continue
-            }
-            if {![string length [package provide $pkg]]} {
-                #no returned version indicates it wasn't loaded - so we can forget its index
-                package forget $pkg
-            }
-        }
-        tcl::tm::add $bootsupport_mod
-    }
-
-
-    if {[file exists [pwd]/modules]} {
-        tcl::tm::add [pwd]/modules
-    }
-
-    #package require Thread
-    # - the full repl requires Threading and punk,shellfilter,shellrun to call and display properly.
-    
-    
-    # tm list already indexed - need 'package forget' to find modules based on current tcl::tm::list
-    #These are strong dependencies 
-    package forget  punk::mix
-    package require punk::mix
-    package forget  punk::repo 
-    package require punk::repo
-    package forget  punkcheck 
-    package require punkcheck
-
-
-
-    #restore module paths and auto_path in addition to the bootsupport ones
-    set tm_list_now [tcl::tm::list]
-    foreach p $original_tm_list {
-        if {$p ni $tm_list_now} {
-            tcl::tm::add $p
-        }
-    }
-    set ::auto_path [list $bootsupport_lib {*}$original_auto_path]
-    #------------------------------------------------------------------------------
-}
-
-# ** *** *** *** *** *** *** *** *** *** *** ***
-#*temporarily* hijack package command
-# ** *** *** *** *** *** *** *** *** *** *** ***
-try {
-    rename ::package ::punkmake::package_temp_aside
-    proc ::package {args} {
-        if {[lindex $args 0] eq "require"} {
-            lappend ::punkmake::pkg_requirements [lindex $args 1]
-        }
-    }
-    package require punk::mix
-    package require punk::repo
-} finally {
-    catch {rename ::package ""}
-    catch {rename ::punkmake::package_temp_aside ::package}
-}
-# ** *** *** *** *** *** *** *** *** *** *** ***
-foreach pkg $::punkmake::pkg_requirements {
-    if {[catch {package require $pkg} errM]} {
-        puts stderr "missing pkg: $pkg"
-        lappend ::punkmake::pkg_missing $pkg 
-    } else {
-        lappend ::punkmake::pkg_loaded $pkg
-    }
-}
-
-
-
-
-
-proc punkmake_gethelp {args} {
-    set scriptname [file tail [info script]]
-    append h "Usage:" \n 
-    append h "" \n
-    append h "  $scriptname -help  or $scriptname --help or $scriptname /? or just $scriptname" \n
-    append h "  - This help." \n \n
-    append h "  $scriptname project ?-k?" \n
-    append h "  - this is the literal word project - and confirms you want to run the project build" \n
-    append h "  - the optional -k flag will terminate processes running as the executable being built (if applicable)" \n \n
-    append h "  $scriptname bootsupport"  \n
-    append h "  - update the src/bootsupport modules as well as the mixtemplates/layouts/<layoutname>/src/bootsupport modules if the folder exists" \n \n
-    append h "  $scriptname get-project-info" \n
-    append h "  - show the name and base folder of the project to be built" \n
-    append h "" \n
-    if {[llength $::punkmake::pkg_missing]} {
-        append h "* ** NOTE ** ***" \n
-        append h "    punkmake has detected that the following packages could not be loaded:" \n
-        append h "    " [join $::punkmake::pkg_missing "\n    "] \n
-        append h "* ** *** *** ***" \n
-        append h "    These packages are required for punk make to function" \n \n
-        append h "* ** *** *** ***" \n\n
-        append h "Successfully Loaded packages:" \n
-        append h "    " [join $::punkmake::pkg_loaded "\n    "] \n
-    }
-    return $h
-}
-set scriptargs $::argv
-set do_help 0
-if {![llength $scriptargs]} {
-    set do_help 1
-} else {
-    foreach h $::punkmake::help_flags {
-        if {[lsearch $scriptargs $h] >= 0} {
-            set do_help 1
-            break
-        }
-    }
-}
-set commands_found [list]
-foreach a $scriptargs {
-    if {![string match -* $a]} {
-        lappend commands_found $a
-    } else {
-        if {$a ni $::punkmake::non_help_flags} {
-            set do_help 1
-        }
-    }
-}
-if {[llength $commands_found] != 1 } {
-    set do_help 1
-} elseif {[lindex $commands_found 0] ni $::punkmake::known_commands} {
-    puts stderr "Unknown command: [lindex $commands_found 0]\n\n"
-    set do_help 1
-}
-if {$do_help} {
-    puts stderr [punkmake_gethelp] 
-    exit 0
-}
-
-set ::punkmake::command [lindex $commands_found 0]
-
-
-if {[lsearch $::argv -k] >= 0} {
-    set forcekill 1
-} else {
-    set forcekill 0
-}
-#puts stdout "::argv  $::argv"
-# ----------------------------------------
-
-set scriptfolder $::punkmake::scriptfolder
-
-
-
-#first look for a project root (something under fossil or git revision control AND matches punk project folder structure)
-#If that fails - just look for a 'project shaped folder' ie meets minimum requirements of /src /src/lib /src/modules /lib /modules
-if {![string length [set projectroot [punk::repo::find_project $scriptfolder]]]} {
-    if {![string length [set projectroot [punk::repo::find_candidate $scriptfolder]]]} {
-        puts stderr "punkmake script unable to determine an approprite project root at or above the path '$scriptfolder' ensure the make script is within a project folder structure"
-        puts stderr " -aborted- "
-        exit 2
-        #todo?
-        #ask user for a project name and create basic structure?
-        #call punk::mix::cli::new $projectname on parent folder?
-    } else {
-        puts stderr "WARNING punkmake script operating in project space that is not under version control"
-    }
-} else {
-    
-}
-
-set sourcefolder $projectroot/src
-
-if {$::punkmake::command eq "get-project-info"} {
-    puts stdout "- -- --- --- --- --- --- --- --- --- ---"
-    puts stdout "- -- get-project-info -- -"
-    puts stdout "- -- --- --- --- --- --- --- --- --- ---"
-    puts stdout "- projectroot     : $projectroot"
-    if {[punk::repo::find_fossil $scriptfolder] eq $projectroot} {
-        set vc "fossil"
-        set rev [punk::repo::fossil_revision $scriptfolder]
-        set rem [punk::repo::fossil_remote $scriptfolder]
-    } elseif {[punk::repo::find_git $scriptfolder] eq $projectroot} {
-        set vc "git"
-        set rev [punk::repo::git_revision $scriptfolder]
-        set rem [punk::repo::git_remote  $scriptfolder]
-    } else {
-        set vc " - none found -"
-        set rev "n/a"
-        set remotes "n/a"
-    }
-    puts stdout "- version control : $vc"
-    puts stdout "- revision        : $rev"
-    puts stdout "- remote          : $rem"
-    puts stdout "- -- --- --- --- --- --- --- --- --- ---"
-
-    exit 0
-}
-
-if {$::punkmake::command eq "shell"} {
-    package require punk
-    package require punk::repl
-    puts stderr "make shell not fully implemented - dropping into ordinary punk shell"
-    repl::start stdin
-
-    exit 1
-}
-
-if {$::punkmake::command eq "bootsupport"} {
-    puts "projectroot: $projectroot"
-    puts "script: [info script]"
-    #puts "-- [tcl::tm::list] --"
-    puts stdout "Updating bootsupport from local files"
-
-    proc bootsupport_localupdate {projectroot} {
-        set bootsupport_modules [list]
-        set bootsupport_module_folders [list]
-        set bootsupport_config  $projectroot/src/bootsupport/include_modules.config ;#
-        if {[file exists $bootsupport_config]} {
-            set targetroot $projectroot/src/bootsupport/modules
-            source $bootsupport_config ;#populate $bootsupport_modules with project-specific list
-            if {![llength $bootsupport_modules]} {
-                puts stderr "No local bootsupport modules configured for updating"
-            } else {
-
-                if {[catch {
-                    #----------
-                    set boot_installer [punkcheck::installtrack new make.tcl $projectroot/src/bootsupport/.punkcheck]
-                    $boot_installer set_source_target $projectroot $projectroot/src/bootsupport
-                    set boot_event [$boot_installer start_event {-make_step bootsupport}]
-                    #----------
-                } errM]} {
-                    puts stderr "Unable to use punkcheck for bootsupport error: $errM"
-                    set boot_event ""
-                }
-
-                foreach {relpath module} $bootsupport_modules {
-                    set module [string trim $module :]
-                    set module_subpath [string map [list :: /] [namespace qualifiers $module]]
-                    set srclocation [file join $projectroot $relpath $module_subpath]
-                    #puts stdout "$relpath  $module $module_subpath $srclocation"
-                    set pkgmatches [glob -nocomplain -dir $srclocation -tail [namespace tail $module]-*]
-                    #lsort won't sort version numbers properly e.g with -dictionary 0.1.1 comes before 0.1
-                    if {![llength $pkgmatches]} {
-                        puts stderr "Missing source for bootsupport module $module - not found in $srclocation"
-                        continue
-                    }
-                    set latestfile [lindex $pkgmatches 0]
-                    set latestver [lindex [split [file rootname $latestfile] -] 1]
-                    foreach m $pkgmatches {
-                        lassign [split [file rootname $m] -] _pkg ver
-                        #puts "comparing $ver vs $latestver"
-                        if {[package vcompare $ver $latestver] == 1} {
-                            set latestver $ver
-                            set latestfile $m
-                        } 
-                    }
-                    set srcfile [file join $srclocation $latestfile]
-                    set tgtfile [file join $targetroot $module_subpath $latestfile]
-                    if {$boot_event ne ""} {
-                        #----------
-                        $boot_event targetset_init INSTALL   $tgtfile
-                        $boot_event targetset_addsource      $srcfile
-                        #----------
-                        if {\
-                                [llength [dict get [$boot_event targetset_source_changes] changed]]\
-                            || [llength [$boot_event get_targets_exist]] < [llength [$boot_event get_targets]]\
-                            } {
-                            file mkdir [file dirname $tgtfile] ;#ensure containing folder for target exists
-                            $boot_event targetset_started
-                            # -- --- --- --- --- ---
-                            puts "BOOTSUPPORT update: $srcfile -> $tgtfile"
-                            if {[catch {
-                                file copy -force $srcfile  $tgtfile
-                            } errM]} {
-                                $boot_event targetset_end FAILED
-                            } else {
-                                $boot_event targetset_end OK
-                            }
-                            # -- --- --- --- --- ---
-                        } else {
-                            puts -nonewline stderr "."
-                            $boot_event targetset_end SKIPPED
-                        }
-                        $boot_event end
-                    } else {
-                        file copy -force $srcfile  $tgtfile
-                    }
-                }
-                if {$boot_event ne ""} {
-                    puts \n
-                    $boot_event destroy
-                    $boot_installer destroy
-                }
-            }
-
-            foreach folder $bootsupport_module_folders {
-                #explicitly ignore punk/mix/templates folder even if specified in config. 
-                #punk/mix/templates contains modules including punk/mix/templates itself - the actual templates aren't needed for the bootsupport system,
-                # as make.tcl shouldn't be building new projects from the one being made.
-                #review.
-                #should we be autodetecting such recursive folder structures - (or is the bootsupport copying in need of a rethink?)
-                if {[string trim $folder /] eq "punk/mix/templates"} {
-                    puts stderr "IGNORING punk/mix/templates - not needed/desirable in bootsupport"
-                    continue
-                }
-                set src [file join $projectroot/modules $folder]
-                if {![file isdirectory $src]} {
-                    puts stderr "bootsupport folder not found: $src"
-                    continue
-                }
-                set tgt [file join $targetroot $folder]
-                file mkdir $tgt
-
-                puts stdout "BOOTSUPPORT non_tm_files $src - copying to $tgt (if source file changed)"
-                set overwrite "installedsourcechanged-targets"
-                set resultdict [punkcheck::install_non_tm_files $src $tgt -installer make.tcl -overwrite $overwrite -punkcheck_folder $projectroot/src/bootsupport]
-                puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-            }
-
-        }
-    }
-
-    bootsupport_localupdate $projectroot
-
-    #/modules/punk/mix/templates/layouts only applies if the project has it's own copy of the punk/mix modules. Generally this should only apply to the punkshell project itself.
-    set layout_bases [list\
-        $sourcefolder/mixtemplates/layouts\
-        $sourcefolder/modules/punk/mix/templates/layouts\
-    ]
-    foreach project_layout_base $layout_bases {
-        if {[file exists $project_layout_base]} {
-            set project_layouts [glob -nocomplain -dir $project_layout_base -type d -tail *]
-            foreach layoutname $project_layouts {
-                if {[file exists  [file join $project_layout_base $layoutname/src/bootsupport]]} {
-                    set antipaths [list\
-                        README.md\
-                    ]
-                    set sourcemodules $projectroot/src/bootsupport/modules
-                    set targetroot [file join $project_layout_base $layoutname/src/bootsupport/modules]
-                    file mkdir $targetroot
-
-                    puts stdout "BOOTSUPPORT layouts/$layoutname: copying from $sourcemodules to $targetroot (if source file changed)"
-                    set resultdict [punkcheck::install $sourcemodules $targetroot -overwrite installedsourcechanged-targets -antiglob_paths $antipaths]
-                    puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-                    flush stdout
-                }
-            }
-        } else {
-            puts stderr "No layout base at $project_layout_base"
-        }
-    }
-    puts stdout " bootsupport done "
-    flush stderr
-    flush stdout
-    #punk86 can hang if calling make.tcl via 'run' without this 'after' delay. punk87 unaffected. cause unknown.
-    #after 500
-    ::exit 0
-}
-
-
-
-if {$::punkmake::command ne "project"} {
-    puts stderr "Command $::punkmake::command not implemented - aborting."
-    flush stderr
-    after 100
-    exit 1
-}
-
-
-
-#only a single consolidated /modules folder used for target
-set target_modules_base $projectroot/modules
-file mkdir $target_modules_base
-
-#external libs and modules first - and any supporting files - no 'building' required
-if {[file exists $sourcefolder/vendorlib]} {
-    #exclude README.md from source folder - but only the root one
-    #-antiglob_paths takes relative patterns e.g
-    # */test.txt  will only match test.txt exactly one level deep.
-    # */*/*.foo will match any path ending in .foo that is exactly 2 levels deep.
-    # **/test.txt will match at any level below the root (but not in the root)
-    set antipaths [list\
-        README.md\
-    ]
-
-    puts stdout "VENDORLIB: copying from $sourcefolder/vendorlib to $projectroot/lib (if source file changed)"
-    set resultdict [punkcheck::install $sourcefolder/vendorlib $projectroot/lib -overwrite installedsourcechanged-targets -antiglob_paths $antipaths]
-    puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-
-} else {
-    puts stderr "VENDORLIB: No src/vendorlib folder found."
-}
-
-if {[file exists $sourcefolder/vendormodules]} {
-    #install .tm *and other files*
-    puts stdout "VENDORMODULES: copying from $sourcefolder/vendormodules to $target_modules_base (if source file changed)"
-    set resultdict [punkcheck::install $sourcefolder/vendormodules  $target_modules_base -installer make.tcl -overwrite installedsourcechanged-targets -antiglob_paths {README.md}]
-    puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-} else {
-    puts stderr "VENDORMODULES: No src/vendormodules folder found."
-}
-
-########################################################
-#templates
-#e.g The default project layout is mainly folder structure and readme files - but has some scripts developed under the main src that we want to sync
-#src to  src/modules/punk/mix/templates/layouts/project/src
-
-set layout_update_list    [list\
-    [list project $sourcefolder/modules/punk/mix/templates]\
-    [list basic $sourcefolder/mixtemplates]\
-    ]  
-
-foreach layoutinfo $layout_update_list {
-    lassign $layoutinfo layout templatebase
-    if {![file exists $templatebase]} {
-        continue
-    }
-    set config [dict create\
-        -make-step sync_templates\
-    ]
-    #----------
-    set tpl_installer [punkcheck::installtrack new make.tcl $templatebase/.punkcheck]
-    $tpl_installer set_source_target $sourcefolder $templatebase
-    set tpl_event [$tpl_installer start_event $config]
-    #----------
-    set pairs [list]
-    set pairs [list\
-        [list $sourcefolder/build.tcl  $templatebase/layouts/$layout/src/build.tcl]\
-        [list $sourcefolder/make.tcl  $templatebase/layouts/$layout/src/make.tcl]\
-    ]
-
-    foreach filepair $pairs {
-        lassign $filepair srcfile tgtfile
-        file mkdir [file dirname $tgtfile]
-        #----------
-        $tpl_event targetset_init INSTALL   $tgtfile
-        $tpl_event targetset_addsource      $srcfile
-        #----------
-        if {\
-               [llength [dict get [$tpl_event targetset_source_changes] changed]]\
-            || [llength [$tpl_event get_targets_exist]] < [llength [$tpl_event get_targets]]\
-            } {
-            $tpl_event targetset_started
-            # -- --- --- --- --- ---
-            puts stdout "punk module templates: Copying from $srcfile to $tgtfile"
-            if {[catch {
-                file copy -force $srcfile $tgtfile
-            } errM]} {
-                $tpl_event targetset_end FAILED -note "copy failed with err: $errM"
-            } else {
-                $tpl_event targetset_end OK -note "test"
-            }
-            # -- --- --- --- --- ---
-        } else {
-            puts stderr "."
-            $tpl_event targetset_end SKIPPED
-        }
-    }
-
-    $tpl_event end
-    $tpl_event destroy
-    $tpl_installer destroy
-}
-########################################################
-
-
-#default source module folder is at projectroot/src/modules
-#There may be multiple other src module folders at same level (e.g folder not being other special-purpose folder and not matching name vendor* that contains at least one .tm file in its root) 
-set source_module_folderlist [punk::mix::cli::lib::find_source_module_paths $projectroot]
-foreach src_module_dir $source_module_folderlist {
-    puts stderr "Processing source module dir: $src_module_dir"
-    set dirtail [file tail $src_module_dir]
-    #modules and associated files belonging to this package/app
-    set copied [punk::mix::cli::lib::build_modules_from_source_to_base $src_module_dir $target_modules_base -glob *.tm] ;#will only accept a glob ending in .tm
-    #set copied [list]
-    puts stdout "--------------------------"
-    puts stderr "Copied [llength $copied] tm modules from src/$dirtail to $target_modules_base "
-    puts stdout "--------------------------"
-
-    set overwrite "installedsourcechanged-targets"
-    #set overwrite "ALL-TARGETS"
-    puts stdout "MODULEFOLDER non_tm_files $src_module_dir - copying to $target_modules_base (if source file changed)"
-    set resultdict [punkcheck::install_non_tm_files $src_module_dir $target_modules_base -installer make.tcl -overwrite $overwrite -antiglob_paths {README.md}]
-    puts stdout [punkcheck::summarize_install_resultdict $resultdict]
-}
-
-set installername "make.tcl"
-
-# ----------------------------------------
-if {[punk::repo::is_fossil_root $projectroot]} {
-    set config [dict create\
-        -make-step configure_fossil\
-    ]
-    #----------
-    set installer [punkcheck::installtrack new $installername $projectroot/.punkcheck]
-    $installer set_source_target $projectroot $projectroot
-
-    set event [$installer start_event $config]
-    $event targetset_init VIRTUAL fossil_settings_mainmenu ;#VIRTUAL - since there is no actual target file
-    set menufile $projectroot/.fossil-custom/mainmenu
-    $event targetset_addsource $menufile
-    #----------
-
-    if {\
-            [llength [dict get [$event targetset_source_changes] changed]]\
-        } {
-        $event targetset_started
-        # -- --- --- --- --- ---
-        puts stdout "Configuring fossil setting: mainmenu from: $menufile"
-        if {[catch {
-            set fd [open $menufile r]
-            fconfigure $fd -translation binary
-            set data [read $fd]
-            close $fd
-            exec fossil settings mainmenu $data
-        } errM]} {
-            $event targetset_end FAILED -note "fossil update failed: $errM"
-        } else {
-            $event targetset_end OK
-        }
-        # -- --- --- --- --- ---
-    } else {
-        puts stderr "."
-        $event targetset_end SKIPPED
-    }
-    $event end
-    $event destroy
-    $installer destroy
-}
-
-set buildfolder [punk::mix::cli::lib::get_build_workdir $sourcefolder]
-if {$buildfolder ne "$sourcefolder/_build"} {
-    puts stderr "$sourcefolder/_build doesn't match the project buildfolder $buildfolder - check project filestructure"
-    puts stdout " -aborted- "
-    exit 2
-}
-
-
-#find runtimes
-set rtfolder $sourcefolder/runtime
-set runtimes [glob -nocomplain -dir $rtfolder -types {f x} -tail *]
-if {![llength $runtimes]} {
-    puts stderr "No executable runtimes found in $rtfolder - unable to build any .vfs folders into executables."
-    puts stderr "Add runtimes to $sourcefolder/runtime if required"
-    exit 0
-}
-
-if {[catch {exec sdx help} errM]} {
-    puts stderr "FAILED to find usable sdx command - check that sdx executable is on path"
-    puts stderr "err: $errM"
-    exit 1
-}
-
-# -- --- --- --- --- --- --- --- --- ---
-#load mapvfs.config file (if any) in runtime folder to map runtimes to vfs folders.
-#build a dict keyed on runtime executable name. 
-#If no mapfile (or no mapfile entry for that runtime) - the runtime will be paired with a matching .vfs folder in src folder.  e.g punk.exe to src/punk.vfs
-#If vfs folders or runtime executables which are explicitly listed in the mapfile don't exist - warn on stderr - but continue. if such nonexistants found; prompt user for whether to continue or abort.
-set mapfile $rtfolder/mapvfs.config
-set runtime_vfs_map [dict create]
-set vfs_runtime_map [dict create]
-if {[file exists $mapfile]} {
-    set fdmap [open $mapfile r]
-    fconfigure $fdmap -translation binary
-    set mapdata [read $fdmap]
-    close $fdmap
-    set mapdata [string map [list \r\n \n] $mapdata]
-    set missing [list]
-    foreach ln [split $mapdata \n] {
-        set ln [string trim $ln]
-        if {$ln eq "" || [string match #* $ln]} {
-            continue
-        }
-        set vfspaths [lassign $ln runtime]
-        if {[string match *.exe $runtime]} {
-            #.exe is superfluous but allowed
-            #drop windows .exe suffix so same config can work cross platform - extension will be re-added if necessary later
-            set runtime [string range $runtime 0 end-4]
-        }
-        if {$runtime ne "-"} {
-            set runtime_test $runtime
-            if {"windows" eq $::tcl_platform(platform)} {
-                set runtime_test $runtime.exe
-            }
-            if {![file exists [file join $rtfolder $runtime_test]]} {
-                puts stderr "WARNING: Missing runtime file $rtfolder/$runtime_test (line in mapvfs.config: $ln)"
-                lappend missing $runtime
-            }
-        }
-        foreach vfs $vfspaths {
-            if {![file isdirectory [file join $sourcefolder $vfs]]} {
-                puts stderr "WARNNING: Missing vfs folder [file join $sourcefolder $vfs] specified in mapvfs.config for runtime $runtime"
-                lappend missing $vfs
-            } 
-            dict lappend vfs_runtime_map $vfs $runtime
-        }
-        if {[dict exists $runtime_vfs_map $runtime]} {
-            puts stderr "CONFIG FILE ERROR. runtime: $runtime was specified more than once in $mapfile."
-            exit 3
-        }
-        dict set runtime_vfs_map $runtime $vfspaths
-    }
-    if {[llength $missing]} {
-        puts stderr "WARNING [llength $missing] missing items from $mapfile. (TODO - prompt user to continue/abort)"
-        foreach m $missing {
-            puts stderr "    $m"
-        }
-        puts stderr "continuing..."
-    }
-}
-# -- --- --- --- --- --- --- --- --- ---
-
-set vfs_folders [glob -nocomplain -dir $sourcefolder -types d -tail *.vfs]
-#add any extra .vfs folders found in runtime/mapvfs.config file (e.g myotherruntimes/something.vfs)
-foreach vfs [dict keys $vfs_runtime_map] {
-    if {$vfs ni $vfs_folders} {
-        lappend vfs_folders $vfs
-    }
-}
-if {![llength $vfs_folders]} {
-    puts stdout "No .vfs folders found at '$sourcefolder' - no kits to build"
-    puts stdout " -done- "
-    exit 0
-}
-
-set vfs_folder_changes [dict create] ;#cache whether each .vfs folder has changes so we don't re-run tests if building from same .vfs with multiple runtime executables
-
-# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-#set runtimefile [lindex $runtimes 0]
-foreach  runtimefile $runtimes {
-    #runtimefile e.g tclkit86bi.exe on windows tclkit86bi on other platforms
-
-    #sdx *may* be pointed to use the runtime we use to build the kit, or the user may manually use this runtime if they don't have tclsh
-    #sdx will complain if the same runtime is used for the shell as is used in the -runtime argument - so we make a copy (REVIEW)
-    #if {![file exists $buildfolder/buildruntime.exe]} {
-    #    file copy $rtfolder/$runtimefile $buildfolder/buildruntime.exe
-    #}
-
-    set basedir $buildfolder
-    set config [dict create\
-        -make-step copy_runtime\
-    ]
-    #----------
-    set installer [punkcheck::installtrack new $installername $basedir/.punkcheck]
-    $installer set_source_target $rtfolder $buildfolder
-    set event [$installer start_event $config]
-    $event targetset_init INSTALL $buildfolder/build_$runtimefile
-    $event targetset_addsource $rtfolder/$runtimefile
-    #----------
-
-    #set changed_unchanged [punkcheck::recordlist::file_install_record_source_changes [lindex [dict get $file_record body] end]]
-    if {\
-            [llength [dict get [$event targetset_source_changes] changed]]\
-         || [llength [$event get_targets_exist]] < [llength [$event get_targets]]\
-        } {
-        $event targetset_started
-        # -- --- --- --- --- ---
-        puts stdout "Copying runtime from $rtfolder/$runtimefile to $buildfolder/build_$runtimefile"
-        if {[catch {
-            file copy -force $rtfolder/$runtimefile $buildfolder/build_$runtimefile
-        } errM]} {
-            $event targetset_end FAILED
-        } else {
-            $event targetset_end OK
-        }
-        # -- --- --- --- --- ---
-    } else {
-        puts stderr "."
-        $event targetset_end SKIPPED
-    }
-    $event end
-
-}
-
-# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-
-#
-# loop over vfs_folders and for each one, loop over configured (or matching)  runtimes - build with sdx if source .vfs or source runtime exe has changed.
-# we are using punkcheck to install result to buildfolder so we create a .punkcheck file at the target folder to store metadata.
-# punkcheck allows us to not rely purely on timestamps (which may be unreliable)  
-#
-set startdir [pwd]
-puts stdout "Found [llength $vfs_folders] .vfs folders - building executable for each..."
-cd [file dirname $buildfolder] 
-#root folder mtime is insufficient for change detection. Tree mtime of folders only is a barely  passable mechanism for vfs change detection in some circumstances - e.g if files added/removed but never edited in place
-#a hash of full tree file & dir mtime may be more reasonable - but it remains to be seen if just tar & checksum is any/much slower.
-#Simply rebuilding all the time may be close the speed of detecting change anyway - and almost certainly much faster when there is a change.
-#Using first mtime encountered that is later than target is another option - but likely to be highly variable in speed. Last file in the tree could happen to be the latest, and this mechanism doesn't handle build on reversion to older source.
-set exe_names_seen [list]
-foreach vfs $vfs_folders {
-    
-    set vfsname [file rootname $vfs]
-    puts stdout "  Processing vfs $sourcefolder/$vfs"
-    puts stdout "  ------------------------------------"
-    set skipped_vfs_build 0
-    # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    set basedir $buildfolder
-    set config [dict create\
-        -make-step build_vfs\
-    ]
-
-    set runtimes  [list]
-    if {[dict exists $vfs_runtime_map $vfs]} {
-        set runtimes [dict get $vfs_runtime_map $vfs] ;#map dict is unsuffixed (.exe stripped or was not present)
-        if {"windows" eq $::tcl_platform(platform)} {
-            set runtimes_raw $runtimes
-            set runtimes [list]
-            foreach rt $runtimes_raw {
-                if {![string match *.exe $rt] && $rt ne "-"} {
-                    set rt $rt.exe
-                }
-                lappend runtimes $rt
-            }
-        }
-    } else {
-        #only match this vfs to a correspondingly named runtime if there was no explicit entry for that runtime
-        set matchrt [file rootname [file tail $vfs]] ;#e.g project.vfs -> project
-        if {![dict exists $runtime_vfs_map $matchrt]} {
-            if {"windows" eq $::tcl_platform(platform)} {
-                if {[file exists $rtfolder/$matchrt.exe]} {
-                    lappend runtimes $matchrt.exe
-                }
-            } else {
-                lappend runtimes $matchrt
-            }
-        }   
-    }
-    #assert $runtimes is a list of executable names suffixed with .exe if on windows - whether or not specified with .exe in the mapvfs.config
-
-
-    #todo - non kit based - zipkit?
-    # $runtimes may now include a dash entry "-" (from mapvfs.config file)
-    foreach rtname $runtimes {
-        #rtname of "-" indicates build a kit without a runtime
-
-        #first configured runtime will be the one to use the same name as .vfs folder for output executable. Additional runtimes on this .vfs will need to suffix the runtime name to disambiguate.
-        #review: This mechanism may not be great for multiplatform builds ? We may be better off consistently combining vfsname and rtname and letting a later platform-specific step choose ones to install in bin with simpler names.
-        if {$rtname eq "-"} {
-            set targetkit $vfsname.kit
-        } else {
-            if {$::tcl_platform(platform) eq "windows"} {
-                set targetkit ${vfsname}.exe
-            } else {
-                set targetkit $vfsname
-            }
-            if {$targetkit in $exe_names_seen} {
-                #more than one runtime for this .vfs 
-                set targetkit ${vfsname}_$rtname
-            }
-        }
-        lappend exe_names_seen $targetkit
-        # -- ----------
-        set vfs_installer [punkcheck::installtrack new $installername $basedir/.punkcheck]
-        $vfs_installer set_source_target $sourcefolder $buildfolder
-        set vfs_event [$vfs_installer start_event {-make-step build_vfs}]
-        $vfs_event targetset_init INSTALL $buildfolder/$targetkit
-        $vfs_event targetset_addsource $sourcefolder/$vfs
-        if {$rtname ne "-"} {
-            $vfs_event targetset_addsource $buildfolder/build_$rtname
-        }
-        # -- ----------
-
-        set changed_unchanged [$vfs_event targetset_source_changes]
-
-        if {[llength [dict get $changed_unchanged changed]] ||  [llength [$vfs_event get_targets_exist]] < [llength [$vfs_event get_targets]]} {
-            #source .vfs folder has changes
-            $vfs_event targetset_started
-            # -- --- --- --- --- ---
-
-            #use 
-            if {[file exists $buildfolder/$vfsname.new]} {
-                puts stderr "deleting existing $buildfolder/$vfsname.new"
-                file delete $buildfolder/$vfsname.new
-            }
-
-            puts stdout "building $vfsname with sdx.. vfsdir:$vfs cwd: [pwd]"
-
-
-            if {[catch {
-                if {$rtname ne "-"} {
-                    exec sdx wrap $buildfolder/$vfsname.new -vfs $sourcefolder/$vfs -runtime $buildfolder/build_$rtname -verbose
-                } else {
-                    exec sdx wrap $buildfolder/$vfsname.new -vfs $sourcefolder/$vfs  -verbose
-                }
-                } result]} {
-                if {$rtname ne "-"} {
-                    puts stderr "sdx wrap $buildfolder/$vfsname.new -vfs $sourcefolder/$vfs -runtime $buildfolder/build_$rtname -verbose failed with msg: $result"
-                } else {
-                    puts stderr "sdx wrap $buildfolder/$vfsname.new -vfs $sourcefolder/$vfs  -verbose failed with msg: $result"
-                }
-            } else {
-                puts stdout "ok - finished sdx"
-                set separator [string repeat = 40]
-                puts stdout $separator
-                puts stdout $result
-                puts stdout $separator
-            }
-
-            if {![file exists $buildfolder/$vfsname.new]} {
-                puts stderr "|err> make.tcl build didn't seem to produce output at $sourcefolder/_build/$vfsname.new"
-                $vfs_event targetset_end FAILED
-                exit 2
-            }
-
-            # -- --- ---
-            if {$::tcl_platform(platform) eq "windows"} {
-                set pscmd "tasklist"
-            } else {
-                set pscmd "ps"
-            }
-
-            #killing process doesn't apply to .kit build 
-            if {$rtname ne "-"} {
-                if {![catch {
-                        exec $pscmd | grep $vfsname
-                    } still_running]} {
-
-                    puts stdout "found $vfsname instances still running\n"
-                    set count_killed 0
-                    foreach ln [split $still_running \n] {
-                        puts stdout "    $ln"
-                        
-                        if {$::tcl_platform(platform) eq "windows"} {
-                            set pid [lindex $ln 1]
-                            if {$forcekill} {
-                                set killcmd [list taskkill /F /PID $pid]
-                            } else {
-                                set killcmd [list taskkill /PID $pid]
-                            }
-                        } else {
-                            set pid [lindex $ln 0]
-                            #review!
-                            if {$forcekill} {
-                                set killcmd [list kill -9 $pid]
-                            } else {
-                                set killcmd [list kill $pid]
-                            }
-                        }
-                        puts stdout "    pid: $pid (attempting to kill now using '$killcmd')"
-                        if {[catch {
-                                exec {*}$killcmd
-                                } errMsg]} {
-                            puts stderr "$killcmd returned an error:"
-                            puts stderr $errMsg
-                            if {!$forcekill} {
-                                puts stderr "(try '[info script] -k' option to force kill)"
-                            }
-                            #avoid exiting if the kill failure was because the task has already exited
-                            #review - *no running instance* works with windows taskkill - "*No such process*" works with kill -9 on FreeBSD and linux - other platforms?
-                            if {![string match "*no running instance*" $errMsg] && ![string match "*No such process*" $errMsg]} {
-                                exit 4
-                            }
-                        } else {
-                            puts stderr "$killcmd ran without error"
-                            incr count_killed
-                        }
-                    }
-                    if {$count_killed > 0} {
-                        puts stderr "\nKilled $count_killed processes. Waiting a short time before attempting to delete executable"
-                        after 1000
-                    }
-                } else {
-                    puts stderr "Ok.. no running '$vfsname' processes found"
-                }
-            }
-
-            if {[file exists $buildfolder/$targetkit]} {
-                puts stderr "deleting existing $buildfolder/$targetkit"
-                if {[catch {
-                    file delete $buildfolder/$targetkit
-                } msg]} {
-                    puts stderr "Failed to delete $buildfolder/$targetkit"
-                    exit 4
-                }
-            }
-            #WINDOWS filesystem 'tunneling' (file replacement within 15secs) could cause targetkit to copy ctime & shortname metadata from previous file!
-            #This is probably harmless - but worth being aware of.
-            file rename $buildfolder/$vfsname.new $buildfolder/$targetkit
-            # -- --- --- --- --- ---
-            $vfs_event targetset_end OK
-
-
-            after 200
-            set deployment_folder [file dirname $sourcefolder]/bin
-            file mkdir $deployment_folder
-
-            # -- ----------
-            set bin_installer [punkcheck::installtrack new "make.tcl" $deployment_folder/.punkcheck]
-            $bin_installer set_source_target $buildfolder $deployment_folder
-            set bin_event [$bin_installer start_event {-make-step final_kit_install}]
-            $bin_event targetset_init INSTALL $deployment_folder/$targetkit
-            #todo - move final deployment step outside of the build vfs loop? (final deployment can fail and then isn't rerun even though _build and deployed versions differ, unless .vfs modified again)
-            #set last_completion [$bin_event targetset_last_complete]
-
-            $bin_event targetset_addsource $buildfolder/$targetkit
-            $bin_event targetset_started
-            # -- ----------
-
-
-            set delete_failed 0
-            if {[file exists $deployment_folder/$targetkit]} {
-                puts stderr "deleting existing deployed at $deployment_folder/$targetkit"
-                if {[catch {
-                    file delete $deployment_folder/$targetkit
-                    } errMsg]} {
-                    puts stderr "deletion of deployed version at $deployment_folder/$targetkit failed: $errMsg"
-                    set delete_failed 1
-                }
-            }
-            if {!$delete_failed} {
-                puts stdout "copying.."
-                puts stdout "$buildfolder/$targetkit"
-                puts stdout "to:"
-                puts stdout "$deployment_folder/$targetkit"
-                after 300
-                file copy $buildfolder/$targetkit $deployment_folder/$targetkit
-                # -- ----------
-                $bin_event targetset_end OK
-                # -- ----------
-            } else {
-                $bin_event targetset_end FAILED -note "could not delete"
-                exit 5
-            }
-            $bin_event destroy
-            $bin_installer destroy
-
-        } else {
-            set skipped_vfs_build 1
-            puts stderr "."
-            puts stdout "Skipping build for vfs $vfs with runtime $rtname - no change detected"
-            $vfs_event targetset_end SKIPPED
-        }
-        $vfs_event destroy
-        $vfs_installer destroy
-    } ;#end foreach rtname in runtimes
-    # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-}
-cd $startdir
-
-puts stdout "done"
-exit 0
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/.gitignore b/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/.gitignore
deleted file mode 100644
index 4d6b6912..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/.gitignore
+++ /dev/null
@@ -1,47 +0,0 @@
-
-/bin/
-/lib/
-#The directory for compiled/built Tcl modules
-/modules/
-/vendorbuilds/
-
-#Temporary files e.g from tests
-/tmp/
-
-/logs/
-**/_aside/
-**/_build/
-scratch*
-
-#Built documentation
-/html/
-/man/
-/md/
-/doc/
-
-/test*
-
-
-#Built tclkits (if any)
-punk*.exe
-tcl*.exe
-
-#ignore fossil database files (but keep .fossil-settings and .fossil-custom in repository even if fossil not being used at your site)
-_FOSSIL_
-.fos
-.fslckout
-*.fossil
-
-#miscellaneous editor files etc 
-*.swp
-
-
-todo.txt
-
-zig-cache/
-zig-out/
-/release/
-/debug/
-/build/
-/build-*/
-/docgen_tmp/
diff --git a/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/README.md b/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/README.md
deleted file mode 100644
index 841c3dd3..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-%project%
-==============================
-
-+ 
-+ 
-
-
-About
-------------------------------
-
-+
-+
-+
diff --git a/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/src/bootsupport/modules/README.md b/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/src/bootsupport/modules/README.md
deleted file mode 100644
index 7646295d..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/src/bootsupport/modules/README.md
+++ /dev/null
@@ -1,24 +0,0 @@
-This is primarily for tcl .tm modules required for your bootstrapping/make/build process.
-It could include other files necessary for this process.
-
-The .tm modules here may be required for your build script if it intended the installation operator uses an existing tclsh or other shell as opposed to a tclkit you may have for distribution which is more likely to include necessary libraries.
-
-The modules here are loaded by your initialisation scripts and so can be a snapshot of different versions than those in your project src.
-The modules can be your own, or 3rd party such as individual items from tcllib.
-
-You can copy modules from a running punk shell to this location using the pmix command.
-
-e.g
->pmix visible_lib_copy_to_modulefolder some::module::lib bootsupport
-
-The pmix command will help you pick the latest version, and will create any necessary file structure matching the namespace of the package.
-
-e.g the result might be a file such as
-<projectname>/src/bootsupport/some/module/lib-0.1.tm 
-
-The originating library may not yet be in .tm form.
-You can copy a pkgIndex.tcl based library that is composed of a single .tcl file the same way using the above process and it will automatically name and file it appropriately but you need to check that the library doesn't require/load additional files - and that it is Tcl script only. 
-
-Always verify that the library is copyable in this manner and test in a shell with tcl::tm::path pointed to ./bootsupport  that it works.
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/src/modules/README.md b/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/src/modules/README.md
deleted file mode 100644
index 1c037091..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/mixtemplates/layouts/basic/src/modules/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
-Tcl Module Source files for the project.
-Consider using the punkshell pmix facility to create and manage these.
-
-pmix::newmodule <name> will create a basic .tm module template and assist in versioning.
-
-Tcl modules can be namespaced.
-For example 
-> pmix::newmodule mymodule::utils
-will create the new module under src/modules/mymodule/utils 
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/modules/README.md b/src/modules/punk/mix/templates/layouts/project/src/modules/README.md
deleted file mode 100644
index 1c037091..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/modules/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
-Tcl Module Source files for the project.
-Consider using the punkshell pmix facility to create and manage these.
-
-pmix::newmodule <name> will create a basic .tm module template and assist in versioning.
-
-Tcl modules can be namespaced.
-For example 
-> pmix::newmodule mymodule::utils
-will create the new module under src/modules/mymodule/utils 
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/runtime/Readme.md b/src/modules/punk/mix/templates/layouts/project/src/runtime/Readme.md
deleted file mode 100644
index 20b177b8..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/runtime/Readme.md
+++ /dev/null
@@ -1,3 +0,0 @@
-Install a tclkit runtime here by running the appropriate fetchruntime script in ../src
-
-Alternatively the runtime can be downloaded from: https://www.gitea1.intx.com.au/jn/punkbin
diff --git a/src/modules/punk/mix/templates/layouts/project/src/runtime/mapvfs.config b/src/modules/punk/mix/templates/layouts/project/src/runtime/mapvfs.config
deleted file mode 100644
index 55e44e87..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/runtime/mapvfs.config
+++ /dev/null
@@ -1,12 +0,0 @@
-##single line per runtime executable. Name of runtime followed by list of .vfs folders with path relative to src folder.
-##if runtime has no entry - it will only match a .vfs folder with a matching filename e.g runtime1.exe runtime1.vfs
-##Use a runtime with a name of dash (-) to build a .kit file from the .vfs folder using no runtime
-##examples:
-#- myproject.vfs
-## will produce myproject.kit
-#tclkit86bi.exe project1.vfs project2.vfs
-## will produce executables project1.exe & project2.exe (on windows) or project1 & project2 on other platforms
-#tclkit87bi.exe project1.vfs
-## will produce project1_tclkit87bi.exe or project1_tclkit87bi because the project1 name was already taken above
-##
-## All kits whether directly executable or not will deploy to the projects /bin folder
diff --git a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sample/pkgIndex.tcl b/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sample/pkgIndex.tcl
deleted file mode 100644
index 4239556a..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sample/pkgIndex.tcl
+++ /dev/null
@@ -1 +0,0 @@
-package ifneeded app-sample 0.1 [list source [file join $dir sample.tcl]]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sample/sample.tcl b/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sample/sample.tcl
deleted file mode 100644
index 8e4dc098..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sample/sample.tcl
+++ /dev/null
@@ -1,8 +0,0 @@
-namespace eval sample {
-    proc main {} {
-        puts stdout "[namespace current] argc $::argc  argv $::argv"
-        puts stdout "[namespace current] done"
-    }
-    main
-}
-package provide app-sample 0.1
diff --git a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sampleshell/pkgIndex.tcl b/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sampleshell/pkgIndex.tcl
deleted file mode 100644
index b1b5469a..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sampleshell/pkgIndex.tcl
+++ /dev/null
@@ -1,2 +0,0 @@
-package ifneeded app-sampleshell 0.1 [list source [file join $dir repl.tcl]]
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sampleshell/repl.tcl b/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sampleshell/repl.tcl
deleted file mode 100644
index 9b7e12a1..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/lib/app-sampleshell/repl.tcl
+++ /dev/null
@@ -1,111 +0,0 @@
-package provide app-sampleshell 1.0
-
-
-#punk linerepl launcher
-
-
-
-#------------------------------------------------------------------------------
-#Module loading
-#------------------------------------------------------------------------------
-#If the current directory contains .tm files when the punk repl starts - then it will attempt to preference them
-# - but first add our other known relative modules paths - as it won't make sense to use current directory as a modulpath if it's an ancestor of one of these..
-
-set original_tm_list [tcl::tm::list]
-tcl::tm::remove {*}$original_tm_list
-
-#tm list first added end up later in the list - and then override earlier ones if version the same - so add pwd-relative 1st to give higher priority
-#1
-if {[file exists [pwd]/modules]} {
-    catch {tcl::tm::add [pwd]/modules}
-}
-
-#2)
-if {[string match "*.vfs/*" [info script]]} {
-    #src/xxx.vfs/lib/app-punk/repl.tcl
-    #we assume if calling directly into .vfs that the user would prefer to use src/modules - so go up 4 levels
-    set modulefolder [file dirname [file dirname [file dirname [file dirname [info script]]]]]/modules
-
-} else {
-    #  .../bin/punkXX.exe  look for ../modules  (i.e modules folder at same level as bin folder)
-    set modulefolder [file dirname [file dirname [info nameofexecutable]]]/modules
-}
-
-if {[file exists $modulefolder]} {
-    tcl::tm::add $modulefolder
-} else {
-    puts stderr "Warning unable to find module folder at: $modulefolder"
-}
-
-#libs are appended to end - so add higher prioriy libraries last (opposite to modules)
-#auto_path - add exe-relative after exe-relative path
-set libfolder [file dirname [file dirname [info nameofexecutable]]]/lib
-if {[file exists $libfolder]} {
-    lappend ::auto_path $libfolder
-}
-if {[file exists [pwd]/lib]} {
-    lappend ::auto_path [pwd]/lib
-}
-
-
-#2)
-#now add current dir (if no conflict with above)
-set currentdir_modules [glob -nocomplain -dir [pwd] -type f -tail *.tm]
-set tcl_core_packages [list tcl::zlib zlib tcl::oo TclOO tcl::tommath tcl::zipfs Tcl Tk]
-if {[llength $currentdir_modules]} {
-    #only forget all *unloaded* package names if we are started in a .tm containing folder
-    foreach pkg [package names] {
-        if {$pkg in $tcl_core_packages} {
-            continue
-        }
-        if {![llength [package versions $pkg]]} {
-            #puts stderr "Got no versions for pkg $pkg"
-            continue
-        }
-        if {![string length [package provide $pkg]]} {
-            package forget $pkg
-        }
-    }
-    catch {tcl::tm::add [pwd]}
-}
-
-
-#puts stdout "$::auto_path"
-package require Thread
-#These are strong dependencies 
-# - the repl requires Threading and punk,shellfilter,shellrun to call and display properly.
-# tm list already indexed - need 'package forget' to find modules based on current tcl::tm::list
-set required [list\
-    shellfilter
-    shellrun\
-    punk\
-    ]
-
-catch {
-    foreach pkg $required {
-        package forget $pkg
-        package require $pkg
-    }
-}
-
-
-#restore module paths 
-set tm_list_now [tcl::tm::list]
-foreach p $original_tm_list {
-    if {$p ni $tm_list_now} {
-        #the prior tm paths go to the head of the list.
-        #They are processed first.. but an item of same version later in the list will override one at the head.
-        tcl::tm::add $p
-    }
-}
-#------------------------------------------------------------------------------
-
-foreach pkg $required {
-    package require $pkg
-}
-
-package require punk::repl
-repl::start stdin
-
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/main.tcl b/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/main.tcl
deleted file mode 100644
index 7220e9fd..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/main.tcl
+++ /dev/null
@@ -1,23 +0,0 @@
-
-if {[catch {package require starkit}]} {
-    #presumably running the xxx.vfs/main.tcl script using a non-starkit tclsh that doesn't have starkit lib available.. lets see if we can move forward anyway
-    lappend ::auto_path [file join [file dirname [info script]] lib]
-} else {
-    starkit::startup
-}
-
-#when run as a tclkit - the exe is mounted as a dir and Tcl's auto_execok doesn't find it
-set thisexe [file tail [info nameofexecutable]]
-set thisexeroot [file rootname $thisexe]
-set ::auto_execs($thisexeroot) [info nameofexecutable]
-if {$thisexe ne $thisexeroot} {
-    set ::auto_execs($thisexe) [info nameofexecutable]
-}
-
-if {[llength $::argv]} {
-    package require app-sample
-} else {
-    package require app-sampleshell
-    repl::start stdin
-}
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/modules/shellfilter-0.1.8.tm b/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/modules/shellfilter-0.1.8.tm
deleted file mode 100644
index 53abd15c..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/modules/shellfilter-0.1.8.tm
+++ /dev/null
@@ -1,2862 +0,0 @@
-#copyright 2023 Julian Marcel Noble
-#license: BSD (revised 3-clause)
-#
-#Note shellfilter is currently only directly useful for unidirectional channels e.g stdin,stderr,stdout, or for example fifo2 where only one direction is being used.
-#To generalize this to bidrectional channels would require shifting around read & write methods on transform objects in a very complicated manner.
-#e.g each transform would probably be a generic transform container which holds sub-objects to which read & write are indirected.
-#This is left as a future exercise...possibly it's best left as a concept for uni-directional channels anyway 
-# - as presumably the reads/writes from a bidirectional channel could be diverted off to unidirectional pipelines for processing with less work
-# (and maybe even better speed/efficiency if the data volume is asymmetrical and there is significant processing on one direction)
-#
-
-
-namespace eval shellfilter::log {
-    variable allow_adhoc_tags 0
-    variable open_logs [dict create]
-
-    #'tag' is an identifier for the log source. 
-    # each tag will use it's own thread to write to the configured log target
-    proc open {tag {settingsdict {}}} {
-        upvar ::shellfilter::sources sourcelist
-        package require shellthread
-        if {![dict exists $settingsdict -tag]} {
-            dict set settingsdict -tag $tag
-        } else {
-            if {$tag ne [dict get $settingsdict -tag]} {
-                error "shellfilter::log::open first argument tag: '$tag' does not match -tag '[dict get $settingsdict -tag]' omit -tag, or supply same value"
-            }
-        }
-        if {$tag ni $sourcelist} {
-            lappend sourcelist $tag
-        }
-
-        #note new_worker 
-        set worker_tid [shellthread::manager::new_worker $tag $settingsdict]
-        #puts stderr "shellfilter::log::open this_threadid: [thread::id] tag: $tag worker_tid: $worker_tid"
-        return $worker_tid
-    }
-    proc write {tag msg} {
-        shellthread::manager::write_log $tag $msg
-    }
-    #write_sync - synchronous processing with logging thread, slower but potentially useful for debugging/testing or forcing delay til log written
-    proc write_sync {tag msg} {
-        shellthread::manager::write_log $tag $msg -async 0
-    }
-    proc close {tag} {
-        #shellthread::manager::close_worker $tag
-        shellthread::manager::unsubscribe [list $tag]; #workertid will be added back to free list if no tags remain subscribed
-    }
-
-    #todo -implement
-    proc require_open {{is_open_required {}}} {
-        variable allow_adhoc_tags
-        if {![string length $is_open_required]} {
-            return $allow_adhoc_tags
-        } else {
-            set truevalues [list y yes true 1]
-            set falsevalues [list n no false 0]
-            if {[string tolower $is_open_required] in $truevalues} {
-                set allow_adhoc_tags 1
-            } elseif {[string tolower $is_open_required] in $falsevalues} {
-                set allow_adhoc_tags 0
-            } else {
-                error "shellfilter::log::require_open unrecognised value '$is_open_required' try one of $truevalues or $falsevalues"
-            }
-        }
-    }
-}
-namespace eval shellfilter::pipe {
-    #write channel for program. workerthread reads other end of fifo2 and writes data somewhere
-    proc open_out {tag_pipename {settingsdict {}}} {
-        package require shellthread
-        #we are only using the fifo in a single direction to pipe to another thread
-        # - so whilst wchan and rchan could theoretically each be both read & write we're only using them for one operation each
-        if {![catch {package require Memchan}]} {
-            lassign [fifo2] wchan rchan
-        } else {
-            package require tcl::chan::fifo2
-            lassign [tcl::chan::fifo2] wchan rchan
-        }
-        #default -translation for both types of fifo on windows is {auto crlf}
-        # -encoding is as per '[encoding system]' on the platform - e.g utf-8 (e.g windows when beta-utf8 enabled)
-        chan configure $wchan -buffering [dict get $settingsdict -buffering] ;#
-        #application end must not be binary for our filters to operate on it
-
-
-        #chan configure $rchan -buffering [dict get $settingsdict -buffering] -translation binary ;#works reasonably..
-        chan configure $rchan -buffering [dict get $settingsdict -buffering] -translation lf 
-
-        set worker_tid [shellthread::manager::new_worker $tag_pipename $settingsdict]
-        #puts stderr "worker_tid: $worker_tid"
-
-        #set_read_pipe does the thread::transfer of the rchan end. -buffering setting is maintained during thread transfer
-        shellthread::manager::set_pipe_read_from_client $tag_pipename $worker_tid $rchan
-
-        set pipeinfo [list localchan $wchan remotechan $rchan workertid $worker_tid direction out]
-        return $pipeinfo
-    }
-
-    #read channel for program.  workerthread writes to other end of fifo2 from whereever it's reading (stdin, file?)
-    proc open_in {tag_pipename {settingsdict {} }} {
-        package require shellthread
-        package require tcl::chan::fifo2
-        lassign [tcl::chan::fifo2] wchan rchan
-        set program_chan $rchan
-        set worker_chan $wchan
-        chan configure $worker_chan     -buffering [dict get $settingsdict -buffering]
-        chan configure $program_chan    -buffering [dict get $settingsdict -buffering]
-
-        chan configure $program_chan -blocking 0
-        chan configure $worker_chan -blocking 0
-        set worker_tid [shellthread::manager::new_worker $tag_pipename $settingsdict]
-
-        shellthread::manager::set_pipe_write_to_client $tag_pipename $worker_tid $worker_chan
-
-        set pipeinfo [list localchan $program_chan remotechan $worker_chan workertid $worker_tid direction in]
-        puts stderr "|jn>pipe::open_in returning $pipeinfo"
-        puts stderr "program_chan: [chan conf $program_chan]"
-        return $pipeinfo
-    }
-
-}
-namespace eval shellfilter::ansi2 {
-    #shellfilter::ansi procs only: adapted from ansicolor page on wiki https://wiki.tcl-lang.org/page/ANSI+color+control except where otherwise marked
-    variable test "blah\033\[1;33mETC\033\[0;mOK"
-    namespace export + = ?
-    #CSI <n> m = SGR (Select Graphic Rendition)
-    variable SGR_setting_map {
-        bold        1   dim             2   blink           5   fastblink   6   noblink     25      hide   8    normal      22
-        underline   4   doubleunderline 21  nounderline     24  strike      9   nostrike    29      italic 3    noitalic    23
-        reverse     7   noreverse       27  defaultfg       39  defaultbg   49
-        overline    53  nooverline      55  frame           51  framecircle 52  noframe     54
-    }
-    variable SGR_colour_map {
-        black       30  red             31  green           32  yellow      33  blue        4       purple 35   cyan        36      white 37
-        Black       40  Red             41  Green           42  Yellow      43  Blue        44      Purple 45   Cyan        46      White 47
-        BLACK       100 RED             101 GREEN           102 YELLOW      103 BLUE        104     PURPLE 105  CYAN        106     WHITE 107
-    }
-    variable SGR_map
-    set SGR_map [dict merge $SGR_colour_map $SGR_setting_map]
-
-    proc colourmap1 {{bgname White}} {
-        package require textblock
-
-        set bg [textblock::block 3 33 "[a+ $bgname] [a=]"]
-        set colormap ""
-        for {set i 0} {$i <= 7} {incr i} {
-            append colormap "_[a+ white bold 48\;5\;$i] $i [a=]"
-        }
-        set map1 [overtype::left -transparent _ $bg "\n$colormap"]
-        return $map1
-    }
-    proc colourmap2 {{bgname White}} {
-        package require textblock
-        set bg [textblock::block 3 39 "[a+ $bgname] [a=]"]
-        set colormap ""
-        for {set i 8} {$i <= 15} {incr i} {
-            append colormap "_[a+ black normal 48\;5\;$i] $i [a=]" ;#black normal is blacker than black bold - which often displays as a grey
-        }
-        set map2 [overtype::left -transparent _ $bg "\n$colormap"]
-        return $map2
-    }
-    proc ? {args} {
-        variable SGR_setting_map
-        variable SGR_colour_map
-
-        if {![llength $args]} {
-            set out ""
-            append out $SGR_setting_map \n
-            append out $SGR_colour_map \n
-
-            try {
-                set bgname "White"
-                set map1 [colourmap1 $bgname]
-                set map1 [overtype::centre -transparent 1 $map1 "[a= black $bgname]Standard colours[a=]"]
-                set map2 [colourmap2 $bgname]
-                set map2 [overtype::centre -transparent 1 $map2 "[a= black $bgname]High-intensity colours[a=]"]
-                append out [textblock::join [textblock::join $map1 "   "] $map2] \n
-                #append out $map1[a=] \n
-                #append out $map2[a=] \n
-
-
-
-            } on error {result options} {
-                puts stderr "Failed to draw colormap"
-                puts stderr "$result"
-            } finally {
-                return $out
-            }
-        } else {
-            set result [list]
-            set rmap [lreverse $map]
-            foreach i $args {
-                if {[string is integer -strict $i]} {
-                    if {[dict exists $rmap $i]} {
-                        lappend result $i [dict get $rmap $i]
-                    }
-                } else {
-                    if {[dict exists $map $i]} {
-                        lappend result $i [dict get $map $i]
-                    }
-                }
-            }
-            return $result
-        }
-    }
-    proc + {args} {
-        #don't disable ansi here.
-        #we want this to be available to call even if ansi is off
-        variable SGR_map
-        set t [list] 
-        foreach i $args {
-            if {[string is integer -strict $i]} {
-                lappend t $i
-            } elseif {[string first ";" $i] >=0} {
-                #literal with params
-                lappend t $i
-            } else {
-                if {[dict exists $SGR_map $i]} {
-                    lappend t [dict get $SGR_map $i]
-                } else {
-                    #accept examples for foreground
-                    #  256f-# or 256fg-# or 256f#
-                    #  rgbf-<r>-<g>-<b>  or rgbfg-<r>-<g>-<b> or rgbf<r>-<g>-<b>
-                    if {[string match -nocase "256f*" $i]} {
-                        set cc [string trim [string range $i 4 end] -gG]
-                        lappend t "38;5;$cc" 
-                    } elseif {[string match -nocase 256b* $i]} {
-                        set cc [string trim [string range $i 4 end] -gG]
-                        lappend t "48;5;$cc" 
-                    } elseif {[string match -nocase rgbf* $i]} {
-                        set rgb [string trim [string range $i 4 end] -gG]
-                        lassign [split $rgb -] r g b
-                        lappend t "38;2;$r;$g;$b"
-                    } elseif {[string match -nocase rgbb* $i]} {
-                        set rgb [string trim [string range $i 4 end] -gG]
-                        lassign [split $rgb -] r g b
-                        lappend t "48;2;$r;$g;$b"
-                    }
-                }
-            }
-        }
-        # \033 - octal.  equivalently \x1b in hex which is more common in documentation
-        if {![llength $t]} {
-            return "" ;# a+ nonexistent should return nothing rather  than a reset ( \033\[\;m  is a reset even without explicit zero(s))
-        }
-        return "\x1b\[[join $t {;}]m"
-    }
-    proc = {args} {
-        #don't disable ansi here.
-        #we want this to be available to call even if ansi is off
-        variable SGR_map
-        set t [list]
-        foreach i $args {
-            if {[string is integer -strict $i]} {
-                lappend t $i
-            } elseif {[string first ";" $i] >=0} {
-                #literal with params
-                lappend t $i
-            } else {
-                if {[dict exists $SGR_map $i]} {
-                    lappend t [dict get $SGR_map $i]
-                } else {
-                    #accept examples for foreground
-                    #  256f-# or 256fg-# or 256f#
-                    #  rgbf-<r>-<g>-<b>  or rgbfg-<r>-<g>-<b> or rgbf<r>-<g>-<b>
-                    if {[string match -nocase "256f*" $i]} {
-                        set cc [string trim [string range $i 4 end] -gG]
-                        lappend t "38;5;$cc" 
-                    } elseif {[string match -nocase 256b* $i]} {
-                        set cc [string trim [string range $i 4 end] -gG]
-                        lappend t "48;5;$cc" 
-                    } elseif {[string match -nocase rgbf* $i]} {
-                        set rgb [string trim [string range $i 4 end] -gG]
-                        lassign [split $rgb -] r g b
-                        lappend t "38;2;$r;$g;$b"
-                    } elseif {[string match -nocase rgbb* $i]} {
-                        set rgb [string trim [string range $i 4 end] -gG]
-                        lassign [split $rgb -] r g b
-                        lappend t "48;2;$r;$g;$b"
-                    }
-                }
-            }
-        }
-        # \033 - octal.  equivalently \x1b in hex which is more common in documentation
-        # empty list [a=] should do reset - same for [a= nonexistant]
-        # explicit reset at beginning of parameter list for a= (as opposed to a+)
-        set t [linsert $t 0 0]
-        return "\x1b\[[join $t {;}]m"
-    }
-
-
-}
-
-
-
-namespace eval shellfilter::ansi {
-    #maint warning - from overtype package
-    proc stripcodes {text} {
-        #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
-        dict set escape_terminals CSI [list @ \\ ^ _ ` | ~ a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z "\{" "\}"]
-        #dict set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
-        dict set escape_terminals OSC [list \007 \033\\] ;#note mix of 1 and 2-byte terminals 
-        #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-        #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-        set inputlist [split $text ""]
-        set outputlist [list] 
-
-        #self-contained 2 byte ansi escape sequences - review more?
-        set  2bytecodes_dict [dict create\
-            "reset_terminal" "\033c"\
-            "save_cursor_posn" "\u001b7"\
-            "restore_cursor_posn" "\u001b8"\
-            "cursor_up_one" "\u001bM"\
-            ]
-        set 2bytecodes [dict values $2bytecodes_dict]
-
-        set in_escapesequence 0
-        #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-        set i 0
-        foreach u $inputlist {
-            set v [lindex $inputlist $i+1]
-            set uv ${u}${v}
-            if {$in_escapesequence eq "2b"} {
-                #2nd byte - done.
-                set in_escapesequence 0
-            } elseif {$in_escapesequence != 0} {
-                set escseq [dict get $escape_terminals $in_escapesequence]
-                if {$u in $escseq} {
-                    set in_escapesequence 0
-                } elseif {$uv in $escseq} {
-                    set in_escapseequence 2b ;#flag next byte as last in sequence
-                }
-            } else {
-                #handle both 7-bit and 8-bit CSI and OSC
-                if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-                    set in_escapesequence CSI
-                } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-                    set in_escapesequence OSC
-                } elseif {$uv in $2bytecodes} {
-                    #self-contained e.g terminal reset - don't pass through.
-                    set in_escapesequence 2b
-                } else {
-                    lappend outputlist $u
-                }
-            }
-            incr i
-        }
-        return [join $outputlist ""]
-    }
-
-}
-namespace eval shellfilter::chan {
-    set testobj ::shellfilter::chan::var
-    if {$testobj ni [info commands $testobj]} {
-
-    oo::class create var {
-        variable o_datavar
-        variable o_trecord 
-        variable o_enc
-        variable o_is_junction
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            set varname [dict get $settingsdict -varname] 
-            set o_datavar $varname
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
-            } else {
-                set o_is_junction 1  ;# as a var is diversionary - default it to be a jucntion
-            }
-        }
-        method initialize {ch mode} {
-            return [list initialize finalize write]
-        }
-        method finalize {ch} {
-            my destroy
-        }
-        method watch {ch events} {
-            # must be present but we ignore it because we do not
-            # post any events
-        }
-        #method read {ch count} {
-        #  return ?
-        #}
-        method write {ch bytes} {
-            set stringdata [encoding convertfrom $o_enc $bytes]
-            append $o_datavar $stringdata
-            return ""
-        }
-        method meta_is_redirection {} {
-            return $o_is_junction 
-        }
-        method meta_buffering_supported {} {
-            return [list line full none]
-        }
-    }
-
-    #todo - something similar for multiple grep specs each with own -pre & -post .. store to dict?
-    oo::class create tee_grep_to_var {
-        variable o_datavar
-        variable o_lastxlines 
-        variable o_trecord 
-        variable o_grepfor
-        variable o_prelines
-        variable o_postlines
-        variable o_postcountdown 
-        variable o_enc
-        variable o_is_junction
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set o_lastxlines [list]
-            set o_postcountdown 0
-            set defaults [dict create -pre 1 -post 1]
-            set settingsdict [dict get $tf -settings]
-            set settings [dict merge $defaults $settingsdict]
-            set o_datavar [dict get $settings -varname]
-            set o_grepfor [dict get $settings -grep]
-            set o_prelines [dict get $settings -pre]
-            set o_postlines [dict get $settings -post]
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
-            } else {
-                set o_is_junction 0
-            }
-        }
-        method initialize {transform_handle mode} {
-            return [list initialize finalize write]
-        }
-        method finalize {transform_handle} {
-            my destroy
-        }
-        method watch {transform_handle events} {
-        }
-        #method read {transform_handle count} {
-        #  return ?
-        #}
-        method write {transform_handle bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
-            set lastx $o_lastxlines 
-            lappend o_lastxlines $logdata
-
-            if {$o_postcountdown > 0} {
-                append $o_datavar $logdata
-                if {[regexp $o_grepfor $logdata]} {
-                    #another match in postlines
-                    set o_postcountdown $o_postlines
-                } else {
-                    incr o_postcountdown -1
-                }
-            } else {
-                if {[regexp $o_grepfor $logdata]} {
-                    append $o_datavar [join $lastx]
-                    append $o_datavar $logdata
-                    set o_postcountdown $o_postlines
-                }
-            }
-
-            if {[llength $o_lastxlines] > $o_prelines} {
-                set o_lastxlines [lrange $o_lastxlines 1 end]
-            }
-            return $bytes
-        }
-        method meta_is_redirection {} {
-            return $o_is_junction
-        }
-        method meta_buffering_supported {} {
-            return [list line]
-        }
-    }
-
-    oo::class create tee_to_var {
-        variable o_datavars
-        variable o_trecord
-        variable o_enc
-        variable o_is_junction
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            set varname [dict get $settingsdict -varname]
-            set o_datavars $varname
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
-            } else {
-                set o_is_junction 0
-            }
-        }
-        method initialize {ch mode} {
-            return [list initialize finalize write]
-        }
-        method finalize {ch} {
-            my destroy
-        }
-        method watch {ch events} {
-            # must be present but we ignore it because we do not
-            # post any events
-        }
-        #method read {ch count} {
-        #  return ?
-        #}
-        method write {ch bytes} {
-            set stringdata [encoding convertfrom $o_enc $bytes]
-            foreach v $o_datavars {
-                append $v $stringdata
-            }
-            return $bytes
-        }
-        method meta_is_redirection {} {
-            return $o_is_junction
-        }
-    }
-    oo::class create tee_to_pipe {
-        variable o_logsource
-        variable o_localchan
-        variable o_enc
-        variable o_trecord
-        variable o_is_junction
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            if {![dict exists $settingsdict -tag]} {
-                error "tee_to_pipe constructor settingsdict missing -tag"
-            }
-            set o_localchan [dict get $settingsdict -pipechan]
-            set o_logsource [dict get $settingsdict -tag]
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
-            } else {
-                set o_is_junction 0
-            }
-        }
-        method initialize {transform_handle mode} {
-            return [list initialize read write finalize]
-        }
-        method finalize {transform_handle} {
-            ::shellfilter::log::close $o_logsource
-            my destroy
-        }
-        method watch {transform_handle events} {
-            # must be present but we ignore it because we do not
-            # post any events
-        }
-        method read {transform_handle bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
-            #::shellfilter::log::write $o_logsource $logdata
-            puts -nonewline $o_localchan $logdata
-            return  $bytes
-        }
-        method write {transform_handle bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
-            #::shellfilter::log::write $o_logsource $logdata
-            puts -nonewline $o_localchan $logdata
-            return $bytes
-        }
-        #a tee is not a redirection - because data still flows along the main path
-        method meta_is_redirection {} {
-            return $o_is_junction
-        }
-
-    }
-    oo::class create tee_to_log  {
-        variable o_tid 
-        variable o_logsource
-        variable o_trecord 
-        variable o_enc
-        variable o_is_junction
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            if {![dict exists $settingsdict -tag]} {
-                error "tee_to_log constructor settingsdict missing -tag"
-            }
-            set o_logsource [dict get $settingsdict -tag]
-            set o_tid [::shellfilter::log::open $o_logsource $settingsdict]
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
-            } else {
-                set o_is_junction 0
-            }
-        }
-        method initialize {ch mode} {
-            return [list initialize read write finalize]
-        }
-        method finalize {ch} {
-            ::shellfilter::log::close $o_logsource
-            my destroy
-        }
-        method watch {ch events} {
-            # must be present but we ignore it because we do not
-            # post any events
-        }
-        method read {ch bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
-            ::shellfilter::log::write $o_logsource $logdata
-            return  $bytes
-        }
-        method write {ch bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
-            ::shellfilter::log::write $o_logsource $logdata
-            return $bytes
-        }
-        method meta_is_redirection {} {
-            return $o_is_junction
-        }
-    }
-
-
-    oo::class create logonly  {
-        variable o_tid
-        variable o_logsource
-        variable o_trecord 
-        variable o_enc
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            if {![dict exists $settingsdict -tag]} {
-                error "logonly constructor settingsdict missing -tag"
-            }
-            set o_logsource [dict get $settingsdict -tag]
-            set o_tid [::shellfilter::log::open $o_logsource $settingsdict]
-        }
-        method initialize {transform_handle mode} {
-            return [list initialize finalize write]
-        }
-        method finalize {transform_handle} {
-            ::shellfilter::log::close $o_logsource
-            my destroy
-        }
-        method watch {transform_handle events} {
-            # must be present but we ignore it because we do not
-            # post any events
-        }
-        #method read {transform_handle count} {
-        #  return ?
-        #}
-        method write {transform_handle bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
-            if 0 {
-                if {"utf-16le" in [encoding names]} {
-                    set logdata [encoding convertfrom utf-16le $bytes]
-                } else {
-                    set logdata [encoding convertto utf-8 $bytes]
-                    #set logdata [encoding convertfrom unicode $bytes]
-                    #set logdata $bytes
-                }
-            }
-            #set logdata $bytes
-            #set logdata [string map [list \r -r- \n -n-] $logdata]
-            #if {[string equal [string range $logdata end-1 end] "\r\n"]} {
-            #  set logdata [string range $logdata 0 end-2]
-            #}
-            #::shellfilter::log::write_sync $o_logsource $logdata
-            ::shellfilter::log::write $o_logsource $logdata
-            #return $bytes
-            return 
-        }
-        method meta_is_redirection {} {
-            return 1
-        }
-    }
-
-    #review - we should probably provide a more narrow filter than only strips color - and one that strips most(?) 
-    # - but does it ever really make sense to strip things like "esc(0" and "esc(B" which flip to the G0 G1 characters? (once stripped - things like box-lines become ordinary letters - unlikely to be desired?)
-    #punk::ansi::stripansi converts at least some of the box drawing G0 chars to unicode - todo - more complete conversion
-    #assumes line-buffering. a more advanced filter required if ansicodes can arrive split accross separate read or write operations!
-    oo::class create ansistrip {
-        variable o_trecord 
-        variable o_enc
-        variable o_is_junction
-        constructor {tf} {
-            package require punk::ansi
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
-            } else {
-                set o_is_junction 0
-            }
-        }
-        method initialize {transform_handle mode} {
-            return [list initialize read write finalize]
-        }
-        method finalize {transform_handle} {
-            my destroy
-        }
-        method watch {transform_handle events} {
-        }
-        method read {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-            set outstring [punk::ansi::stripansi $instring]
-            return [encoding convertto $o_enc $outstring]
-        }
-        method write {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-            set outstring [punk::ansi::stripansi $instring]
-            return [encoding convertto $o_enc $outstring]
-            #return [encoding convertto unicode $outstring]
-        }
-        method meta_is_redirection {} {
-            return $o_is_junction
-        }
-    }
-
-    #a test
-    oo::class create reconvert {
-        variable o_trecord 
-        variable o_enc
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-        }
-        method initialize {transform_handle mode} {
-            return [list initialize read write finalize]
-        }
-        method finalize {transform_handle} {
-            my destroy
-        }
-        method watch {transform_handle events} {
-        }
-        method read {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-
-            set outstring $instring
-
-            return [encoding convertto $o_enc $outstring]
-        }
-        method write {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-
-            set outstring $instring
-
-            return [encoding convertto $o_enc $outstring]
-        }
-    }
-    oo::define reconvert {
-        method meta_is_redirection {} {
-            return 0
-        }
-    }
-
-    oo::class create ansiwrap {
-        variable o_trecord
-        variable o_enc
-        variable o_colour
-        variable o_do_colour
-        variable o_do_normal
-        variable o_is_junction
-        constructor {tf} {
-            package require punk::ansi
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            if {[dict exists $settingsdict -colour]} {
-                set o_colour [dict get $settingsdict -colour]
-                set o_do_colour [punk::ansi::a+ {*}$o_colour]
-                set o_do_normal [punk::ansi::a]
-            } else {
-                set o_colour {}
-                set o_do_colour ""
-                set o_do_normal ""
-            }
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
-            } else {
-                set o_is_junction 0
-            }
-        }
-        method initialize {transform_handle mode} {
-            return [list initialize  write finalize]
-        }
-        method finalize {transform_handle} {
-            my destroy
-        }
-        method watch {transform_handle events} {
-        }
-        method write {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes]
-            set outstring "$o_do_colour$instring$o_do_normal"
-            #set outstring ">>>$instring"
-            return [encoding convertto $o_enc $outstring]
-        }
-        method meta_is_redirection {} {
-            return $o_is_junction
-        }
-    }
-    #todo - something 
-    oo::class create rebuffer {
-        variable o_trecord 
-        variable o_enc
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-        }
-        method initialize {transform_handle mode} {
-            return [list initialize read write finalize]
-        }
-        method finalize {transform_handle} {
-            my destroy
-        }
-        method watch {transform_handle events} {
-        }
-        method read {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-
-            set outstring $instring
-
-            return [encoding convertto $o_enc $outstring]
-        }
-        method write {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-
-            #set outstring [string map [list \n <N>] $instring]
-            set outstring $instring
-
-            return [encoding convertto $o_enc $outstring]
-            #return [encoding convertto utf-16le $outstring]
-        }
-    }
-    oo::define rebuffer {
-        method meta_is_redirection {} {
-            return 0
-        }
-    }
-
-    #has slight buffering/withholding of lone training cr - we can't be sure that a cr at end of chunk is part of \r\n sequence 
-    oo::class create tounix {
-        variable o_trecord 
-        variable o_enc
-        variable o_last_char_was_cr
-        variable o_is_junction
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
-            } else {
-                set o_is_junction 0
-            }
-            set o_last_char_was_cr 0
-        }
-        method initialize {transform_handle mode} {
-            return [list initialize write finalize]
-        }
-        method finalize {transform_handle} {
-            my destroy
-        }
-        method watch {transform_handle events} {
-        }
-        #don't use read
-        method read {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-
-            set outstring $instring
-
-            return [encoding convertto $o_enc $outstring]
-        }
-        method write {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-            #set outstring [string map [list \n <N>] $instring]
-
-            if {$o_last_char_was_cr} {
-                set instring "\r$instring"
-            }
-
-            set outstring [string map [list \r\n \n] $instring]
-            set lastchar [string range $outstring end end] 
-            if {$lastchar eq "\r"} {
-                set o_last_char_was_cr 1
-                set outstring [string range $outstring 0 end-1]
-            } else {
-                set o_last_char_was_cr 0
-            }
-            #review! can we detect eof here on the transform_handle?
-            #if eof, we don't want to strip a trailing \r
-
-            return [encoding convertto $o_enc $outstring]
-            #return [encoding convertto utf-16le $outstring]
-        }
-    }
-    oo::define tounix {
-        method meta_is_redirection {} {
-            return $o_is_junction
-        }
-    }
-    #write to handle case where line-endings already \r\n too
-    oo::class create towindows  {
-        variable o_trecord 
-        variable o_enc
-        variable o_last_char_was_cr
-        variable o_is_junction
-        constructor {tf} {
-            set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
-            } else {
-                set o_is_junction 0
-            }
-            set o_last_char_was_cr 0
-        }
-        method initialize {transform_handle mode} {
-            return [list initialize write finalize]
-        }
-        method finalize {transform_handle} {
-            my destroy
-        }
-        method watch {transform_handle events} {
-        }
-        #don't use read
-        method read {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-
-            set outstring $instring
-
-            return [encoding convertto $o_enc $outstring]
-        }
-        method write {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes] 
-            #set outstring [string map [list \n <N>] $instring]
-
-            if {$o_last_char_was_cr} {
-                set instring "\r$instring"
-            }
-
-            set outstring [string map [list \r\n \uFFFF] $instring]
-            set outstring [string map [list \n \r\n] $outstring]
-            set outstring [string map [list \uFFFF \r\n] $outstring]
-
-            set lastchar [string range $outstring end end] 
-            if {$lastchar eq "\r"} {
-                set o_last_char_was_cr 1
-                set outstring [string range $outstring 0 end-1]
-            } else {
-                set o_last_char_was_cr 0
-            }
-            #review! can we detect eof here on the transform_handle?
-            #if eof, we don't want to strip a trailing \r
-
-            return [encoding convertto $o_enc $outstring]
-            #return [encoding convertto utf-16le $outstring]
-        }
-    }
-    oo::define towindows {
-        method meta_is_redirection {} {
-            return $o_is_junction 
-        }
-    }
-
-    }
-}
-
-# ----------------------------------------------------------------------------
-#review float/sink metaphor.
-#perhaps something with the concept of upstream and downstream?
-#need concepts for push towards data, sit in middle where placed, and lag at tail of data stream. 
-## upstream for stdin is at the bottom of the stack and for stdout is the top of the stack.
-#upstream,neutral-upstream,downstream,downstream-aside,downstream-replace  (default neutral-upstream - require action 'stack' to use standard channel stacking concept and ignore other actions)
-#This is is a bit different from the float/sink metaphor which refers to the channel stacking order as opposed to the data-flow direction.
-#The idea would be that whether input or output 
-# upstream additions go to the side closest to the datasource
-# downstream additions go furthest from the datasource 
-# - all new additions go ahead of any diversions as the most upstream diversion is the current end of the stream in a way.
-# - this needs review regarding subsequent removal of the diversion and whether filters re-order in response.. 
-#    or if downstream & neutral additions are reclassified upon insertion if they land among existing upstreams(?) 
-# neutral-upstream goes to the datasource side of the neutral-upstream list. 
-#   No 'neutral' option provided so that we avoid the need to think forwards or backwards when adding stdin vs stdout shellfilter does the necessary pop/push reordering.
-#   No 'neutral-downstream' to reduce complexity.
-# downstream-replace & downstream-aside head downstream to the first diversion they encounter. ie these actions are no longer referring to the stack direction but only the dataflow direction.
-#
-# ----------------------------------------------------------------------------
-#
-# 'filters' are transforms that don't redirect
-# - limited range of actions to reduce complexity.
-# - any requirement not fulfilled by float,sink,sink-replace,sink-sideline should be done by multiple pops and pushes
-#
-#actions can float to top of filters or sink to bottom of filters
-#when action is of type sink, it can optionally replace or sideline the first non-filter it encounters (highest redirection on the stack.. any lower are starved of the stream anyway)
-# - sideline means to temporarily replace the item and keep a record, restoring if/when we are removed from the transform stack
-#
-##when action is of type float it can't replace or sideline anything. A float is added above any existing floats and they stay in the same order relative to each other,
-#but non-floats added later will sit below all floats.
-#(review - float/sink initially designed around output channels. For stdin the dataflow is reversed. implement float-aside etc?)
-#
-#
-#action: float sink sink-replace,sink-sideline
-#
-#
-## note - whether stack is for input or output we maintain it in the same direction - which is in sync with the tcl chan pop chan push concept.
-## 
-namespace eval shellfilter::stack {
-    #todo - implement as oo
-    variable pipelines [list]
-
-    proc items {} {
-        #review - stdin,stdout,stderr act as pre-existing pipelines, and we can't create a new one with these names - so they should probably be autoconfigured and listed..
-        # - but in what contexts? only when we find them in [chan names]?
-        variable pipelines
-        return [dict keys $pipelines]
-    }
-
-    proc status {{pipename *} args} {
-        variable pipelines
-
-        set pipecount [dict size $pipelines]
-        set tableprefix "$pipecount pipelines active\n"
-        package require overtype
-        #todo -verbose
-        set table ""
-        set ac1 [string repeat " " 15]
-        set ac2 [string repeat " " 32]
-        set ac3 [string repeat " " 80]
-        append table "[overtype::left $ac1 channel-ident] "
-        append table "[overtype::left $ac2 device-info] "
-        append table "[overtype::left $ac3 stack-info]"
-        append table \n
-
-
-        set bc1 [string repeat " " 5]  ;#stack id
-        set bc2 [string repeat " " 25] ;#transform
-        set bc3 [string repeat " " 50] ;#settings
-
-        foreach k [dict keys $pipelines $pipename] {
-            set lc [dict get $pipelines $k device localchan]
-
-
-            set col1 [overtype::left $ac1 $k]
-            set col2 [overtype::left $ac2 "localchan: $lc"]
-
-            set stack [dict get $pipelines $k stack]
-            if {![llength $stack]} {
-                    set col3 $ac3
-            } else {
-                set rec [lindex $stack 0]
-                set bcol1 [overtype::left $bc1 [dict get $rec -id]]
-                set bcol2 [overtype::left $bc2 [namespace tail [dict get $rec -transform]]]
-                set bcol3 [overtype::left $bc3 [dict get $rec -settings]]
-                set stackrow "$bcol1 $bcol2 $bcol3"
-                set col3 [overtype::left $ac3 $stackrow]
-            }
-
-            append table  "$col1 $col2 $col3\n"
-
-
-            foreach rec [lrange $stack 1 end] {
-                set col1 $ac1
-                set col2 $ac2
-                if {[llength $rec]} {
-                    set bc1 [overtype::left $bc1 [dict get $rec -id]]
-                    set bc2 [overtype::left $bc2 [namespace tail [dict get $rec -transform]]]
-                    set bc3 [overtype::left $bc3 [dict get $rec -settings]]
-                    set stackrow "$bc1 $bc2 $bc3"
-                    set col3 [overtype::left $ac3 $stackrow]
-                } else {
-                    set col3 $ac3
-                }
-                append table  "$col1 $col2 $col3\n"
-            }
-
-        }
-        return $tableprefix$table
-    }
-    #used for output channels - we usually want to sink redirections below the floaters and down to topmost existing redir 
-    proc _get_stack_floaters {stack} {
-        set floaters [list]
-        foreach t [lreverse $stack] {
-            if {[dict get $t -action] eq "float"} {
-                lappend floaters $t
-            } else {
-                break
-            }
-        }
-        return [lreverse $floaters]
-    }
-
-
-
-    #for output-channel sinking
-    proc _get_stack_top_redirection {stack} {
-        set r 0 ;#reverse index
-        foreach t [lreverse $stack] {
-            set obj [dict get $t -obj]
-            if {[$obj meta_is_redirection]} {
-                set idx [expr {[llength $stack] - ($r + 1) }] ;#forward index
-                return [list index $idx record $t]
-            }
-            incr r
-        }
-        #not found
-        return [list index -1 record {}]
-    }
-    #exclude float-locked, locked, sink-locked
-    proc _get_stack_top_redirection_replaceable {stack} {
-        set r 0 ;#reverse index
-        foreach t [lreverse $stack] {
-            set action [dict get $t -action]
-            if {![string match "*locked*" $action]} {
-                set obj [dict get $t -obj]
-                if {[$obj meta_is_redirection]} {
-                    set idx [expr {[llength $stack] - ($r + 1) }] ;#forward index
-                    return [list index $idx record $t]
-                }
-            }
-            incr r
-        }
-        #not found
-        return [list index -1 record {}]
-    }
-
-
-    #for input-channels ? 
-    proc _get_stack_bottom_redirection {stack} {
-        set i 0 
-        foreach t $stack {
-            set obj [dict get $t -obj]
-            if {[$obj meta_is_redirection]} {
-                return [linst index $i record $t]
-            }
-            incr i
-        }
-        #not found
-        return [list index -1 record {}]
-    }
-
-
-    proc get_next_counter {pipename} {
-        variable pipelines
-        #use dictn incr ?
-        set counter [dict get $pipelines $pipename counter]
-        incr counter
-        dict set pipelines $pipename counter $counter
-        return $counter
-    }
-
-    proc unwind {pipename} {
-        variable pipelines
-        set stack [dict get $pipelines $pipename stack]
-        set localchan [dict get $pipelines $pipename device localchan]
-        foreach tf [lreverse $stack] {
-            chan pop $localchan
-        }
-        dict set pipelines $pipename [list]
-    }
-    #todo
-    proc delete {pipename} {
-        set pipeinfo [dict get $pipename]
-        set deviceinfo [dict get $pipeinfo device] 
-        set localchan [dict get $deviceinfo localchan]
-        unwind $pipename
-
-
-        chan close $localchan
-    }
-    proc remove {pipename remove_id} {
-        variable pipelines
-        if {![dict exists $pipelines $pipename]} {
-            puts stderr "WARNING: shellfilter::stack::remove pipename '$pipename' not found in pipelines dict: '$pipelines' [info level -1]"
-            return
-        }
-        set stack [dict get $pipelines $pipename stack]
-        set localchan [dict get $pipelines $pipename device localchan]
-        set posn 0
-        set idposn -1
-        set asideposn -1
-        foreach  t $stack {
-            set id [dict get $t -id]
-            if {$id eq $remove_id} {
-                set idposn $posn
-                break
-            }
-            #look into asides (only can be one for now)
-            if {[llength [dict get $t -aside]]} {
-                set a [dict get $t -aside]
-                if {[dict get $a -id] eq $remove_id} {
-                    set asideposn $posn 
-                    break
-                }
-            }
-            incr posn
-        }
-
-        if {$asideposn > 0} {
-            #id wasn't found directly in stack, but in an -aside. we don't need to pop anything - just clear this aside record
-            set container [lindex $stack $asideposn]
-            dict set container -aside {}
-            lset stack $asideposn $container 
-            dict set pipelines $pipename stack $stack
-        } else {
-            if {$idposn < 0} {
-                ::shellfilter::log::write shellfilter "ERROR shellfilter::stack::remove $pipename id '$remove_id' not found"
-                puts stderr "|WARNING>shellfilter::stack::remove $pipename id '$remove_id' not found"
-                return 0
-            }
-            set removed_item [lindex $stack $idposn] 
-
-            #include idposn in poplist
-            set poplist [lrange $stack $idposn end]
-            set stack [lreplace $stack $idposn end]
-            #pop all chans before adding anything back in!
-            foreach p $poplist {
-                chan pop $localchan
-            }
-
-            if {[llength [dict get $removed_item -aside]]} {
-                set restore [dict get $removed_item -aside]
-                set t [dict get $restore -transform]
-                set tsettings [dict get $restore -settings]
-                set obj [$t new $restore]
-                set h [chan push $localchan $obj]
-                dict set restore -handle $h
-                dict set restore -obj $obj
-                lappend stack $restore
-            }
-
-            #put popped back except for the first one, which we want to remove
-            foreach p [lrange $poplist 1 end] {
-                set t [dict get $p -transform]
-                set tsettings [dict get $p -settings]
-                set obj [$t new $p]
-                set h [chan push $localchan $obj]
-                dict set p -handle $h
-                dict set p -obj $obj
-                lappend stack $p
-            }
-            dict set pipelines $pipename stack $stack
-        }
-        show_pipeline $pipename -note "after_remove $remove_id"
-
-        return 1
-    }
-
-    #pop a number of items of the top of the stack, add our transform record, and add back all (or the tail of poplist if pushstartindex > 0)
-    proc insert_transform {pipename stack transformrecord poplist {pushstartindex 0}} {
-        variable pipelines
-        set bottom_pop_posn [expr {[llength $stack] - [llength $poplist]}]
-        set poplist [lrange $stack $bottom_pop_posn end]
-        set stack [lreplace $stack $bottom_pop_posn end]
-
-        set localchan [dict get $pipelines $pipename device localchan]
-        foreach p [lreverse $poplist] {
-            chan pop $localchan
-        }
-        set transformname [dict get $transformrecord -transform]
-        set transformsettings [dict get $transformrecord -settings]
-        set obj [$transformname new $transformrecord]
-        set h [chan push $localchan $obj] 
-        dict set transformrecord -handle $h
-        dict set transformrecord -obj $obj
-        dict set transformrecord -note "insert_transform"
-        lappend stack $transformrecord
-        foreach p [lrange $poplist $pushstartindex end] {
-            set t [dict get $p -transform]
-            set tsettings [dict get $p -settings]
-            set obj [$t new $p]
-            set h [chan push $localchan $obj]
-            #retain previous -id  - code that added it may have kept reference and not expecting it to change
-            dict set p -handle $h
-            dict set p -obj $obj
-            dict set p -note "re-added"
-
-            lappend stack $p
-        }
-        return $stack
-    }
-
-    #fifo2 
-    proc new {pipename args} {
-        variable pipelines
-        if {($pipename in [dict keys $pipelines]) || ($pipename in [chan names])} {
-            error "shellfilter::stack::new error: pipename '$pipename' already exists"
-        }
-
-        set opts [dict merge {-settings {}} $args] 
-        set defaultsettings [dict create -raw 1 -buffering line -direction out]
-        set targetsettings [dict merge $defaultsettings [dict get $opts -settings]]
-
-        set direction [dict get $targetsettings -direction]
-
-        #pipename is the source/facility-name ?
-        if {$direction eq "out"} {
-            set pipeinfo [shellfilter::pipe::open_out $pipename $targetsettings]
-        } else {
-            puts stderr "|jn> pipe::open_in $pipename $targetsettings"
-            set pipeinfo [shellfilter::pipe::open_in $pipename $targetsettings]
-        }
-        #open_out/open_in will configure buffering based on targetsettings
-
-        set program_chan [dict get $pipeinfo localchan]
-        set worker_chan [dict get $pipeinfo remotechan]
-        set workertid [dict get $pipeinfo workertid]
-
-
-        set deviceinfo [dict create pipename $pipename localchan $program_chan remotechan $worker_chan workertid $workertid direction $direction]
-        dict set pipelines $pipename [list counter 0 device $deviceinfo stack [list]]
-
-        return $deviceinfo
-    }
-    #we 'add' rather than 'push' because transforms can float,sink and replace/sideline so they don't necessarily go to the top of the transform stack
-    proc add {pipename transformname args} {
-        variable pipelines
-        if {($pipename ni [chan names]) && ($pipename ni [dict keys $pipelines])} {
-            error "shellfilter::stack::add no existing chan or pipename matching '$pipename' use stdin/stderr/stdout or shellfilter::stack::new <pipename>"
-        }
-        set args [dict merge {-action "" -settings {}} $args]
-        set action [dict get $args -action]
-        set transformsettings [dict get $args -settings]
-        if {[string first "::" $transformname] < 0} {
-            set transformname ::shellfilter::chan::$transformname
-        }
-        if {![llength [info commands $transformname]]} {
-            error "shellfilter::stack::push unknown transform '$transformname'"
-        }
-
-
-        if {![dict exists $pipelines $pipename]} {
-            #pipename must be in chan names - existing device/chan
-            #record a -read and -write end even if the device is only being used as one or the other
-            set deviceinfo [dict create pipename $pipename localchan $pipename remotechan {}]
-            dict set pipelines $pipename [list counter 0 device $deviceinfo stack [list]]
-        } else {
-            set deviceinfo [dict get $pipelines $pipename device]
-        }
-
-        set id [get_next_counter $pipename] 
-        set stack [dict get $pipelines $pipename stack]
-        set localchan [dict get $deviceinfo localchan]
-
-        #we redundantly store chan in each transform -  makes debugging clearer
-        # -encoding similarly could be stored only at the pipeline level (or even queried directly each filter-read/write),
-        # but here it may help detect unexpected changes during lifetime of the stack and avoids the chance of callers incorrectly using the transform handle?)
-        # jn
-        set transform_record [list -id $id -chan $pipename -encoding [chan configure $localchan -encoding] -transform $transformname -aside {} {*}$args]
-
-        if {$action in [list "float" "float-locked"]} {
-            set obj [$transformname new $transform_record]
-            set h [chan push $localchan $obj]
-            dict set transform_record -handle $h
-            dict set transform_record -obj $obj
-            lappend stack $transform_record
-        } elseif {$action in [list "locked" ""]} {
-            set floaters [_get_stack_floaters $stack]
-            if {![llength $floaters]} {
-                set obj [$transformname new $transform_record]
-                set h [chan push $localchan $obj]
-                dict set transform_record -handle $h
-                dict set transform_record -obj $obj
-                lappend stack $transform_record
-            } else {
-                set poplist $floaters
-                set stack [insert_transform $pipename $stack $transform_record $poplist]
-            }
-        } elseif {[string match sink* $action]} {
-            set redirinfo [_get_stack_top_redirection $stack]
-            set idx_existing_redir [dict get $redirinfo index]
-            if {$idx_existing_redir == -1} {
-                #no existing redirection transform on the stack
-                #pop everything.. add this record as the first redirection on the stack
-                set poplist $stack
-                set stack [insert_transform $pipename $stack $transform_record $poplist]
-            } else {
-                if {$action eq "sink-replace"} {
-                    #include that index in the poplist
-                    set poplist [lrange $stack $idx_existing_redir end]
-                    #pop all from idx_existing_redir  to end, but put back 'lrange $poplist 1 end'
-                    set stack [insert_transform $pipename $stack $transform_record $poplist 1]
-                } elseif {[string match "sink-aside*" $action]} {
-                    set existing_redir_record [lindex $stack $idx_existing_redir]
-                    if {[string match "*locked*" [dict get $existing_redir_record -action]]} {
-                        set put_aside 0
-                        #we can't aside this one - sit above it instead.
-                        set poplist [lrange $stack $idx_existing_redir+1 end]
-                        set stack [lrange $stack 0 $idx_existing_redir]
-                    } else {
-                        set put_aside 1
-                        dict set transform_record -aside [lindex $stack $idx_existing_redir]
-                        set poplist [lrange $stack $idx_existing_redir end]
-                        set stack [lrange $stack 0 $idx_existing_redir-1]
-                    }
-                    foreach p $poplist {
-                        chan pop $localchan
-                    }
-                    set transformname [dict get $transform_record -transform]
-                    set transform_settings [dict get $transform_record -settings]
-                    set obj [$transformname new $transform_record]
-                    set h [chan push $localchan $obj] 
-                    dict set transform_record -handle $h
-                    dict set transform_record -obj $obj
-                    dict set transform_record -note "insert_transform-with-aside"
-                    lappend stack $transform_record
-                    #add back poplist *except* the one we transferred into -aside (if we were able)
-                    foreach p [lrange $poplist $put_aside end] {
-                        set t [dict get $p -transform]
-                        set tsettings [dict get $p -settings]
-                        set obj [$t new $p]
-                        set h [chan push $localchan $obj]
-                        #retain previous -id  - code that added it may have kept reference and not expecting it to change
-                        dict set p -handle $h
-                        dict set p -obj $obj
-                        dict set p -note "re-added-after-sink-aside"
-                        lappend stack $p
-                    }
-                } else {
-                    #plain "sink"
-                    #we only sink to the topmost redirecting filter - which makes sense for an output channel
-                    #For stdin.. this is more problematic as we're more likely to want to intercept the bottom most redirection.
-                    #todo - review. Consider making default insert position for input channels to be at the source... and float/sink from there.
-                    # - we don't currently know from the stack api if adding input vs output channel - so this needs work to make intuitive.
-                    # consider splitting stack::add to stack::addinput stack::addoutput to split the different behaviour
-                    set poplist [lrange $stack $idx_existing_redir+1 end]
-                    set stack [insert_transform $pipename $stack $transform_record $poplist]
-                }
-            }
-        } else {
-            error "shellfilter::stack::add unimplemented action '$action'"
-        }
-
-        dict set pipelines $pipename stack $stack
-        #puts stdout "=="
-        #puts stdout "==>stack: $stack"
-        #puts stdout "=="
-        show_pipeline $pipename -note "after_add $transformname $args"
-        return $id
-    }
-    proc show_pipeline {pipename args} {
-        variable pipelines
-        set stack [dict get $pipelines $pipename stack]
-        set tag "SHELLFILTER::STACK"
-        #JMN - load from config
-        #::shellfilter::log::open $tag {-syslog 127.0.0.1:514}
-        ::shellfilter::log::open $tag {-syslog ""}
-        ::shellfilter::log::write $tag "transform stack for $pipename $args"
-        foreach tf $stack {
-            ::shellfilter::log::write $tag " $tf"
-        }
-
-    }
-}
-
-
-namespace eval shellfilter {
-    variable sources [list]
-    variable stacks [dict create]
-
-    proc ::shellfilter::redir_channel_to_log {chan args} {
-        variable sources
-        set default_logsettings [dict create \
-            -tag redirected_$chan -syslog "" -file ""\
-            ]
-        if {[dict exists $args -action]} {
-            set action [dict get $args -action]
-        } else {
-            # action "sink" is a somewhat reasonable default for an output redirection transform
-            # but it can make it harder to configure a plain ordered stack if the user is not expecting it, so we'll default to stack 
-            # also.. for stdin transform sink makes less sense.. 
-            #todo - default "stack" instead of empty string
-            set action ""
-        }
-        if {[dict exists $args -settings]} {
-            set logsettings [dict get $args -settings]
-        } else {
-            set logsettings {}
-        }
-
-        set logsettings [dict merge $default_logsettings $logsettings]
-        set tag [dict get $logsettings -tag]
-        if {$tag ni $sources} {
-            lappend sources $tag
-        }
-
-        set id [shellfilter::stack::add $chan logonly -action $action -settings $logsettings]
-        return $id
-    }
-
-    proc ::shellfilter::redir_output_to_log {tagprefix args} {
-        variable sources
-
-        set default_settings [list -tag ${tagprefix} -syslog "" -file ""]
-
-        set opts [dict create -action "" -settings {}]
-        set opts [dict merge $opts $args]
-        set optsettings [dict get $opts -settings]
-        set settings [dict merge $default_settings $optsettings]
-
-        set tag [dict get $settings -tag]
-        if {$tag ne $tagprefix} {
-            error "shellfilter::redir_output_to_log -tag value must match supplied tagprefix:'$tagprefix'. Omit -tag, or make it the same. It will automatically be suffixed with stderr and stdout. Use redir_channel_to_log if you want to separately configure each channel" 
-        }
-        lappend sources ${tagprefix}stdout ${tagprefix}stderr 
-
-        set stdoutsettings $settings
-        dict set stdoutsettings -tag ${tagprefix}stdout
-        set stderrsettings $settings
-        dict set stderrsettings -tag ${tagprefix}stderr
-
-        set idout [redir_channel_to_log stdout -action [dict get $opts -action] -settings $stdoutsettings]
-        set iderr [redir_channel_to_log stderr -action [dict get $opts -action] -settings $stderrsettings]
-
-        return [list $idout $iderr]
-    } 
-
-    #return a dict keyed on numerical list index showing info about each element 
-    # - particularly 
-    #  'wouldbrace' to indicate that the item would get braced by Tcl when added to another list
-    #  'head_tail_chars' to show current first and last character  (in case it's wrapped e.g in double or single quotes or an existing set of braces)
-    proc list_element_info {inputlist} {
-        set i 0
-        set info [dict create]
-        set testlist [list]
-        foreach original_item $inputlist {
-            #---
-            # avoid sharing internal rep with original items in the list (avoids shimmering of rep in original list for certain items such as paths)
-            unset -nocomplain item
-            append item $original_item {}
-            #---
-
-            set iteminfo [dict create]
-            set itemlen [string length $item]
-            lappend testlist $item
-            set tcl_len [string length $testlist]
-            set diff [expr {$tcl_len - $itemlen}]
-            if {$diff == 0} {
-                dict set iteminfo wouldbrace 0
-                dict set iteminfo wouldescape 0
-            } else {
-                #test for escaping vs bracing!
-                set testlistchars [split $testlist ""]
-                if {([lindex $testlistchars 0] eq "\{") && ([lindex $testlistchars end] eq "\}")} {
-                    dict set iteminfo wouldbrace 1
-                    dict set iteminfo wouldescape 0
-                } else {
-                    dict set iteminfo wouldbrace 0
-                    dict set iteminfo wouldescape 1
-                }
-            }
-            set testlist [list]
-            set charlist [split $item ""]
-            set char_a [lindex $charlist 0]
-            set char_b [lindex $charlist 1]
-            set char_ab ${char_a}${char_b}
-            set char_y [lindex $charlist end-1]
-            set char_z [lindex $charlist end]
-            set char_yz ${char_y}${char_z}
-
-            if { ("{" in $charlist) || ("}" in $charlist) } {
-                dict set iteminfo has_braces 1
-                set innerchars [lrange $charlist 1 end-1]
-                if {("{" in $innerchars) || ("}" in $innerchars)} {
-                    dict set iteminfo has_inner_braces 1
-                } else {
-                    dict set iteminfo has_inner_braces 0
-                }
-            } else {
-                dict set iteminfo has_braces 0
-                dict set iteminfo has_inner_braces 0
-            }
-
-            #todo - brace/char counting to determine if actually 'wrapped'
-            #e.g we could have list element {((abc)} - which appears wrapped if only looking at first and last chars.
-            #also {(x) (y)} as a list member.. how to treat?
-            if {$itemlen <= 1} {
-                dict set iteminfo apparentwrap "not"
-            } else {
-                if {($char_a eq {"}) && ($char_z eq {"})} {
-                    dict set iteminfo apparentwrap "doublequotes"
-                } elseif {($char_a eq "'") && ($char_z eq "'")} {
-                    dict set iteminfo apparentwrap "singlequotes"
-                } elseif {($char_a eq "(") && ($char_z eq ")")} {
-                    dict set iteminfo apparentwrap "brackets"
-                } elseif {($char_a eq "\{") && ($char_z eq "\}")} {
-                    dict set iteminfo apparentwrap "braces"
-                } elseif {($char_a eq "^") && ($char_z eq "^")} {
-                    dict set iteminfo apparentwrap "carets"
-                } elseif {($char_a eq "\[") && ($char_z eq "\]")} {
-                    dict set iteminfo apparentwrap "squarebrackets"
-                } elseif {($char_a eq "`") && ($char_z eq "`")} {
-                    dict set iteminfo apparentwrap "backquotes"
-                } elseif {($char_a eq "\n") && ($char_z eq "\n")} {
-                    dict set iteminfo apparentwrap "lf-newline"
-                } elseif {($char_ab eq "\r\n") && ($char_yz eq "\r\n")} {
-                    dict set iteminfo apparentwrap "crlf-newline"
-                } else {
-                    dict set iteminfo apparentwrap "not-determined"
-                }
-
-            }
-            dict set iteminfo wrapbalance "unknown"  ;#a hint to caller that apparentwrap is only a guide. todo - possibly make wrapbalance indicate 0 for unbalanced.. and positive numbers for outer-count of wrappings.
-            #e.g {((x)} == 0  {((x))} == 1 {(x) (y (z))} == 2
-            dict set iteminfo head_tail_chars [list $char_a $char_z]
-            set namemap [list \
-                 \r cr\
-                 \n lf\
-                 {"} doublequote\
-                 {'} singlequote\
-                 "`" backquote\
-                 "^" caret\
-                 \t tab\
-                 " " sp\
-                 "\[" lsquare\
-                 "\]" rsquare\
-                 "(" lbracket\
-                 ")" rbracket\
-                 "\{" lbrace\
-                 "\}" rbrace\
-                 \\ backslash\
-                 / forwardslash\
-                 ]
-            if {[string length $char_a]} {
-                set char_a_name [string map $namemap $char_a]
-            } else {
-                set char_a_name "emptystring"
-            }
-            if {[string length $char_z]} {
-                set char_z_name [string map $namemap $char_z]
-            } else {
-                set char_z_name "emptystring"
-            }
-
-            dict set iteminfo head_tail_names [list $char_a_name $char_z_name]
-            dict set iteminfo len $itemlen
-            dict set iteminfo difflen $diff ;#2 for braces, 1 for quoting?, or 0.
-            dict set info $i $iteminfo
-            incr i
-        }
-        return $info
-    }
-
-
-    #parse bracketed expression (e.g produced by vim "shellxquote=(" ) into a tcl (nested) list
-    #e.g {(^c:/my spacey/path^ >^somewhere^)} 
-    #e.g {(blah (etc))}"  
-    #Result is always a list - even if only one toplevel set of brackets - so it may need [lindex $result 0] if input is the usual case of {( ...)}  
-    # - because it also supports the perhaps less likely case of: {( ...) unbraced (...)} etc
-    # Note that 
-    #maintenance warning - duplication in branches for bracketed vs unbracketed!
-    proc parse_cmd_brackets {str} {
-        #wordwrappers currently best suited to non-bracket entities - no bracket matching within - anything goes until end-token reached.
-        # - but.. they only take effect where a word can begin. so a[x y]  may be split at the space unless it's within some other wraper e.g " a[x y]" will not break at the space
-        # todo - consider extending the in-word handling of word_bdepth which is currently only applied to ()  i.e aaa(x y) is supported but aaa[x y] is not as the space breaks the word up.
-        set wordwrappers [list \
-            "\"" [list "\"" "\"" "\""]\
-            {^} [list "\"" "\"" "^"]\
-            "'" [list "'" "'" "'"]\
-            "\{" [list "\{" "\}" "\}"]\
-            {[} [list {[} {]} {]}]\
-            ] ;#dict mapping start_character to {replacehead replacetail expectedtail}
-        set shell_specials [list "|" "|&" "<" "<@" "<<" ">" "2>" ">&" ">>" "2>>" ">>&" ">@" "2>@" "2>@1" ">&@" "&" "&&" ] ;#words/chars that may precede an opening bracket but don't merge with the bracket to form a word.    
-        #puts "pb:$str"
-        set in_bracket 0
-        set in_word 0
-        set word ""
-        set result {}
-        set word_bdepth 0 
-        set word_bstack [list]
-        set wordwrap "" ;#only one active at a time
-        set bracketed_elements [dict create]
-        foreach char [split $str ""] {
-            #puts "c:$char bracketed:$bracketed_elements"
-            if {$in_bracket > 0} {
-                if {$in_word} {
-                    if {[string length $wordwrap]} {
-                        #anything goes until end-char
-                        #todo - lookahead and only treat as closing if before a space or ")" ?
-                        lassign [dict get $wordwrappers $wordwrap] _open closing endmark
-                        if {$char eq $endmark} {
-                            set wordwrap ""
-                            append word $closing
-                            dict lappend bracketed_elements $in_bracket $word
-                            set word ""
-                            set in_word 0
-                        } else {
-                            append word $char
-                        }
-                    } else {
-                        if {$word_bdepth == 0} {
-                            #can potentially close off a word - or start a new one if word-so-far is a shell-special
-                            if {$word in $shell_specials} {
-                                if {$char eq ")"} {
-                                    dict lappend bracketed_elements $in_bracket $word 
-                                    set  subresult [dict get $bracketed_elements $in_bracket]
-                                    dict set bracketed_elements $in_bracket [list]
-                                    incr in_bracket -1
-                                    if {$in_bracket == 0} {
-                                        lappend result $subresult
-                                    } else {
-                                        dict lappend bracketed_elements $in_bracket $subresult
-                                    }
-                                    set word ""
-                                    set in_word 0
-                                } elseif {[regexp {[\s]} $char]} {
-                                    dict lappend bracketed_elements $in_bracket $word 
-                                    set word ""
-                                    set in_word 0
-                                } elseif {$char eq "("} {    
-                                    dict lappend bracketed_elements $in_bracket $word 
-                                    set word ""
-                                    set in_word 0
-                                    incr in_bracket
-                                } else {
-                                    #at end of shell-specials is another point to look for word started by a wordwrapper char
-                                    #- expect common case of things like >^/my/path^
-                                    if {$char in [dict keys $wordwrappers]} {
-                                        dict lappend bracketed_elements $in_bracket $word 
-                                        set word ""
-                                        set in_word 1 ;#just for explicitness.. we're straight into the next word.
-                                        set wordwrap $char
-                                        set word [lindex [dict get $wordwrappers $char] 0] ;#replace trigger char with the start value it maps to.
-                                    } else {
-                                        #something unusual.. keep going with word!
-                                        append word $char
-                                    }
-                                }
-                            } else {
-                            
-                                if {$char eq ")"} {
-                                    dict lappend bracketed_elements $in_bracket $word
-                                    set  subresult [dict get $bracketed_elements $in_bracket]
-                                    dict set bracketed_elements $in_bracket [list]
-                                    incr in_bracket -1
-                                    if {$in_bracket == 0} {
-                                        lappend result $subresult
-                                    } else {
-                                        dict lappend bracketed_elements $in_bracket $subresult
-                                    }
-                                    set word ""
-                                    set in_word 0
-                                } elseif {[regexp {[\s]} $char]} {
-                                    dict lappend bracketed_elements $in_bracket $word
-                                    set word ""
-                                    set in_word 0
-                                } elseif {$char eq "("} {
-                                    #ordinary word up-against and opening bracket - brackets are part of word.
-                                    incr word_bdepth 
-                                    append word "("
-                                } else {
-                                    append word $char
-                                }
-                            }
-                        } else {
-                            #currently only () are used for word_bdepth - todo  add all or some wordwrappers chars so that the word_bstack can have multiple active.
-                            if {$char eq "("} {
-                                incr word_bdepth
-                                lappend word_bstack $char
-                                append word $char 
-                            } elseif {$char eq ")"} {
-                                incr word_bdepth -1
-                                set word_bstack [lrange $word_bstack 0 end-1]
-                                append word $char 
-                            } else {
-                                #spaces and chars added to word as it's still in a bracketed section
-                                append word $char
-                            }
-                        }
-                    }
-                } else {
-                    
-                    if {$char eq "("} {
-                        incr in_bracket
-                        
-                    } elseif {$char eq ")"} {
-                        set subresult [dict get $bracketed_elements $in_bracket]
-                        dict set bracketed_elements $in_bracket [list]
-                        incr in_bracket -1
-                        if {$in_bracket == 0} {
-                            lappend result $subresult
-                        } else {
-                            dict lappend bracketed_elements $in_bracket $subresult
-                        }
-                    } elseif {[regexp {[\s]} $char]} {
-                        #
-                    } else {
-                        #first char of word - look for word-wrappers
-                        if {$char in [dict keys $wordwrappers]} {
-                            set wordwrap $char
-                            set word [lindex [dict get $wordwrappers $char] 0] ;#replace trigger char with the start value it maps to.
-                        } else {
-                            set word $char
-                        }
-                        set in_word 1
-                    }
-                }
-            } else {
-                if {$in_word} {
-                    if {[string length $wordwrap]} {
-                        lassign [dict get $wordwrappers $wordwrap] _open closing endmark
-                        if {$char eq $endmark} {
-                            set wordwrap ""
-                            append word $closing
-                            lappend result $word
-                            set word ""
-                            set in_word 0
-                        } else {
-                            append word $char
-                        }
-                    } else {
-                        
-                        if {$word_bdepth == 0} {
-                            if {$word in $shell_specials} {
-                                if {[regexp {[\s]} $char]} {
-                                    lappend result $word 
-                                    set word ""
-                                    set in_word 0
-                                } elseif {$char eq "("} {    
-                                    lappend result $word 
-                                    set word ""
-                                    set in_word 0
-                                    incr in_bracket
-                                } else {
-                                    #at end of shell-specials is another point to look for word started by a wordwrapper char
-                                    #- expect common case of things like >^/my/path^
-                                    if {$char in [dict keys $wordwrappers]} {
-                                        lappend result $word 
-                                        set word ""
-                                        set in_word 1 ;#just for explicitness.. we're straight into the next word.
-                                        set wordwrap $char
-                                        set word [lindex [dict get $wordwrappers $char] 0] ;#replace trigger char with the start value it maps to.
-                                    } else {
-                                        #something unusual.. keep going with word!
-                                        append word $char
-                                    }
-                                }
-                        
-                            } else {
-                                if {[regexp {[\s)]} $char]} {
-                                    lappend result $word
-                                    set word ""
-                                    set in_word 0
-                                } elseif {$char eq "("} {
-                                    incr word_bdepth
-                                    append word $char
-                                } else {
-                                append word $char
-                                }
-                            }
-                        } else {
-                            if {$char eq "("} {
-                                incr word_bdepth
-                                append word $char
-                            } elseif {$char eq ")"} {
-                                incr word_bdepth -1
-                                append word $char
-                            } else {
-                                append word $char
-                            }
-                        }
-                    }
-                } else {
-                    if {[regexp {[\s]} $char]} {
-                        #insig whitespace(?)
-                    } elseif {$char eq "("} {
-                        incr in_bracket
-                        dict set bracketed_elements $in_bracket [list]
-                    } elseif {$char eq ")"} {
-                        error "unbalanced bracket - unable to proceed result so far: $result bracketed_elements:$bracketed_elements"
-                    } else {
-                        #first char of word - look for word-wrappers
-                        if {$char in [dict keys $wordwrappers]} {
-                            set wordwrap $char
-                            set word [lindex [dict get $wordwrappers $char] 0] ;#replace trigger char with the start value it maps to.
-                        } else {
-                            set word $char
-                        }
-                        set in_word 1
-                    }
-                }
-            }
-            #puts "----$bracketed_elements"
-        }
-        if {$in_bracket > 0} {
-            error "shellfilter::parse_cmd_brackets missing close bracket. input was '$str'"
-        }
-        if {[dict exists $bracketed_elements 0]} {
-            #lappend result [lindex [dict get $bracketed_elements 0] 0]
-            lappend result [dict get $bracketed_elements 0]
-        }
-        if {$in_word} {
-            lappend result $word
-        }
-        return $result
-    }
-
-    #only double quote if argument not quoted with single or double quotes
-    proc dquote_if_not_quoted {a} {
-        if {([string range $a 0 0] eq {"}) && ([string range $a end end] eq {"})} {
-            return $a
-        } elseif {([string range $a 0 0] eq {'}) && ([string range $a end end] eq {'})} {
-            return $a
-        } else {
-            set newinner [string map [list {"} "\\\""] $a]
-            return "\"$newinner\""
-        }
-    }
-
-    #proc dquote_if_not_bracketed/braced? 
-
-    #wrap in double quotes if not double-quoted
-    proc dquote_if_not_dquoted {a} {
-        if {([string range $a 0 0] eq {"}) && ([string range $a end end] eq {"})} {
-            return $a
-        } else {
-            #escape any inner quotes..
-            set newinner [string map [list {"} "\\\""] $a]
-            return "\"$newinner\""
-        }
-    }
-    proc dquote {a} {
-        #escape any inner quotes..
-        set newinner [string map [list {"} "\\\""] $a]
-        return "\"$newinner\""
-    }
-    proc get_scriptrun_from_cmdlist_dquote_if_not {cmdlist {shellcmdflag ""}} {
-        set scr [auto_execok "script"]
-        if {[string length $scr]} {
-            #set scriptrun "( $c1 [lrange $cmdlist 1 end] )"
-            set arg1 [lindex $cmdlist 0]
-            if {[string first " " $arg1]>0} {
-                set c1 [dquote_if_not_quoted $arg1]
-                #set c1 "\"$arg1\""
-            } else {
-                set c1 $arg1
-            }
-
-            if {[string length $shellcmdflag]} {
-                set scriptrun "$shellcmdflag \$($c1 "
-            } else {
-                set scriptrun "\$($c1 "
-            }
-            #set scriptrun "$c1 "
-            foreach a [lrange $cmdlist 1 end] {
-                #set a [string map [list "/" "//"] $a]
-                #set a [string map [list "\"" "\\\""] $a]
-                if {[string first " " $a] > 0} {
-                    append scriptrun [dquote_if_not_quoted $a]
-                } else {
-                    append scriptrun $a
-                }
-                append scriptrun " "
-            }
-            set scriptrun [string trim $scriptrun]
-            append scriptrun ")"
-            #return [list $scr -q -e -c $scriptrun /dev/null]
-            return [list $scr -e -c $scriptrun /dev/null]
-        } else {
-            return $cmdlist
-        }
-    }
-
-    proc ::shellfilter::trun {commandlist args} {
-        #jmn
-    }
-
-
-    # run a command (or tcl script) with tees applied to stdout/stderr/stdin (or whatever channels are being used) 
-    # By the point run is called - any transforms should already be in place on the channels if they're needed.
-    # The tees will be inline with none,some or all of those transforms depending on how the stack was configured
-    #  (upstream,downstream configured via -float,-sink etc)
-    proc ::shellfilter::run {commandlist args} {
-        #must be a list. If it was a shell commandline string. convert it elsewhere first.
-
-        variable sources
-        set runtag "shellfilter-run"
-        #set tid [::shellfilter::log::open $runtag [list -syslog 127.0.0.1:514]]
-        set tid [::shellfilter::log::open $runtag [list -syslog ""]]
-        ::shellfilter::log::write $runtag " commandlist:'$commandlist' len:[llength $commandlist]"
-
-        #flush stdout
-        #flush stderr 
-
-        #adding filters with sink-aside will temporarily disable the existing redirection
-        #All stderr/stdout from the shellcommand will now tee to the underlying stderr/stdout as well as the configured syslog
-
-        set defaults [dict create \
-            -teehandle command \
-            -outchan stdout \
-            -errchan stderr \
-            -inchan stdin \
-            -tclscript 0 \
-            ]
-        set opts                    [dict merge $defaults $args]
-
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set outchan                 [dict get $opts -outchan]
-        set errchan                 [dict get $opts -errchan]
-        set inchan                  [dict get $opts -inchan]
-        set teehandle               [dict get $opts -teehandle]
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set is_script               [dict get $opts -tclscript]
-        dict unset opts -tclscript ;#don't pass it any further
-        # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
-        set teehandle_out ${teehandle}out   ;#default commandout
-        set teehandle_err ${teehandle}err
-        set teehandle_in ${teehandle}in
-
-
-        #puts stdout "shellfilter initialising tee_to_pipe transforms for in/out/err"
-
-        # sources should be added when stack::new called instead(?)
-        foreach source [list $teehandle_out $teehandle_err] {
-            if {$source ni $sources} {
-                lappend sources $source
-            }
-        }
-        set outdeviceinfo [dict get $::shellfilter::stack::pipelines $teehandle_out device]
-        set outpipechan [dict get $outdeviceinfo localchan]
-        set errdeviceinfo [dict get $::shellfilter::stack::pipelines $teehandle_err device]
-        set errpipechan [dict get $errdeviceinfo localchan]
-
-        #set indeviceinfo [dict get $::shellfilter::stack::pipelines $teehandle_in device]
-        #set inpipechan [dict get $indeviceinfo localchan]
-
-        #NOTE:These transforms are not necessarily at the top of each stack! 
-        #The float/sink mechanism, along with whether existing transforms are diversionary decides where they sit.
-        set id_out [shellfilter::stack::add $outchan tee_to_pipe -action sink-aside -settings [list -tag $teehandle_out -pipechan $outpipechan]]
-        set id_err [shellfilter::stack::add $errchan tee_to_pipe -action sink-aside -settings [list -tag $teehandle_err -pipechan $errpipechan]]
-
-        # need to use os level channel handle for stdin - try named pipes (or even sockets) instead of fifo2 for this
-        # If non os-level channel - the command can't be run with the redirection
-        # stderr/stdout can be run with non-os handles in the call - 
-        # but then it does introduce issues with terminal-detection and behaviour for stdout at least
-        #
-        # input is also a tee - we never want to change the source at this point - just log/process a side-channel of it.
-        #
-        #set id_in  [shellfilter::stack::add $inchan  tee_to_pipe -action sink-aside -settings [list -tag commandin -pipechan $inpipechan]]
-
-
-        #set id_out [shellfilter::stack::add stdout tee_to_log -action sink-aside -settings [list -tag shellstdout -syslog 127.0.0.1:514 -file ""]]
-        #set id_err [shellfilter::stack::add stderr tee_to_log -action sink-aside -settings [list -tag shellstderr -syslog 127.0.0.1:514 -file "stderr.txt"]]
-
-        #we need to catch errors - and ensure stack::remove calls occur.
-        #An error can be raised if the command couldn't even launch, as opposed to a non-zero exitcode and stderr output from the command itself.
-        #
-        if {!$is_script} { 
-            set experiment 0
-            if $experiment {
-                try {
-                    set results [exec {*}$commandlist]
-                    set exitinfo [list exitcode 0]
-                } trap CHILDSTATUS {results options} {
-                    set exitcode [lindex [dict get $options -errorcode] 2]
-                    set exitinfo [list exitcode $exitcode]
-                }
-            } else {
-                if {[catch { 
-                    #run process with stdout/stderr/stdin or with configured channels
-                    #set exitinfo [shellcommand_stdout_stderr $commandlist $outchan $errchan $inpipechan {*}$opts]
-                    set exitinfo [shellcommand_stdout_stderr $commandlist $outchan $errchan stdin {*}$opts]
-                    #puts stderr "---->exitinfo $exitinfo"
-
-                    #subprocess result should usually have an "exitcode" key
-                    #but for background execution we will get a "pids" key of process ids.
-                } errMsg]} {
-                    set exitinfo [list error "$errMsg" source shellcommand_stdout_stderr]
-                }
-            }
-        } else {
-            if {[catch {
-                #script result
-                set exitinfo [list result [uplevel #0 [list eval $commandlist]]]
-            } errMsg]} {
-                set exitinfo [list error "$errMsg" errorCode $::errorCode errorInfo "$::errorInfo"]
-            }
-        }
-
-
-        #the previous redirections on the underlying inchan/outchan/errchan items will be restored from the -aside setting during removal
-        #Remove execution-time Tees from stack
-        shellfilter::stack::remove stdout $id_out
-        shellfilter::stack::remove stderr $id_err
-        #shellfilter::stack::remove stderr $id_in
-
-
-        #chan configure stderr -buffering line
-        #flush stdout
-
-
-        ::shellfilter::log::write $runtag " return '$exitinfo'"
-        ::shellfilter::log::close $runtag
-        return $exitinfo
-    }
-    proc ::shellfilter::logtidyup { {tags {}} } {
-        variable sources
-        set worker_errorlist [list]
-        set tidied_sources [list]
-        set tidytag "logtidy"
-        set tid [::shellfilter::log::open $tidytag {-syslog 127.0.0.1:514}]
-        ::shellfilter::log::write $tidytag " logtidyuptags '$tags'"
-        foreach s $sources {
-            if {$s eq $tidytag} {
-                continue
-            }
-            #puts "logtidyup source $s"
-            set close 1
-            if {[llength $tags]} {
-                if {$s ni $tags} {
-                    set close 0
-                }
-            }
-            if {$close} {
-                lappend tidied_sources $s
-                shellfilter::log::close $s
-                lappend worker_errorlist {*}[shellthread::manager::get_and_clear_errors $s]
-            }
-        }
-        set remaining_sources [list]
-        foreach s $sources {
-            if {$s ni $tidied_sources} {
-                lappend remaining_sources $s
-            }
-        } 
-        set sources [concat $remaining_sources $tidytag]
-        #shellfilter::stack::unwind stdout
-        #shellfilter::stack::unwind stderr
-        return [list tidied $tidied_sources errors $worker_errorlist]
-    }
-
-    #package require tcl::chan::null
-    # e.g set errchan [tcl::chan::null]
-    # e.g chan push stdout [shellfilter::chan::var new ::some_var]
-    proc  ::shellfilter::shellcommand_stdout_stderr {commandlist outchan errchan inchan args} {
-        set valid_flags [list \
-            -timeout \
-            -outprefix \
-            -errprefix \
-            -debug \
-            -copytempfile \
-            -outbuffering \
-            -errbuffering \
-            -inbuffering \
-            -readprocesstranslation \
-            -outtranslation \
-            -stdinhandler \
-            -outchan \
-            -errchan \
-            -inchan \
-            -teehandle\
-            ]
-
-        set runtag shellfilter-run2
-        #JMN - load from config
-        #set tid [::shellfilter::log::open $runtag [list -syslog "127.0.0.1:514"]]
-        set tid [::shellfilter::log::open $runtag [list -syslog ""]]
-
-        if {([llength $args] % 2) != 0} {
-            error "Trailing arguments after any positional arguments must be in pairs of the form -argname argvalue. Valid flags are:'$valid_flags'"
-        }
-        set invalid_flags [list]
-        foreach k [dict keys $args] {
-            if {$k ni $valid_flags} {
-                lappend invalid_flags $k
-            }
-        }
-        if {[llength $invalid_flags]} {
-            error "Unknown option(s)'$invalid_flags': must be one of '$valid_flags'"
-        }
-        #line buffering generally best for output channels.. keeps relative output order of stdout/stdin closer to source order
-        #there may be data where line buffering is inappropriate, so it's configurable per std channel 
-        #reading inputs with line buffering can result in extraneous newlines as we can't detect trailing data with no newline before eof.
-        set defaults [dict create \
-            -outchan stdout \
-            -errchan stderr \
-            -inchan stdin \
-            -outbuffering none \
-            -errbuffering none \
-            -readprocesstranslation auto \
-            -outtranslation lf \
-            -inbuffering none \
-            -timeout 900000\
-            -outprefix ""\
-            -errprefix ""\
-            -debug 0\
-            -copytempfile 0\
-            -stdinhandler ""\
-            ]
-
-
-
-        set args [dict merge $defaults $args]
-        set outbuffering   [dict get $args -outbuffering]
-        set errbuffering   [dict get $args -errbuffering]
-        set inbuffering               [dict get $args -inbuffering]
-        set readprocesstranslation    [dict get $args -readprocesstranslation]
-        set outtranslation            [dict get $args -outtranslation]
-        set timeout                   [dict get $args -timeout]
-        set outprefix   [dict get $args -outprefix]
-        set errprefix   [dict get $args -errprefix]
-        set debug       [dict get $args -debug]
-        set copytempfile [dict get $args -copytempfile]
-        set stdinhandler [dict get $args -stdinhandler]
-
-        set debugname "shellfilter-debug"
-
-        if {$debug} {
-            set tid [::shellfilter::log::open $debugname [list -syslog "127.0.0.1:514"]]
-            ::shellfilter::log::write $debugname " commandlist '$commandlist'"
-        }
-        #'clock micros' good enough id for shellcommand calls unless one day they can somehow be called concurrently or sequentially within a microsecond and within the same interp.
-        # a simple counter would probably work too
-        #consider other options if an alternative to the single vwait in this function is used.
-        set call_id [clock micros] ;
-        set ::shellfilter::shellcommandvars($call_id,exitcode) ""
-        set waitvar ::shellfilter::shellcommandvars($call_id,waitvar)
-        if {$debug} {
-            ::shellfilter::log::write $debugname " waitvar '$waitvar'"
-        }
-        lassign [chan pipe] rderr wrerr
-        chan configure $wrerr -blocking 0
-
-        set lastitem [lindex $commandlist end]
-        #todo - ensure we can handle 2> file  (space after >)
-
-        if {[string trim [lindex $commandlist end]] eq "&"} {
-            set name [lindex $commandlist 0]
-            #background execution - stdout and stderr from child still comes here - but process is backgrounded 
-            #FIX! - this is broken for paths with backslashes for example
-            #set pidlist [exec {*}[concat $name [lrange $commandlist 1 end]]]
-            set pidlist [exec {*}$commandlist]
-            return [list pids $pidlist]
-        }
-
-        #review - reconsider the handling of redirections such that tcl-style are handled totally separately to other shell syntaxes!
-        #
-        #note 2>@1 must ocur as last word for tcl - but 2@stdout can occur elsewhere
-        #(2>@stdout echoes to main stdout - not into pipeline)
-        #To properly do pipelines it looks like we will have to split on | and call this proc multiple times and wire it up accordingly (presumably in separate threads)
-        set custom_stderr ""
-        if {[string trim $lastitem] in [list {2>&1} {2>@1}]} {
-            set custom_stderr {2>@1}  ;#use the tcl style
-            set commandlist [lrange $commandlist 0 end-1]
-        } else {
-            # 2> filename 
-            # 2>> filename
-            # 2>@ openfileid
-            set redir2test [string range $lastitem 0 1]
-            if {$redir2test eq "2>"} {
-                set custom_stderr $lastitem
-                set commandlist [lrange $commandlist 0 end-1]
-            }
-        }
-        set lastitem [lindex $commandlist end]
-
-        set teefile "" ;#empty string, write, append
-        #an ugly hack.. because redirections seem to arrive wrapped  - review!
-        #There be dragons here..
-        #Be very careful with list manipulation of the commandlist string.. backslashes cause havoc. commandlist must always be a well-formed list. generally avoid string manipulations on entire list or accidentally breaking a list element into parts if it shouldn't be..
-        #The problem here - is that we can't always know what was intended on the commandline regarding quoting
-
-        ::shellfilter::log::write $runtag "checking for redirections in $commandlist"
-        #sometimes we see a redirection without a following space  e.g >C:/somewhere 
-        #normalize
-        if {[regexp {^>[/[:alpha:]]+} $lastitem]} {
-            set lastitem "> [string range $lastitem 1 end]"
-        }
-        if {[regexp {^>>[/[:alpha:]]+} $lastitem]} {
-            set lastitem ">> [string range $lastitem 2 end]"
-        }
-
-        #for a redirection, we assume either a 2-element list at tail of form {> {some path maybe with spaces}}
-        #or that the tail redirection is not wrapped..  x y z > {some path maybe with spaces}
-        #we can't use list methods such as llenth on a member of commandlist
-        set wordlike_parts [regexp -inline -all {\S+} $lastitem]
-
-        if {([llength $wordlike_parts] >= 2) && ([lindex $wordlike_parts 0] in [list ">>" ">"])} {
-            #wrapped redirection - but maybe not 'well' wrapped (unquoted filename)
-            set lastitem [string trim $lastitem]  ;#we often see { > something}
-
-            #don't use lassign or lrange on the element itself without checking first
-            #we can treat the commandlist as a whole as a well formed list but not neccessarily each element within.
-            #lassign $lastitem redir redirtarget 
-            #set commandlist [lrange $commandlist 0 end-1]
-            #
-            set itemchars [split $lastitem ""]
-            set firstchar [lindex $itemchars 0]
-            set lastchar [lindex $itemchars end]
-
-            #NAIVE test for double quoted only!
-            #consider for example {"a" x="b"} 
-            #testing first and last is not decisive
-            #We need to decide what level of drilling down is even appropriate here.. 
-            #if something was double wrapped - it was perhaps deliberate so we don't interpret it as something(?)
-            set head_tail_chars [list $firstchar $lastchar]
-            set doublequoted [expr {[llength [lsearch -all $head_tail_chars "\""]] == 2}]
-            if {[string equal "\{" $firstchar] && [string equal "\}" $lastchar]} {
-                set curlyquoted 1
-            } else {
-                set curlyquoted 0
-            }
-
-            if {$curlyquoted} {
-                #these are not the tcl protection brackets but ones supplied in the argument
-                #it's still not valid to use list operations on a member of the commandlist
-                set inner [string range $lastitem 1 end-1]
-                #todo - fix! we still must assume there could be list-breaking data!
-                set innerwords [regexp -inline -all {\S+} $inner] ;#better than [split $inner] because we don't get extra empty elements for each whitespace char
-                set redir [lindex $innerwords 0] ;#a *potential* redir - to be tested below
-                set redirtarget [lrange $innerwords 1 end] ;#all the rest
-            } elseif {$doublequoted} {
-                ::shellfilter::log::write $debugname "doublequoting at tail of command '$commandlist'" 
-                set inner [string range $lastitem 1 end-1]
-                set innerwords [regexp -inline -all {\S+} $inner]
-                set redir [lindex $innerwords 0]
-                set redirtarget [lrange $innerwords 1 end] 
-            } else {
-                set itemwords [regexp -inline -all {\S+} $lastitem]
-                # e.g > c:\test   becomes > {c:\test}
-                # but > c/mnt/c/test/temp.txt stays as > /mnt/c/test/temp.txt
-                set redir [lindex $itemwords 0]
-                set redirtarget [lrange $itemwords 1 end]
-            }
-            set commandlist [lrange $commandlist 0 end-1]
-        
-      } elseif {[lindex $commandlist end-1] in [list ">>" ">"]} {
-        #unwrapped redirection
-        #we should be able to use list operations like lindex and lrange here as the command itself is hopefully still a well formed list
-        set redir [lindex $commandlist end-1]
-        set redirtarget [lindex $commandlist end]
-        set commandlist [lrange $commandlist 0 end-2]
-      } else {
-        #no redirection 
-        set redir ""
-        set redirtarget ""
-        #no change to command list
-      }
-
-
-
-      if {$redir in [list ">>" ">"]} {
-          set redirtarget [string trim $redirtarget "\""]
-          ::shellfilter::log::write $runtag " have redirection '$redir' to '$redirtarget'"
-          
-
-          set winfile $redirtarget ;#default assumption
-          if {[string match "/c/*" $redirtarget]} {
-            set winfile "c:/[string range $redirtarget 3 end]"
-          }
-          if {[string match "/mnt/c/*" $redirtarget]} {
-            set winfile "c:/[string range $redirtarget 7 end]"
-          }
-
-          if {[file exists [file dirname $winfile]]} {
-            #containing folder for target exists
-            if {$redir eq ">"} {
-              set teefile "write"
-            } else {
-              set teefile "append"
-            }
-            ::shellfilter::log::write $runtag "Directory exists '[file dirname $winfile]' operation:$teefile"
-
-          } else {
-            #we should be writing to a file.. but can't
-            ::shellfilter::log::write $runtag "cannot verify directory exists '[file dirname $winfile]'"
-
-          }
-      } else {
-          ::shellfilter::log::write $runtag "No redir found!!" 
-      }
-      #often first element of command list is wrapped and cannot be run directly
-      #e.g {{ls -l} {> {temp.tmp}}}
-      #we will assume that if there is a single element which is a pathname containing a space - it is doubly wrapped.
-      # this may not be true - and the command may fail if it's just {c:\program files\etc}  but it is the less common case and we currently have no way to detect.
-      #unwrap first element.. will not affect if not wrapped anyway (subject to comment above re spaces)
-      set commandlist [concat [lindex $commandlist 0] [lrange $commandlist 1 end]]
-
-      #todo?
-      #child process environment.
-      # - to pass a different environment to the child - we would need to save the env array, modify as required, and then restore the env array.
-
-      #to restore buffering states after run
-      set remember_in_out_err_buffering [list \
-         [chan configure $inchan -buffering] \
-         [chan configure $outchan -buffering] \
-         [chan configure $errchan -buffering] \
-         ]
-
-      set remember_in_out_err_translation [list \
-          [chan configure $inchan -translation] \
-          [chan configure $outchan -translation] \
-          [chan configure $errchan -translation] \
-          ]
-          
-      
-      
-
-
-      chan configure $inchan -buffering  $inbuffering -blocking 0  ;#we are setting up a readable handler for this - so non-blocking ok
-      chan configure $errchan -buffering $errbuffering
-      #chan configure $outchan -blocking 0
-      chan configure $outchan -buffering $outbuffering ;#don't configure non-blocking. weird duplicate of *second* line occurs if you do.
-      #
-
-      #--------------------------------------------
-      #Tested on windows. Works to stop <cr><cr><lf> in output when buffering is none, reading from channel with -translation auto
-      #cmd, pwsh, tcl 
-      #chan configure $outchan -translation lf
-      #chan configure $errchan -translation lf
-      #--------------------------------------------
-      chan configure $outchan -translation $outtranslation
-      chan configure $errchan -translation $outtranslation
-
-      #puts stderr "chan configure $wrerr [chan configure $wrerr]"
-      if {$debug} {
-        ::shellfilter::log::write $debugname "COMMAND  [list $commandlist] strlen:[string length $commandlist] llen:[llength $commandlist]"
-      }
-      #todo - handle custom redirection of stderr to a file?
-      if {[string length $custom_stderr]} {
-        #::shellfilter::log::write $runtag "LAUNCH open |[concat $commandlist $custom_stderr] a+"
-        #set rdout [open |[concat $commandlist $custom_stderr] a+] 
-        ::shellfilter::log::write $runtag "LAUNCH open |[concat $commandlist [list $custom_stderr <@$inchan]] [list RDONLY]"
-        set rdout [open |[concat $commandlist [list <@$inchan $custom_stderr]] [list RDONLY]] 
-        set rderr "bogus" ;#so we don't wait for it
-      } else {
-        ::shellfilter::log::write $runtag "LAUNCH open |[concat $commandlist [list 2>@$wrerr <@$inchan]] [list RDONLY]"
-        #set rdout [open |[concat $commandlist [list 2>@$wrerr]] a+]
-        #set rdout [open |[concat $commandlist [list 2>@$wrerr]] [list RDWR]]
-
-        # If we don't redirect stderr to our own tcl-based channel - then the transforms don't get applied. 
-        # This is the whole reason we need these file-event loops.
-        # Ideally we need something like exec,open in tcl that interacts with transformed channels directly and emits as it runs, not only at termination
-        #  - and that at least appears like a terminal to the called command.
-        #set rdout [open |[concat $commandlist [list 2>@stderr <@$inchan]] [list RDONLY]]
-        
-
-        set rdout [open |[concat $commandlist [list 2>@$wrerr <@$inchan]] [list RDONLY]]
-
-        chan configure $rderr -buffering $errbuffering -blocking 0
-        chan configure $rderr -translation $readprocesstranslation
-      }
-
-
-
-      set command_pids [pid $rdout]
-        #puts stderr "command_pids: $command_pids"
-        #tcl::process ensemble only available in 8.7+ - and it didn't prove useful here anyway
-        # the child process generally won't shut down until channels are closed.
-        # premature EOF on grandchild process launch seems to be due to lack of terminal emulation when redirecting stdin/stdout.
-        # worked around in punk/repl using 'script' command as a fake tty.
-        #set subprocesses [tcl::process::list]
-        #puts stderr "subprocesses: $subprocesses"
-        #if {[lindex $command_pids 0] ni $subprocesses} {
-        #    puts stderr "pid [lindex $command_pids 0] not running $errMsg"
-        #} else {
-        #    puts stderr "pid [lindex $command_pids 0] is running"
-        #}
-
-      
-      if {$debug} {
-          ::shellfilter::log::write $debugname "pipeline pids: $command_pids"
-      }
-
-      #jjj
-
-
-      chan configure $rdout -buffering $outbuffering -blocking 0
-      chan configure $rdout -translation $readprocesstranslation 
-
-      if {![string length $custom_stderr]} { 
-        chan event $rderr readable [list apply {{chan other wrerr outchan errchan waitfor errprefix errbuffering debug debugname pids} {
-            if {$errbuffering eq "line"} {
-                set countchunk [chan gets $chan chunk] ;#only get one line so that order between stderr and stdout is more likely to be preserved
-                #errprefix only applicable to line buffered output
-                if {$countchunk >= 0} {
-                    if {[chan eof $chan]} {
-                        puts -nonewline $errchan ${errprefix}$chunk
-                    } else {
-                        puts $errchan "${errprefix}$chunk"
-                    }
-                }
-            } else {
-                set chunk [chan read $chan]
-                if  {[string length $chunk]} {
-                    puts -nonewline $errchan $chunk
-                }
-            } 
-            if {[chan eof $chan]} {
-                flush $errchan ;#jmn
-                #set subprocesses [tcl::process::list]
-                #puts stderr "subprocesses: $subprocesses"
-                #if {[lindex $pids 0] ni $subprocesses} {
-                #    puts stderr "stderr reader: pid [lindex $pids 0] no longer running"
-                #} else {
-                #    puts stderr "stderr reader: pid [lindex $pids 0] still running"
-                #}
-                    chan close $chan
-                    #catch {chan close $wrerr}
-                    if {$other ni [chan names]} {
-                        set $waitfor stderr
-                    }
-            }
-        }} $rderr $rdout $wrerr $outchan $errchan $waitvar $errprefix $errbuffering $debug $debugname $command_pids]
-      }
-
-        #todo - handle case where large amount of stdin coming in faster than rdout can handle
-        #as is - arbitrary amount of memory could be used because we aren't using a filevent for rdout being writable
-        # - we're just pumping it in to the non-blocking rdout buffers 
-        # ie there is no backpressure and stdin will suck in as fast as possible.
-        # for most commandlines this probably isn't too big a deal.. but it could be a problem for multi-GB disk images etc
-        #
-        #
-        
-        ## Note - detecting trailing missing nl before eof is basically the same  here as when reading rdout from executable
-        # - but there is a slight difference in that with rdout we get an extra blocked state just prior to the final read.
-        # Not known if that is significant
-        ## with inchan configured -buffering line 
-        #c:\repo\jn\shellspy\test>printf "test\netc\n" | tclsh shellspy.vfs/main.tcl -r cat
-        #warning reading input with -buffering line. Cannot detect missing trailing-newline at eof
-        #instate  b:0 eof:0 pend:-1 count:4
-        #test
-        #instate  b:0 eof:0 pend:-1 count:3
-        #etc
-        #instate  b:0 eof:1 pend:-1 count:-1
-
-        #c:\repo\jn\shellspy\test>printf "test\netc" | tclsh shellspy.vfs/main.tcl -r cat
-        #warning reading input with -buffering line. Cannot detect missing trailing-newline at eof
-        #instate  b:0 eof:0 pend:-1 count:4
-        #test
-        #instate  b:0 eof:1 pend:-1 count:3
-        #etc
-
-        if 0 {
-            chan event $inchan readable [list apply {{chan wrchan inbuffering waitfor} {
-                #chan copy stdin $chan ;#doesn't work in a chan event
-                if {$inbuffering eq "line"} {
-                    set countchunk [chan gets $chan chunk]
-                    #puts $wrchan "stdinstate  b:[chan blocked $chan] eof:[chan eof $chan] pend:[chan pending output $chan] count:$countchunk"
-                    if {$countchunk >= 0} {
-                        if {[chan eof $chan]} {
-                            puts -nonewline $wrchan $chunk
-                        } else {
-                            puts $wrchan $chunk
-                        }
-                    }
-                } else {
-                    set chunk [chan read $chan]
-                    if {[string length $chunk]} {
-                        puts -nonewline $wrchan $chunk
-                    } 
-                }
-                if {[chan eof $chan]} {
-                    puts stderr "|stdin_reader>eof [chan configure stdin]"
-                    chan event $chan readable {}
-                    #chan close $chan 
-                    chan close $wrchan write ;#half close
-                    #set $waitfor "stdin"
-                }
-            }} $inchan $rdout $inbuffering $waitvar]
-       
-            if {[string length $stdinhandler]} {
-                chan configure stdin -buffering line -blocking 0
-                chan event stdin readable $stdinhandler
-            }
-       } 
-
-        set actual_proc_out_buffering [chan configure $rdout -buffering]
-        set actual_outchan_buffering [chan configure $outchan -buffering]
-        #despite whatever is configured - we match our reading to how we need to output
-        set read_proc_out_buffering $actual_outchan_buffering
-      
-
-
-      if {[string length $teefile]} {
-        set logname "redir_[string map [list : _ ] $winfile]_[clock micros]"
-        set tid [::shellfilter::log::open $logname {-syslog 127.0.0.1:514}]
-        if {$teefile eq "write"} {
-          ::shellfilter::log::write $logname "opening '$winfile' for write" 
-          set fd [open $winfile w]
-        } else {
-          ::shellfilter::log::write $logname "opening '$winfile' for appending" 
-          set fd [open $winfile a]
-        }
-        #chan configure $fd -translation lf 
-        chan configure $fd -translation $outtranslation
-        chan configure $fd -encoding utf-8 
-
-        set tempvar_bytetotal [namespace current]::totalbytes[clock micros] 
-        set $tempvar_bytetotal 0
-        chan event $rdout readable [list apply {{chan other wrerr outchan errchan read_proc_out_buffering waitfor outprefix call_id debug debugname writefile writefilefd copytempfile bytevar logtag} {
-            #review - if we write outprefix to normal stdout.. why not to redirected file?  
-            #usefulness of outprefix is dubious
-            upvar $bytevar totalbytes
-            if {$read_proc_out_buffering eq "line"} {
-                #set outchunk [chan read $chan]
-                set countchunk [chan gets $chan outchunk] ;#only get one line so that order between stderr and stdout is more likely to be preserved
-                if  {$countchunk >= 0} {
-                    if {![chan eof $chan]} {
-                        set numbytes [expr {[string length $outchunk] + 1}]  ;#we are assuming \n not \r\n - but count won't/can't be completely accurate(?) - review
-                        puts $writefilefd $outchunk
-                    } else {
-                        set numbytes [string length $outchunk]
-                        puts -nonewline $writefilefd $outchunk
-                    }
-                    incr totalbytes $numbytes
-                    ::shellfilter::log::write $logtag "${outprefix} wrote $numbytes  bytes to $writefile"
-                    #puts $outchan "${outprefix} wrote $numbytes  bytes to $writefile"
-                }
-            } else {
-                set outchunk [chan read $chan]
-                if {[string length $outchunk]} {
-                    puts -nonewline $writefilefd $outchunk
-                    set numbytes [string length $outchunk]
-                    incr totalbytes $numbytes
-                    ::shellfilter::log::write $logtag "${outprefix} wrote $numbytes  bytes to $writefile"
-                }
-            }
-            if {[chan eof $chan]} {
-                flush $writefilefd ;#jmn
-                #set blocking so we can get exit code
-                chan configure $chan -blocking 1 
-                catch {::shellfilter::log::write $logtag "${outprefix} total bytes $totalbytes written to $writefile"}
-                #puts $outchan "${outprefix} total bytes $totalbytes written to $writefile"
-                catch {close $writefilefd}
-                if {$copytempfile} {
-                  catch {file copy $writefile "[file rootname $writefile]_copy[file extension $writefile]"}
-                }
-                try {
-                    chan close $chan
-                    set ::shellfilter::shellcommandvars($call_id,exitcode) 0
-                    if {$debug} {
-                        ::shellfilter::log::write $debugname "(teefile) -- child process returned no error. (exit code 0) --"
-                    }
-                } trap CHILDSTATUS {result options} {
-                    set code [lindex [dict get $options -errorcode] 2]
-                    if {$debug} {
-                        ::shellfilter::log::write $debugname "(teefile) CHILD PROCESS EXITED with code: $code"
-                    }
-                    set ::shellfilter::shellcommandvars($call_id,exitcode) $code
-                }
-                catch {chan close $wrerr}
-                if {$other ni [chan names]} {
-                    set $waitfor stdout
-                }
-            }
-        }} $rdout $rderr $wrerr $outchan $errchan $read_proc_out_buffering $waitvar $outprefix $call_id $debug $debugname $winfile $fd $copytempfile $tempvar_bytetotal $logname]
-        
-      } else {
-
-        # This occurs when we have outbuffering set to 'line' - as the 'input' from rdout which comes from the executable is also configured to 'line'
-        # where b:0|1 is whether chan blocked $chan returns 0 or 1
-        # pend is the result of chan pending $chan
-        # eof is the resot of chan eof $chan
-
-
-        ##-------------------------
-        ##If we still read with gets,to retrieve line by line for output to line-buffered output - but the input channel is configured with -buffering none
-        ## then we can detect the difference
-        # there is an extra blocking read - but we can stil use eof with data to detect the absent newline and avoid passing an extra one on.
-        #c:\repo\jn\shellspy\test>printf "test\netc\n" | tclsh shellspy.vfs/main.tcl /c cat
-        #instate  b:0 eof:0 pend:-1 count:4
-        #test
-        #instate  b:0 eof:0 pend:-1 count:3
-        #etc
-        #instate  b:0 eof:1 pend:-1 count:-1
-
-        #c:\repo\jn\shellspy\test>printf "test\netc" | tclsh shellspy.vfs/main.tcl /u/c cat
-        #instate  b:0 eof:0 pend:-1 count:4
-        #test
-        #instate  b:1 eof:0 pend:-1 count:-1
-        #instate  b:0 eof:1 pend:-1 count:3
-        #etc
-        ##------------------------
-
-
-        #this should only occur if upstream is coming from stdin reader that has  line buffering and hasn't handled the difference properly..
-        ###reading with gets from line buffered input with trailing newline
-        #c:\repo\jn\shellspy\test>printf "test\netc\n" | tclsh shellspy.vfs/main.tcl /c cat
-        #instate  b:0 eof:0 pend:-1 count:4
-        #test
-        #instate  b:0 eof:0 pend:-1 count:3
-        #etc
-        #instate  b:0 eof:1 pend:-1 count:-1
-
-        ###reading with gets from line buffered input with trailing newline
-        ##No detectable difference!
-        #c:\repo\jn\shellspy\test>printf "test\netc" | tclsh shellspy.vfs/main.tcl /c cat
-        #instate  b:0 eof:0 pend:-1 count:4
-        #test
-        #instate  b:0 eof:0 pend:-1 count:3
-        #etc
-        #instate  b:0 eof:1 pend:-1 count:-1
-        ##-------------------------
-
-        #Note that reading from -buffering none and writing straight out gives no problem because we pass the newlines through as is
-
-        
-        #set ::shellfilter::chan::lastreadblocked_nodata_noeof($rdout) 0 ;#a very specific case of readblocked prior to eof.. possibly not important
-        #this detection is disabled for now - but left for debugging in case it means something.. or changes 
-        chan event $rdout readable [list apply {{chan other wrerr outchan errchan read_proc_out_buffering waitfor outprefix call_id debug debugname pids} {
-            #set outchunk [chan read $chan]
-            
-            if {$read_proc_out_buffering eq "line"} {
-                set countchunk [chan gets $chan outchunk] ;#only get one line so that order between stderr and stdout is more likely to be preserved
-                #countchunk can be -1 before eof e.g when blocked
-                #debugging output inline with data - don't leave enabled
-                #puts $outchan "instate  b:[chan blocked $chan] eof:[chan eof $chan] pend:[chan pending output $chan] count:$countchunk"
-                if {$countchunk >= 0} {
-                    if {![chan eof $chan]} { 
-                        puts $outchan ${outprefix}$outchunk
-                    } else {
-                        puts -nonewline $outchan ${outprefix}$outchunk
-                        #if {$::shellfilter::chan::lastreadblocked_nodata_noeof($chan)} {
-                        #   seems to be the usual case
-                        #} else {
-                        #    #false alarm, or ? we've reached eof with data but didn't get an empty blocking read just prior
-                        #    #Not known if this occurs
-                        #    #debugging output inline with data - don't leave enabled
-                        #    puts $outchan "!!!prev read didn't block: instate  b:[chan blocked $chan] eof:[chan eof $chan] pend:[chan pending output $chan] count:$countchunk"
-                        #}
-                    }
-                    #set ::shellfilter::chan::lastreadblocked_nodata_noeof($chan) 0
-                } else {
-                    #set ::shellfilter::chan::lastreadblocked_nodata_noeof($chan) [expr {[chan blocked $chan] && ![chan eof $chan]}]
-                }
-            } else {
-                #puts $outchan "read  CHANNEL $chan  [chan configure $chan]"
-                #puts $outchan "write CHANNEL $outchan b:[chan configure $outchan -buffering] t:[chan configure $outchan -translation] e:[chan configure $outchan -encoding]"
-                set outchunk [chan read $chan]
-                #puts $outchan "instate  b:[chan blocked $chan] eof:[chan eof $chan] pend:[chan pending output $chan] count:[string length $outchunk]"
-                if  {[string length $outchunk]} {
-                    #set stringrep [encoding convertfrom utf-8 $outchunk] 
-                    #set newbytes [encoding convertto utf-16 $stringrep]
-                    #puts -nonewline $outchan $newbytes
-                    puts -nonewline $outchan $outchunk
-                }
-            }
-
-            if {[chan eof $chan]} {
-                flush $outchan ;#jmn
-                #for now just look for first element in the pid list..
-                #set subprocesses [tcl::process::list]
-                #puts stderr "subprocesses: $subprocesses"
-                #if {[lindex $pids 0] ni $subprocesses} {
-                #    puts stderr "stdout reader pid: [lindex $pids 0] no longer running"
-                #} else {
-                #    puts stderr "stdout reader pid: [lindex $pids 0] still  running"
-                #}
-
-                #puts $outchan "instate  b:[chan blocked $chan] eof:[chan eof $chan] pend:[chan pending output $chan]"
-                    chan configure $chan -blocking 1 ;#so we can get exit code
-                    try {
-                        chan close $chan
-                        set ::shellfilter::shellcommandvars($call_id,exitcode) 0
-                        if {$debug} {
-                            ::shellfilter::log::write $debugname " -- child process returned no error. (exit code 0) --"
-                        }
-                    } trap CHILDSTATUS {result options} {
-                        set code [lindex [dict get $options -errorcode] 2]
-                        if {$debug} {
-                            ::shellfilter::log::write $debugname " CHILD PROCESS EXITED with code: $code"
-                        }
-                        set ::shellfilter::shellcommandvars($call_id,exitcode) $code
-                    } trap CHILDKILLED {result options} {
-                        #set code [lindex [dict get $options -errorcode] 2]
-                        #set ::shellfilter::shellcommandvars(%id%,exitcode) $code
-                        set ::shellfilter::shellcommandvars($call_id,exitcode) "childkilled"
-                        ::shellfilter::log::write $debugname " CHILD PROCESS EXITED with result:'$result' options:'$options'"
-
-                    } finally {
-                        #puts stdout "HERE"
-                        #flush stdout
-
-                    }
-                    catch {chan close $wrerr}
-                    if {$other ni [chan names]} {
-                        set $waitfor stdout
-                    } 
-
-            }
-        }} $rdout $rderr $wrerr $outchan $errchan $read_proc_out_buffering $waitvar $outprefix $call_id $debug $debugname $command_pids]
-      }
-
-      #todo - add ability to detect activity/data-flow and change timeout to only apply for period with zero data
-      #e.g x hrs with no data(?)
-      #reset timeout when data detected. 
-      after $timeout [string map [list %w $waitvar %id% $call_id %wrerr% $wrerr %rdout% $rdout %rderr% $rderr %debug% $debug %debugname% $debugname] {
-          if {[info exists ::shellfilter::shellcommandvars(%id%,exitcode)]} {
-              if {[set  ::shellfilter::shellcommandvars(%id%,exitcode)] ne ""} {
-                  catch { chan close %wrerr% }
-                  catch { chan close %rdout%}
-                  catch { chan close %rderr%}
-              } else {
-                  chan configure %rdout% -blocking 1
-                  try {
-                      chan close %rdout%
-                      set ::shellfilter::shellcommandvars(%id%,exitcode) 0
-                      if {%debug%} {
-                          ::shellfilter::log::write %debugname% "(timeout) -- child process returned no error. (exit code 0) --"
-                      }
-                  } trap CHILDSTATUS {result options} {
-                      set code [lindex [dict get $options -errorcode] 2]
-                      if {%debug%} {
-                          ::shellfilter::log::write %debugname% "(timeout) CHILD PROCESS EXITED with code: $code"
-                      }
-                      set ::shellfilter::shellcommandvars(%id%,exitcode) $code
-                  } trap CHILDKILLED {result options} {
-                      set code [lindex [dict get $options -errorcode] 2]
-                      #set code [dict get $options -code]
-                      #set ::shellfilter::shellcommandvars(%id%,exitcode) $code
-                      set ::shellfilter::shellcommandvars($call_id,exitcode) "childkilled-timeout"
-                      if {%debug%} {
-                          ::shellfilter::log::write %debugname% "(timeout) CHILDKILLED with code: $code"
-                          ::shellfilter::log::write %debugname% "(timeout) result:$result options:$options"
-                      }
-
-                  }
-                  catch { chan close %wrerr% }
-                  catch { chan close %rderr%}
-
-              }
-              set %w "timeout"
-          }
-      }]
-     
-
-      vwait $waitvar
-
-      set exitcode [set ::shellfilter::shellcommandvars($call_id,exitcode)]
-      if {![string is digit -strict $exitcode]} {
-          puts stderr "Process exited with non-numeric code: $exitcode"
-          flush stderr
-      }
-      if {[string length $teefile]} {
-          #cannot be called from within an event handler above.. vwait reentrancy etc
-          catch {::shellfilter::log::close $logname}
-      }
-
-      if {$debug} {
-          ::shellfilter::log::write $debugname " closed by: [set $waitvar] with exitcode: $exitcode"
-          catch {::shellfilter::log::close $debugname}
-      }
-      array unset ::shellfilter::shellcommandvars $call_id,*
-
-
-      #restore buffering to pre shellfilter::run state
-      lassign $remember_in_out_err_buffering bin bout berr
-      chan configure $inchan  -buffering $bin
-      chan configure $outchan -buffering $bout
-      chan configure $errchan -buffering $berr
-
-      lassign $remember_in_out_err_translation tin tout terr
-      chan configure $inchan  -translation $tin
-      chan configure $outchan -translation $tout
-      chan configure $errchan -translation $terr
-
-
-      #in channel probably closed..(? review - should it be?)
-      catch {
-        chan configure $inchan  -buffering $bin
-      }
-
-
-      return [list exitcode $exitcode]
-  }
-
-}
-
-package provide shellfilter [namespace eval shellfilter {
-    variable version
-    set version 0.1.8
-}]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/modules/shellrun-0.1.tm b/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/modules/shellrun-0.1.tm
deleted file mode 100644
index 5988ec40..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/modules/shellrun-0.1.tm
+++ /dev/null
@@ -1,710 +0,0 @@
-# vim: set ft=tcl
-#
-#purpose: handle the run commands that call shellfilter::run
-#e.g run,runout,runerr,runx
-
-package require shellfilter
-package require punk::ansi
-
-#NOTE: the run,runout,runerr,runx commands only produce an error if the command didn't run.
-# - If it did run, but there was a non-zero exitcode it is up to the application to check that.
-#This is deliberate, but means 'catch' doesn't catch errors within the command itself -  the exitcode has to be checked.
-#The user can always use exec for different process error semantics (they don't get exitcode with exec)
-
-namespace eval shellrun {
-    variable runout
-    variable runerr
-
-    #do we need these?
-    variable punkout
-    variable punkerr
-
-    #some ugly coupling with punk/punk::config for now
-    #todo - something better
-    if {[info exists ::punk::config::running]} {
-        upvar ::punk::config::running conf
-        set syslog_stdout [dict get $conf syslog_stdout] 
-        set syslog_stderr [dict get $conf syslog_stderr]
-        set logfile_stdout [dict get $conf logfile_stdout]
-        set logfile_stderr [dict get $conf logfile_stderr]
-    } else {
-        lassign [list "" "" "" ""] syslog_stdout syslog_stderr logfile_stdout logfile_stderr
-    }
-    set outdevice [shellfilter::stack::new punkout -settings [list -tag "punkout" -buffering none -raw 1 -syslog $syslog_stdout -file $logfile_stdout]]
-    set out [dict get $outdevice localchan]
-    set errdevice [shellfilter::stack::new punkerr -settings [list -tag "punkerr" -buffering none -raw 1 -syslog $syslog_stderr -file $logfile_stderr]]
-    set err [dict get $errdevice localchan]
-
-    namespace import ::punk::ansi::a+ 
-    namespace import ::punk::ansi::a
-
-
-
- 
-    #repltelemetry - additional/alternative display info used in a repl context i.e info directed towards the screen
-    #todo - package up in repltelemetry module and rewrite proc based on whether the module was found/loaded.
-    #somewhat strong coupling to punk - but let's try to behave decently if it's not loaded
-    #The last_run_display is actually intended for the repl - but is resident in the punk namespace with a view to the possibility of a different repl being in use.
-    proc set_last_run_display {chunklist} {
-        #chunklist as understood by the 
-        if {![info exists ::punk::repltelemetry_emmitters]} {
-            namespace eval ::punk {
-                variable repltelemetry_emmitters
-                set repltelemetry_emmitters "shellrun"
-            }
-        } else {
-            if {"shellrun" ni $::punk::repltelemetry_emmitters} {
-                lappend punk::repltelemetry_emmitters "shellrun"       
-            }
-        }
-
-        #most basic of validity tests here.. just that it is a list (can be empty). We don't want to duplicate or over-constrain the way repls/shells/terminals interpet the info
-        if {[catch {llength $chunklist} errMsg]} {
-            error  "set_last_run_display expects a list. Value supplied doesn't appear to be a well formed tcl list. '$errMsg'"
-        }
-        #todo - 
-        set ::punk::last_run_display  $chunklist
-    }
-
-
-
-    #maintenance: similar used in punk::ns & punk::winrun
-    #todo - take runopts + aliases as args
-    proc get_run_opts {arglist} {
-        if {[catch {
-            set callerinfo [info level -1]
-        } errM]} {
-            set caller ""
-        } else {
-            set caller [lindex $callerinfo 0]
-        }
-
-        #we provide -nonewline even for 'run' even though run doesn't deliver stderr or stdout to the tcl return value
-        #This is for compatibility with other runX commands, and the difference is also visible when calling from repl.
-        set known_runopts [list "-echo" "-e" "-nonewline" "-n" "-tcl"]
-        set aliases [list "-e" "-echo" "-echo" "-echo" "-n" "-nonewline" "-nonewline" "-nonewline" "-tcl" "-tcl"] ;#include map to self
-        set runopts [list]
-        set cmdargs [list]
-        set idx_first_cmdarg [lsearch -not $arglist "-*"]
-        set runopts [lrange $arglist 0 $idx_first_cmdarg-1]
-        set cmdargs [lrange $arglist $idx_first_cmdarg end]
-        foreach o $runopts {
-            if {$o ni $known_runopts} {
-                error "$caller: Unknown runoption $o - known options $known_runopts"
-            }
-        }
-        set runopts [lmap o $runopts {dict get $aliases $o}]
-        return [list runopts $runopts cmdargs $cmdargs]
-    }
-
-
-
-    proc run {args} {
-        set_last_run_display [list]
-
-        set splitargs [get_run_opts $args]
-        set runopts [dict get $splitargs runopts]
-        set cmdargs [dict get $splitargs cmdargs]
-
-        if {"-nonewline" in $runopts} {
-            set nonewline 1
-        } else {
-            set nonewline 0
-        }
-        set idlist_stderr [list] 
-        #we leave stdout without imposed ansi colouring - because the source may be colourised
-        #stderr might have source colouring - but it usually doesn't seem to, and the visual distiction of red stderr is very handy for the run command.
-        #A further enhancement could be to detect well-known options such as --color and/or use a configuration for specific commands that have useful colourised stderr,
-        #but defaulting stderr to red is a pretty reasonable compromise.
-        #Note that the other run commands, runout,runerr, runx don't emit in real-time - so for those commands there may be options to detect and/or post-process stdout and stderr.
-        #TODO - fix. This has no effect because the repl adds an ansiwrap transform 
-        # what we probably want to do is 'aside' that transform for runxxx commands only.
-        #lappend idlist_stderr [shellfilter::stack::add stderr ansiwrap -settings {-colour {red bold}}]
-
-        set callopts [dict create]
-        if {"-tcl" in $runopts} {
-            dict set callopts  -tclscript 1
-        }
-        #---------------------------------------------------------------------------------------------
-        set exitinfo [shellfilter::run $cmdargs {*}$callopts -teehandle punk -inbuffering none -outbuffering none ]
-        #---------------------------------------------------------------------------------------------
-
-        foreach id $idlist_stderr {
-            shellfilter::stack::remove stderr $id
-        } 
-
-        flush stderr
-        flush stdout
-
-        if {[dict exists $exitinfo error]} {
-            error "[dict get $exitinfo error]\n$exitinfo"
-        }
-
-        return $exitinfo
-    }
-
-    proc runout {args} {
-        set_last_run_display [list]
-        variable runout
-        variable runerr
-        set runout ""
-        set runerr ""
-
-        set splitargs [get_run_opts $args]
-        set runopts [dict get $splitargs runopts]
-        set cmdargs [dict get $splitargs cmdargs]
-
-        if {"-nonewline" in $runopts} {
-            set nonewline 1
-        } else {
-            set nonewline 0
-        }
-    
-        #puts stdout "RUNOUT cmdargs: $cmdargs"
-       
-        #todo   add -data boolean and -data lastwrite to -settings with default being -data all
-        # because sometimes we're only interested in last char (e.g to detect something was output)
-
-        #set outvar_stackid [shellfilter::stack::add commandout tee_to_var  -action float -settings {-varname ::runout}]
-        #
-        #when not echoing - use float-locked so that the repl's stack is bypassed
-        if {"-echo" in $runopts} {
-            set stdout_stackid [shellfilter::stack::add stdout tee_to_var -action float-locked -settings {-varname ::shellrun::runout}]
-            set stderr_stackid [shellfilter::stack::add stderr tee_to_var -action float-locked -settings {-varname ::shellrun::runerr}]
-            #set stderr_stackid [shellfilter::stack::add stderr tee_to_var -action sink-locked -settings {-varname ::shellrun::runerr}]
-        } else {
-            set stdout_stackid [shellfilter::stack::add stdout var -action float-locked -settings {-varname ::shellrun::runout}]
-            set stderr_stackid [shellfilter::stack::add stderr var -action float-locked -settings {-varname ::shellrun::runerr}]
-        }
-
-        set callopts ""
-        if {"-tcl" in $runopts} {
-            append callopts " -tclscript 1"
-        }
-
-        #shellfilter::run [lrange $args 1 end] -teehandle punk -outchan stdout -inbuffering none -outbuffering none -stdinhandler ::repl::repl_handler
-        set exitinfo [shellfilter::run $cmdargs {*}$callopts -teehandle punk -inbuffering none -outbuffering none ]
-
-        flush stderr
-        flush stdout
-
-        shellfilter::stack::remove stdout $stdout_stackid
-        shellfilter::stack::remove stderr $stderr_stackid
-
-        #shellfilter::stack::remove commandout $outvar_stackid
-
-        if {[dict exists $exitinfo error]} {
-            if {"-tcl" in $runopts} {
-
-            } else {
-                #we must raise an error. 
-                #todo - check errorInfo makes sense.. return -code? tailcall?
-                #
-                set msg ""
-                append msg [dict get $exitinfo error]
-                append msg "\n(add -tcl option to run as a tcl command/script instead of an external command)"
-                error $msg
-            }
-        }
-
-        set chunklist [list]
-
-        #exitcode not part of return value for runout - colourcode appropriately
-        set n [a]
-        set c ""
-        if [dict exists $exitinfo exitcode] {
-            set code [dict get $exitinfo exitcode]
-            if {$code == 0} {
-                set c [a+ green]
-            } else {
-                set c [a+ white bold]
-            }
-            lappend chunklist [list "info" "$c$exitinfo$n"]
-        } elseif [dict exists $exitinfo error] {
-            set c [a+ yellow bold]
-            lappend chunklist [list "info" "${c}error [dict get $exitinfo error]$n"]
-            lappend chunklist [list "info" "errorCode [dict get $exitinfo errorCode]"]
-            #lappend chunklist [list "info" "errorInfo [list [dict get $exitinfo errorInfo]]"]
-            lappend chunklist [list "info" errorInfo]
-            lappend chunklist [list "stderr" [dict get $exitinfo errorInfo]]
-        } else {
-            set c [a+ Yellow red bold]
-            lappend chunklist [list "info" "$c$exitinfo$n"]
-        }
-
-
-        set chunk "[a+ red bold]stderr[a]"
-        lappend chunklist [list "info" $chunk]
-
-        set chunk ""
-        if {[string length $::shellrun::runerr]} {
-            if {$nonewline} {
-                set e [string trimright $::shellrun::runerr \r\n]
-            } else {
-                set e $::shellrun::runerr
-            }
-            #append chunk "[a+ red light]$e[a]\n"
-            append chunk "[a+ red light]$e[a]"
-        }
-        lappend chunklist [list stderr $chunk]
-
-
-
-
-        lappend chunklist [list "info" "[a+ white bold]stdout[a]"]
-        set chunk ""
-        if {[string length $::shellrun::runout]} {
-            if {$nonewline} {
-                set o [string trimright $::shellrun::runout \r\n]
-            } else {
-                set o $::shellrun::runout
-            }
-            append chunk "$o"  
-        }
-        lappend chunklist [list result $chunk]
-
-
-        set_last_run_display $chunklist
-
-        if {$nonewline} {
-            return [string trimright $::shellrun::runout \r\n]
-        } else {
-            return $::shellrun::runout
-        }
-    }
-
-    proc runerr {args} {
-        set_last_run_display [list]
-        variable runout 
-        variable runerr
-        set runout ""
-        set runerr ""
-
-        set splitargs [get_run_opts $args]
-        set runopts [dict get $splitargs runopts]
-        set cmdargs [dict get $splitargs cmdargs]
-
-        if {"-nonewline" in $runopts} {
-            set nonewline 1
-        } else {
-            set nonewline 0
-        }
-
-        set callopts ""
-        if {"-tcl" in $runopts} {
-            append callopts " -tclscript 1"
-        }
-        if {"-echo" in $runopts} {
-            set stderr_stackid [shellfilter::stack::add stderr tee_to_var -action float-locked -settings {-varname ::shellrun::runerr}]
-            set stdout_stackid [shellfilter::stack::add stdout tee_to_var -action float-locked -settings {-varname ::shellrun::runout}]
-        } else {
-            set stderr_stackid [shellfilter::stack::add stderr var -action float-locked -settings {-varname ::shellrun::runerr}]
-            set stdout_stackid [shellfilter::stack::add stdout var -action float-locked -settings {-varname ::shellrun::runout}]
-        }
-
-
-        set exitinfo [shellfilter::run $cmdargs {*}$callopts -teehandle punk -inbuffering none -outbuffering none -stdinhandler ::repl::repl_handler]
-        shellfilter::stack::remove stderr $stderr_stackid
-        shellfilter::stack::remove stdout $stdout_stackid
-
-
-        flush stderr
-        flush stdout
-
-        #we raise an error because an error during calling is different to collecting stderr from a command, and the caller should be able to wrap in a catch
-        # to determine something other than just a nonzero exit code or output  on stderr.
-        if {[dict exists $exitinfo error]} {
-            if {"-tcl" in $runopts} {
-
-            } else {
-                #todo - check errorInfo makes sense.. return -code? tailcall?
-                error [dict get $exitinfo error]
-            }
-        }
-
-        set chunklist [list]
-
-        set n [a]
-        set c ""
-        if [dict exists $exitinfo exitcode] {
-            set code [dict get $exitinfo exitcode]
-            if {$code == 0} {
-                set c [a+ green]
-            } else {
-                set c [a+ white bold]
-            }
-
-            lappend chunklist [list "info" "$c$exitinfo$n"]
-            
-        } elseif [dict exists $exitinfo error] {
-            set c [a+ yellow bold]
-            lappend chunklist [list "info" "error [dict get $exitinfo error]"]
-            lappend chunklist [list "info" "errorCode [dict get $exitinfo errorCode]"]
-            lappend chunklist [list "info" "errorInfo [list [dict get $exitinfo errorInfo]]"]
-        } else {
-            set c [a+ Yellow red bold]
-            lappend chunklist [list "info" "$c$exitinfo$n"]
-        }
-
-
-        lappend chunklist [list "info" "[a+ white bold]stdout[a]"]
-        set chunk ""
-        if {[string length $::shellrun::runout]} {
-            if {$nonewline} {
-                set o [string trimright $::shellrun::runout \r\n]
-            } else {
-                set o $::shellrun::runout
-            }
-            append chunk "[a+ white light]$o[a]\n"  ;#this newline is the display output separator - always there whether data has trailing newline or not.
-        }
-        lappend chunklist [list stdout $chunk]
-
-
-
-        set chunk "[a+ red bold]stderr[a]"
-        lappend chunklist [list "info" $chunk]
-
-        set chunk ""
-        if {[string length $::shellrun::runerr]} {
-            if {$nonewline} {
-                set e [string trimright $::shellrun::runerr \r\n]
-            } else {
-                set e $::shellrun::runerr
-            }
-            append chunk "$e"
-        }
-        lappend chunklist [list resulterr $chunk]
-
-
-        set_last_run_display $chunklist
-
-        if {$nonewline} {
-            return [string trimright $::shellrun::runerr \r\n]
-        }
-        return $::shellrun::runerr
-    }
-
-
-    proc runx {args} {
-        set_last_run_display [list] 
-        variable runout 
-        variable runerr
-        set runout ""
-        set runerr ""
-
-        set splitargs [get_run_opts $args]
-        set runopts [dict get $splitargs runopts]
-        set cmdargs [dict get $splitargs cmdargs]
-
-        if {"-nonewline" in $runopts} {
-            set nonewline 1
-        } else {
-            set nonewline 0
-        }
-
-        #shellfilter::stack::remove stdout $::repl::id_outstack
-
-        if {"-echo" in $runopts} {
-            #float to ensure repl transform doesn't interfere with the output data
-            set stderr_stackid [shellfilter::stack::add stderr tee_to_var -action float -settings {-varname ::shellrun::runerr}]
-            set stdout_stackid [shellfilter::stack::add stdout tee_to_var -action float -settings {-varname ::shellrun::runout}]
-        } else {
-            #set stderr_stackid [shellfilter::stack::add stderr var -action sink-locked -settings {-varname ::shellrun::runerr}]
-            #set stdout_stackid [shellfilter::stack::add stdout var -action sink-locked -settings {-varname ::shellrun::runout}]
-
-            #float above the repl's tee_to_var to deliberately block it.
-            #a var transform is naturally a junction point because there is no flow-through..
-            # - but mark it with -junction 1 just to be explicit
-            set stderr_stackid [shellfilter::stack::add stderr var -action float-locked -junction 1 -settings {-varname ::shellrun::runerr}]
-            set stdout_stackid [shellfilter::stack::add stdout var -action float-locked -junction 1 -settings {-varname ::shellrun::runout}]
-        }
-        
-        set callopts ""
-        if {"-tcl" in $runopts} {
-            append callopts " -tclscript 1"
-        }
-        #set exitinfo [shellfilter::run $cmdargs -teehandle punk -inbuffering none -outbuffering none -stdinhandler ::repl::repl_handler]
-        set exitinfo [shellfilter::run $cmdargs {*}$callopts -teehandle punk -inbuffering none -outbuffering none]
-
-        shellfilter::stack::remove stdout $stdout_stackid
-        shellfilter::stack::remove stderr $stderr_stackid
-
-
-        flush stderr
-        flush stdout
-       
-        if {[dict exists $exitinfo error]} {
-            if {"-tcl" in $runopts} {
-
-            } else {
-                #todo - check errorInfo makes sense.. return -code? tailcall?
-                error [dict get $exitinfo error]
-            }
-        }
-        
-        #set x [shellfilter::stack::add stdout var -action sink-locked -settings {-varname ::repl::runxoutput}]
-
-        set chunk ""
-        if {[string length $::shellrun::runout]} {
-            if {$nonewline} {
-                set o [string trimright $::shellrun::runout \r\n]
-            } else {
-                set o $::shellrun::runout
-            }
-            set chunk $o
-        }
-        set chunklist [list]
-        lappend chunklist [list "info" " "]
-        lappend chunklist [list "result" stdout] ;#key 'stdout' forms part of the resulting dictionary output
-        lappend chunklist [list "info" "[a+ white bold]stdout[a]"]
-        lappend chunklist [list result $chunk]   ;#value corresponding to 'stdout' key in resulting dict
-
-
-        lappend chunklist [list "info" " "]
-        set chunk "[a+ red bold]stderr[a]"
-        lappend chunklist [list "result" $chunk]
-        lappend chunklist [list "info" stderr]
-
-        set chunk ""
-        if {[string length $::shellrun::runerr]} {
-            if {$nonewline} {
-                set e [string trimright $::shellrun::runerr \r\n]
-            } else {
-                set e $::shellrun::runerr
-            }
-            set chunk $e
-        }
-        #stderr is part of the result
-        lappend chunklist [list "resulterr" $chunk]
-
-
-
-        set n [a]
-        set c ""
-        if {[dict exists $exitinfo exitcode]} {
-            set code [dict get $exitinfo exitcode]
-            if {$code == 0} {
-                set c [a+ green]
-            } else {
-                set c [a+ yellow bold]
-            }
-            lappend chunklist [list "info" " "]
-            lappend chunklist [list "result" exitcode]
-            lappend chunklist [list "info" "exitcode $code"]
-            lappend chunklist [list "result" "$c$code$n"]
-            set exitdict [list exitcode $code]
-        } elseif {[dict exists $exitinfo result]} {
-            # presumably from a -tcl call
-            set val [dict get $exitinfo result] 
-            lappend chunklist [list "info" " "]
-            lappend chunklist [list "result" result]
-            lappend chunklist [list "info"   result]
-            lappend chunklist [list "result" $val]
-            set exitdict [list result $val]
-        } elseif {[dict exists $exitinfo error]} {
-            # -tcl call with error
-            #set exitdict [dict create]
-            lappend chunklist [list "info" " "]
-            lappend chunklist [list "result" error]
-            lappend chunklist [list "info"   error]
-            lappend chunklist [list "result" [dict get $exitinfo error]]
-
-            lappend chunklist [list "info" " "]
-            lappend chunklist [list "result" errorCode]
-            lappend chunklist [list "info"   errorCode]
-            lappend chunklist [list "result" [dict get $exitinfo errorCode]]
-
-            lappend chunklist [list "info" " "]
-            lappend chunklist [list "result" errorInfo]
-            lappend chunklist [list "info"   errorInfo]
-            lappend chunklist [list "result" [dict get $exitinfo errorInfo]]
-
-            set exitdict $exitinfo
-        } else {
-            #review - if no exitcode or result. then what is it?
-            lappend chunklist [list "info" exitinfo]
-            set c [a+ yellow bold]
-            lappend chunklist [list result "$c$exitinfo$n"]
-            set exitdict [list exitinfo $exitinfo]
-        }
-
-        set_last_run_display $chunklist
-
-        #set ::repl::result_print 0
-        #return [lindex [list [list stdout $::runout stderr $::runerr {*}$exitinfo] [shellfilter::stack::remove stdout $x][puts -nonewline stdout $pretty][set ::repl::output ""]] 0]
-
-
-        if {$nonewline} {
-            return [list {*}$exitdict stdout [string trimright $::shellrun::runout \r\n] stderr [string trimright $::shellrun::runerr \r\n]]
-        }
-        #always return exitinfo $code at beginning of dict (so that punk unknown can interpret the exit code as a unix-style bool if double evaluated)
-        return [list {*}$exitdict stdout $::shellrun::runout stderr $::shellrun::runerr]
-    }
-
-    #an experiment
-    #
-    #run as raw string instead of tcl-list - no variable subst  etc
-    #
-    #dummy repl_runraw that repl will intercept
-    proc repl_runraw {args} {
-        error "runraw: only available in repl as direct call - not from script"
-    }
-    #we can only call runraw with a single (presumably braced) string if we want to use it from both repl and tcl scripts  (why? todo with unbalanced quotes/braces?)
-    proc runraw {commandline} {
-        #runraw fails as intended - because we can't bypass exec/open interference quoting :/
-        set_last_run_display [list] 
-        variable runout 
-        variable runerr
-        set runout ""
-        set runerr ""
-
-        #return [shellfilter::run [lrange $args 1 end] -teehandle punk -inbuffering none -outbuffering none -stdinhandler ::repl::repl_handler]
-        puts stdout ">>runraw got: $commandline"
-        
-        #run always echoes anyway.. as we aren't diverting stdout/stderr off for capturing
-        #for consistency with other runxxx commands - we'll just consume it. (review)
-
-        set reallyraw 1
-        if {$reallyraw} {
-            set wordparts [regexp -inline -all {\S+} $commandline]
-            set runwords $wordparts
-        } else {
-            #shell style args parsing not suitable for windows where we can't assume matched quotes etc.
-            package require string::token::shell
-            set parts [string token shell -indices -- $commandline]
-            puts stdout ">>shellparts: $parts"
-            set runwords [list]
-            foreach p $parts {
-                set ptype [lindex $p 0]
-                set pval [lindex $p 3]
-                if {$ptype eq "PLAIN"} {
-                    lappend runwords [lindex $p 3]
-                } elseif {$ptype eq "D:QUOTED"} {
-                    set v {"}
-                    append v $pval
-                    append v {"}
-                    lappend runwords $v
-                } elseif {$ptype eq "S:QUOTED"} {
-                    set v {'}
-                    append v $pval
-                    append v {'}
-                    lappend runwords $v
-                }
-            }
-        }
-        
-        puts stdout ">>runraw runwords: $runwords"
-        set runwords [lrange $runwords 1 end]
-        
-        puts stdout ">>runraw runwords: $runwords"
-        #set args [lrange $args 1 end]
-        #set runwords [lrange $wordparts 1 end]
-        
-        set known_runopts [list "-echo" "-e" "-terminal" "-t"]
-        set aliases [list "-e" "-echo" "-echo" "-echo" "-t" "-terminal" "-terminal" "-terminal"] ;#include map to self
-        set runopts [list]
-        set cmdwords [list]
-        set idx_first_cmdarg [lsearch -not $runwords "-*"]
-        set runopts [lrange $runwords 0 $idx_first_cmdarg-1]
-        set cmdwords [lrange $runwords $idx_first_cmdarg end]
-        
-        foreach o $runopts {
-            if {$o ni $known_runopts} {
-                error "runraw: Unknown runoption $o"
-            }
-        }
-        set runopts [lmap o $runopts {dict get $aliases $o}]
-        
-        set cmd_as_string [join $cmdwords " "]
-        puts stdout ">>cmd_as_string: $cmd_as_string"
-        
-        if {"-terminal" in $runopts} {
-            #fake terminal using 'script' command.
-            #not ideal: smushes stdout & stderr together amongst other problems
-            set tcmd [shellfilter::get_scriptrun_from_cmdlist_dquote_if_not $cmdwords]
-            puts stdout ">>tcmd: $tcmd"
-            set exitinfo [shellfilter::run $tcmd -teehandle punk -inbuffering line -outbuffering none ]
-            set exitinfo "exitcode not-implemented"
-        } else {
-            set exitinfo [shellfilter::run $cmdwords -teehandle punk -inbuffering line -outbuffering none ]
-        }
-        
-        if {[dict exists $exitinfo error]} {
-            #todo - check errorInfo makes sense.. return -code? tailcall?
-            error [dict get $exitinfo error]
-        }
-        set code [dict get $exitinfo exitcode]
-        if {$code == 0} {
-            set c [a+ green]
-        } else {
-            set c [a+ white bold]
-        }
-        puts stderr $c
-        return $exitinfo
-    }
-
-    proc sh_run {args} {
-        set splitargs [get_run_opts $args]
-        set runopts [dict get $splitargs runopts]
-        set cmdargs [dict get $splitargs cmdargs]
-        #e.g sh -c "ls -l *"
-        #we pass cmdargs to sh -c as a list, not individually
-        tailcall shellrun::run {*}$runopts sh -c $cmdargs
-    }
-    proc sh_runout {args} {
-        set splitargs [get_run_opts $args]
-        set runopts [dict get $splitargs runopts]
-        set cmdargs [dict get $splitargs cmdargs]
-        tailcall shellrun::runout {*}$runopts sh -c $cmdargs
-    }
-    proc sh_runerr {args} {
-        set splitargs [get_run_opts $args]
-        set runopts [dict get $splitargs runopts]
-        set cmdargs [dict get $splitargs cmdargs]
-        tailcall shellrun::runerr {*}$runopts sh -c $cmdargs
-    }
-    proc sh_runx {args} {
-        set splitargs [get_run_opts $args]
-        set runopts [dict get $splitargs runopts]
-        set cmdargs [dict get $splitargs cmdargs]
-        tailcall shellrun::runx {*}$runopts sh -c $cmdargs
-    }
-}
-
-namespace eval shellrun {
-    interp alias {} run     {} shellrun::run
-    interp alias {} sh_run  {} shellrun::sh_run
-    interp alias {} runout  {} shellrun::runout
-    interp alias {} sh_runout  {} shellrun::sh_runout
-    interp alias {} runerr  {} shellrun::runerr
-    interp alias {} sh_runerr  {} shellrun::sh_runerr
-    interp alias {} runx    {} shellrun::runx
-    interp alias {} sh_runx  {} shellrun::sh_runx
-
-    interp alias {} runraw {} shellrun::runraw
-
-
-    #the shortened versions deliberately don't get pretty output from the repl
-    interp alias {} r       {} shellrun::run
-    interp alias {} ro      {} shellrun::runout
-    interp alias {} re      {} shellrun::runerr
-    interp alias {} rx      {} shellrun::runx
-    
-
-}
-
-namespace eval shellrun {
-    proc test_cffi {} {
-        package require test_cffi
-        cffi::Wrapper create ::shellrun::kernel32 [file join $env(windir) system32 Kernel32.dll]
-        ::shellrun::kernel32 stdcall CreateProcessA 
-        #todo - stuff.
-        return ::shellrun::kernel32
-    }
-
-}
-
-package provide shellrun [namespace eval shellrun {
-    variable version
-    set version 0.1
-}]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/modules/shellthread-1.6.tm b/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/modules/shellthread-1.6.tm
deleted file mode 100644
index 7085e66d..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/sample.vfs/modules/shellthread-1.6.tm
+++ /dev/null
@@ -1,702 +0,0 @@
-#package require logger
-
-package provide shellthread [namespace eval shellthread {
-  variable version
-  set version 1.6
-}]
-
-
-package require Thread
-
-namespace eval shellthread {
-
-  proc iso8601 {{tsmicros ""}} {
-    if {$tsmicros eq ""} {
-        set tsmicros [clock micros]
-    } else {
-        set microsnow [clock micros]
-        if {[string length $tsmicros] != [string length $microsnow]} {
-            error "iso8601 requires 'clock micros' or empty string to create timestamp"
-        }
-    }
-    set seconds [expr {$tsmicros / 1000000}]
-    return [clock format $seconds  -format "%Y-%m-%d_%H-%M-%S"]
-  }
-}
-
-namespace eval shellthread::worker {
-    variable settings
-    variable sysloghost_port
-    variable sock
-    variable logfile ""
-    variable fd
-    variable client_ids [list]
-    variable ts_start_micros
-    variable errorlist [list]
-    variable inpipe ""
-
-    proc bgerror {args} {
-       variable errorlist
-       lappend errorlist $args
-    }
-    proc send_errors_now {tidcli} {
-      variable errorlist
-      thread::send -async $tidcli [list shellthread::manager::report_worker_errors [list worker_tid [thread::id] errors $errorlist]]
-    }
-    proc add_client_tid {tidcli} {
-      variable client_ids
-      if {$tidcli ni $client_ids} {
-        lappend client_ids $tidcli
-      }
-    }
-    proc init {tidclient start_m settingsdict} {
-        variable sysloghost_port
-        variable logfile
-        variable settings
-        interp bgerror {} shellthread::worker::bgerror
-        package require overtype
-        variable client_ids
-        variable ts_start_micros
-        lappend client_ids $tidclient
-        set ts_start_micros $start_m
-
-        set defaults [list -raw 0 -file "" -syslog "" -direction out]
-        set settings [dict merge $defaults $settingsdict]
-
-        set syslog [dict get $settings -syslog]
-        if {[string length $syslog]} {
-            lassign [split $syslog :] s_host s_port
-            set sysloghost_port [list $s_host $s_port]
-        } else {
-            set sysloghost_port ""
-        }
-        if {[catch {package require udp} errm]} {
-            #disable rather than bomb and interfere with any -file being written
-            set sysloghost_port ""
-        }
-
-        set logfile [dict get $settings -file]
-    }
-
-    proc start_pipe_read {source readchan args} {
-        #assume 1 inpipe for now
-        variable inpipe
-        variable sysloghost_port
-        variable logfile
-        set defaults [dict create -buffering \uFFFF ]
-        set opts [dict merge $defaults $args]
-        if {[dict exists $opts -readbuffering]} {
-            set readbuffering [dict get $opts -readbuffering]
-        } else {
-            if {[dict get $opts -buffering] eq "\uFFFF"} {
-                #get buffering setting from the channel as it was set prior to thread::transfer
-                set readbuffering [chan configure $readchan -buffering]
-            } else {
-                set readbuffering [dict get $opts -buffering]
-                chan configure $readchan -buffering $readbuffering
-            }
-        }
-        if {[dict exists $opts -writebuffering]} {
-            set writebuffering [dict get $opts -writebuffering]
-        } else {
-            if {[dict get $opts -buffering] eq "\uFFFF"} {
-                set writebuffering line
-                #set writebuffering [chan configure $writechan -buffering]
-            } else {
-                set writebuffering [dict get $opts -buffering]
-                #can configure $writechan -buffering $writebuffering
-            }
-        }
-
-        chan configure $readchan -translation lf
-
-        if {$readchan ni [chan names]} {
-            error "shellthread::worker::start_pipe_read - inpipe not configured. Use shellthread::manager::set_pipe_read_from_client to thread::transfer the pipe end"    
-        }
-        set inpipe $readchan
-        #::shellthread::worker::log $inpipe 0 - $source - info "START PIPE READ HELLO\n" line
-        chan configure $readchan -blocking 0
-        #::shellthread::worker::log $inpipe 0 - $source - info "START PIPE READ HELLO2 readbuffering: $readbuffering syslog $sysloghost_port filename $logfile" line
-
-        set waitvar ::shellthread::worker::wait($inpipe,[clock micros])
-        chan event $readchan readable [list apply {{chan source waitfor readbuffering writebuffering} {
-           if {$readbuffering eq "line"} {
-               set chunksize [chan gets $chan chunk]
-               if {$chunksize >= 0} {
-                   if {![chan eof $chan]} {
-                        ::shellthread::worker::log pipe 0 - $source - info $chunk\n $writebuffering 
-                   } else {
-                       ::shellthread::worker::log pipe 0 - $source - info $chunk $writebuffering 
-                   }
-               }
-           } else {
-               set chunk [chan read $chan]
-               ::shellthread::worker::log pipe 0 - $source - info $chunk $writebuffering 
-           } 
-           if {[chan eof $chan]} {
-               chan event $chan readable {}
-               set $waitfor "pipe"
-               chan close $chan
-           }
-        }} $readchan $source $waitvar $readbuffering $writebuffering] 
-        #::shellthread::worker::log $inpipe 0 - $source - info "START PIPE READ HELLO3 vwaiting on $waitvar\n" line
-        vwait $waitvar
-    }
-
-    proc start_pipe_write {source writechan args} {
-        variable outpipe
-        set defaults [dict create -buffering \uFFFF ]
-        set opts [dict merge $defaults $args]
-        
-        #todo!
-        set readchan stdin
-        
-        if {[dict exists $opts -readbuffering]} {
-            set readbuffering [dict get $opts -readbuffering]
-        } else {
-            if {[dict get $opts -buffering] eq "\uFFFF"} {
-                set readbuffering [chan configure $readchan -buffering]
-            } else {
-                set readbuffering [dict get $opts -buffering]
-                chan configure $readchan -buffering $readbuffering
-            }
-        }
-        if {[dict exists $opts -writebuffering]} {
-            set writebuffering [dict get $opts -writebuffering]
-        } else {
-            if {[dict get $opts -buffering] eq "\uFFFF"} {
-                #nothing explicitly set - take from transferred channel
-                set writebuffering [chan configure $writechan -buffering]
-            } else {
-                set writebuffering [dict get $opts -buffering]
-                can configure $writechan -buffering $writebuffering
-            }
-        }
-        
-        if {$writechan ni [chan names]} {
-            error "shellthread::worker::start_pipe_write - outpipe not configured. Use shellthread::manager::set_pipe_write_to_client to thread::transfer the pipe end"    
-        }
-        set outpipe $writechan
-        chan configure $readchan -blocking 0
-        chan configure $writechan -blocking 0
-        set waitvar ::shellthread::worker::wait($outpipe,[clock micros])
-        
-        chan event $readchan readable [list apply {{chan writechan source waitfor readbuffering} {
-            if {$readbuffering eq "line"} {
-                set chunksize [chan gets $chan chunk]
-                if {$chunksize >= 0} {
-                    if {![chan eof $chan]} {
-                        puts $writechan $chunk
-                    } else {
-                        puts -nonewline $writechan $chunk
-                    }
-                }
-            } else {
-                set chunk [chan read $chan]
-                puts -nonewline $writechan $chunk
-            }
-            if {[chan eof $chan]} {
-                chan event $chan readable {}
-                set $waitfor "pipe"
-                chan close $writechan 
-                if {$chan ne "stdin"} {
-                    chan close $chan
-                }
-            }
-        }} $readchan $writechan $source $waitvar $readbuffering]
-
-        vwait $waitvar
-    }
-
-
-    proc _initsock {} {
-      variable sysloghost_port
-      variable sock
-      if {[string length $sysloghost_port]} {
-        if {[catch {fconfigure $sock} state]} {
-          set sock [udp_open]
-          fconfigure $sock -buffering none -translation binary
-          fconfigure $sock -remote $sysloghost_port
-        }
-      }
-    } 
-    proc _reconnect {} {
-        variable sock
-        catch {close $sock}
-        _initsock
-        return [fconfigure $sock] 
-    }
-
-    proc send_info {client_tid ts_sent source msg} {
-        set ts_received [clock micros]
-        set lag_micros [expr {$ts_received - $ts_sent}]
-        set lag [expr {$lag_micros / 1000000.0}] ;#lag as x.xxxxxx seconds
-        
-        log $client_tid $ts_sent $lag $source - info $msg line 1
-    }
-    proc log {client_tid ts_sent lag source service level msg writebuffering {islog 0}} {
-        variable sock
-        variable fd
-        variable sysloghost_port
-        variable logfile
-        variable settings
-
-        set logchunk $msg
-
-        if {![dict get $settings -raw]} {
-            set tail_crlf 0
-            set tail_lf 0
-            set tail_cr 0
-            #for cooked  - always remove the trailing newline  before splitting.. 
-            #
-            #note that if we got our data from reading a non-line-buffered binary channel - then this naive line splitting will not split neatly for mixed line-endings.
-            #
-            #Possibly not critical as cooked is for logging and we are still preserving all \r and \n chars - but review and consider implementing a better split
-            #but add it back exactly as it was afterwards 
-            #we can always split on \n - and any adjacent \r will be preserved in the rejoin
-            set lastchar [string range $logchunk end end]
-            if {[string range $logchunk end-1 end] eq "\r\n"} {
-                set tail_crlf 1
-                set logchunk [string range $logchunk 0 end-2]
-            } else {
-                if {$lastchar eq "\n"} {
-                    set tail_lf 1
-                    set logchunk [string range $logchunk 0 end-1]
-                } elseif {$lastchar eq "\r"} {
-                    #\r line-endings are obsolete..and unlikely... and ugly as they can hide characters on the console. but we'll pass through anyway.
-                    set tail_cr 1
-                    set logchunk [string range $logchunk 0 end-1]
-                } else {
-                    #possibly a single line with no linefeed.. or has linefeeds only in the middle
-                }
-            }
-
-            if {$ts_sent != 0} {
-                set micros [lindex [split [expr {$ts_sent / 1000000.0}] .] end]
-                set time_info [::shellthread::iso8601 $ts_sent].$micros
-                #set time_info "${time_info}+$lag"
-                set lagfp "+[format %f $lag]"
-            } else {
-                #from pipe - no ts_sent/lag info available
-                set time_info ""
-                set lagfp ""
-            }
-
-            set idtail [string range $client_tid end-8 end] ;#enough for display purposes id - mostly zeros anyway
-            set col0 [string repeat " " 9]
-            set col1 [string repeat " " 27]
-            set col2 [string repeat " " 11]
-            set col3 [string repeat " " 20]
-            #do not columnize the final data column or append to tail - or we could muck up the crlf integrity
-
-            lassign [list [overtype::left $col0 $idtail] [overtype::left $col1 $time_info] [overtype::left $col2 $lagfp] [overtype::left $col3 $source]] c0 c1 c2 c3 
-
-            #split on \n no matter the actual line-ending in use
-            #shouldn't matter as long as we don't add anything at the end of the line other than the raw data
-            #ie - don't quote or add spaces
-            set lines [split $logchunk \n] 
-            
-            set i 1
-            set outlines [list]
-            foreach ln $lines {
-                if {$i == 1} {
-                    lappend outlines "$c0 $c1 $c2 $c3 $ln"
-                } else {
-                    lappend outlines "$c0 $c1 $col2 $c3 $ln"
-                }
-                incr i
-            }
-            if {$tail_lf} {
-                set logchunk "[join $outlines \n]\n"
-            } elseif {$tail_crlf} {
-                set logchunk "[join $outlines \r\n]\r\n"
-            } elseif {$tail_cr} {
-                set logchunk "[join $outlines \r]\r"
-            } else {
-                #no trailing linefeed
-                set logchunk [join $outlines \n] 
-
-            }
-
-            #set logchunk "[overtype::left $col0 $idtail] [overtype::left $col1 $time_info] [overtype::left $col2 "+$lagfp"] [overtype::left $col3 $source] $msg"
-        }
-        
-        if {[string length $sysloghost_port]} {
-            _initsock
-            catch {puts -nonewline $sock $logchunk}
-        }
-        #todo - sockets etc?
-        if {[string length $logfile]} {
-            #todo - setting to maintain open filehandle and reduce io.
-            # possible settings for buffersize - and maybe logrotation, although this could be left to client
-            #for now - default to safe option of open/close each write despite the overhead.
-            set fd [open $logfile a]
-            chan configure $fd -translation auto -buffering $writebuffering
-            #whether line buffered or not - by now our logchunk includes newlines
-            puts -nonewline $fd $logchunk
-            close $fd
-        }
-    }
-
-    # - withdraw just this client 
-    proc finish {tidclient} {
-      variable client_ids
-      if {($tidclient in $clientids) && ([llength $clientids] == 1)} {
-          terminate $tidclient
-      } else {
-         set posn [lsearch $client_ids $tidclient]
-         set client_ids [lreplace $clientids $posn $posn]
-      }
-    }
-
-    #allow any client to terminate
-    proc terminate {tidclient} {
-        variable sock
-        variable client_ids
-        if {$tidclient in $client_ids} {
-            catch {close $sock}
-            set client_ids [list]
-            return 1
-        } else {
-            return 0
-        }
-    }
-
-
-}
-
-
-namespace eval shellthread::manager {
-    variable workers [dict create]
-    variable worker_errors [list]
-
-    variable free_threads [list]
-    #variable log_threads
-
-    #new datastructure regarding workers and sourcetags required.
-    #one worker can service multiple sourcetags - but each sourcetag may be used by multiple threads too.
-    #generally each thread will use a specific sourcetag - but we may have pools doing similar things which log to same destination.
-    #
-    #As a convention we may use a sourcetag for the thread which started the worker that isn't actually used for logging - but as a common target for joins
-    #If the thread which started the thread calls leave_worker with that 'primary' sourcetag it means others won't be able to use that target - which seems reasonable.
-    #If another thread want's to maintain joinability beyond the span provided by the starting client,
-    #it can join with both the primary tag and a tag it will actually use for logging.
-    #A thread can join the logger with any existingtag - not just the 'primary' 
-    #(which is arbitrary anyway. It will usually be the first in the list - but may be unsubscribed by clients and disappear)
-    proc join_worker {existingtag sourcetaglist} {
-        set client_tid [thread::id]
-        #todo - allow a source to piggyback on existing worker by referencing one of the sourcetags already using the worker
-    }
-    #it is up to caller to use a unique sourcetag (e.g by prefixing with own thread::id etc)
-    # This allows multiple threads to more easily write to the same named sourcetag if necessary
-    # todo - change sourcetag for a list of tags which will be handled by the same thread. e.g for multiple threads logging to same file 
-    #
-    # todo - some protection mechanism for case where target is a file to stop creation of multiple worker threads writing to same file.
-    # Even if we use open fd,close fd wrapped around writes.. it is probably undesirable to have multiple threads with same target  
-    # On the other hand socket targets such as UDP can happily be written to by multiple threads.
-    # For now the mechanism is that a call to new_worker (rename to open_worker?) will join the same thread if a sourcetag matches.. 
-    # but, as sourcetags can get removed(unsubbed via leave_worker) this doesn't guarantee two threads with same -file settings won't fight.
-    # Also.. the settingsdict is ignored when joining with a tag that exists.. this is problematic.. e.g logrotation where previous file still being written by existing worker
-    # todo - rename 'sourcetag' concept to 'targettag' ?? the concept is a mixture of both.. it is somewhat analagous to a syslog 'facility' 
-    # probably new_worker should disallow auto-joining and we allow different workers to handle same tags simultaneously to support overlap during logrotation etc.
-    proc new_worker {sourcetaglist {settingsdict {}}} {
-        variable workers
-        set ts_start [clock micros]
-        set tidclient [thread::id]
-        set sourcetag [lindex $sourcetaglist 0] ;#todo - use all
-
-        if {[dict exists $workers $sourcetag]} {
-           set winfo [dict get $workers $sourcetag]
-           if {[thread::exists [dict get $winfo tid]]} {
-              #add our client-info to existing worker thread
-              dict lappend winfo list_client_tids $tidclient
-              dict set workers $sourcetag $winfo  ;#writeback
-              return [dict get $winfo tid]
-           }
-        }
-
-        #check if there is an existing unsubscribed thread first
-        variable free_threads
-        if {[llength $free_threads]} {
-            #todo - re-use from tail - as most likely to have been doing similar work?? review
-
-            set free_threads [lassign $free_threads tidworker]
-            #todo - keep track of real ts_start of free threads... kill when too old
-            set winfo [dict create tid $tidworker list_client_tids [list $tidclient] ts_start $ts_start ts_end_list [list]]
-            puts stderr "shellfilter::new_worker Re-using free worker thread: $tidworker with tag $sourcetag"
-            dict set workers $sourcetag $winfo
-            return $tidworker
-        }
-
-
-        #set ts_start [::shellthread::iso8601]
-        set tidworker [thread::create -preserved]
-        set init_script [string map [list %ts_start% $ts_start %mp% [tcl::tm::list] %ap% $::auto_path %tidcli% $tidclient %sd% $settingsdict] {
-            #set tclbase [file dirname [file dirname [info nameofexecutable]]]
-            #set tcllib $tclbase/lib
-            #if {$tcllib ni $::auto_path} {
-            #    lappend ::auto_path $tcllib
-            #}
-           
-            set ::settingsinfo [dict create %sd%]  
-            #if the executable running things is something like a tclkit,
-            # then it's likely we will need to use the caller's auto_path and tcl::tm::list to find things
-            #The caller can tune the thread's package search by providing a settingsdict
-            if {![dict exists $::settingsinfo tcl_tm_list]} {
-                ::tcl::tm::add %mp%
-            } else {
-                tcl::tm::remove {*}[tcl::tm::list]
-                ::tcl::tm::add {*}[dict get $::settingsinfo tcl_tm_list]
-            }
-            if {![dict exists $::settingsinfo auto_path]} {
-                set ::auto_path [list %ap%]
-            } else {
-                set ::auto_path [dict get $::settingsinfo auto_path]
-            }
-
-            package require Thread
-            package require shellthread
-            if {![catch {::shellthread::worker::init %tidcli% %ts_start% $::settingsinfo} errmsg]} {
-              unset ::settingsinfo
-              set ::shellthread_init "ok"
-            } else {
-              unset ::settingsinfo
-              set ::shellthread_init "err $errmsg"
-            }
-        }]
-
-        thread::send -async $tidworker $init_script
-        #thread::send $tidworker $init_script
-        set winfo [dict create tid $tidworker list_client_tids [list $tidclient] ts_start $ts_start ts_end_list [list]]
-        dict set workers $sourcetag $winfo
-        return $tidworker
-    }
-
-    proc set_pipe_read_from_client {tag_pipename worker_tid rchan args} {
-        variable workers
-        if {![dict exists $workers $tag_pipename]} {
-            error "workerthread::manager::set_pipe_read_from_client source/pipename $tag_pipename not found"
-        }
-        set match_worker_tid [dict get $workers $tag_pipename tid]
-        if {$worker_tid ne $match_worker_tid} {
-            error "workerthread::manager::set_pipe_read_from_client source/pipename $tag_pipename workert_tid mismatch '$worker_tid' vs existing:'$match_worker_tid'"
-        }
-        #buffering set during channel creation will be preserved on thread::transfer
-        thread::transfer $worker_tid $rchan
-        #start_pipe_read will vwait - so we have to send async
-        thread::send -async $worker_tid [list ::shellthread::worker::start_pipe_read $tag_pipename $rchan]
-        #client may start writing immediately - but presumably it will buffer in fifo2
-    }
-
-    proc set_pipe_write_to_client {tag_pipename worker_tid wchan args} {
-        variable workers
-        if {![dict exists $workers $tag_pipename]} {
-            error "workerthread::manager::set_pipe_write_to_client pipename $tag_pipename not found"
-        }
-        set match_worker_tid [dict get $workers $tag_pipename tid]
-        if {$worker_tid ne $match_worker_tid} {
-            error "workerthread::manager::set_pipe_write_to_client pipename $tag_pipename workert_tid mismatch '$worker_tid' vs existing:'$match_worker_tid'"
-        }
-        #buffering set during channel creation will be preserved on thread::transfer
-        thread::transfer $worker_tid $wchan
-        thread::send -async $worker_tid [list ::shellthread::worker::start_pipe_write $tag_pipename $wchan]
-    }
-
-    proc write_log {source msg args} {
-        variable workers 
-        set ts_micros_sent [clock micros]
-        set defaults [list -async 1 -level info]
-        set opts [dict merge $defaults $args]
-
-        if {[dict exists $workers $source]} {
-            set tidworker [dict get $workers $source tid]
-            if {![thread::exists $tidworker]} {
-                set tidworker [new_worker $source]
-            }
-        } else {
-            #auto create with no requirement to call new_worker.. warn?
-            set tidworker [new_worker $source]
-        }
-        set client_tid [thread::id]
-        if {[dict get $opts -async]} {
-            thread::send -async $tidworker [list ::shellthread::worker::send_info $client_tid $ts_micros_sent $source $msg]
-        } else {
-            thread::send $tidworker [list ::shellthread::worker::send_info $client_tid $ts_micros_sent $source $msg]
-        }
-    } 
-    proc report_worker_errors {errdict} {
-       variable workers
-       set reporting_tid [dict get $errdict worker_tid]
-       dict for {src srcinfo} $workers {
-          if {[dict get $srcinfo tid] eq $reporting_tid} {
-            dict set srcinfo errors [dict get $errdict errors]
-            dict set workers $src $srcinfo ;#writeback updated
-            break
-          }
-       }
-    }
-
-    #aka leave_worker
-    #Note that the tags may be on separate workertids, or some tags may share workertids
-    proc unsubscribe {sourcetaglist} {
-        variable workers
-        #workers structure example:
-        #[list sourcetag1 [list tid <tidworker> list_client_tids <clients>] ts_start <ts_start> ts_end_list {}]
-        variable free_threads
-        set mytid [thread::id] ;#caller of shellthread::manager::xxx is the client thread
-
-        set subscriberless_tags [list]
-        foreach source $sourcetaglist {
-            if {[dict exists $workers $source]} {
-                set list_client_tids [dict get $workers $source list_client_tids]
-                if {[set posn [lsearch $list_client_tids $mytid]] >= 0} {
-                    set list_client_tids [lreplace $list_client_tids $posn $posn]
-                    dict set workers $source list_client_tids $list_client_tids
-                }
-                if {![llength $list_client_tids]} {
-                    lappend subscriberless_tags $source
-                }
-            }
-        }
-
-        #we've removed our own tid from all the tags - possibly across multiplew workertids, and possibly leaving some workertids with no subscribers for a particular tag - or no subscribers at all.
-
-        set subscriberless_workers [list]
-        set shuttingdown_workers [list]
-        foreach deadtag $subscriberless_tags {
-            set workertid [dict get $workers $deadtag tid]
-            set worker_tags [get_worker_tagstate $workertid] 
-            set subscriber_count 0
-            set kill_count 0 ;#number of ts_end_list entries - even one indicates thread is doomed
-            foreach taginfo $worker_tags {
-                incr subscriber_count [llength [dict get $taginfo list_client_tids]]
-                incr kill_count [llength [dict get $taginfo ts_end_list]]
-            }
-            if {$subscriber_count == 0} {
-                lappend subscriberless_workers $workertid
-            }
-            if {$kill_count > 0} {
-                lappend shuttingdown_workers $workertid
-            }
-        }
-
-        #if worker isn't shutting down - add it to free_threads list
-        foreach workertid $subscriberless_workers {
-            if {$workertid ni $shuttingdown_workers} {
-                if {$workertid ni $free_threads} {
-                    lappend free_threads $workertid
-                }
-            }
-        }
-
-        #todo
-        #unsub this client_tid from the sourcetags in the sourcetaglist. if no more client_tids exist for sourcetag, remove sourcetag,
-        #if no more sourcetags - add worker to free_threads
-    }
-    proc get_worker_tagstate {workertid} {
-        variable workers
-        set taginfo_list [list]
-        dict for {source sourceinfo} $workers {
-            if {[dict get $sourceinfo tid] eq $workertid} {
-                lappend taginfo_list $sourceinfo
-            }
-        }
-        return $taginfo_list
-    }
-
-    #TODO - important.
-    #REVIEW!
-    #since moving to the unsubscribe mechansm -  close_worker $source isn't being called
-    # - we need to set a limit to the number of free threads and shut down excess when detected during unsubscription 
-    #instruction to shut-down the thread that has this source. 
-    proc close_worker {source {timeout 2500}} {
-        variable workers
-        variable worker_errors
-        variable free_threads
-        set ts_now [clock micros]
-        #puts stderr "close_worker $source"
-        if {[dict exists $workers $source]} {
-            set tidworker [dict get $workers $source tid]
-            if {$tidworker in $freethreads} {
-                #make sure a thread that is being closed is removed from the free_threads list
-                set posn [lsearch $freethreads $tidworker]
-                set freethreads [lreplace $freethreads $posn $posn]
-            }
-            set mytid [thread::id]
-            set client_tids [dict get $workers $source list_client_tids]
-            if {[set posn [lsearch $client_tids $mytid]] >= 0} {
-                set client_tids [lreplace $client_tids $posn $posn]
-                #remove self from list of clients
-                dict set workers $source list_client_tids $client_tids
-            }
-            set ts_end_list [dict get $workers $source ts_end_list] ;#ts_end_list is just  a list of timestamps of closing calls for this source - only one is needed to close, but they may all come in a flurry.
-            if {[llength $ts_end_list]} {
-              set last_end_ts [lindex $ts_end_list end]
-              if {[expr {(($tsnow - $last_end_ts) / 1000) >= $timeout}]} {
-                lappend ts_end_list $ts_now
-                dict set workers $source ts_end_list $ts_end_list
-              } else {
-                #existing close in progress.. assume it will work
-                return
-              }
-            }
-
-            if {[thread::exists $tidworker]} {
-                #puts stderr "shellthread::manager::close_worker: thread $tidworker for source $source still running.. terminating"
-                set timeoutarr($source) 0
-                after $timeout  [list set timeoutarr($source) 2]
-
-                thread::send -async $tidworker [list shellthread::worker::send_errors_now [thread::id]]
-                thread::send -async $tidworker [list shellthread::worker::terminate [thread::id]] timeoutarr($source)
-
-                #thread::send -async $tidworker [string map [list %tidclient% [thread::id]] {
-                #    shellthread::worker::terminate %tidclient%
-                #}] timeoutarr($source)
-                
-                vwait timeoutarr($source)
-                #puts stderr "shellthread::manager::close_worker: thread $tidworker for source $source DONE1"
-
-                thread::release $tidworker
-                #puts stderr "shellthread::manager::close_worker: thread $tidworker for source $source DONE2"
-                if {[dict exists $workers $source errors]} {
-                    set errlist [dict get $workers $source errors]
-                    if {[llength $errlist]} {
-                        lappend worker_errors [list $source [dict get $workers $source]]
-                    }
-                }
-                dict unset workers $source
-            } else {
-                #thread may have been closed by call to close_worker with another source with same worker
-                #clear workers record for this source
-                #REVIEW - race condition for re-creation of source with new workerid?
-                #check that record is subscriberless to avoid this
-                if {[llength [dict get $workers $source list_client_tids]] == 0} {
-                    dict unset workers $source
-                }
-            }
-        }
-        #puts stdout "close_worker $source - end"
-    }
-
-    #worker errors only available for a source after close_worker called on that source
-    #It is possible for there to be multiple entries for a source because new_worker can be called multiple times with same sourcetag,
-    # e.g if a thread 
-    proc get_and_clear_errors {source} {
-      variable worker_errors
-      set source_errors [lsearch -all -inline -index 0        $worker_errors $source]
-      set worker_errors [lsearch -all -inline -index 0 -not   $worker_errors $source]
-      return $source_errors
-    }
-
-
-}
-
-
-
-
-
-
-
-
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/scriptapps/README.md b/src/modules/punk/mix/templates/layouts/project/src/scriptapps/README.md
deleted file mode 100644
index a3027744..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/scriptapps/README.md
+++ /dev/null
@@ -1,20 +0,0 @@
-Create multishell scripts from your .tcl .sh and .ps1 scripts that are stored here.
-
-Use the pmix wrap functions to generate a multishell .cmd file from your scripts.
-This .cmd is a 'polyglot' script - it should run when called from any of the target interpreters.
-
-
-A multishell .cmd file is a cross-platform script that can easily be run on Windows and unix-like platforms.
-
-The .cmd extension is primarily a convenience so that it can be run easily by name on windows but it is ok to either leave it as that on other platforms, or rename it appropriately.
-
-On unix-like platforms it can be called with a bourne shell such as sh or bash.
-
-On windows, it can also be called with sh or bash if they are available - but the usual method would be to run it under cmd.exe initially just by opening a cmd prompt and running it.
-This will run some windows batch script to automatically generate a corresponding .ps1 file and execution will switch to powershell 5 or powershell 7 (pwsh) if available.
-Subsequently the command can be run directly from powershell. 
-
-Whether called from Bourne shell, or cmd.exe or powershell - the usual payload would be your wrapped Tcl code - but it's also possible for powershell or sh/bash to be the primary payload script.
-Any of these languages could easily be used to detect and launch other scripts/utilities that you may distribute with your app.
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/scriptapps/wrappers/README.md b/src/modules/punk/mix/templates/layouts/project/src/scriptapps/wrappers/README.md
deleted file mode 100644
index 05bfdd08..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/scriptapps/wrappers/README.md
+++ /dev/null
@@ -1,99 +0,0 @@
-These wrappers are intended to be used with the pmix wrapper functions to automate wrapping of tcl,sh,powershell scripts into a polyglot script which will run in multiple environments
-
-You may also use these to hand-craft polyglot scripts.
-
-To override the default wrapper provided by the pmix command - you can create copies of the sample_ files and remove just the sample_ part
-pmix wrap will then never wrap with latest version from the punk project - but only what you have in your scriptapps/wrappers folder.
-
-Alternatively you can copy the sample_ files and name them anything you like that doesn't begin with "punk-" 
-Then you can call the pmix wrap functions with the -template option and just the name of your file.
-(only the scriptapps/wrappers folder will be used to locate your template)
-
-
-You can create a yourscriptname.wrapconf file in the scriptapps folder alongside yourscriptname.tcl, yourscriptname.sh etc 
-This .wrapconf is only required if you need to do more complex wrapping.
-
-By default, with no yourscriptname.wrapconf found:
-
-yourscriptname.tcl  will be substituted between
-#<tcl-payload>
-#</tcl-payload>
-
-yourscriptname.sh (if present) will be substituted between
-#<shell-payload-pre-tcl>
-#</shell-payload-pre-tcl>
-
-yourscriptname.ps1 (if present) will be substituted between
-#<powershell-payload-pre-tcl>
-#</powershell-payload-pre-tcl>
-
-
-By providing a yourscriptname.wrapconf 
-you can specify the exact names of the files (in the scriptapps folder) that you want to include - and use more tags such as:
-
-#<shell-launch-tcl>
-#</shell-launch-tcl>
-
-#<shell-payload-post-tcl>
-#</shell-payload-post-tcl>
-
-
-#<powershell-launch-tcl>
-#/<powershell-launch-tcl>
-
-#<powershell-payload-post-tcl>
-#</powershell-payload-post-tcl>
-
-The .wrapconf file can have comment lines (beginning with # and possibly whitespace)
-
-e.g  myutility.wrapconf might contain:
-#------------------------
-tagdata <shell-payload-pre-tcl>         file    myutility_download-tclkit2.sh
-tagdata <shell-payload-pre-tcl>         line    {# code to verify download follows}
-tagdata <shell-payload-pre-tcl>         file    myutility_download-tclkit2_verification.sh
-tagdata <shell-launch-tcl>              file    myutility_launch-with-tclkit2.sh
-tagdata <powershell-payload-pre-tcl>    file    myutility_download-tclkit2.ps1
-tagdata <powershell-launch-tcl>         file    myutility_launch-with-tclkit2.ps1
-
-#------------------------
-
-Where tagdata command uses the specified file contents to replace all the lines between the starting tag and corresponding closing tag
-tagdata can be called multiple times per tag and each file/line is appended to the substitution lines for that tag
-
-It is an error to use the tagdata command on a self-closing tag  (aka 'singleton' tag - such as <tag/>  vs a paired set <tag> .. </tag>
-
-paired tags must have their opening and closing tags on different lines.
-hence the following line is invalid.
-# <mytag> something etc </mytag> # etc
-This is because system is designed to allow repeated updates and analysis of existing output files.
-i.e Tags are only supported in places where the languages will accept/ignore them (generally as part of comments)
-This means it should be possible to reliably detect which template was used and when template upgrades/fixes can be safely applied in the presence of possibly tweaked non-template script data.
-Possible exceptions are cases where 2 templates differ only in the default data on singleton-tag lines or default data between paired tags, and that default data has been replaced.
-There are of course other more flexible/standard methods (e.g diff) to achieve this sort of thing - but this method was chosen to provide more explicit readability of where the insertion points are.
-
-singleton or paired tags can be replaced. 
-Failing to include the tag in the resultant line results in an error.
-tagline can only be called once per tagname (e.g once for opening <tag> and once for closing </tag>  or just once for self-closing tag <tag/>)
-#------------------------
-#replacement of a singleton tag
-tagline <batch-nextshell-line/>      line    {@set "nextshell=tclsh" & :: @<batch-nextshell-line/>}
-#replacement of closing tag of a paired-tag
-tagline </powershell-launch-tcl>     line    {#</powershell-launch-tcl>  some comment or data}
-#------------------------
-
-
-The .wrapconf could also specify a specific template in your scriptapps/wrappers folder e.g:
-#------------------------
-template                        myutility-multishell.cmd
-#------------------------
-
-Leave template line out, or specify the defaults if you want to use the wrappers from the punk shell you are using. e.g
-#------------------------
-template                        punk-multishell.cmd
-#------------------------
-
-
-
-
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/vendorlib/README.md b/src/modules/punk/mix/templates/layouts/project/src/vendorlib/README.md
deleted file mode 100644
index eaf72fe4..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/vendorlib/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-Tcl library dependencies
-
-Any pkgIndex based libraries that are external to the project but which the project owners wish to distribute with the project and keep under source control.
-
-These should generally be kept to a minimum 
-- with dependency and version numbers being tracked instead; along with the provision of a mechanism for the project end-users to update.
-
-
diff --git a/src/modules/punk/mix/templates/layouts/project/src/vendormodules/README.md b/src/modules/punk/mix/templates/layouts/project/src/vendormodules/README.md
deleted file mode 100644
index 942fe325..00000000
--- a/src/modules/punk/mix/templates/layouts/project/src/vendormodules/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-Tcl module dependencies
-
-Any .tm files that are external to the project but which the project owners wish to distribute with the project and keep under source control.
-
-These should generally be kept to a minimum 
-- with dependency and version numbers being tracked instead; along with the provision of a mechanism for the project end-users to update.
-
diff --git a/src/modules/punk/mix/templates/utility/scriptappwrappers/multishell.cmd b/src/modules/punk/mix/templates/utility/scriptappwrappers/multishell.cmd
index 0e6b9ff9..fff93dcc 100644
--- a/src/modules/punk/mix/templates/utility/scriptappwrappers/multishell.cmd
+++ b/src/modules/punk/mix/templates/utility/scriptappwrappers/multishell.cmd
@@ -18,7 +18,7 @@ set -- "$@" "a=[Hide <#;Hide set;s 1 list]"; set -- : "$@";$1 = @'
 @REM ############################################################################################################################
 @REM On windows, change the value of nextshell to one of the listed 2 digit values if desired, and add code within payload sections for tcl,sh,bash,powershell as appropriate.
 @REM This wrapper can be edited manually (carefully!) - or sh,bash,tcl,powershell scripts can be wrapped using the Tcl-based punkshell system
-@REM e.g from within a running punkshell: pmix scriptwrap.multishell <inputfilepath> -outputfolder <folderpath> 
+@REM e.g from within a running punkshell: deck scriptwrap.multishell <inputfilepath> -outputfolder <folderpath> 
 @REM On unix-like systems, call with sh, bash or tclsh. (powershell untested on unix - and requires wscript if security elevation is used)
 @REM Due to lack of shebang (#! line) Unix-like systems will probably (hopefully) default to sh if the script is called without an interpreter - but it may depend on the shell in use when called.
 @REM If you find yourself really wanting/needing to add a shebang line - do so on the basis that the script will exist on unix-like systems only. 
@@ -54,16 +54,16 @@ set -- "$@" "a=[Hide <#;Hide set;s 1 list]"; set -- : "$@";$1 = @'
 @REM  -- Due to this issue -seemingly trivial edits of the batch file section can break the script! (for Windows anyway)
 @REM  -- Even something as simple as adding or removing an @REM
 @REM  -- From within punkshell - use:
-@REM  --     pmix scriptwrap.checkfile <filepath>
+@REM  --     deck scriptwrap.checkfile <filepath>
 @REM  -- to check your templates or final wrapped scripts for byte boundary issues
 @REM  -- It will report any labels that are on boundaries
 @REM  -- This is why the nextshell value above is a 2 digit key instead of a string - so that editing the value doesn't change the byte offsets.
-@REM  -- Editing your sh,bash,tcl,pwsh payloads is much less likely to cause an issue. There is the possibility of the final batch :exit_multishell label spanning a boundary - so testing using pmix scriptwrap.checkfile is still recommended.
+@REM  -- Editing your sh,bash,tcl,pwsh payloads is much less likely to cause an issue. There is the possibility of the final batch :exit_multishell label spanning a boundary - so testing using deck scriptwrap.checkfile is still recommended.
 @REM  -- Alternatively, as you should do anyway - test the final script on windows   
 @REM  -- Aside from adding comments/whitespace to tweak the location of labels - you can try duplicating the label (e.g just add the label on a line above) but this is not guaranteed to work in all situations.
 @REM  -- '@REM' is a safer comment mechanism than a leading colon - which is used sparingly here.
 @REM  -- A colon anywhere in the script that happens to land on a 512 Byte boundary (from file start or from a callsite) could be misinterpreted as a label
-@REM  -- It is unknown what versions of cmd interpreters behave this way - and pmix scriptwrap.checkfile doesn't check all such boundaries.
+@REM  -- It is unknown what versions of cmd interpreters behave this way - and deck scriptwrap.checkfile doesn't check all such boundaries.
 @REm  -- For this reason, batch labels should be chosen to be relatively unlikely to collide with other strings in the file, and simple names such as :exit or :end should probably be avoided
 @REM ############################################################################################################################
 @REM  -- custom windows payloads should be in powershell,tclsh (or sh/bash if available) code sections
diff --git a/src/modules/punk/ns-999999.0a1.0.tm b/src/modules/punk/ns-999999.0a1.0.tm
index 975dd862..eaca7511 100644
--- a/src/modules/punk/ns-999999.0a1.0.tm
+++ b/src/modules/punk/ns-999999.0a1.0.tm
@@ -17,7 +17,7 @@
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Requirements
 ##e.g package require frobz
-
+package require punk::args
 
 namespace eval ::punk_dynamic::ns {
 
@@ -1601,23 +1601,33 @@ namespace eval punk::ns {
     }
     interp alias "" use "" punk::ns::pkguse
 
-    proc nsimport_noclobber {pattern {ns ""}} {
-        set source_ns [namespace qualifiers $pattern]
+    proc nsimport_noclobber {args} {
+        set argspecs {
+            -targetnamespace -default "" -optional 1
+            -prefix -default "" -optional 1
+            sourcepattern -type string -optional 0
+        }
+        lassign [punk::args::opts_values $argspecs $args -minvalues 1 -maxvalues 1] _o opts _v values
+        set sourcepattern [dict get $values sourcepattern]
+
+        set source_ns [namespace qualifiers $sourcepattern]
         if {![namespace exists $source_ns]} {
             error "nsimport_noclobber error namespace $source_ns not found"
         }
-        if {$ns eq ""} {
-            set ns [uplevel 1 {namespace current}]
-        } elseif {![string match ::* $ns]} {
-            set nscaller [uplevel 1 {namespace current}]
-            set ns [punk::nsjoin $nscaller $ns]
+        set target_ns [dict get $opts -targetnamespace]
+        set nscaller [uplevel 1 {namespace current}]
+        if {$target_ns eq ""} {
+            set target_ns $nscaller
+        } elseif {![string match ::* $target_ns]} {
+            set target_ns [punk::nsjoin $nscaller $target_ns]
         }
+
         set a_export_patterns [namespace eval $source_ns {namespace export}] 
-        set a_commands [info commands $pattern]
+        set a_commands [info commands $sourcepattern]
         set a_tails [lmap v $a_commands {namespace tail $v}]
         set a_exported_tails [list]
-        foreach pattern $a_export_patterns {
-            set matches [lsearch -all -inline $a_tails $pattern]
+        foreach epattern $a_export_patterns {
+            set matches [lsearch -all -inline $a_tails $epattern]
             foreach m $matches {
                 if {$m ni $a_exported_tails} {
                     lappend a_exported_tails $m
@@ -1626,7 +1636,7 @@ namespace eval punk::ns {
         }
         set imported_commands [list]
         foreach e $a_exported_tails {
-            set imported [namespace eval $ns [string map [list <func> $e <a> $source_ns] {
+            set imported [namespace eval $target_ns [string map [list <func> $e <a> $source_ns] {
                 set cmd ""
                 if {![catch {namespace import <a>::<func>}]} {
                     set cmd <func>
diff --git a/src/modules/punk/repl-0.1.tm b/src/modules/punk/repl-0.1.tm
index d1c071ee..fcccbc97 100644
--- a/src/modules/punk/repl-0.1.tm
+++ b/src/modules/punk/repl-0.1.tm
@@ -942,431 +942,446 @@ proc repl::repl_handler {inputchan prompt_config} {
     variable loopcomplete
     incr loopinstance
     if {[catch {
-    variable prompt_reset_flag
-    #catch {puts stderr "xx--->[rep $::arglej]"}
-    if {$prompt_reset_flag == 1} {
-        set prompt_config [get_prompt_config]
-        set prompt_reset_flag 0
-    }
-    variable last_repl_char "" ;#last char emitted by this handler to stdout/stderr
-    variable lastoutchar ""
-    variable lasterrchar ""
-    variable commandstr
-    variable running 
-    variable reading
-    variable post_script
-    variable id_outstack
-    upvar ::punk::last_run_display last_run_display
-    upvar ::punk::config::running running_config
-    if {$::repl::signal_control_c > 0} {
-
-        if {[lindex $::errorCode 0] eq "CHILDKILLED"} {
-            #rputs stderr "\n|repl> ctrl-c  errorCode: $::errorCode"
-            #avoid spurious triggers after interrupting a command..
-            #review - dodgy.. we just want to interrupt child processes but then still be able to interrupt repl
-            set ::repl::signal_control_c 0
-            set preverr [string map [list "child killed" "child_killed"] $::errorInfo]
-            catch {error $preverr}   ;#for errorInfo display 
-        } else {
-            set ::repl::signal_control_c 0
-            fileevent $inputchan readable {}
-            set reading 0 
-            set running 0
-            if {$::tcl_interactive} {
-                rputs stderr "\n|repl> EOF on $inputchan."
-            }
-            set [namespace current]::done 1
-            #test
-            tailcall repl::reopen_stdin
+        variable prompt_reset_flag
+        #catch {puts stderr "xx--->[rep $::arglej]"}
+        if {$prompt_reset_flag == 1} {
+            set prompt_config [get_prompt_config]
+            set prompt_reset_flag 0
         }
-    }
-    set chunksize [gets $inputchan line]
-    if {$chunksize < 0} {
-        if {[chan eof $inputchan]} {
-            fileevent $inputchan readable {}
-            set reading 0 
-            set running 0
-            if {$::tcl_interactive} {
-                rputs stderr "\n|repl> EOF on $inputchan."
-            }
-            set [namespace current]::done 1
-            #test
-            #JMN
-            #tailcall repl::reopen_stdin
-        }
-    }
-    set resultprompt    [dict get $prompt_config resultprompt]
-    set nlprompt        [dict get $prompt_config nlprompt]
-    set infoprompt      [dict get $prompt_config infoprompt]
-    set debugprompt     [dict get $prompt_config debugprompt]
-
-
-    append commandstr $line\n
-    #puts "=============>$commandstr"
-    set ::repl::last_repl_char "\n" ;#this is actually the eol from stdin
-    screen_last_char_add "\n" stdin $line
-    if {[info complete $commandstr]} {
-        set ::repl::output_stdout ""
-        set ::repl::output_stderr ""
-        set outstack [list]
-        set errstack [list]
-
-
-        #oneshot repl debug 
-        set wordparts [regexp -inline -all {\S+} $commandstr]
-        lassign $wordparts cmd_firstword cmd_secondword
-        if {$cmd_firstword eq "debugrepl"} {
-            if {[string is integer -strict $cmd_secondword]} {
-                incr ::punkrepl::debug_repl $cmd_secondword
+        variable last_repl_char "" ;#last char emitted by this handler to stdout/stderr
+        variable lastoutchar ""
+        variable lasterrchar ""
+        variable commandstr
+        variable running 
+        variable reading
+        variable post_script
+        variable id_outstack
+        upvar ::punk::last_run_display last_run_display
+        upvar ::punk::config::running running_config
+        if {$::repl::signal_control_c > 0} {
+
+            if {[lindex $::errorCode 0] eq "CHILDKILLED"} {
+                #rputs stderr "\n|repl> ctrl-c  errorCode: $::errorCode"
+                #avoid spurious triggers after interrupting a command..
+                #review - dodgy.. we just want to interrupt child processes but then still be able to interrupt repl
+                set ::repl::signal_control_c 0
+                set preverr [string map [list "child killed" "child_killed"] $::errorInfo]
+                catch {error $preverr}   ;#for errorInfo display 
             } else {
-                incr ::punkrepl::debug_repl
+                set ::repl::signal_control_c 0
+                fileevent $inputchan readable {}
+                set reading 0 
+                set running 0
+                if {$::tcl_interactive} {
+                    rputs stderr "\n|repl> EOF on $inputchan."
+                }
+                set [namespace current]::done 1
+                #test
+                tailcall repl::reopen_stdin
             }
-            set commandstr "set ::punkrepl::debug_repl"
         }
-        if {$::punkrepl::debug_repl > 0} {
-            proc debug_repl_emit {msg} [string map [list %p% [list $debugprompt]] {
-                set p %p%
-                #don't auto-append \n even if missing.
-                #we may want to use debug_repl_emit with multiple calls for one output line
-                #if {[string index $msg end] ne "\n"} {
-                #    set msg "$msg\n"
-                #}
-                #set last_char [string index $::repl::screen_last_chars end]
-                set last_char [screen_last_char_get]
-                if {$last_char ne "\n"} {
-                    set clearance "\n"
-                } else {
-                    set clearance ""
+        set chunksize [gets $inputchan line]
+        if {$chunksize < 0} {
+            if {[chan eof $inputchan]} {
+                fileevent $inputchan readable {}
+                set reading 0 
+                set running 0
+                if {$::tcl_interactive} {
+                    rputs stderr "\n|repl> EOF on $inputchan."
                 }
-                rputs stderr $clearance$p[string map [list \n \n$p] $msg]
-            }]
-            set info ""
-            append info "repl loopinstance: $loopinstance\n"
-            append info "last_run_info\n"
-            append  info "length: [llength $::punk::last_run_display]\n"
-            append info "namespace: $punk::ns::ns_current"
-            debug_repl_emit $info
-        } else {
-            proc debug_repl_emit {msg} {return}
-        }
-
-        #-----------------------------------------
-        #review!
-        #work around weird behaviour in tcl 8.6 & 8.7a5 (at least) part1
-        #https://wiki.tcl-lang.org/page/representation
-        #/scriptlib/tests/listrep_bug.tcl
-        #after the uplevel #0 $commandstr  call 
-        # vars within the script that were set to a list, and have no string-rep, will generate a string-rep once the script (commandstr) is unset, or set to another value
-        global run_command_string
-        set run_command_string "$commandstr\n"  ;#add anything that won't affect script.
-        global run_command_cache
-        #-----------------------------------------
-
-        set ::punk::last_run_display [list] 
-        set ::repl::last_unknown ""
-        #***********************************************************
-        #don't use puts,rputs or debug_repl_emit in this block
-        #***********************************************************
-
-        if {[string length [dict get $running_config color_stdout]] && [punk::console::colour]} {
-            lappend outstack [shellfilter::stack::add stdout ansiwrap -settings [list -colour [dict get $running_config color_stdout]]]
-        }
-
-        lappend outstack [shellfilter::stack::add stdout tee_to_var -settings {-varname ::repl::output_stdout}]
-        if {[string length [dict get $running_config color_stderr]] && [punk::console::colour]} {
-            lappend errstack [shellfilter::stack::add stderr ansiwrap -settings [list -colour [dict get $running_config color_stderr]]]
+                set [namespace current]::done 1
+                #test
+                #JMN
+                #tailcall repl::reopen_stdin
+            }
         }
-
-        lappend errstack [shellfilter::stack::add stderr tee_to_var -settings {-varname ::repl::output_stderr}]
-        #chan configure stdout -buffering none
-        fileevent $inputchan readable {}
-        set reading 0
-        #don't let unknown use 'args' to convert commandstr to list
-        #===============================================================================
-        #Actual command call
-        #puts "____>[rep $commandstr]"
-        #===============================================================================
-        if {[string equal -length [string length "repl_runraw "] "repl_runraw " $commandstr]} {
-            #pass unevaluated command to runraw
-            set status [catch {uplevel #0 [list runraw $commandstr]} raw_result]
+        set resultprompt    [dict get $prompt_config resultprompt]
+        set nlprompt        [dict get $prompt_config nlprompt]
+        set infoprompt      [dict get $prompt_config infoprompt]
+        set debugprompt     [dict get $prompt_config debugprompt]
+
+
+        set stdinconf [fconfigure stdin]
+        if {$::tcl_platform(platform) eq "windows" && [dict get $stdinconf -encoding] ni [list unicode utf-16]} {
+            puts "--stdin> [fconfigure stdin]"
+            append commandstr $line
+            puts "1=============>[string length $commandstr] bytes , [string map [list \r -r- \n -n-] $commandstr] , info complete:[info complete $line]"
+            set commandstr [string range $commandstr 0 end-3]
+            set commandstr [encoding convertfrom utf-16be $commandstr]
+            set commandstr [string trimright $commandstr]
+            puts "2=============>[string length $commandstr] bytes , [string map [list \r -r- \n -n-] $commandstr] , info complete:[info complete $line]"
+            append commandstr \n
         } else {
-            #puts stderr "repl uplevel 0 '$command'"
-            set status [catch {
-                 #uplevel 1 $run_command_string
-                 #uplevel 1 {namespace eval $punk::ns::ns_current $run_command_string}
-                 set weirdns 0
-                 set parts [punk::ns::nsparts $punk::ns::ns_current] 
-                 foreach p $parts {
-                     if {[string match :* $p] || [string match *: $p]} {
-                         set weirdns 1
-                         break
-                     }
-                 }
-                 
-                 if {$weirdns} {
-                    uplevel 1 {punk::ns::nseval $punk::ns::ns_current $run_command_string}
-                 } else {
-                    uplevel 1 {namespace inscope $punk::ns::ns_current $run_command_string}
-                 }
-            } raw_result]
-        }
-        #set result $raw_result
-        #append result ""; #copy on write
-        #copy on write
-        append result $raw_result ""
-        #===============================================================================
-        flush stdout
-        flush stderr
-        foreach s [lreverse $outstack] {
-            shellfilter::stack::remove stdout $s
-        }
-        foreach s [lreverse $errstack] {
-            shellfilter::stack::remove stderr $s
+            #append commandstr $line
+            #puts "0=============>[string length $commandstr] bytes , [string map [list \r -r- \n -n-] $commandstr] , info complete:[info complete $line]"
+            append commandstr $line\n    
         }
 
-        #-----------------------------------------
-        #list/string-rep bug workaround part 2
-        #todo - set flag based on punkrepl::has_script_var_bug
-        lappend run_command_cache $run_command_string
-        #puts stderr "run_command_string rep: [rep $run_command_string]"
-        if {[llength $run_command_cache] > 2000} {
-            set run_command_cache [lrange $run_command_cache 1750 end]
-        }
-        #-----------------------------------------
-    
-        set lastoutchar [string index [punk::ansi::stripansi $::repl::output_stdout] end]
-        set lasterrchar [string index [punk::ansi::stripansi $::repl::output_stderr] end]
-
-        #to determine whether cursor is back at col0 of newline
-        screen_last_char_add [string index $lastoutchar$lasterrchar end] "stdout/stderr"
-
-        set result_is_chunk_list 0
-        #------
-        #todo - fix. It doesn't make much sense to only detect if the unknown command occurred in first word.
-        #e.g set x [something arg]  not detected vs something arg
-        #also - unknown commands aren't the only things that can write directly to the os handles stderr & stdout
-        if  {
-                [string length $::repl::last_unknown] && \
-                [string equal -length [string length $::repl::last_unknown] $::repl::last_unknown $line]
-            } {
-            #can't currently detect stdout/stderr writes from unknown's call to exec
-            #add a clearance newline for direct unknown calls for now
-            #there is usually output anyway - but we will get an extra blank line now even for a call that only had an exit code
-            #
-            #
-            set unknown_clearance "\n* repl newline"
-            screen_last_char_add "\uFFFF" clearance "clearance after direct unknown call"
-            if {[llength $last_run_display]} {
-                if {$status == 0} {
-                    set result $last_run_display
+        #puts "=============>[string length $commandstr] bytes , [string map [list \r -r- \n -n-] $commandstr] , info complete:[info complete $line]"
+        set ::repl::last_repl_char "\n" ;#this is actually the eol from stdin
+        screen_last_char_add "\n" stdin $line
+        if {[info complete $commandstr]} {
+            set ::repl::output_stdout ""
+            set ::repl::output_stderr ""
+            set outstack [list]
+            set errstack [list]
+
+
+            #oneshot repl debug 
+            set wordparts [regexp -inline -all {\S+} $commandstr]
+            lassign $wordparts cmd_firstword cmd_secondword
+            if {$cmd_firstword eq "debugrepl"} {
+                if {[string is integer -strict $cmd_secondword]} {
+                    incr ::punkrepl::debug_repl $cmd_secondword
                 } else {
-                    
+                    incr ::punkrepl::debug_repl
                 }
-                set result_is_chunk_list 1
+                set commandstr "set ::punkrepl::debug_repl"
             }
-        }
-        #------
-        #ok to use repl::screen_needs_clearance from here down.. (code smell proc only valid use in narrow context)
-        #***********************************************************
-        #rputs -nonewline stderr $unknown_clearance
-        set lastcharinfo "\n"
-        set whatcol [string repeat " " 12]
-        foreach cinfo $::repl::screen_last_char_list {
-            lassign $cinfo c whatinfo whyinfo
-            set cdisplay [string map [list \r "-r-" \n "-n-"] $c]
-            if {[string length $cdisplay] == 1} {
-                set cdisplay "$cdisplay  " ;#make 3 wide to match -n- and -r-
+            if {$::punkrepl::debug_repl > 0} {
+                proc debug_repl_emit {msg} [string map [list %p% [list $debugprompt]] {
+                    set p %p%
+                    #don't auto-append \n even if missing.
+                    #we may want to use debug_repl_emit with multiple calls for one output line
+                    #if {[string index $msg end] ne "\n"} {
+                    #    set msg "$msg\n"
+                    #}
+                    #set last_char [string index $::repl::screen_last_chars end]
+                    set last_char [screen_last_char_get]
+                    if {$last_char ne "\n"} {
+                        set clearance "\n"
+                    } else {
+                        set clearance ""
+                    }
+                    rputs stderr $clearance$p[string map [list \n \n$p] $msg]
+                }]
+                set info ""
+                append info "repl loopinstance: $loopinstance\n"
+                append info "last_run_info\n"
+                append  info "length: [llength $::punk::last_run_display]\n"
+                append info "namespace: $punk::ns::ns_current"
+                debug_repl_emit $info
+            } else {
+                proc debug_repl_emit {msg} {return}
             }
-            set whatinfo [string range $whatinfo$whatcol 0 [string length $whatcol]]
-            set whysummary [string map [list \n "-n-"] $whyinfo]
-            append lastcharinfo "$cdisplay $whatinfo $whysummary\n"
-        }
-        debug_repl_emit "screen_last_chars: $lastcharinfo"
-        debug_repl_emit "lastoutchar:'$lastoutchar'  lasterrchar: '$lasterrchar'"
-        if {$status == 0} {
-            debug_repl_emit "command call status: $status  OK"
-        } else {
-            debug_repl_emit "command call status: $status  ERR"
-        }
-
-
 
+            #-----------------------------------------
+            #review!
+            #work around weird behaviour in tcl 8.6 & 8.7a5 (at least) part1
+            #https://wiki.tcl-lang.org/page/representation
+            #/scriptlib/tests/listrep_bug.tcl
+            #after the uplevel #0 $commandstr  call 
+            # vars within the script that were set to a list, and have no string-rep, will generate a string-rep once the script (commandstr) is unset, or set to another value
+            global run_command_string
+            set run_command_string "$commandstr\n"  ;#add anything that won't affect script.
+            global run_command_cache
+            #-----------------------------------------
+
+            set ::punk::last_run_display [list] 
+            set ::repl::last_unknown ""
+            #***********************************************************
+            #don't use puts,rputs or debug_repl_emit in this block
+            #***********************************************************
+
+            if {[string length [dict get $running_config color_stdout]] && [punk::console::colour]} {
+                lappend outstack [shellfilter::stack::add stdout ansiwrap -settings [list -colour [dict get $running_config color_stdout]]]
+            }
 
-        #puts stderr "<output>'$::repl::output_stdout' lastoutchar:'$lastoutchar' result:'$result'"
-        #$command is an unevaluated script at this point 
-        # so may not be a well formed list e.g 'set x [list a "b"]' 
-        #- lindex will fail
-        #if {[lindex $command 0] eq "runx"} {}
-      
+            lappend outstack [shellfilter::stack::add stdout tee_to_var -settings {-varname ::repl::output_stdout}]
+            if {[string length [dict get $running_config color_stderr]] && [punk::console::colour]} {
+                lappend errstack [shellfilter::stack::add stderr ansiwrap -settings [list -colour [dict get $running_config color_stderr]]]
+            }
 
-        if  {
-                [string equal -length [string length "d/ "] "d/ " $commandstr] || \
-                [string equal "d/\n" $commandstr] || \
-                [string equal -length [string length "dd/ "] "dd/ " $commandstr] || \
-                [string equal "dd/\n" $commandstr] || \
-                [string equal -length [string length "./ "] "./ " $commandstr] || \
-                [string equal "./\n" $commandstr] || \
-                [string equal -length [string length "../ "] "../ " $commandstr] || \
-                [string equal "../\n" $commandstr] || \
-                [string equal -length [string length "runx "] "runx " $commandstr] || \
-                [string equal -length [string length "sh_runx "] "sh_runx " $commandstr] || \
-                [string equal -length [string length "runout "] "runout " $commandstr] || \
-                [string equal -length [string length "sh_runout "] "sh_runout " $commandstr] || \
-                [string equal -length [string length "runerr "] "runerr " $commandstr] || \
-                [string equal -length [string length "sh_runerr "] "sh_runerr " $commandstr]
+            lappend errstack [shellfilter::stack::add stderr tee_to_var -settings {-varname ::repl::output_stderr}]
+            #chan configure stdout -buffering none
+            fileevent $inputchan readable {}
+            set reading 0
+            #don't let unknown use 'args' to convert commandstr to list
+            #===============================================================================
+            #Actual command call
+            #puts "____>[rep $commandstr]"
+            #===============================================================================
+            if {[string equal -length [string length "repl_runraw "] "repl_runraw " $commandstr]} {
+                #pass unevaluated command to runraw
+                set status [catch {uplevel #0 [list runraw $commandstr]} raw_result]
+            } else {
+                #puts stderr "repl uplevel 0 '$command'"
+                set status [catch {
+                    #uplevel 1 $run_command_string
+                    #uplevel 1 {namespace eval $punk::ns::ns_current $run_command_string}
+                    set weirdns 0
+                    set parts [punk::ns::nsparts $punk::ns::ns_current] 
+                    foreach p $parts {
+                        if {[string match :* $p] || [string match *: $p]} {
+                            set weirdns 1
+                            break
+                        }
+                    }
+                    
+                    if {$weirdns} {
+                        uplevel 1 {punk::ns::nseval $punk::ns::ns_current $run_command_string}
+                    } else {
+                        uplevel 1 {namespace inscope $punk::ns::ns_current $run_command_string}
+                    }
+                } raw_result]
+            }
+            #set result $raw_result
+            #append result ""; #copy on write
+            #copy on write
+            append result $raw_result ""
+            #===============================================================================
+            flush stdout
+            flush stderr
+            foreach s [lreverse $outstack] {
+                shellfilter::stack::remove stdout $s
+            }
+            foreach s [lreverse $errstack] {
+                shellfilter::stack::remove stderr $s
+            }
 
+            #-----------------------------------------
+            #list/string-rep bug workaround part 2
+            #todo - set flag based on punkrepl::has_script_var_bug
+            lappend run_command_cache $run_command_string
+            #puts stderr "run_command_string rep: [rep $run_command_string]"
+            if {[llength $run_command_cache] > 2000} {
+                set run_command_cache [lrange $run_command_cache 1750 end]
+            }
+            #-----------------------------------------
+        
+            set lastoutchar [string index [punk::ansi::stripansi $::repl::output_stdout] end]
+            set lasterrchar [string index [punk::ansi::stripansi $::repl::output_stderr] end]
+
+            #to determine whether cursor is back at col0 of newline
+            screen_last_char_add [string index $lastoutchar$lasterrchar end] "stdout/stderr"
+
+            set result_is_chunk_list 0
+            #------
+            #todo - fix. It doesn't make much sense to only detect if the unknown command occurred in first word.
+            #e.g set x [something arg]  not detected vs something arg
+            #also - unknown commands aren't the only things that can write directly to the os handles stderr & stdout
+            if  {
+                    [string length $::repl::last_unknown] && \
+                    [string equal -length [string length $::repl::last_unknown] $::repl::last_unknown $line]
                 } {
-            if {[llength $last_run_display]} {
-                set result $last_run_display
-                set result_is_chunk_list 1
+                #can't currently detect stdout/stderr writes from unknown's call to exec
+                #add a clearance newline for direct unknown calls for now
+                #there is usually output anyway - but we will get an extra blank line now even for a call that only had an exit code
+                #
+                #
+                set unknown_clearance "\n* repl newline"
+                screen_last_char_add "\uFFFF" clearance "clearance after direct unknown call"
+                if {[llength $last_run_display]} {
+                    if {$status == 0} {
+                        set result $last_run_display
+                    } else {
+                        
+                    }
+                    set result_is_chunk_list 1
+                }
+            }
+            #------
+            #ok to use repl::screen_needs_clearance from here down.. (code smell proc only valid use in narrow context)
+            #***********************************************************
+            #rputs -nonewline stderr $unknown_clearance
+            set lastcharinfo "\n"
+            set whatcol [string repeat " " 12]
+            foreach cinfo $::repl::screen_last_char_list {
+                lassign $cinfo c whatinfo whyinfo
+                set cdisplay [string map [list \r "-r-" \n "-n-"] $c]
+                if {[string length $cdisplay] == 1} {
+                    set cdisplay "$cdisplay  " ;#make 3 wide to match -n- and -r-
+                }
+                set whatinfo [string range $whatinfo$whatcol 0 [string length $whatcol]]
+                set whysummary [string map [list \n "-n-"] $whyinfo]
+                append lastcharinfo "$cdisplay $whatinfo $whysummary\n"
+            }
+            debug_repl_emit "screen_last_chars: $lastcharinfo"
+            debug_repl_emit "lastoutchar:'$lastoutchar'  lasterrchar: '$lasterrchar'"
+            if {$status == 0} {
+                debug_repl_emit "command call status: $status  OK"
+            } else {
+                debug_repl_emit "command call status: $status  ERR"
             }
-        }
 
-        # -- --- --- --- --- --- --- --- --- ---
-        ##an attempt to preserve underlying rep 
-        ##this is not for performance - just to be less disruptive to underlying rep to aid in learning/debugging
-        # -- --- --- --- --- --- --- --- --- ---
-        # JN 2023 - The lrange operation is destructive to path intrep 
-        # The lrange operation is destructive to strings with leading/trailing newlines
-        # -- --- --- --- --- --- --- --- --- ---
-        #set saved_errorCode $::errorCode
-        #set saved_errorInfo $::errorInfo
-        #if {[catch {lrange $result 0 end} result_as_list]} {
-        #    set is_result_empty [expr {$result eq ""}]
-        #    set ::errorCode $saved_errorCode
-        #    set ::errorInfo $saved_errorInfo
-        #} else {
-        #    set is_result_empty [expr {[llength $result_as_list] == 0}]
-        #}
-        # -- --- --- --- --- --- --- --- --- ---
-        #set resultrep [::tcl::unsupported::representation $result] 
-
-        set is_result_empty [expr {$result eq ""}]
-        
-        #catch {puts stderr "yy--->[rep $::arglej]"}
+
+
+
+            #puts stderr "<output>'$::repl::output_stdout' lastoutchar:'$lastoutchar' result:'$result'"
+            #$command is an unevaluated script at this point 
+            # so may not be a well formed list e.g 'set x [list a "b"]' 
+            #- lindex will fail
+            #if {[lindex $command 0] eq "runx"} {}
         
-        set reading 1
-        if {!$is_result_empty} {
-            if {$status == 0} {
-                if {[screen_needs_clearance]} {
-                    rputs -nonewline stderr \n
+
+            if  {
+                    [string equal -length [string length "d/ "] "d/ " $commandstr] || \
+                    [string equal "d/\n" $commandstr] || \
+                    [string equal -length [string length "dd/ "] "dd/ " $commandstr] || \
+                    [string equal "dd/\n" $commandstr] || \
+                    [string equal -length [string length "./ "] "./ " $commandstr] || \
+                    [string equal "./\n" $commandstr] || \
+                    [string equal -length [string length "../ "] "../ " $commandstr] || \
+                    [string equal "../\n" $commandstr] || \
+                    [string equal -length [string length "runx "] "runx " $commandstr] || \
+                    [string equal -length [string length "sh_runx "] "sh_runx " $commandstr] || \
+                    [string equal -length [string length "runout "] "runout " $commandstr] || \
+                    [string equal -length [string length "sh_runout "] "sh_runout " $commandstr] || \
+                    [string equal -length [string length "runerr "] "runerr " $commandstr] || \
+                    [string equal -length [string length "sh_runerr "] "sh_runerr " $commandstr]
+
+                    } {
+                if {[llength $last_run_display]} {
+                    set result $last_run_display
+                    set result_is_chunk_list 1
                 }
-                if {$result_is_chunk_list} {
-                    foreach c $result {
-                        lassign $c termchan text
-                        if {[string length $text]} {
-                            if {$termchan eq "result"} {
-                                rputs stdout $resultprompt[string map [list \n "\n$resultprompt"] $text]
-                                #puts -nonewline stdout $text
-                            } elseif {$termchan eq "resulterr"} {
-                                rputs stderr $resultprompt[string map [list \n "\n$resultprompt"] $text]
-                            } elseif {$termchan eq "info"} {
-                                rputs stderr $infoprompt[string map [list \n "\n$infoprompt"] $text]
-                            } else {
-                                #rputs -nonewline $termchan $text
-                                set chanprompt "_ "
-                                rputs $termchan ${chanprompt}[string map [list \n "\n${chanprompt}"] $text]
+            }
+
+            # -- --- --- --- --- --- --- --- --- ---
+            ##an attempt to preserve underlying rep 
+            ##this is not for performance - just to be less disruptive to underlying rep to aid in learning/debugging
+            # -- --- --- --- --- --- --- --- --- ---
+            # JN 2023 - The lrange operation is destructive to path intrep 
+            # The lrange operation is destructive to strings with leading/trailing newlines
+            # -- --- --- --- --- --- --- --- --- ---
+            #set saved_errorCode $::errorCode
+            #set saved_errorInfo $::errorInfo
+            #if {[catch {lrange $result 0 end} result_as_list]} {
+            #    set is_result_empty [expr {$result eq ""}]
+            #    set ::errorCode $saved_errorCode
+            #    set ::errorInfo $saved_errorInfo
+            #} else {
+            #    set is_result_empty [expr {[llength $result_as_list] == 0}]
+            #}
+            # -- --- --- --- --- --- --- --- --- ---
+            #set resultrep [::tcl::unsupported::representation $result] 
+
+            set is_result_empty [expr {$result eq ""}]
+            
+            #catch {puts stderr "yy--->[rep $::arglej]"}
+            
+            set reading 1
+            if {!$is_result_empty} {
+                if {$status == 0} {
+                    if {[screen_needs_clearance]} {
+                        rputs -nonewline stderr \n
+                    }
+                    if {$result_is_chunk_list} {
+                        foreach c $result {
+                            lassign $c termchan text
+                            if {[string length $text]} {
+                                if {$termchan eq "result"} {
+                                    rputs stdout $resultprompt[string map [list \n "\n$resultprompt"] $text]
+                                    #puts -nonewline stdout $text
+                                } elseif {$termchan eq "resulterr"} {
+                                    rputs stderr $resultprompt[string map [list \n "\n$resultprompt"] $text]
+                                } elseif {$termchan eq "info"} {
+                                    rputs stderr $infoprompt[string map [list \n "\n$infoprompt"] $text]
+                                } else {
+                                    #rputs -nonewline $termchan $text
+                                    set chanprompt "_ "
+                                    rputs $termchan ${chanprompt}[string map [list \n "\n${chanprompt}"] $text]
+                                }
                             }
                         }
-                    }
 
-                } else {
-                    #-----------------------------------------------------------
-                    # avoid repl forcing string rep of simple results. This is just to aid analysis using tcl::unsupported::representation
-                    #set rparts [split $result {}] 
-                    #if {[lsearch $rparts \n] < 0} {
-                    #    #type of $result unaffected
-                    #    rputs "$resultprompt $result"
-                    #} else {
-                    #    #$result will be a string due to use of string map
-                    #   rputs $resultprompt[string map [list \n "\n$resultprompt"] $result]
-                    #}
-                    #-----------------------------------------------------------
-                    
-                    #we have copied rawresult using append with empty string - so our string interaction with result var here shouldn't affect the returned value
-                    #empty-string result handled in other branch
-                    set flat [string map [list \r\n "" \n ""] $result]
-                    if {[string length $flat] == [string length $result]} {
-                        #no line-endings in data
-                        rputs "$resultprompt$result" 
                     } else {
-                        #if {[string index $result end] eq "\n"} {
-                        #    set result [string range $result 0 end-1]
+                        #-----------------------------------------------------------
+                        # avoid repl forcing string rep of simple results. This is just to aid analysis using tcl::unsupported::representation
+                        #set rparts [split $result {}] 
+                        #if {[lsearch $rparts \n] < 0} {
+                        #    #type of $result unaffected
+                        #    rputs "$resultprompt $result"
+                        #} else {
+                        #    #$result will be a string due to use of string map
+                        #   rputs $resultprompt[string map [list \n "\n$resultprompt"] $result]
                         #}
-                        if {[string length $flat] == 0} {
-                            if {[string range $result end-1 end] eq "\r\n"} {
-                                set result [string range $result 0 end-2]
-                            } else  {
-                                set result [string range $result 0 end-1]
+                        #-----------------------------------------------------------
+                        
+                        #we have copied rawresult using append with empty string - so our string interaction with result var here shouldn't affect the returned value
+                        #empty-string result handled in other branch
+                        set flat [string map [list \r\n "" \n ""] $result]
+                        if {[string length $flat] == [string length $result]} {
+                            #no line-endings in data
+                            rputs "$resultprompt$result" 
+                        } else {
+                            #if {[string index $result end] eq "\n"} {
+                            #    set result [string range $result 0 end-1]
+                            #}
+                            if {[string length $flat] == 0} {
+                                if {[string range $result end-1 end] eq "\r\n"} {
+                                    set result [string range $result 0 end-2]
+                                } else  {
+                                    set result [string range $result 0 end-1]
+                                }
                             }
+                            rputs $resultprompt[string map [list \r\n "\n$resultprompt" \n "\n$resultprompt"] $result]
                         }
-                        rputs $resultprompt[string map [list \r\n "\n$resultprompt" \n "\n$resultprompt"] $result]
                     }
-                }
-                doprompt "P% "
-            } else {
-                #tcl err
-                if {$result_is_chunk_list} {
-                    foreach c $last_run_display {
-                        lassign $c termchan text
-                        if {[string length $text]} {
-                            if {$termchan eq "result"} {
-                                rputs stdout $resultprompt[string map [list \n "\n$resultprompt"] $text]
-                                #puts -nonewline stdout $text
-                            } elseif {$termchan eq "resulterr"} {
-                                rputs stderr $resultprompt[string map [list \n "\n$resultprompt"] $text]
-                            } elseif {$termchan eq "info"} {
-                                rputs stderr $infoprompt[string map [list \n "\n$infoprompt"] $text]
-                            } else {
-                                rputs -nonewline $termchan $text
+                    doprompt "P% "
+                } else {
+                    #tcl err
+                    if {$result_is_chunk_list} {
+                        foreach c $last_run_display {
+                            lassign $c termchan text
+                            if {[string length $text]} {
+                                if {$termchan eq "result"} {
+                                    rputs stdout $resultprompt[string map [list \n "\n$resultprompt"] $text]
+                                    #puts -nonewline stdout $text
+                                } elseif {$termchan eq "resulterr"} {
+                                    rputs stderr $resultprompt[string map [list \n "\n$resultprompt"] $text]
+                                } elseif {$termchan eq "info"} {
+                                    rputs stderr $infoprompt[string map [list \n "\n$infoprompt"] $text]
+                                } else {
+                                    rputs -nonewline $termchan $text
+                                }
                             }
                         }
                     }
+                    
+                    set c [a yellow bold]
+                    set n [a]
+                    rputs stderr $c$result$n
+                    #tcl err hint prompt - lowercase
+                    doprompt "p% "
                 }
-                
-                set c [a yellow bold]
-                set n [a]
-                rputs stderr $c$result$n
-                #tcl err hint prompt - lowercase
-                doprompt "p% "
-            }
-        } else {
-            if {[screen_needs_clearance]} {
-                doprompt "\nP% "
             } else {
-                doprompt "P% "
+                if {[screen_needs_clearance]} {
+                    doprompt "\nP% "
+                } else {
+                    doprompt "P% "
+                }
+            }
+            #catch {puts stderr "zz1--->[rep $::arglej]"}
+            #puts stderr "??? $commandstr"
+            if {$::punkrepl::debug_repl > 0} {
+                incr ::punkrepl::debug_repl -1
             }
-        }
-        #catch {puts stderr "zz1--->[rep $::arglej]"}
-        #puts stderr "??? $commandstr"
-        if {$::punkrepl::debug_repl > 0} {
-            incr ::punkrepl::debug_repl -1
-        }
-        set commandstr ""
-        #catch {puts stderr "zz2---->[rep $::arglej]"}
-    } else {
-        #append commandstr \n
-        if {$::repl::signal_control_c} {
-            set ::repl::signal_control_c 0
-            fileevent $inputchan readable {}
-            rputs stderr  "* console_control: control-c"
-            flush stderr
-            set c [a yellow bold]
-            set n [a]
-            rputs stderr "${c}repl interrupted$n"
-            #set commandstr [list error "repl interrupted"]
             set commandstr ""
-            doprompt ">_ "
-            flush stdout
-
+            #catch {puts stderr "zz2---->[rep $::arglej]"}
         } else {
-            doprompt ">  "
+            #append commandstr \n
+            if {$::repl::signal_control_c} {
+                set ::repl::signal_control_c 0
+                fileevent $inputchan readable {}
+                rputs stderr  "* console_control: control-c"
+                flush stderr
+                set c [a yellow bold]
+                set n [a]
+                rputs stderr "${c}repl interrupted$n"
+                #set commandstr [list error "repl interrupted"]
+                set commandstr ""
+                doprompt ">_ "
+                flush stdout
+
+            } else {
+                doprompt ">  "
+            }
         }
-    }
-    fileevent $inputchan readable [list ::repl::repl_handler $inputchan $prompt_config]
-    update idletasks
-    #fileevent $inputchan readable [list repl::repl_handler $inputchan $prompt_config]
-    #catch {puts stderr "zend--->[rep $::arglej]"}
+        fileevent $inputchan readable [list ::repl::repl_handler $inputchan $prompt_config]
+        update idletasks
+        #fileevent $inputchan readable [list repl::repl_handler $inputchan $prompt_config]
+        #catch {puts stderr "zend--->[rep $::arglej]"}
     } repl_error]} {
         puts stderr "error in repl_handler: $repl_error" 
         set stdinreader [fileevent $inputchan readable]
diff --git a/src/modules/punk/repo-999999.0a1.0.tm b/src/modules/punk/repo-999999.0a1.0.tm
index 281c2024..f2bbce66 100644
--- a/src/modules/punk/repo-999999.0a1.0.tm
+++ b/src/modules/punk/repo-999999.0a1.0.tm
@@ -779,10 +779,10 @@ namespace eval punk::repo {
 
             package require overtype
             set title1 "Path"
-            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {punk::strlen $v}]]
+            set widest1 [tcl::mathfunc::max {*}[lmap v [concat [list $title1] $col1items] {lib::strlen $v}]]
             set col1 [string repeat " " $widest1]
             set title2 "Repo-type(s)"
-            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {punk::strlen $v}]]
+            set widest2 [tcl::mathfunc::max {*}[lmap v [concat [list $title2] $col2items] {string length $v}]]
             set col2 [string repeat " " $widest2]
             set tablewidth [expr {$widest1 + 1 + $widest2}]
 
@@ -827,19 +827,61 @@ namespace eval punk::repo {
         }
     }
     proc fossil_get_repository_folder_for_project {projectname args} {
-
-        set defaults [list -parentfolder \uFFFF -extrachoice \uFFFF] 
+        set defaults [list\
+            -parentfolder \uFFFF\
+            -extrachoices \uFFFF\
+            -askpath   0\
+            -ansi \uFFFF\
+            -ansi_prompt \uFFFF\
+            -ansi_warning  \uFFFF\
+        ] 
+        if {[llength $args] % 2 != 0} {
+            error "fossil_get_repository_folder requires args to be option-value pairs. Received '$args'"
+        }
+        dict for {k v} $args {
+            if {$k ni [dict keys $defaults]} {
+                error "fossil_get_repository_folder unrecognised option $k. Known options: [dict keys $defaults]"
+            }
+        }
         set opts            [dict merge $defaults $args]
-
+        # -- --- --- --- --- ---
         set opt_parentfolder [dict get $opts -parentfolder]
         if {$opt_parentfolder eq "\uFFFF"} {
             set opt_parentfolder [pwd]
         }
-        set opt_extrachoice [dict get $opts -extrachoice]
-        set extrachoice ""
-        if {$opt_extrachoice ne "\uFFFF"} {
-            set extrachoice $opt_extrachoice
+        # -- --- --- --- --- ---
+        set opt_extrachoices [dict get $opts -extrachoices]
+        set extrachoices [list]
+        if {$opt_extrachoices ne "\uFFFF"} {
+            set extrachoices $opt_extrachoices
+        }
+        # -- --- --- --- --- ---
+        set opt_askpath [dict get $opts -askpath]
+        # -- --- --- --- --- ---
+        set opt_ansi [dict get $opts -ansi]
+        set opt_ansi_prompt [dict get $opts -ansi_prompt]
+        set opt_ansi_warning [dict get $opts -ansi_warning]
+        if {$opt_ansi eq "\uFFFF"} {
+            set opt_ansi 1
+        }
+        if {$opt_ansi} {
+            if {$opt_ansi_prompt eq "\uFFFF"} {
+                set ansiprompt [a+ green bold] 
+            } else {
+                set ansiprompt [$opt_ansi_prompt]
+            }
+            if {$opt_ansi_warning eq "\uFFFF"} {
+                set ansiwarn [a+ red bold]
+            } else {
+                set ansiwarn [$opt_ansi_warning]
+            }
+            set ansireset [a]
+        } else {
+            set ansiprompt ""
+            set ansiwarn ""
+            set ansireset ""
         }
+        # -- --- --- --- --- ---
 
         set startdir $opt_parentfolder
 
@@ -849,25 +891,8 @@ namespace eval punk::repo {
             return
         }
 
-        set fossilinfo [exec {*}$fossil_prog info] ;#will give us the necessary config-db info whether in a project folder or not
-        set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
-        if {[llength $matching_lines] != 1} {
-            puts stderr "Unable to find config-db info from fossil. Check your fossil installation."
-            puts stderr "Fossil output was:"
-            puts stderr "-------------"
-            puts stderr "$fossilinfo"
-            puts stderr "-------------"
-            puts stderr "config-db info:"
-            puts stderr "$matching_lines"
-            return
-        }
-        set trimmedline [string trim [lindex $matching_lines 0]]
-        set firstcolon [string first : $trimmedline]
-        set config_db_path [string trim [string range $trimmedline $firstcolon+1 end]]
-        if {![file exists $config_db_path]} {
-            puts stderr "Unable to verify fossil global configuration info at path: $config_db_path"
-            return
-        }
+        set config_db_path [fossil_get_configdb]
+
         set config_db_folder [file dirname $config_db_path]
 
         #NOTE: we could use fossil all info to detect all locations of .fossil files - but there may be many that are specific to projects if the user wasn't in the habit of using a default location
@@ -914,10 +939,11 @@ namespace eval punk::repo {
         if {$tp ni $testpaths} {
             lappend testpaths $tp
         }
-        if {[string length $extrachoice]} {
-            set tp $extrachoice
-            if {$tp ni $testpaths} {
-                lappend testpaths $tp
+        if {[llength $extrachoices]} {
+            foreach tp $extrachoices {
+                if {$tp ni $testpaths} {
+                    lappend testpaths $tp
+                }
             }
         }
 
@@ -956,7 +982,7 @@ namespace eval punk::repo {
                 set existingfossils "( no existing .fossil files found )"
             }
             if {"$projectname.fossil" in $existing_fossils} {
-                set conflict "CONFLICT - $projectname.fossil already exists in this folder"
+                set conflict "${ansiwarn}CONFLICT - $projectname.fossil already exists in this folder${ansireset}"
             } else {
                 set conflict ""
             }
@@ -975,9 +1001,9 @@ namespace eval punk::repo {
 
         set menu_message ""
         if {[llength $choice_folders]} {
-            append menu_message "Select the number of the folder to use to store the .fossil repository file" \n
+            append menu_message "${ansiprompt}Select the number of the folder to use to store the .fossil repository file${ansireset}" \n
         } else {
-            append menu_message "--- NO suitable writable folders or locations found for .fossil file. Consider setting FOSSIL_HOME environment variable and check that folders are writable.--" \n
+            append menu_message "${ansiwarn}--- NO suitable writable folders or locations found for .fossil file. Consider setting FOSSIL_HOME environment variable and check that folders are writable.--${ansireset}" \n
         }
 
         set conflicted_options [list]
@@ -1003,7 +1029,7 @@ namespace eval punk::repo {
         if {[llength $readonly_repo_folder_locations]} {
             append menu_message "--------------------------------------------------" \n
             foreach readonly $readonly_repo_folder_locations {
-                append menu_message "<unavailable not writable> $readonly" \n
+                append menu_message "${ansiwarn}<unavailable not writable> $readonly${ansireset}" \n
             }
             append menu_message "--------------------------------------------------" \n
         }
@@ -1011,11 +1037,11 @@ namespace eval punk::repo {
         #see if we can reasonably use the only available option and not bug the user
         #Todo - option to always prompt?
         #we will not auto-select if there is even one conflicted_option - as that seems like something you should know about
-        if {![llength $conflicted_options] && ([llength $choice_folders] == 1)} {
+        if {![llength $conflicted_options] && ([llength $choice_folders] == 1) && !$opt_askpath} {
             set repo_folder_choice [lindex $choice_folders 0]
             set repository_folder [dict get $repo_folder_choice folder]
         } else {
-            if {[llength $choice_folders]} {
+            if {[llength $choice_folders] || $opt_askpath} {
                 puts stdout $menu_message
                 set max [llength $choice_folders] 
                 if {$max == 1} {
@@ -1023,24 +1049,73 @@ namespace eval punk::repo {
                 } else {
                     set rangemsg "a number from 1 to $max" 
                 }
-                set answer [askuser "Enter $rangemsg to select location. (or N to abort)"]
-                if {![string is integer -strict $answer]} {
-                    puts stderr "Aborting"
-                    return
+                set menuprompt "${ansiprompt}Enter $rangemsg to select location. (or N to abort)${ansireset}"
+                if {$opt_askpath} {
+                    set askpathprompt "${ansiprompt}Enter the word: path followed by an absolute path to a folder if you would like to manually enter a folder${ansireset}"
+                    append menuprompt \n $askpathprompt
                 }
+                set answer [askuser $menuprompt]
+                if {$opt_askpath && [string match "path*" [string tolower $answer]]} {
+                    set is_done 0
+                    set repository_folder [string trim [string range $answer 4 end]]
+                    while {!$is_done} {
+
+                        if {![file isdirectory $repository_folder]} {
+                            puts stderr "${ansiwarn}Sorry - unable to find entered location '$repository_folder'${ansireset}"
+                            if {[file isdirectory [file dirname $repository_folder]]} {
+                                set answer [askuser "${ansiprompt}Do you want to create this folder? Type just the word mkdir to create it, or N for no${ansireset}"]
+                                if {[string equal mkdir [string tolower $answer]]} {
+                                    if {[catch {file mkdir $repository_folder} errM]} {
+                                        puts stderr "Failed to create folder $repository_folder. Error $errM" 
+                                    }
+                                }
+                            } else {
+                                puts stderr "${ansiwarn}Not offering to create directory because parent folder not found${ansireset}"
+                            }
+                        }
 
-                set index [expr {int($answer) -1}]
-                if {$index >= 0 && $index <= $max-1} {
-                    set repo_folder_choice [lindex $choice_folders $index]
-                    set repository_folder [dict get $repo_folder_choice folder]
-                    puts stdout "Selected fossil location $repository_folder" 
+                        if {![file isdirectory $repository_folder]} {
+                            set answer [askuser "${ansiprompt}Try again? (Y|N)${ansireset}"]
+                            if {[string match y* [string tolower $answer]]} {
+                                set answer [askuser $askpathprompt]
+                                if {[string match "path*" [string tolower $answer]]} {
+                                    set repository_folder [string trim [string range $answer 4 end]]
+                                } else {
+                                    puts stderr "Answer didn't begin with the word path"
+                                    set is_done 1
+                                }
+                            } else {
+                                set is_done 1
+                            }
+                        } else {
+                            set is_done 1
+                        }
+                    }
+                    if {$is_done && ![file isdirectory $repository_folder]} {
+                        puts stderr "Aborting"
+                        return
+                    }
                 } else {
-                    puts stderr " No menu number matched - aborting."
-                    return
+                    if {![string is integer -strict $answer]} {
+                        puts stderr "Aborting"
+                        return
+                    }
+                    set index [expr {int($answer) -1}]
+                    if {$index >= 0 && $index <= $max-1} {
+                        set repo_folder_choice [lindex $choice_folders $index]
+                        set repository_folder [dict get $repo_folder_choice folder]
+                        puts stdout "Selected fossil location $repository_folder" 
+                    } else {
+                        puts stderr " No menu number matched - aborting."
+                        return
+                    }
                 }
+
+
+
             } else {
                 puts stdout $menu_message
-                set answer [askuser "Hit enter to exit"]
+                set answer [askuser "${ansiprompt}Hit enter to exit${ansireset}"]
                 return
             }
         }
@@ -1053,26 +1128,26 @@ namespace eval punk::repo {
         if {$path eq {}} { set path [pwd] }
         # ::kettle::path::revision.git
         do_in_path $path {
-        try {
-            #git describe will error with 'No names found' if repo has no tags
-            #set v [::exec {*}[auto_execok git] describe]
-            set v [::exec {*}[auto_execok git] rev-parse HEAD] ;# consider 'git rev-parse --short HEAD'
-        } on error {e o} {
-            set v [lindex [split [dict get $o -errorinfo] \n] 0]
-        }
+            try {
+                #git describe will error with 'No names found' if repo has no tags
+                #set v [::exec {*}[auto_execok git] describe]
+                set v [::exec {*}[auto_execok git] rev-parse HEAD] ;# consider 'git rev-parse --short HEAD'
+            } on error {e o} {
+                set v [lindex [split [dict get $o -errorinfo] \n] 0]
+            }
         }
         return [string trim $v]
     }
     proc git_remote {{path {{}}}} {
         if {$path eq {}} { set path [pwd] }
         do_in_path $path {
-        try {
-            #git describe will error with 'No names found' if repo has no tags
-            #set v [::exec {*}[auto_execok git] describe]
-            set v [::exec {*}[auto_execok git] -remote -v] ;# consider 'git rev-parse --short HEAD'
-        } on error {e o} {
-            set v [lindex [split [dict get $o -errorinfo] \n] 0]
-        }
+            try {
+                #git describe will error with 'No names found' if repo has no tags
+                #set v [::exec {*}[auto_execok git] describe]
+                set v [::exec {*}[auto_execok git] -remote -v] ;# consider 'git rev-parse --short HEAD'
+            } on error {e o} {
+                set v [lindex [split [dict get $o -errorinfo] \n] 0]
+            }
         }
         return [string trim $v]
     }
@@ -1104,6 +1179,148 @@ namespace eval punk::repo {
             return Unknown
         }
     }
+    proc fossil_get_configdb {{path {}}} {
+        #fossil info will *usually* give us the necessary config-db info whether in a project folder or not but..
+        #a) It's expensive to shell-out and call it
+        #b) it won't give us a result if we are in a checkout folder which has had its repository moved 
+        #this fairly extensive mechanism is designed to find it even if the environment has some weird goings-on regarding the filesystem/environment variables
+        #This is unlikely to be necessary in most scenarios, where the location is related to the user's home directory
+        
+        #attempt 1 - environment vars  and well-known locations 
+        #This is first because it's faster - but hopefully it's aligned with how fossil does it
+
+        if {"windows" eq $::tcl_platform(platform)} {
+            foreach varname [list FOSSIL_HOME LOCALAPPDATA APPDATA USERPROFILES] {
+                if {[info exists ::env($varname)]} {
+                    set testfile [file join $::env($varname) _fossil]
+                    if {[file exists $testfile]} {
+                        return $testfile
+                    }
+                }
+            }
+            if {[info exists ::env(HOMEDRIVE)] && [info exists ::env(HOMEPATH)]} {
+                set testfile $::env(HOMEDRIVE)$::env(HOMEPATH)\\_fossil"
+                if {[file exists $testfile]} {
+                    return $testfile
+                }
+            } 
+        } else {
+            foreach varname [list FOSSIL_HOME HOME ] {
+                if {[info exists ::env($varname)]} {
+                    set testfile [file join $::env($varname) .fossil]
+                    if {[file exists $testfile]} {
+                        return $testfile
+                    }
+                }
+            }
+            if {[info exists ::env(XDG_CONFIG_HOME)]} {
+                set testfile [file join $::env(XDG_CONFIG_HOME) fossil.db]
+                if {[file exists $testfile]} {
+                    return $testfile
+                }
+                set testfile [file join $::env(XDG_CONFIG_HOME) .config fossil.db]
+                if {[file exists $testfile]} {
+                    return $testfile
+                }
+            } 
+            if {[info exists ::env(HOME)]} {
+                set testfile [file join $::env(HOME) .config fossil.db]
+                if {[file exists $testfile]} {
+                    return $testfile
+                }
+            } 
+        }
+
+
+        set original_cwd [pwd]
+        #attempt2 - let fossil do it for us - hopefully based on current folder
+        if {$path eq {}} {set path [pwd]}
+        set fossilcmd [auto_execok fossil]
+        if {![llength $fossilcmd]} {
+            set fossil_ok 0
+        } else {
+            set fossil_ok 1
+        }
+        try {
+            while {$fossil_ok} {
+                cd $path
+                if {[catch {exec {*}$fossilcmd info} fossilinfo]} {
+                    #a detached repo above us can result in an error from fossil info
+                    set next [file dirname $path]
+                } else {
+                    set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
+                    if {[llength $matching_lines] == 1} {
+                        set trimmedline [string trim [lindex $matching_lines 0]]
+                        set firstcolon [string first : $trimmedline]
+                        set config_db_path [string trim [string range $trimmedline $firstcolon+1 end]]
+                        if {[file exists $config_db_path]} {
+                            return $config_db_path
+                        }
+                    }
+                    set next [file dirname $path]
+                }
+
+                if {$next eq $path || $next eq ""} {
+                    break
+                }
+                set path $next
+            }
+        } on error {errmsg options} {
+            #puts "errmsg:$errmgs options:$options"
+        } finally {
+            cd $original_cwd
+        }
+
+        #attempt 3 - getting desperate.. find other repos, determine their checkouts and run fossil in them to get a result 
+        if {$fossil_ok} {
+            #It should be extremely rare to need to resort to sqlite on the databases to find other potential repo paths
+            #Conceivably only on some weird VFS or where some other filesystem strangeness is going on with our original path - or if the root volume itself is a broken fossil checkout
+            #Examining the other repos gives us a chance at discovering some other filesystem/paths where things may not be broken
+            if {![catch {package require sqlite3} errPackage]} {
+                #use fossil all ls and sqlite 
+                if {[catch {exec {*}$fossilcmd all ls} repolines]} {
+                    error "fossil_get_configdb cannot find repositories"
+                } else {
+                    set repolines [string map [list \r\n \n] $repolines]
+                    set repolist [split $repolines \n]
+                    set dbcmd "fossil_get_configdb_tempdb"
+                    foreach repodb $repolist {
+                        catch {rename $dbcmd ""}
+                        if {[file exists $repodb]} {
+                            if {![catch {sqlite3 $dbcmd $repodb}]} {
+                                set ckoutrecords [$dbcmd eval {select name from config where name like 'ckout:%'}]
+                                catch {$dbcmd close}
+                                foreach ck $ckoutrecords {
+                                    set ckfolder [string range $ck 6 end]
+                                    #puts stdout "ckfolder $ckfolder"
+                                    if {[file isdirectory $ckfolder]} {
+                                        set result ""
+                                        do_in_path $ckfolder {
+                                            if {![catch {exec {*}$fossilcmd info} fossilinfo]} {
+                                                set matching_lines [punk::repo::grep {config-db:*} $fossilinfo]
+                                                if {[llength $matching_lines] == 1} {
+                                                    set trimmedline [string trim [lindex $matching_lines 0]]
+                                                    set firstcolon [string first : $trimmedline]
+                                                    set config_db_path [string trim [string range $trimmedline $firstcolon+1 end]]
+                                                    if {[file exists $config_db_path]} {
+                                                        set result $config_db_path
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        if {$result ne ""} {
+                                            return $result
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        error "fossil_get_configdb exhausted search options"
+    }
     #------------------------------------
     
     #temporarily cd to workpath to run script - return to correct path even on failure
@@ -1256,7 +1473,19 @@ namespace eval punk::repo {
     interp alias {} gconf {} git config --global -l
 
 }
+namespace eval punk::repo::lib {
+    #-----------------------------------------------------------------------------------
+    #strlen is important for testing issues with string representationa and shimmering.
+    #This specific implementation with append (as at 2023-09) is designed to ensure the original str representation isn't changed
+    #It may need to be reviewed with different Tcl versions in case the append empty string is 'optimised/tuned' in some way that affects the behaviour
+    #The use of this function instead of string length can make a difference in certain circumstances with 'path' object representations
+    proc strlen {str} {
+        append str2 $str {}
+        string length $str2
+    }
+    #-----------------------------------------------------------------------------------
 
+}
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
diff --git a/src/modules/punk/winrun-999999.0a1.0.tm b/src/modules/punk/winrun-999999.0a1.0.tm
index 0b201442..9acea356 100644
--- a/src/modules/punk/winrun-999999.0a1.0.tm
+++ b/src/modules/punk/winrun-999999.0a1.0.tm
@@ -18,6 +18,7 @@
 ##  Requirements
 ##e.g package require frobz
 #package require twapi ;#not loaded here because as of 2023-11 load is *very* slow. Todo - query APN re return to faster partial loading facility for twapi subsets.
+#update 2024 - while twapi is slower to load than other packages - it's not *that* bad. Earlier tests were on a machine which may have had disk issues, and made twapi's relative difference noticeable.
 #slow twapi load at startup can be ameliorated by async loading the dll in another thread in circumstances where it's not needed immediately anyway - but this doesn't help for filters where we need twapi functionality asap.
 
 #see also: https://daviddeley.com/autohotkey/parameters/parameters.htm#WINNOSTANDARD
diff --git a/src/modules/punkcheck-0.1.0.tm b/src/modules/punkcheck-0.1.0.tm
index 4582ac50..c58fe244 100644
--- a/src/modules/punkcheck-0.1.0.tm
+++ b/src/modules/punkcheck-0.1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
@@ -36,6 +36,7 @@ namespace eval punkcheck {
             uuid\
             start_installer_event  installfile_*
 
+        #antiglob_dir & antiglob_file entries match the pattern at any level - should not contain path separators
         variable default_antiglob_dir_core  [list "#*" "_aside" ".git" ".fossil*"]
         variable default_antiglob_file_core ""
         proc uuid {} {
@@ -1155,15 +1156,15 @@ namespace eval punkcheck {
                 -installer punkcheck::install\
                 ]
 
-            set opts [dict merge $defaults $args]
             if {([llength $args] %2) != 0} {
                 error "punkcheck::install requires option-style arguments to be in pairs. Received args: $args"
             }
-            foreach k [dict keys $args] {
+            foreach {k -} $args {
                 if {$k ni [dict keys $defaults]} {
                     error "punkcheck::install  unrecognised option '$k' known options: '[dict keys $defaults]'"
                 }
             }
+            set opts [dict merge $defaults $args]
 
             #The choice to recurse using the original values of srcdir & tgtdir, and passing the subpath down as a list in -subdirlist seems an odd one.
             #(as opposed to a more 'standard' mechanism of adjusting srcdir & tgtdir as we move down the tree)
@@ -1194,6 +1195,12 @@ namespace eval punkcheck {
             }
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set opt_antiglob_file                       [dict get $opts -antiglob_file]
+            #validate no path seps
+            foreach af $opt_antiglob_file {
+                if {[llength [file split $af]] > 1} {
+                    error "punkcheck::install received invalid -antiglob_file entry '$af'. -antiglob_file entries are meant to match to a file name at any level so cannot contain path separators"
+                }
+            } 
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set opt_antiglob_dir_core                   [dict get $opts -antiglob_dir_core]
             if {$opt_antiglob_dir_core eq "\uFFFF"} {
@@ -1202,8 +1209,15 @@ namespace eval punkcheck {
             }
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set opt_antiglob_dir                        [dict get $opts -antiglob_dir]
+            #validate no path seps
+            foreach ad $opt_antiglob_dir {
+                if {[llength [file split $ad]] > 1} {
+                    error "punkcheck::install received invalid -antiglob_dir entry '$ad'. -antiglob_dir entries are meant to match to a directory name at any level so cannot contain path separators"
+                }
+            } 
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set opt_antiglob_paths                     [dict get $opts -antiglob_paths] ;#todo - combine with config file in source tree .punkcheckpublish (?)
+            #antiglob_paths will usually contain file separators - and may contain glob patterns within each segment
             set antiglob_paths_matched [list]
             # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
             set known_whats [list no-targets newer-targets older-targets all-targets installedsourcechanged-targets synced-targets]
@@ -1586,6 +1600,21 @@ namespace eval punkcheck {
                     continue
                 }
 
+                set relative_source_path [file join $relative_source_dir $d]
+                set is_antipath 0
+                foreach antipath $opt_antiglob_paths {
+                    #puts "testing folder - globmatchpath $antipath  vs $relative_source_path" 
+                    if {[punk::path::globmatchpath $antipath $relative_source_path]} {
+                        lappend antiglob_paths_matched [file join $current_source_dir $d]
+                        puts stdout "SKIPPING FOLDER $relative_source_path due to antiglob_path-match: $antipath "
+                        set is_antipath 1
+                        break
+                    }
+                }
+                if {$is_antipath} {
+                    continue
+                }
+                
 
                 if {![file exists $current_target_dir/$d]} {
                     file mkdir $current_target_dir/$d
diff --git a/src/modules/shellfilter-0.1.8.tm b/src/modules/shellfilter-0.1.8.tm
index 33999fbc..0498b594 100644
--- a/src/modules/shellfilter-0.1.8.tm
+++ b/src/modules/shellfilter-0.1.8.tm
@@ -2186,7 +2186,7 @@ namespace eval shellfilter {
             error "Trailing arguments after any positional arguments must be in pairs of the form -argname argvalue. Valid flags are:'$valid_flags'"
         }
         set invalid_flags [list]
-        foreach k [dict keys $args] {
+        dict for {k -} $args {
             if {$k ni $valid_flags} {
                 lappend invalid_flags $k
             }
@@ -2542,7 +2542,7 @@ namespace eval shellfilter {
         # - but there is a slight difference in that with rdout we get an extra blocked state just prior to the final read.
         # Not known if that is significant
         ## with inchan configured -buffering line 
-        #c:\repo\jn\shellspy\test>printf "test\netc\n" | tclsh shellspy.vfs/main.tcl -r cat
+        #c:\repo\jn\punk\test>printf "test\netc\n" | tclsh punk.vfs/main.tcl -r cat
         #warning reading input with -buffering line. Cannot detect missing trailing-newline at eof
         #instate  b:0 eof:0 pend:-1 count:4
         #test
@@ -2550,7 +2550,7 @@ namespace eval shellfilter {
         #etc
         #instate  b:0 eof:1 pend:-1 count:-1
 
-        #c:\repo\jn\shellspy\test>printf "test\netc" | tclsh shellspy.vfs/main.tcl -r cat
+        #c:\repo\jn\punk\test>printf "test\netc" | tclsh punk.vfs/main.tcl -r cat
         #warning reading input with -buffering line. Cannot detect missing trailing-newline at eof
         #instate  b:0 eof:0 pend:-1 count:4
         #test
@@ -2684,14 +2684,14 @@ namespace eval shellfilter {
         ##If we still read with gets,to retrieve line by line for output to line-buffered output - but the input channel is configured with -buffering none
         ## then we can detect the difference
         # there is an extra blocking read - but we can stil use eof with data to detect the absent newline and avoid passing an extra one on.
-        #c:\repo\jn\shellspy\test>printf "test\netc\n" | tclsh shellspy.vfs/main.tcl /c cat
+        #c:\repo\jn\punk\test>printf "test\netc\n" | tclsh punk.vfs/main.tcl /c cat
         #instate  b:0 eof:0 pend:-1 count:4
         #test
         #instate  b:0 eof:0 pend:-1 count:3
         #etc
         #instate  b:0 eof:1 pend:-1 count:-1
 
-        #c:\repo\jn\shellspy\test>printf "test\netc" | tclsh shellspy.vfs/main.tcl /u/c cat
+        #c:\repo\jn\punk\test>printf "test\netc" | tclsh punk.vfs/main.tcl /u/c cat
         #instate  b:0 eof:0 pend:-1 count:4
         #test
         #instate  b:1 eof:0 pend:-1 count:-1
@@ -2702,7 +2702,7 @@ namespace eval shellfilter {
 
         #this should only occur if upstream is coming from stdin reader that has  line buffering and hasn't handled the difference properly..
         ###reading with gets from line buffered input with trailing newline
-        #c:\repo\jn\shellspy\test>printf "test\netc\n" | tclsh shellspy.vfs/main.tcl /c cat
+        #c:\repo\jn\punk\test>printf "test\netc\n" | tclsh punk.vfs/main.tcl /c cat
         #instate  b:0 eof:0 pend:-1 count:4
         #test
         #instate  b:0 eof:0 pend:-1 count:3
@@ -2711,7 +2711,7 @@ namespace eval shellfilter {
 
         ###reading with gets from line buffered input with trailing newline
         ##No detectable difference!
-        #c:\repo\jn\shellspy\test>printf "test\netc" | tclsh shellspy.vfs/main.tcl /c cat
+        #c:\repo\jn\punk\test>printf "test\netc" | tclsh punk.vfs/main.tcl /c cat
         #instate  b:0 eof:0 pend:-1 count:4
         #test
         #instate  b:0 eof:0 pend:-1 count:3
diff --git a/src/modules/tcl9test-999999.0a1.0.tm b/src/modules/tcl9test-999999.0a1.0.tm
index aacdf497..02641fc2 100644
--- a/src/modules/tcl9test-999999.0a1.0.tm
+++ b/src/modules/tcl9test-999999.0a1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
diff --git a/src/modules/textblock-999999.0a1.0.tm b/src/modules/textblock-999999.0a1.0.tm
index 748785e9..19eec9e5 100644
--- a/src/modules/textblock-999999.0a1.0.tm
+++ b/src/modules/textblock-999999.0a1.0.tm
@@ -18,10 +18,11 @@
 ##  Requirements
 ##e.g package require frobz
 package require punk
+package require punk::args
 package require punk::char
 package require patternpunk
 package require overtype
-package require term::ansi::code::macros
+package require term::ansi::code::macros ;#required for frame if old ansi g0 used - review - make package optional?
 package require textutil
 
 
@@ -30,6 +31,7 @@ package require textutil
 #Note: A textblock does not necessarily have lines the same length - either in number of characters or print-width
 #
 namespace eval textblock {
+    namespace export block width
     namespace eval cd {
         #todo - save and restore existing namespace export in case macros::cd has default exports in future
         namespace eval ::term::ansi::code::macros::cd {namespace export *}
@@ -38,28 +40,31 @@ namespace eval textblock {
     }
 
     #return a homogenous block of characters - ie lines all same length, all same character
-    #printing-width in terminal columns is not necessarily same as blockcols even if a single char is passed (could be full-width unicode character)
-    proc block {blockrows blockcols {char " "}} {
-        if {($blockrows <= 0 || $blockcols <= 0)} {
-            error "textblock::block blockrows and blockcols must be positive integers"
+    #printing-width in terminal columns is not necessarily same as blockwidth even if a single char is passed (could be full-width unicode character)
+    proc block {blockwidth blockheight {char " "}} {
+        if {$blockwidth < 0} {
+            error "textblock::block blockwidth  must be an integer greater than or equal to zero"
+        }
+        if {$blockheight <= 0} {
+            error "textblock::block blockheight must be a positive integer"
         }
         if {$char eq ""} {return ""}
         if {[string length $char] == 1} {
-            set row [string repeat $char $blockcols]
-            set mtrx [lrepeat $blockrows $row]
+            set row [string repeat $char $blockwidth]
+            set mtrx [lrepeat $blockheight $row]
             return [::join $mtrx \n]
         } else {
             set charblock [string map [list \r\n \n] $char] 
             if {[string first \n $charblock] >= 0} {
-                if {$blockcols > 1} {
-                    set row [.= val $charblock {*}[lrepeat [expr {$blockcols -1}] |> piper_blockjoin $charblock]]
+                if {$blockwidth > 1} {
+                    set row [.= val $charblock {*}[lrepeat [expr {$blockwidth -1}] |> piper_blockjoin $charblock]]
                 } else {
                     set row $charblock
                 }
             } else {
-                set row [string repeat $char $blockcols]
+                set row [string repeat $char $blockwidth]
             }
-            set mtrx [lrepeat $blockrows $row]
+            set mtrx [lrepeat $blockheight $row]
             return [::join $mtrx \n]
         }
     }
@@ -176,12 +181,9 @@ namespace eval textblock {
         return [list_as_lines -- $outlines]
     }
 
-    namespace eval ::textblock::piper {
-        proc join {rhs existing} {
-            tailcall ::textblock::join $existing $rhs
-        }
+    proc ::textblock::trim {block} {
+        set trimlines []
     }
-    interp alias {} piper_blockjoin {} ::textblock::piper::join
 
     pipealias ::textblock::join_right .= {list $lhs [string repeat " " [width $lhs]] $rhs [string repeat " " [width $rhs]]} {|
                 /2,col1/1,col2/3
@@ -254,12 +256,95 @@ namespace eval textblock {
         }
 
     }
+    proc gcross {{size 1} args} {
+        if {$size == 0} {
+            return ""
+        }
+
+        set defaults [list\
+            -max_cross_size 0
+        ]
+        set opts [dict merge $defaults $args]
+        set opt_max_cross_size [dict get $opts -max_cross_size]
+
+        #set fit_size [punk::lib::greatestOddFactor $size]
+        set fit_size $size 
+        if {$opt_max_cross_size == 0} {
+            set max_cross_size $fit_size 
+        } else {
+            #todo - only allow divisors
+            #set testsize [expr {min($fit_size,$opt_max_cross_size)}]
+
+            set factors [punk::lib::factors $size]
+            #pick odd size in list that is smaller or equal to test_size
+            set max_cross_size [lindex $factors end]
+            set last_ok [lindex $factors 0]
+            for {set i 0} {$i < [llength $factors]} {incr i} {
+                set s [lindex $factors $i]
+                if {$s > $opt_max_cross_size} {
+                    break
+                }
+                set last_ok $s
+            }
+            set max_cross_size $last_ok
+        }
+        set crosscount [expr {$size / $max_cross_size}]
+
+        package require punk::char
+        set x [punk::char::charshort boxd_ldc]
+        set bs [punk::char::charshort boxd_ldgullr]
+        set fs [punk::char::charshort boxd_ldgurll]
+
+        set onecross ""
+        set crossrows [list]
+        set armsize [expr {int(floor($max_cross_size /2))}]
+        set row [lrepeat $max_cross_size " "]    
+        #toparm
+        for {set i 0} {$i < $armsize} {incr i} {
+            set r $row
+            lset r $i $bs
+            lset r end-$i $fs
+            #append onecross [::join $r ""] \n
+            lappend crossrows [::join $r ""]
+        }
+
+        if {$max_cross_size % 2 != 0} {
+            #only put centre cross in for odd sized crosses
+            set r $row
+            lset r $armsize $x
+            #append onecross [::join $r ""] \n
+            lappend crossrows [::join $r ""]
+        }
+
+        for {set i [expr {$armsize -1}]} {$i >= 0} {incr i -1} {
+            set r $row
+            lset r $i $fs
+            lset r end-$i $bs
+            #append onecross [::join $r ""] \n
+            lappend crossrows [::join $r ""]
+        }
+        #set onecross [string trimright $onecross \n]
+        set onecross [::join $crossrows \n]
+
+        #fastest to do row first then columns - because textblock::join must do line by line
+
+        if {$crosscount > 1} {
+            package require textblock
+            set row [textblock::join {*}[lrepeat $crosscount $onecross]]
+            set rows [lrepeat $crosscount $row]
+            set out [::join $rows \n]
+        } else {
+            set out $onecross
+        }
+
+        return $out
+    }
 
     #Test we can join two coloured blocks 
     proc test_colour {} {
         set b1 [a= red]1\n2\n3[a=]
         set b2 [a= green]a\nb\nc[a=]
-        set result [join $b1 $b2]
+        set result [textblock::join $b1 $b2]
         puts $result
         return [list $b1 $b2 $result]
     }
@@ -267,6 +352,13 @@ namespace eval textblock {
 }
 
 
+namespace eval ::textblock::piper {
+    namespace export *
+    proc join {rhs pipelinedata} {
+        tailcall ::textblock::join $pipelinedata $rhs
+    }
+}
+interp alias {} piper_blockjoin {} ::textblock::piper::join
 
 
 
diff --git a/src/modules/winlibreoffice-999999.0a1.0.tm b/src/modules/winlibreoffice-999999.0a1.0.tm
index 6272abb1..5e9d180f 100644
--- a/src/modules/winlibreoffice-999999.0a1.0.tm
+++ b/src/modules/winlibreoffice-999999.0a1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
 #
 # Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
 # Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
diff --git a/src/vendormodules/natsort-0.1.1.5.tm b/src/vendormodules/natsort-0.1.1.5.tm
index 0dcf57e7..0e4260b8 100644
--- a/src/vendormodules/natsort-0.1.1.5.tm
+++ b/src/vendormodules/natsort-0.1.1.5.tm
@@ -238,8 +238,13 @@ namespace eval natsort {
 
     #considered using hex to make large numbers more compact for viewing in debug output - but it's not that much shorter and probably obscures more than it helps.
     proc hex2dec {largeHex} {
+        #todo - use punk::lib::hex2dec - (scan supports ll so can do larger hex values directly)
         set res 0
         set largeHex [string map [list _ ""] $largeHex]
+        if {[string length $largeHex] <=7} {
+            #scan can process up to FFFFFFF and does so quickly
+            return [scan $largeHex %x]
+        }
         foreach hexDigit [split $largeHex {}] {
             set new 0x$hexDigit
             set res [expr {16*$res + $new}]
@@ -249,6 +254,8 @@ namespace eval natsort {
     proc dec2hex {decimalNumber} {
         format %4.4llX $decimalNumber
     }
+
+    #punk::lib::trimzero
     proc trimzero {number} {
         set trimmed [string trimleft $number 0]
         if {[string length $trimmed] == 0} {
@@ -382,6 +389,7 @@ namespace eval natsort {
     }
 
     proc get_char_count {str char} {
+        #faster than lsearch on split for str of a few K
         expr {[string length $str]-[string length [string map [list $char {}] $str]]}
     }
     
diff --git a/src/mixtemplates/layouts/basic/src/bootsupport/modules/overtype-1.5.0.tm b/src/vendormodules/overtype-1.5.1.tm
similarity index 74%
rename from src/mixtemplates/layouts/basic/src/bootsupport/modules/overtype-1.5.0.tm
rename to src/vendormodules/overtype-1.5.1.tm
index f4e466f3..92f2464a 100644
--- a/src/mixtemplates/layouts/basic/src/bootsupport/modules/overtype-1.5.0.tm
+++ b/src/vendormodules/overtype-1.5.1.tm
@@ -7,23 +7,69 @@
 # (C) Julian Noble 2003-2023
 #
 # @@ Meta Begin
-# Application overtype 1.5.0
+# Application overtype 1.5.1
 # Meta platform     tcl
 # Meta license      BSD 
 # @@ Meta End
 
 
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin overtype_module_overtype 0 1.5.1]
+#[copyright "2024"]
+#[titledesc {overtype text layout - ansi aware}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {overtype text layout}]             [comment {-- Description at end of page heading --}] 
+#[require overtype]
+#[keywords module text ansi]
+#[description]
+#[para] -
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of overtype 
+#[subsection Concepts]
+#[para] -
+
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Requirements
-##e.g package require frobz
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by overtype 
+#[list_begin itemized]
+
+package require Tcl 8.6
 package require textutil
 package require punk::ansi  ;#required to detect, split, strip and calculate lengths
 package require punk::char  ;#box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+#*** !doctools
+#[item] [package {Tcl 8.6}]
+#[item] [package textutil]
+#[item] [package punk::ansi]
+#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
+#[item] [package punk::char]
+#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+
+# #package require frobz
+# #*** !doctools
+# #[item] [package {frobz}]
+
+#*** !doctools
+#[list_end]
+
 
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[section API]
+
 
 #Julian Noble <julian@precisium.com.au> - 2003 
 #Released under standard 'BSD license' conditions.
@@ -83,183 +129,69 @@ namespace eval overtype {
 }
 
 
-#candidate for zig/c implementation?
-proc overtype::stripansi {text} {
-    variable escape_terminals  ;#dict
-    variable ansi_2byte_codes_dict
-    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-        #\033 same as \x1b
-        return $text
-    }
-
-    set text [convert_g0 $text] 
-
-    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-    set inputlist [split $text ""]
-    set outputlist [list] 
-
-    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-
-    set in_escapesequence 0
-    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-    set i 0
-    foreach u $inputlist {
-        set v [lindex $inputlist $i+1]
-        set uv ${u}${v}
-        if {$in_escapesequence eq "2b"} {
-            #2nd byte - done.
-            set in_escapesequence 0
-        } elseif {$in_escapesequence != 0} {
-            set escseq [dict get $escape_terminals $in_escapesequence]
-            if {$u in $escseq} {
-                set in_escapesequence 0
-            } elseif {$uv in $escseq} {
-                set in_escapseequence 2b ;#flag next byte as last in sequence
-            }
-        } else {
-            #handle both 7-bit and 8-bit CSI and OSC
-            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-                set in_escapesequence CSI
-            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-                set in_escapesequence OSC
-            } elseif {$uv in $2bytecodes} {
-                #self-contained e.g terminal reset - don't pass through.
-                set in_escapesequence 2b
-            } else {
-                lappend outputlist $u
-            }
-        }
-        incr i
-    }
-    return [join $outputlist ""]
-}
-
-#review
-#todo - map other chars  to unicode equivs
-proc overtype::convert_g0 {text} {
-    #using not \033 inside to stop greediness - review how does it compare to ".*?"
-    set re {\033\(0[^\033]*\033\(B} 
-    set re2 {\033\(0(.*)\033\(B} ;#capturing
-    set parts [ta::_perlish_split $re $text]
-    set out ""
-    foreach {pt g} $parts {
-        append out $pt
-        if {$g ne ""} {
-            #puts --$g--
-            #box sample
-            #lqk
-            #x x
-            #mqj
-            #m = boxd_lur
-            #set map [list l \u250f k \u2513] ;#heavy
-            set map [list l \u250c q \u2500 k \u2510 x \u2502 m \u2514 j \u2518] ;#light
-
-            regexp $re2 $g _match contents
-            append out [string map $map $contents]
-        }
-    }
-    return $out
-}
-
-#todo - convert esc(0 graphics sequences to single char unicode equivalents e.g box drawing set
-# esc) ??
-proc overtype::stripansi_gx {text} {
-        #e.g "\033(0" - select VT100 graphics for character set G0
-        #e.g "\033(B" - reset 
-        #e.g "\033)0" - select VT100 graphics for character set G1
-        #e.g "\033)X" - where X is any char other than 0 to reset ??
-        return [convert_g0 $text]
-}
-
-
-#This shouldn't be called on text containing ansi codes!
-proc overtype::strip_nonprinting_ascii {str} {
-    #review - some single-byte 'control' chars have visual representations e.g ETX as heart
-    #It is currently used for screen display width calculations
-    #equivalent for various unicode combining chars etc?
-    set map [list\
-        \007 ""\
-        [format %c 0] ""\
-        [format %c 0x7f] ""\
-    ]
-    return [string map $map $str]
-}
-
-#length of text for printing characters only
-#review - unicode and other non-printing chars and combining sequences?
-#certain unicode chars are full-width (single char 2 columns wide) e.g see "Halfwdith and fullwidth forms" and ascii_fuillwidth blocks in punk::char::charset_names
-#review - is there an existing library or better method? print to a terminal and query cursor position?
-#Note this length calculation is only suitable for lines being appended to other strings if the line is pre-processed to account for backspace and carriage returns first
-#If the raw line is appended to another string without such processing - the backspaces & carriage returns can affect data prior to the start of the string. 
-proc overtype::printing_length {line} {
-    if {[string first \n $line] >= 0} {
-        error "line_print_length must not contain newline characters"
-    }
+#proc overtype::stripansi {text} {
+#    variable escape_terminals  ;#dict
+#    variable ansi_2byte_codes_dict
+#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
+#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
+#        #\033 same as \x1b
+#        return $text
+#    }
+#
+#    set text [convert_g0 $text] 
+#
+#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
+#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
+#    set inputlist [split $text ""]
+#    set outputlist [list] 
+#
+#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
+#
+#    set in_escapesequence 0
+#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
+#    set i 0
+#    foreach u $inputlist {
+#        set v [lindex $inputlist $i+1]
+#        set uv ${u}${v}
+#        if {$in_escapesequence eq "2b"} {
+#            #2nd byte - done.
+#            set in_escapesequence 0
+#        } elseif {$in_escapesequence != 0} {
+#            set escseq [dict get $escape_terminals $in_escapesequence]
+#            if {$u in $escseq} {
+#                set in_escapesequence 0
+#            } elseif {$uv in $escseq} {
+#                set in_escapseequence 2b ;#flag next byte as last in sequence
+#            }
+#        } else {
+#            #handle both 7-bit and 8-bit CSI and OSC
+#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
+#                set in_escapesequence CSI
+#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
+#                set in_escapesequence OSC
+#            } elseif {$uv in $2bytecodes} {
+#                #self-contained e.g terminal reset - don't pass through.
+#                set in_escapesequence 2b
+#            } else {
+#                lappend outputlist $u
+#            }
+#        }
+#        incr i
+#    }
+#    return [join $outputlist ""]
+#}
 
-    #review - 
-    set line [stripansi $line]
 
-    set line [strip_nonprinting_ascii $line] ;#only strip nonprinting after stripansi - some like BEL are part of ansi
-    #backspace 0x08 only erases* printing characters anyway - so presumably order of processing doesn't matter
-    #(* more correctly - moves cursor back)
-    #backspace will not move beyond a preceding newline - but we have disallowed newlines for this function already
-    #leading backspaces will eat into any string (even prompt in non-standard tclsh shell) that is prepended to the line
-    # - but for the purposes of overtype we wouldn't want that - so we strip it here in the length calculation and should strip leading backspaces in the actual data concatenation operations too.
-    #curiously - a backspace sequence at the end of a string also doesn't reduce the printing width - so we can also strip from RHS
 
-    #Note that backspace following a \t will only shorten the string by one (ie it doesn't move back the whole tab width like it does interactively in the terminal)
-    #for this reason - it would seem best to normalize the tabs to spaces prior to performing the backspace calculation - otherwise we won't account for the 'short' tabs it effectivley produces
-    #normalize tabs to an appropriate* width
-    #*todo - handle terminal/context where tabwidth != the default 8 spaces
-    set line [textutil::tabify::untabify2 $line]
 
-    set bs [format %c 0x08]
-    #set line [string map [list "\r${bs}" "\r"] $line] ;#backsp following a \r will have no effect
-    set line [string trim $line $bs]
-    set n 0
-
-    set chars [split $line ""] 
-    #build an output 
-    set idx 0
-    set outchars [list]
-    set outsizes [list]
-    foreach c $chars {
-        if {$c eq $bs} {
-            if {$idx > 0} {
-                incr idx -1
-            }
-        } elseif {$c eq "\r"} {
-            set idx 0
-        } else {
-            priv::printing_length_addchar $idx $c
-            incr idx
-        }
-    }
-    set line2 [join $outchars ""]
-    return [punk::char::string_width $line2]
-}
 
 proc overtype::string_columns {text} {
     if {[punk::ansi::ta::detect $text]} {
-        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with overtype::stripansi. Alternatively try overtype::printing_length"
+        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
     }
     return [punk::char::string_width $text]
 }
 
-namespace eval overtype::priv {
-    proc printing_length_addchar {i c} {
-        upvar outchars outc 
-        upvar outsizes outs
-        set nxt [llength $outc] 
-        if {$i < $nxt} {
-            lset outc $i $c
-        } else {
-            lappend outc $c
-        }
-    }
-}
 
 #string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
 proc overtype::left {args} {
@@ -299,13 +231,13 @@ proc overtype::left {args} {
     set overblock  [string map $norm $overblock]
 
     set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
+    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
     set overlines  [split $overblock \n]
 
     set outputlines [list]
     foreach undertext $underlines overtext $overlines {    
-        set undertext_printlen [printing_length $undertext]
-        set overlen [printing_length $overtext]
+        set undertext_printlen [punk::ansi::printing_length $undertext]
+        set overlen [punk::ansi::printing_length $overtext]
         set diff [expr {$overlen - $colwidth}]
 
         #review
@@ -387,46 +319,53 @@ proc overtype::centre {args} {
     set overblock  [string map $norm $overblock]
 
     set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
+    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
     set overlines  [split $overblock \n]
+    set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
 
     set outputlines [list]
     foreach undertext $underlines overtext $overlines {    
-        set olen [printing_length $overtext]
-        set ulen [printing_length $undertext]
+        #set olen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
         if {$ulen < $colwidth} {
             set udiff [expr {$colwidth - $ulen}]
             set undertext "$undertext[string repeat { } $udiff]"
         }
         #review
-        append overtext "\033\[0m"
+        #append overtext "\033\[0m"
 
-        set diff [expr {$colwidth - $olen}]
-        if {$diff > 0} {
+        set under_exposed [expr {$colwidth - $overblock_width}]
+        if {$under_exposed > 0} {
             #background block is wider
-            set half [expr {round(int($diff / 2))}]
-            if {[string match right [dict get $opts -bias]]} {
-                if {[expr {2 * $half}] < $diff} {
-                    incr half
+            if {$under_exposed % 2 == 0} {
+                #even left/right exposure
+                set left_exposed [expr {$under_exposed / 2}]
+            } else {
+                set beforehalf [expr {$under_exposed / 2}] ;#1 less than half due to integer division
+                if {[string tolower [dict get $opts -bias]] eq "left"} {
+                    set left_exposed $beforehalf
+                } else {
+                    #bias to the right
+                    set left_exposed [expr {$beforehalf + 1}]
                 }
             }
             
+            if 0 {
             set rhs [expr {$diff - $half - 1}]
             set lhs [expr {$half - 1}]
             set rhsoffset [expr {$rhs +1}]
-            if 0 {
             set a [string range $undertext 0 $lhs]
             set background [string range $undertext $lhs+1 end-$rhsoffset]
             set b [renderline -transparent $opt_transparent $background $overtext]
             set c [string range $undertext end-$rhs end]
             lappend outputlines $a$b$c
             }
-            lappend outputlines [renderline -start $lhs -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+            lappend outputlines [renderline -start $left_exposed -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
 
         } else {
             #overlay wider or equal
             set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {$diff < 0} {
+            if {$under_exposed < 0} {
                 #overlay is wider - trim if overflow not specified in opts
                 if {![dict get $opts -overflow]} {
                     #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
@@ -436,7 +375,7 @@ proc overtype::centre {args} {
                     }
                 }
             } else {
-                #widths match
+                #zero under_exposed - widths match
             }
             lappend outputlines $rendered
             #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
@@ -485,13 +424,13 @@ proc overtype::right {args} {
     set overblock  [string map $norm $overblock]
 
     set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
+    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
     set overlines  [split $overblock \n]
 
     set outputlines [list]
     foreach undertext $underlines overtext $overlines {    
-        set olen [printing_length $overtext]
-        set ulen [printing_length $undertext]
+        set olen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
         if {$ulen < $colwidth} {
             set udiff [expr {$colwidth - $ulen}]
             set undertext "$undertext[string repeat { } $udiff]"
@@ -547,7 +486,7 @@ namespace eval overtype::piper {
 interp alias "" piper_renderline "" overtype::piper::renderline 
 
 #-returnextra to enable returning of overflow and length
-# todo - use ta::detect to short-circuit processing and do simple string calcs as an optimisation?
+# todo - use punk::ansi::ta::detect to short-circuit processing and do simple string calcs as an optimisation?
 #review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
 #todo - review transparency issues with single/double width characters!
 proc overtype::renderline {args} {
@@ -905,9 +844,10 @@ namespace eval overtype::priv {
 
 
 # -- --- --- --- --- --- --- --- --- --- ---
+if 0 {
 namespace eval overtype::ta {
     namespace path ::overtype
-    #*based* on but not identical to:
+    # *based* on but not identical to:
     #https://github.com/perlancar/perl-Text-ANSI-Util/blob/master/lib/Text/ANSI/BaseUtil.pm
 
     #handle both 7-bit and 8-bit csi 
@@ -934,45 +874,28 @@ namespace eval overtype::ta {
 
     #detect any ansi escapes
     #review - only detect 'complete' codes - or just use the opening escapes for performance?
-    proc detect {text} {
-        variable re_ansi_detect
-        #variable re_csi_open
-        #variable re_esc_osc1
-        #variable re_esc_osc2
-        #todo - other escape sequences
-        #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
-        expr {[regexp $re_ansi_detect $text]}
-    }
+    #proc detect {text} {
+    #    variable re_ansi_detect
+    #    #variable re_csi_open
+    #    #variable re_esc_osc1
+    #    #variable re_esc_osc2
+    #    #todo - other escape sequences
+    #    #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
+    #    expr {[regexp $re_ansi_detect $text]}
+    #}
     #not in perl ta
-    proc detect_csi {text} {
-        variable re_csi_colour
-        expr {[regexp $re_csi_colour $text]}
-    }
+    #proc detect_csi {text} {
+    #    variable re_csi_colour
+    #    expr {[regexp $re_csi_colour $text]}
+    #}
     proc strip {text} {
-        tailcall stripansi $text
+        tailcall punk::ansi::stripansi $text
     }
     #note this is character length after stripping ansi codes - not the printing length
     proc length {text} {
-        string length [overtype::stripansi $text]
-    }
-    #todo - handle newlines
-    #not in perl ta
-    proc printing_length {text} {
-
+        string length [punk::ansi::stripansi $text]
     }
 
-    proc trunc {text width args} {
-
-    }
-
-    #not in perl ta
-    #returns just the plaintext portions in a list
-    proc split_at_codes {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        textutil::splitx $text "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-    }
     
     # -- --- --- --- --- --- 
     #Split $text to a list containing alternating ANSI color codes and text.
@@ -987,43 +910,41 @@ namespace eval overtype::ta {
     #ta_split_codes "\e[31ma\e[0mb" # => {""    "\e[31m"       "a"  "\e[0m", "b"}
     #ta_split_codes "\e[31m\e[0mb"  # => {""    "\e[31m\e[0m"  "b"}
     #
-    proc split_codes {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
-        return [_perlish_split $re $text]
-    }
-    #like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
-    proc split_codes_single {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-        return [_perlish_split $re $text]
-    }
-
-    #review - tcl greedy expressions may match multiple in one element
-    proc _perlish_split {re text} {
-        if {[string length $text] == 0} {
-            return {}
-        }
-        set list [list]
-        set start 0
-        while {[regexp -start $start -indices -- $re $text match]} {
-            lassign $match      matchStart matchEnd
-            lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
-            set start [expr {$matchEnd+1}]
-        }
-        lappend list [string range $text $start end]
-        return $list
-    }
-    proc _ws_split {text} {
-        regexp -all -inline {(?:\S+)|(?:\s+)} $text
-    }
-    # -- --- --- --- --- --- 
+    #proc split_codes {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
+    #    return [_perlish_split $re $text]
+    #}
+    ##like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
+    #proc split_codes_single {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
+    #    return [_perlish_split $re $text]
+    #}
+
+    ##review - tcl greedy expressions may match multiple in one element
+    #proc _perlish_split {re text} {
+    #    if {[string length $text] == 0} {
+    #        return {}
+    #    }
+    #    set list [list]
+    #    set start 0
+    #    while {[regexp -start $start -indices -- $re $text match]} {
+    #        lassign $match      matchStart matchEnd
+    #        lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
+    #        set start [expr {$matchEnd+1}]
+    #    }
+    #    lappend list [string range $text $start end]
+    #    return $list
+    #}
+    ## -- --- --- --- --- --- 
 
 }
+} ;# end if 0
 
 # -- --- --- --- --- --- --- --- --- --- ---
 namespace eval overtype {
@@ -1034,6 +955,9 @@ namespace eval overtype {
 ##  Ready   
 package provide overtype [namespace eval overtype {
     variable version
-    set version 1.5.0 
+    set version 1.5.1 
 }]
-return
\ No newline at end of file
+return
+
+#*** !doctools
+#[manpage_end]
diff --git a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/overtype-1.5.0.tm b/src/vendormodules/overtype-1.5.2.tm
similarity index 69%
rename from src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/overtype-1.5.0.tm
rename to src/vendormodules/overtype-1.5.2.tm
index f4e466f3..dda4dcd6 100644
--- a/src/modules/punk/mix/templates/layouts/project/src/bootsupport/modules/overtype-1.5.0.tm
+++ b/src/vendormodules/overtype-1.5.2.tm
@@ -7,23 +7,69 @@
 # (C) Julian Noble 2003-2023
 #
 # @@ Meta Begin
-# Application overtype 1.5.0
+# Application overtype 1.5.2
 # Meta platform     tcl
 # Meta license      BSD 
 # @@ Meta End
 
 
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin overtype_module_overtype 0 1.5.2]
+#[copyright "2024"]
+#[titledesc {overtype text layout - ansi aware}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {overtype text layout}]             [comment {-- Description at end of page heading --}] 
+#[require overtype]
+#[keywords module text ansi]
+#[description]
+#[para] -
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of overtype 
+#[subsection Concepts]
+#[para] -
+
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Requirements
-##e.g package require frobz
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by overtype 
+#[list_begin itemized]
+
+package require Tcl 8.6
 package require textutil
 package require punk::ansi  ;#required to detect, split, strip and calculate lengths
 package require punk::char  ;#box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+#*** !doctools
+#[item] [package {Tcl 8.6}]
+#[item] [package textutil]
+#[item] [package punk::ansi]
+#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
+#[item] [package punk::char]
+#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+
+# #package require frobz
+# #*** !doctools
+# #[item] [package {frobz}]
+
+#*** !doctools
+#[list_end]
+
 
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[section API]
+
 
 #Julian Noble <julian@precisium.com.au> - 2003 
 #Released under standard 'BSD license' conditions.
@@ -83,183 +129,69 @@ namespace eval overtype {
 }
 
 
-#candidate for zig/c implementation?
-proc overtype::stripansi {text} {
-    variable escape_terminals  ;#dict
-    variable ansi_2byte_codes_dict
-    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-        #\033 same as \x1b
-        return $text
-    }
-
-    set text [convert_g0 $text] 
-
-    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-    set inputlist [split $text ""]
-    set outputlist [list] 
-
-    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-
-    set in_escapesequence 0
-    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-    set i 0
-    foreach u $inputlist {
-        set v [lindex $inputlist $i+1]
-        set uv ${u}${v}
-        if {$in_escapesequence eq "2b"} {
-            #2nd byte - done.
-            set in_escapesequence 0
-        } elseif {$in_escapesequence != 0} {
-            set escseq [dict get $escape_terminals $in_escapesequence]
-            if {$u in $escseq} {
-                set in_escapesequence 0
-            } elseif {$uv in $escseq} {
-                set in_escapseequence 2b ;#flag next byte as last in sequence
-            }
-        } else {
-            #handle both 7-bit and 8-bit CSI and OSC
-            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-                set in_escapesequence CSI
-            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-                set in_escapesequence OSC
-            } elseif {$uv in $2bytecodes} {
-                #self-contained e.g terminal reset - don't pass through.
-                set in_escapesequence 2b
-            } else {
-                lappend outputlist $u
-            }
-        }
-        incr i
-    }
-    return [join $outputlist ""]
-}
-
-#review
-#todo - map other chars  to unicode equivs
-proc overtype::convert_g0 {text} {
-    #using not \033 inside to stop greediness - review how does it compare to ".*?"
-    set re {\033\(0[^\033]*\033\(B} 
-    set re2 {\033\(0(.*)\033\(B} ;#capturing
-    set parts [ta::_perlish_split $re $text]
-    set out ""
-    foreach {pt g} $parts {
-        append out $pt
-        if {$g ne ""} {
-            #puts --$g--
-            #box sample
-            #lqk
-            #x x
-            #mqj
-            #m = boxd_lur
-            #set map [list l \u250f k \u2513] ;#heavy
-            set map [list l \u250c q \u2500 k \u2510 x \u2502 m \u2514 j \u2518] ;#light
-
-            regexp $re2 $g _match contents
-            append out [string map $map $contents]
-        }
-    }
-    return $out
-}
-
-#todo - convert esc(0 graphics sequences to single char unicode equivalents e.g box drawing set
-# esc) ??
-proc overtype::stripansi_gx {text} {
-        #e.g "\033(0" - select VT100 graphics for character set G0
-        #e.g "\033(B" - reset 
-        #e.g "\033)0" - select VT100 graphics for character set G1
-        #e.g "\033)X" - where X is any char other than 0 to reset ??
-        return [convert_g0 $text]
-}
-
-
-#This shouldn't be called on text containing ansi codes!
-proc overtype::strip_nonprinting_ascii {str} {
-    #review - some single-byte 'control' chars have visual representations e.g ETX as heart
-    #It is currently used for screen display width calculations
-    #equivalent for various unicode combining chars etc?
-    set map [list\
-        \007 ""\
-        [format %c 0] ""\
-        [format %c 0x7f] ""\
-    ]
-    return [string map $map $str]
-}
-
-#length of text for printing characters only
-#review - unicode and other non-printing chars and combining sequences?
-#certain unicode chars are full-width (single char 2 columns wide) e.g see "Halfwdith and fullwidth forms" and ascii_fuillwidth blocks in punk::char::charset_names
-#review - is there an existing library or better method? print to a terminal and query cursor position?
-#Note this length calculation is only suitable for lines being appended to other strings if the line is pre-processed to account for backspace and carriage returns first
-#If the raw line is appended to another string without such processing - the backspaces & carriage returns can affect data prior to the start of the string. 
-proc overtype::printing_length {line} {
-    if {[string first \n $line] >= 0} {
-        error "line_print_length must not contain newline characters"
-    }
+#proc overtype::stripansi {text} {
+#    variable escape_terminals  ;#dict
+#    variable ansi_2byte_codes_dict
+#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
+#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
+#        #\033 same as \x1b
+#        return $text
+#    }
+#
+#    set text [convert_g0 $text] 
+#
+#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
+#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
+#    set inputlist [split $text ""]
+#    set outputlist [list] 
+#
+#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
+#
+#    set in_escapesequence 0
+#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
+#    set i 0
+#    foreach u $inputlist {
+#        set v [lindex $inputlist $i+1]
+#        set uv ${u}${v}
+#        if {$in_escapesequence eq "2b"} {
+#            #2nd byte - done.
+#            set in_escapesequence 0
+#        } elseif {$in_escapesequence != 0} {
+#            set escseq [dict get $escape_terminals $in_escapesequence]
+#            if {$u in $escseq} {
+#                set in_escapesequence 0
+#            } elseif {$uv in $escseq} {
+#                set in_escapseequence 2b ;#flag next byte as last in sequence
+#            }
+#        } else {
+#            #handle both 7-bit and 8-bit CSI and OSC
+#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
+#                set in_escapesequence CSI
+#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
+#                set in_escapesequence OSC
+#            } elseif {$uv in $2bytecodes} {
+#                #self-contained e.g terminal reset - don't pass through.
+#                set in_escapesequence 2b
+#            } else {
+#                lappend outputlist $u
+#            }
+#        }
+#        incr i
+#    }
+#    return [join $outputlist ""]
+#}
 
-    #review - 
-    set line [stripansi $line]
 
-    set line [strip_nonprinting_ascii $line] ;#only strip nonprinting after stripansi - some like BEL are part of ansi
-    #backspace 0x08 only erases* printing characters anyway - so presumably order of processing doesn't matter
-    #(* more correctly - moves cursor back)
-    #backspace will not move beyond a preceding newline - but we have disallowed newlines for this function already
-    #leading backspaces will eat into any string (even prompt in non-standard tclsh shell) that is prepended to the line
-    # - but for the purposes of overtype we wouldn't want that - so we strip it here in the length calculation and should strip leading backspaces in the actual data concatenation operations too.
-    #curiously - a backspace sequence at the end of a string also doesn't reduce the printing width - so we can also strip from RHS
 
-    #Note that backspace following a \t will only shorten the string by one (ie it doesn't move back the whole tab width like it does interactively in the terminal)
-    #for this reason - it would seem best to normalize the tabs to spaces prior to performing the backspace calculation - otherwise we won't account for the 'short' tabs it effectivley produces
-    #normalize tabs to an appropriate* width
-    #*todo - handle terminal/context where tabwidth != the default 8 spaces
-    set line [textutil::tabify::untabify2 $line]
 
-    set bs [format %c 0x08]
-    #set line [string map [list "\r${bs}" "\r"] $line] ;#backsp following a \r will have no effect
-    set line [string trim $line $bs]
-    set n 0
-
-    set chars [split $line ""] 
-    #build an output 
-    set idx 0
-    set outchars [list]
-    set outsizes [list]
-    foreach c $chars {
-        if {$c eq $bs} {
-            if {$idx > 0} {
-                incr idx -1
-            }
-        } elseif {$c eq "\r"} {
-            set idx 0
-        } else {
-            priv::printing_length_addchar $idx $c
-            incr idx
-        }
-    }
-    set line2 [join $outchars ""]
-    return [punk::char::string_width $line2]
-}
 
 proc overtype::string_columns {text} {
     if {[punk::ansi::ta::detect $text]} {
-        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with overtype::stripansi. Alternatively try overtype::printing_length"
+        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
     }
     return [punk::char::string_width $text]
 }
 
-namespace eval overtype::priv {
-    proc printing_length_addchar {i c} {
-        upvar outchars outc 
-        upvar outsizes outs
-        set nxt [llength $outc] 
-        if {$i < $nxt} {
-            lset outc $i $c
-        } else {
-            lappend outc $c
-        }
-    }
-}
 
 #string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
 proc overtype::left {args} {
@@ -272,8 +204,10 @@ proc overtype::left {args} {
 	}
     lassign [lrange $args end-1 end] underblock overblock
     set defaults [dict create\
+        -bias       ignored\
         -ellipsis   0\
         -ellipsistext   $default_ellipsis_horizontal\
+        -ellipsiswhitespace 0\
         -overflow   0\
         -transparent 0\
         -exposed1 \uFFFD\
@@ -290,8 +224,9 @@ proc overtype::left {args} {
     # -- --- --- --- --- ---
     set opt_transparent     [dict get $opts -transparent]
     set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
+    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
+    set opt_exposed1        [dict get $opts -exposed1] ;#widechar_exposed_left  - todo
+    set opt_exposed2        [dict get $opts -exposed2] ;#widechar_exposed_right - todo
     # -- --- --- --- --- ---
 
     set norm [list \r\n \n]
@@ -299,30 +234,50 @@ proc overtype::left {args} {
     set overblock  [string map $norm $overblock]
 
     set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
+    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $underlines] colwidth colheight
     set overlines  [split $overblock \n]
+    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $overlines] overblock_width overblock_height
+    set under_exposed_max [expr {$colwidth - $overblock_width}]
+    set right_exposed $under_exposed_max 
 
     set outputlines [list]
     foreach undertext $underlines overtext $overlines {    
-        set undertext_printlen [printing_length $undertext]
-        set overlen [printing_length $overtext]
-        set diff [expr {$overlen - $colwidth}]
+        set undertext_printlen [punk::ansi::printing_length $undertext]
+        if {$undertext_printlen < $colwidth} {
+            set udiff [expr {$colwidth - $undertext_printlen}]
+            set undertext "$undertext[string repeat { } $udiff]"
+        }
+        set overtext_printlen [punk::ansi::printing_length $overtext]
+        set overflowlength [expr {$overtext_printlen - $colwidth}]
 
         #review
         #append overtext "\033\[0m"
 
-        if {$diff > 0} {
-            #background line is narrower 
+
+        if {$overflowlength > 0} {
+            #background line is narrower than data in line
             set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow [dict get $opts -overflow] $undertext $overtext]
             if {![dict get $opts -overflow]} {
                 #set overtext [string range $overtext 0 $colwidth-1] ;#string range won't be correct e.g if contains ansi codes or leading \r or \b etc
                 if {[dict get $opts -ellipsis]} {
-                    set rendered [overtype::right $rendered $opt_ellipsistext]
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[string trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
+                        set rendered [overtype::right $rendered $opt_ellipsistext]
+                    }
                 }
             }
             lappend outputlines $rendered
         } else {
-            #we know overtext is shorter or equal
+            #we know overtext data is shorter or equal (for this line)
             lappend outputlines [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
         }
     }
@@ -357,10 +312,12 @@ proc overtype::centre {args} {
 	
     foreach {underblock overblock} [lrange $args end-1 end] break
 
+    #todo - vertical vs horizontal overflow for blocks
     set defaults [dict create\
         -bias       left\
         -ellipsis   0\
         -ellipsistext   $default_ellipsis_horizontal\
+        -ellipsiswhitespace 0\
         -overflow   0\
         -transparent 0\
         -exposed1 \uFFFD\
@@ -376,7 +333,9 @@ proc overtype::centre {args} {
     set opts [dict merge $defaults $argsflags]
     # -- --- --- --- --- ---
     set opt_transparent     [dict get $opts -transparent]
+    set opt_ellipsis        [dict get $opts -ellipsis]
     set opt_ellipsistext    [dict get $opts -ellipsistext]
+    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
     set opt_exposed1        [dict get $opts -exposed1]
     set opt_exposed2        [dict get $opts -exposed2]
     # -- --- --- --- --- ---
@@ -387,65 +346,75 @@ proc overtype::centre {args} {
     set overblock  [string map $norm $overblock]
 
     set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
+    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $underlines] colwidth colheight
     set overlines  [split $overblock \n]
+    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $overlines] overblock_width overblock_height 
+    set under_exposed_max [expr {$colwidth - $overblock_width}]
+    if {$under_exposed_max > 0} {
+        #background block is wider
+        if {$under_exposed_max % 2 == 0} {
+            #even left/right exposure
+            set left_exposed [expr {$under_exposed_max / 2}]
+        } else {
+            set beforehalf [expr {$under_exposed_max / 2}] ;#1 less than half due to integer division
+            if {[string tolower [dict get $opts -bias]] eq "left"} {
+                set left_exposed $beforehalf
+            } else {
+                #bias to the right
+                set left_exposed [expr {$beforehalf + 1}]
+            }
+        }
+    } else {
+        set left_exposed 0
+    }
 
     set outputlines [list]
     foreach undertext $underlines overtext $overlines {    
-        set olen [printing_length $overtext]
-        set ulen [printing_length $undertext]
+        set overtext_datalen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
         if {$ulen < $colwidth} {
             set udiff [expr {$colwidth - $ulen}]
             set undertext "$undertext[string repeat { } $udiff]"
         }
-        #review
-        append overtext "\033\[0m"
-
-        set diff [expr {$colwidth - $olen}]
-        if {$diff > 0} {
-            #background block is wider
-            set half [expr {round(int($diff / 2))}]
-            if {[string match right [dict get $opts -bias]]} {
-                if {[expr {2 * $half}] < $diff} {
-                    incr half
-                }
-            }
-            
-            set rhs [expr {$diff - $half - 1}]
-            set lhs [expr {$half - 1}]
-            set rhsoffset [expr {$rhs +1}]
-            if 0 {
-            set a [string range $undertext 0 $lhs]
-            set background [string range $undertext $lhs+1 end-$rhsoffset]
-            set b [renderline -transparent $opt_transparent $background $overtext]
-            set c [string range $undertext end-$rhs end]
-            lappend outputlines $a$b$c
-            }
-            lappend outputlines [renderline -start $lhs -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
 
-        } else {
-            #overlay wider or equal
-            set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {$diff < 0} {
-                #overlay is wider - trim if overflow not specified in opts
-                if {![dict get $opts -overflow]} {
-                    #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
-                    #set overtext [string range $overtext 0 $colwidth-1 ]
-                    if {[dict get $opts -ellipsis]} {
+        set overflowlength [expr {$overtext_datalen - $colwidth}]
+        #review - right-to-left langs should elide on left! - extra option required
+
+        if {$overflowlength > 0} {
+            #overlay line wider or equal
+            set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+            #overlay line data is wider - trim if overflow not specified in opts - and overtype an ellipsis at right if it was specified
+            if {![dict get $opts -overflow]} {
+                #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
+                #set overtext [string range $overtext 0 $colwidth-1 ]
+                if {$opt_ellipsis} {
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[string trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
                         set rendered [overtype::right $rendered $opt_ellipsistext]
                     }
                 }
-            } else {
-                #widths match
             }
             lappend outputlines $rendered
             #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
+        } else {
+            #background block is wider than or equal to data for this line
+            lappend outputlines [renderline -start $left_exposed -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
         }
     }
     return [join $outputlines \n]
 }
 
 proc overtype::right {args} {
+    #NOT the same as align-right - which should be done to the overblock first if required
     variable default_ellipsis_horizontal
 	# @d !todo - implement overflow, length checks etc
 
@@ -455,9 +424,10 @@ proc overtype::right {args} {
     foreach {underblock overblock} [lrange $args end-1 end] break
 
     set defaults [dict create\
-        -bias       left\
+        -bias       ignored\
         -ellipsis   0\
         -ellipsistext   $default_ellipsis_horizontal\
+        -ellipsiswhitespace 0\
         -overflow   0\
         -transparent 0\
         -exposed1 \uFFFD\
@@ -475,6 +445,7 @@ proc overtype::right {args} {
     set opt_transparent     [dict get $opts -transparent]
     set opt_ellipsis         [dict get $opts -ellipsis]
     set opt_ellipsistext    [dict get $opts -ellipsistext]
+    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
     set opt_overflow        [dict get $opts -overflow]
     set opt_exposed1        [dict get $opts -exposed1]
     set opt_exposed2        [dict get $opts -exposed2]
@@ -485,33 +456,51 @@ proc overtype::right {args} {
     set overblock  [string map $norm $overblock]
 
     set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
+    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $underlines] colwidth colheight
     set overlines  [split $overblock \n]
+    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $overlines] overblock_width overblock_height 
+    set under_exposed_max [expr {$colwidth - $overblock_width}]
+    set left_exposed $under_exposed_max 
 
     set outputlines [list]
     foreach undertext $underlines overtext $overlines {    
-        set olen [printing_length $overtext]
-        set ulen [printing_length $undertext]
+        set overtext_datalen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
         if {$ulen < $colwidth} {
             set udiff [expr {$colwidth - $ulen}]
             set undertext "$undertext[string repeat { } $udiff]"
         }
-        #review
-        #append overtext "\033\[0m"
+        if {$overtext_datalen < $overblock_width} {
+            set odiff [expr {$overblock_width - $overtext_datalen}]
+            #padding always on right - if alignment is required it should be done to block beforehand - not here
+            set overtextpadding "$overtext[string repeat { } $odiff]"
+        }
 
-        set overflowlength [expr {$olen - $colwidth}]
+        set overflowlength [expr {$overtext_datalen - $colwidth}]
         if {$overflowlength > 0} {	
-            #overtext wider than undertext column
+            #raw overtext wider than undertext column
             set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -start 0 $undertext $overtext]
             if {!$opt_overflow} {
                 if {$opt_ellipsis} {
-                    set rendered [overtype::right $rendered $opt_ellipsistext]
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[string trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
+                        set rendered [overtype::right $rendered $opt_ellipsistext]
+                    }
                 }
             }
             lappend outputlines $rendered
         } else {
-            #lappend outputlines [string range $undertext 0 end-$olen]$overtext
-            lappend outputlines [renderline -transparent $opt_transparent -start [expr {$colwidth - $olen}] $undertext $overtext]
+            #padded overtext 
+            lappend outputlines [renderline -transparent $opt_transparent -start $left_exposed $undertext $overtext]
         }
     }
 
@@ -547,7 +536,7 @@ namespace eval overtype::piper {
 interp alias "" piper_renderline "" overtype::piper::renderline 
 
 #-returnextra to enable returning of overflow and length
-# todo - use ta::detect to short-circuit processing and do simple string calcs as an optimisation?
+# todo - use punk::ansi::ta::detect to short-circuit processing and do simple string calcs as an optimisation?
 #review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
 #todo - review transparency issues with single/double width characters!
 proc overtype::renderline {args} {
@@ -854,7 +843,30 @@ proc overtype::test_renderline {} {
     set missing \uFFFD
     return [list $t $u A${t}B]
 }
+
+#same as textblock::size - but we don't want that circular dependency
+proc overtype::blocksize {textblock} {
+    if {$textblock eq ""} {
+        return [list 0 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
+    }
+    set textblock [textutil::tabify::untabify2 $textblock]
+    #stripansi on entire block in one go rather than line by line - result should be the same - review - make tests
+    set textblock [punk::ansi::stripansi $textblock]
+    if {[string first \n $textblock] >= 0} {
+        set width [tcl::mathfunc::max {*}[lmap v [lines_as_list -- $textblock] {::punk::char::string_width $v}]]
+    } else {
+        set width [punk::char::string_width $textblock] 
+    }
+    set num_le [expr {[string length $textblock]-[string length [string map [list \n {}] $textblock]]}] ;#faster than splitting into single-char list
+    #our concept of block-height is likely to be different to other line-counting mechanisms
+    set height [expr {$num_le + 1}] ;# one line if no le - 2 if there is one trailing le even if no data follows le
+
+    return [list $width $height]
+}
+
 namespace eval overtype::priv {
+
+
     #todo - move to punk::ansi::codetype
     proc is_sgr {code} {
         #SGR (Select Graphic Rendition) - codes ending in 'm' - e.g colour/underline 
@@ -905,9 +917,10 @@ namespace eval overtype::priv {
 
 
 # -- --- --- --- --- --- --- --- --- --- ---
+if 0 {
 namespace eval overtype::ta {
     namespace path ::overtype
-    #*based* on but not identical to:
+    # *based* on but not identical to:
     #https://github.com/perlancar/perl-Text-ANSI-Util/blob/master/lib/Text/ANSI/BaseUtil.pm
 
     #handle both 7-bit and 8-bit csi 
@@ -934,45 +947,28 @@ namespace eval overtype::ta {
 
     #detect any ansi escapes
     #review - only detect 'complete' codes - or just use the opening escapes for performance?
-    proc detect {text} {
-        variable re_ansi_detect
-        #variable re_csi_open
-        #variable re_esc_osc1
-        #variable re_esc_osc2
-        #todo - other escape sequences
-        #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
-        expr {[regexp $re_ansi_detect $text]}
-    }
+    #proc detect {text} {
+    #    variable re_ansi_detect
+    #    #variable re_csi_open
+    #    #variable re_esc_osc1
+    #    #variable re_esc_osc2
+    #    #todo - other escape sequences
+    #    #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
+    #    expr {[regexp $re_ansi_detect $text]}
+    #}
     #not in perl ta
-    proc detect_csi {text} {
-        variable re_csi_colour
-        expr {[regexp $re_csi_colour $text]}
-    }
+    #proc detect_csi {text} {
+    #    variable re_csi_colour
+    #    expr {[regexp $re_csi_colour $text]}
+    #}
     proc strip {text} {
-        tailcall stripansi $text
+        tailcall punk::ansi::stripansi $text
     }
     #note this is character length after stripping ansi codes - not the printing length
     proc length {text} {
-        string length [overtype::stripansi $text]
-    }
-    #todo - handle newlines
-    #not in perl ta
-    proc printing_length {text} {
-
+        string length [punk::ansi::stripansi $text]
     }
 
-    proc trunc {text width args} {
-
-    }
-
-    #not in perl ta
-    #returns just the plaintext portions in a list
-    proc split_at_codes {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        textutil::splitx $text "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-    }
     
     # -- --- --- --- --- --- 
     #Split $text to a list containing alternating ANSI color codes and text.
@@ -987,43 +983,41 @@ namespace eval overtype::ta {
     #ta_split_codes "\e[31ma\e[0mb" # => {""    "\e[31m"       "a"  "\e[0m", "b"}
     #ta_split_codes "\e[31m\e[0mb"  # => {""    "\e[31m\e[0m"  "b"}
     #
-    proc split_codes {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
-        return [_perlish_split $re $text]
-    }
-    #like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
-    proc split_codes_single {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-        return [_perlish_split $re $text]
-    }
-
-    #review - tcl greedy expressions may match multiple in one element
-    proc _perlish_split {re text} {
-        if {[string length $text] == 0} {
-            return {}
-        }
-        set list [list]
-        set start 0
-        while {[regexp -start $start -indices -- $re $text match]} {
-            lassign $match      matchStart matchEnd
-            lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
-            set start [expr {$matchEnd+1}]
-        }
-        lappend list [string range $text $start end]
-        return $list
-    }
-    proc _ws_split {text} {
-        regexp -all -inline {(?:\S+)|(?:\s+)} $text
-    }
-    # -- --- --- --- --- --- 
+    #proc split_codes {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
+    #    return [_perlish_split $re $text]
+    #}
+    ##like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
+    #proc split_codes_single {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
+    #    return [_perlish_split $re $text]
+    #}
+
+    ##review - tcl greedy expressions may match multiple in one element
+    #proc _perlish_split {re text} {
+    #    if {[string length $text] == 0} {
+    #        return {}
+    #    }
+    #    set list [list]
+    #    set start 0
+    #    while {[regexp -start $start -indices -- $re $text match]} {
+    #        lassign $match      matchStart matchEnd
+    #        lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
+    #        set start [expr {$matchEnd+1}]
+    #    }
+    #    lappend list [string range $text $start end]
+    #    return $list
+    #}
+    ## -- --- --- --- --- --- 
 
 }
+} ;# end if 0
 
 # -- --- --- --- --- --- --- --- --- --- ---
 namespace eval overtype {
@@ -1034,6 +1028,9 @@ namespace eval overtype {
 ##  Ready   
 package provide overtype [namespace eval overtype {
     variable version
-    set version 1.5.0 
+    set version 1.5.2 
 }]
-return
\ No newline at end of file
+return
+
+#*** !doctools
+#[manpage_end]
diff --git a/src/vendormodules/overtype-1.5.3.tm b/src/vendormodules/overtype-1.5.3.tm
new file mode 100644
index 00000000..6b54a4ac
--- /dev/null
+++ b/src/vendormodules/overtype-1.5.3.tm
@@ -0,0 +1,1037 @@
+# -*- tcl -*-
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+#
+# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
+# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# (C) Julian Noble 2003-2023
+#
+# @@ Meta Begin
+# Application overtype 1.5.3
+# Meta platform     tcl
+# Meta license      BSD 
+# @@ Meta End
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin overtype_module_overtype 0 1.5.3]
+#[copyright "2024"]
+#[titledesc {overtype text layout - ansi aware}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {overtype text layout}]             [comment {-- Description at end of page heading --}] 
+#[require overtype]
+#[keywords module text ansi]
+#[description]
+#[para] -
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of overtype 
+#[subsection Concepts]
+#[para] -
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Requirements
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by overtype 
+#[list_begin itemized]
+
+package require Tcl 8.6
+package require textutil
+package require punk::ansi  ;#required to detect, split, strip and calculate lengths
+package require punk::char  ;#box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+#*** !doctools
+#[item] [package {Tcl 8.6}]
+#[item] [package textutil]
+#[item] [package punk::ansi]
+#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
+#[item] [package punk::char]
+#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
+
+# #package require frobz
+# #*** !doctools
+# #[item] [package {frobz}]
+
+#*** !doctools
+#[list_end]
+
+
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[section API]
+
+
+#Julian Noble <julian@precisium.com.au> - 2003 
+#Released under standard 'BSD license' conditions.
+#
+#todo - ellipsis truncation indicator for center,right
+
+#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
+# - need to extract and replace ansi codes?
+
+namespace eval overtype {
+	namespace export *
+    variable default_ellipsis_horizontal "..." ;#fallback 
+    variable default_ellipsis_vertical "..." 
+    namespace eval priv {
+        proc _init {} {
+            upvar ::overtype::default_ellipsis_horizontal e_h
+            upvar ::overtype::default_ellipsis_vertical e_v
+            set e_h [format %c 0x2026] ;#Unicode Horizontal Ellipsis
+            set e_v [format %c 0x22EE]
+            #The unicode ellipsis looks more natural than triple-dash which is centred vertically whereas ellipsis is at floorline of text
+            #Also - unicode ellipsis has semantic meaning that other processors can interpret
+            #unicode does also provide a midline horizontal ellipsis 0x22EF
+
+            #set e [format %c 0x2504] ;#punk::char::charshort boxd_ltdshhz  - Box Drawings Light Triple Dash Horizontal
+            #if {![catch {package require punk::char}]} {
+            #    set e [punk::char::charshort boxd_ltdshhz] 
+            #}
+        }
+    }
+    priv::_init
+}
+proc overtype::about {} {
+	return "Simple text formatting. Author JMN. BSD-License"
+}
+
+namespace eval overtype {
+    variable escape_terminals
+    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
+    dict set escape_terminals CSI [list @ \\ ^ _ ` | ~ a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z "\{" "\}"]
+    #dict set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
+    dict set escape_terminals OSC [list \007 \033\\] ;#note mix of 1 and 2-byte terminals 
+
+    #self-contained 2 byte ansi escape sequences - review more?
+    variable ansi_2byte_codes_dict
+    set  ansi_2byte_codes_dict [dict create\
+        "reset_terminal"            "\u001bc"\
+        "save_cursor_posn"          "\u001b7"\
+        "restore_cursor_posn"       "\u001b8"\
+        "cursor_up_one"             "\u001bM"\
+        "NEL - Next Line"           "\u001bE"\
+        "IND - Down one line"       "\u001bD"\
+        "HTS - Set Tab Stop"        "\u001bH"\
+        ]
+
+        #debatable whether strip should reveal the somethinghidden - some terminals don't hide it anyway.
+        #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
+}
+
+
+#proc overtype::stripansi {text} {
+#    variable escape_terminals  ;#dict
+#    variable ansi_2byte_codes_dict
+#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
+#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
+#        #\033 same as \x1b
+#        return $text
+#    }
+#
+#    set text [convert_g0 $text] 
+#
+#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
+#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
+#    set inputlist [split $text ""]
+#    set outputlist [list] 
+#
+#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
+#
+#    set in_escapesequence 0
+#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
+#    set i 0
+#    foreach u $inputlist {
+#        set v [lindex $inputlist $i+1]
+#        set uv ${u}${v}
+#        if {$in_escapesequence eq "2b"} {
+#            #2nd byte - done.
+#            set in_escapesequence 0
+#        } elseif {$in_escapesequence != 0} {
+#            set escseq [dict get $escape_terminals $in_escapesequence]
+#            if {$u in $escseq} {
+#                set in_escapesequence 0
+#            } elseif {$uv in $escseq} {
+#                set in_escapseequence 2b ;#flag next byte as last in sequence
+#            }
+#        } else {
+#            #handle both 7-bit and 8-bit CSI and OSC
+#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
+#                set in_escapesequence CSI
+#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
+#                set in_escapesequence OSC
+#            } elseif {$uv in $2bytecodes} {
+#                #self-contained e.g terminal reset - don't pass through.
+#                set in_escapesequence 2b
+#            } else {
+#                lappend outputlist $u
+#            }
+#        }
+#        incr i
+#    }
+#    return [join $outputlist ""]
+#}
+
+
+
+
+
+proc overtype::string_columns {text} {
+    if {[punk::ansi::ta::detect $text]} {
+        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
+    }
+    return [punk::char::string_width $text]
+}
+
+
+#string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
+proc overtype::left {args} {
+	# @c overtype starting at left (overstrike) 
+	# @c can/should we use something like this?: 'format "%-*s" $len $overtext 
+    variable default_ellipsis_horizontal
+
+	if {[llength $args] < 2} {
+		error {usage: ?-transparent [0|1]? ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
+	}
+    lassign [lrange $args end-1 end] underblock overblock
+    set defaults [dict create\
+        -bias       ignored\
+        -ellipsis   0\
+        -ellipsistext   $default_ellipsis_horizontal\
+        -ellipsiswhitespace 0\
+        -overflow   0\
+        -transparent 0\
+        -exposed1 \uFFFD\
+        -exposed2 \uFFFD\
+    ]
+    set known_opts [dict keys $defaults]
+    set argsflags [lrange $args 0 end-2]
+    dict for {k v} $argsflags {
+        if {$k ni $known_opts} {
+            error "overtype::left unknown option '$k'. Known options: $known_opts"
+        }
+    }
+    set opts [dict merge $defaults $argsflags]
+    # -- --- --- --- --- ---
+    set opt_transparent     [dict get $opts -transparent]
+    set opt_ellipsistext    [dict get $opts -ellipsistext]
+    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
+    set opt_exposed1        [dict get $opts -exposed1] ;#widechar_exposed_left  - todo
+    set opt_exposed2        [dict get $opts -exposed2] ;#widechar_exposed_right - todo
+    # -- --- --- --- --- ---
+
+    set norm [list \r\n \n]
+    set underblock [string map $norm $underblock]
+    set overblock  [string map $norm $overblock]
+
+    set underlines [split $underblock \n]
+    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $underblock] _w colwidth _h colheight
+    set overlines  [split $overblock \n]
+    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $overblock] _w overblock_width _h overblock_height
+    set under_exposed_max [expr {$colwidth - $overblock_width}]
+    set right_exposed $under_exposed_max 
+
+    set outputlines [list]
+    foreach undertext $underlines overtext $overlines {    
+        set undertext_printlen [punk::ansi::printing_length $undertext]
+        if {$undertext_printlen < $colwidth} {
+            set udiff [expr {$colwidth - $undertext_printlen}]
+            set undertext "$undertext[string repeat { } $udiff]"
+        }
+        set overtext_printlen [punk::ansi::printing_length $overtext]
+        set overflowlength [expr {$overtext_printlen - $colwidth}]
+
+        #review
+        #append overtext "\033\[0m"
+
+
+        if {$overflowlength > 0} {
+            #background line is narrower than data in line
+            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow [dict get $opts -overflow] $undertext $overtext]
+            if {![dict get $opts -overflow]} {
+                #set overtext [string range $overtext 0 $colwidth-1] ;#string range won't be correct e.g if contains ansi codes or leading \r or \b etc
+                if {[dict get $opts -ellipsis]} {
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[string trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
+                        set rendered [overtype::right $rendered $opt_ellipsistext]
+                    }
+                }
+            }
+            lappend outputlines $rendered
+        } else {
+            #we know overtext data is shorter or equal (for this line)
+            lappend outputlines [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+        }
+    }
+    return [join $outputlines \n]
+
+}
+
+namespace eval overtype::piper {
+    proc overcentre {args} {
+        if {[llength $args] < 2} {
+            error {usage: ?-bias left|right? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
+        }
+        lassign [lrange $args end-1 end] over under
+        set argsflags [lrange $args 0 end-2]
+        tailcall overtype::centre {*}$argsflags $under $over
+    }
+    proc overleft {args} {
+        if {[llength $args] < 2} {
+            error {usage: ?-start <column>? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
+        }
+        lassign [lrange $args end-1 end] over under
+        set argsflags [lrange $args 0 end-2]
+        tailcall overtype::left {*}$argsflags $under $over
+    }
+}
+#todo - left-right ellipsis ?
+proc overtype::centre {args} {
+    variable default_ellipsis_horizontal
+	if {[llength $args] < 2} {
+		error {usage: ?-transparent [0|1]? ?-bias [left|right]?  ?-overflow [1|0]? undertext overtext}
+	}
+	
+    foreach {underblock overblock} [lrange $args end-1 end] break
+
+    #todo - vertical vs horizontal overflow for blocks
+    set defaults [dict create\
+        -bias       left\
+        -ellipsis   0\
+        -ellipsistext   $default_ellipsis_horizontal\
+        -ellipsiswhitespace 0\
+        -overflow   0\
+        -transparent 0\
+        -exposed1 \uFFFD\
+        -exposed2 \uFFFD\
+    ]
+    set known_opts [dict keys $defaults]
+    set argsflags [lrange $args 0 end-2]
+    dict for {k v} $argsflags {
+        if {$k ni $known_opts} {
+            error "overtype::centre unknown option '$k'. Known options: $known_opts"
+        }
+    }
+    set opts [dict merge $defaults $argsflags]
+    # -- --- --- --- --- ---
+    set opt_transparent     [dict get $opts -transparent]
+    set opt_ellipsis        [dict get $opts -ellipsis]
+    set opt_ellipsistext    [dict get $opts -ellipsistext]
+    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
+    set opt_exposed1        [dict get $opts -exposed1]
+    set opt_exposed2        [dict get $opts -exposed2]
+    # -- --- --- --- --- ---
+
+
+    set norm [list \r\n \n]
+    set underblock [string map $norm $underblock]
+    set overblock  [string map $norm $overblock]
+
+    set underlines [split $underblock \n]
+    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $underblock] _w colwidth _h colheight
+    set overlines  [split $overblock \n]
+    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
+    set under_exposed_max [expr {$colwidth - $overblock_width}]
+    if {$under_exposed_max > 0} {
+        #background block is wider
+        if {$under_exposed_max % 2 == 0} {
+            #even left/right exposure
+            set left_exposed [expr {$under_exposed_max / 2}]
+        } else {
+            set beforehalf [expr {$under_exposed_max / 2}] ;#1 less than half due to integer division
+            if {[string tolower [dict get $opts -bias]] eq "left"} {
+                set left_exposed $beforehalf
+            } else {
+                #bias to the right
+                set left_exposed [expr {$beforehalf + 1}]
+            }
+        }
+    } else {
+        set left_exposed 0
+    }
+
+    set outputlines [list]
+    foreach undertext $underlines overtext $overlines {    
+        set overtext_datalen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
+        if {$ulen < $colwidth} {
+            set udiff [expr {$colwidth - $ulen}]
+            set undertext "$undertext[string repeat { } $udiff]"
+        }
+
+        set overflowlength [expr {$overtext_datalen - $colwidth}]
+        #review - right-to-left langs should elide on left! - extra option required
+
+        if {$overflowlength > 0} {
+            #overlay line wider or equal
+            set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+            #overlay line data is wider - trim if overflow not specified in opts - and overtype an ellipsis at right if it was specified
+            if {![dict get $opts -overflow]} {
+                #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
+                #set overtext [string range $overtext 0 $colwidth-1 ]
+                if {$opt_ellipsis} {
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[string trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
+                        set rendered [overtype::right $rendered $opt_ellipsistext]
+                    }
+                }
+            }
+            lappend outputlines $rendered
+            #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
+        } else {
+            #background block is wider than or equal to data for this line
+            lappend outputlines [renderline -start $left_exposed -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+        }
+    }
+    return [join $outputlines \n]
+}
+
+proc overtype::right {args} {
+    #NOT the same as align-right - which should be done to the overblock first if required
+    variable default_ellipsis_horizontal
+	# @d !todo - implement overflow, length checks etc
+
+	if {[llength $args] < 2} {
+		error {usage: ?-overflow [1|0]? undertext overtext}
+	}
+    foreach {underblock overblock} [lrange $args end-1 end] break
+
+    set defaults [dict create\
+        -bias       ignored\
+        -ellipsis   0\
+        -ellipsistext   $default_ellipsis_horizontal\
+        -ellipsiswhitespace 0\
+        -overflow   0\
+        -transparent 0\
+        -exposed1 \uFFFD\
+        -exposed2 \uFFFD\
+    ]
+    set known_opts [dict keys $defaults]
+    set argsflags [lrange $args 0 end-2]
+    dict for {k v} $argsflags {
+        if {$k ni $known_opts} {
+            error "overtype::centre unknown option '$k'. Known options: $known_opts"
+        }
+    }
+    set opts [dict merge $defaults $argsflags]
+    # -- --- --- --- --- ---
+    set opt_transparent     [dict get $opts -transparent]
+    set opt_ellipsis         [dict get $opts -ellipsis]
+    set opt_ellipsistext    [dict get $opts -ellipsistext]
+    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
+    set opt_overflow        [dict get $opts -overflow]
+    set opt_exposed1        [dict get $opts -exposed1]
+    set opt_exposed2        [dict get $opts -exposed2]
+    # -- --- --- --- --- ---
+    
+    set norm [list \r\n \n]
+    set underblock [string map $norm $underblock]
+    set overblock  [string map $norm $overblock]
+
+    set underlines [split $underblock \n]
+    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $underblock] _w colwidth _h colheight
+    set overlines  [split $overblock \n]
+    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
+    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
+    set under_exposed_max [expr {$colwidth - $overblock_width}]
+    set left_exposed $under_exposed_max 
+
+    set outputlines [list]
+    foreach undertext $underlines overtext $overlines {    
+        set overtext_datalen [punk::ansi::printing_length $overtext]
+        set ulen [punk::ansi::printing_length $undertext]
+        if {$ulen < $colwidth} {
+            set udiff [expr {$colwidth - $ulen}]
+            puts xxx
+            set undertext "$undertext[string repeat { } $udiff]"
+        }
+        if {$overtext_datalen < $overblock_width} {
+            set odiff [expr {$overblock_width - $overtext_datalen}]
+            #padding always on right - if alignment is required it should be done to block beforehand - not here
+            set overtextpadding "$overtext[string repeat { } $odiff]"
+        }
+
+        set overflowlength [expr {$overtext_datalen - $colwidth}]
+        if {$overflowlength > 0} {	
+            #raw overtext wider than undertext column
+            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -start 0 $undertext $overtext]
+            if {!$opt_overflow} {
+                if {$opt_ellipsis} {
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[string trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
+                        set rendered [overtype::right $rendered $opt_ellipsistext]
+                    }
+                }
+            }
+            lappend outputlines $rendered
+        } else {
+            #padded overtext 
+            lappend outputlines [renderline -transparent $opt_transparent -start $left_exposed $undertext $overtext]
+        }
+    }
+
+    return [join $outputlines \n]
+}
+
+# -- --- --- --- --- --- --- --- --- --- ---
+proc overtype::transparentline {args} {
+    foreach {under over} [lrange $args end-1 end] break
+    set argsflags [lrange $args 0 end-2]
+    set defaults [dict create\
+        -transparent 1\
+        -exposed 1 " "\
+        -exposed 2 " "\
+    ]
+    set newargs [dict merge $defaults $argsflags]
+    tailcall overtype::renderline {*}$newargs $under $over
+}
+#renderline may not make sense as it is in the long run for blocks of text - but is handy in the single-line-handling form anyway.
+# We are trying to handle ansi codes in a block of text which is acting like a mini-terminal in some sense.
+#We can process standard cursor moves such as \b \r - but no way to respond to other cursor movements e.g moving to other lines.
+#
+namespace eval overtype::piper {
+    proc renderline {args} {
+        if {[llength $args] < 2} {
+            error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
+        }
+        foreach {over under} [lrange $args end-1 end] break
+        set argsflags [lrange $args 0 end-2]
+        tailcall overtype::renderline {*}$argsflags $under $over
+    }
+}
+interp alias "" piper_renderline "" overtype::piper::renderline 
+
+#-returnextra to enable returning of overflow and length
+# todo - use punk::ansi::ta::detect to short-circuit processing and do simple string calcs as an optimisation?
+#review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
+#todo - review transparency issues with single/double width characters!
+proc overtype::renderline {args} {
+	if {[llength $args] < 2} {
+		error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? undertext overtext}
+	}
+    lassign [lrange $args end-1 end] under over
+    if {[string first \n $under] >=0 || [string first \n $over] >= 0} {
+        error "overtype::renderline not allowed to contain newlines"
+    }
+    set defaults [dict create\
+        -overflow   0\
+        -transparent 0\
+        -start 0\
+        -returnextra 0\
+        -exposed1 \uFFFD\
+        -exposed2 \uFFFD\
+    ]
+    #exposed1 and exposed2 for first and second col of underying 2wide char which is truncated by transparency or overflow
+
+    set known_opts [dict keys $defaults]
+    set argsflags [lrange $args 0 end-2]
+    dict for {k v} $argsflags {
+        if {$k ni $known_opts} {
+            error "overtype::renderline unknown option '$k'. Known options: $known_opts"
+        }
+    }
+    set opts [dict merge $defaults $argsflags]
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+    set opt_overflow            [dict get $opts -overflow]
+    set opt_colstart            [dict get $opts -start]
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+    set opt_transparent         [dict get $opts -transparent]  
+    if {$opt_transparent eq "0"} {
+        set do_transparency 0
+    } else {
+        set do_transparency 1
+        if {$opt_transparent eq "1"} {
+            set opt_transparent {[\s]}
+        }
+    }
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+    set opt_returnextra         [dict get $opts -returnextra]
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+    set opt_exposed1            [dict get $opts -exposed1]
+    set opt_exposed2            [dict get $opts -exposed2]
+    # -- --- --- --- --- --- --- --- --- --- --- ---
+
+    #-----
+    #
+    if {[string first \t $under] >= 0} {
+        #set under [textutil::tabify::untabify2 $under]
+        set under [textutil::tabify::untabifyLine $under 8] ;#8 is default for untabify2 - review
+    }
+    set overdata $over
+    if {[string first \t $over] >= 0} {
+        #set overdata [textutil::tabify::untabify2 $over]
+        set overdata [textutil::tabify::untabifyLine $over 8]
+    }
+    #-------
+
+    #ta_detect ansi and do simpler processing?
+
+
+    # -- --- --- --- --- --- --- ---
+    set undermap [punk::ansi::ta::split_codes_single $under]
+    set understacks [dict create]
+
+    set i_u -1
+    set i_o 0 
+    set out [list] 
+    set u_codestack [list]
+    set pt_underchars "" ;#for string_columns length calculation for overflow 0 truncation
+    set remainder [list] ;#for returnextra
+    foreach {pt code} $undermap {
+        #pt = plain text
+        append pt_underchars $pt
+        foreach ch [split $pt ""] {
+            set width [punk::char::string_width $ch]
+            incr i_u
+            dict set understacks $i_u $u_codestack 
+            lappend out $ch
+            if {$width > 1} {
+                #presumably there are no triple-column or wider unicode chars.. until the aliens arrive.(?)
+                incr i_u
+                dict set understacks $i_u $u_codestack 
+                lappend out ""
+            }
+        }
+        #underlay should already have been rendered and not have non-sgr codes - but let's check for and not stack them if other codes are here
+        if {[priv::is_sgr $code]} {
+            if {[priv::has_sgr_leadingreset $code]} {
+                set u_codestack [list $code]
+            } else {
+                lappend u_codestack $code
+            }
+        }
+        #consider also other codes that should be stacked..?
+    }
+    #trailing codes in effect for underlay
+    if {[llength $undermap]} {
+        dict set understacks [expr {$i_u + 1}] $u_codestack
+    }
+
+
+    # -- --- --- --- --- --- --- ---
+    ####
+    #if opt_colstart - we need to build a space (or any singlewidth char really) padding on the left of the right number of columns.
+    #this will be processed as transparent - and handle doublewidth underlay characters appropriately
+    set startpad [string repeat " " $opt_colstart]
+    append startpad $overdata ;#overdata with left padding spaces based on col-start under will show through for left-padding portion regardless of -transparency
+    set overmap  [punk::ansi::ta::split_codes_single $startpad]
+    ####
+
+
+
+    set overstacks [dict create]
+    set o_codestack [list]
+    set pt_overchars ""
+    foreach {pt code} $overmap {
+        append pt_overchars $pt
+        foreach ch [split $pt ""] {
+           dict set overstacks $i_o $o_codestack 
+           incr i_o 
+        }
+        if {[priv::is_sgr $code]} {
+            #only stack SGR (graphics rendition) codes - not title sets, cursor moves etc 
+            if {[priv::has_sgr_leadingreset $code]} {
+                #m code which has sgr reset at start - no need to replay prior sgr codes 
+                set o_codestack [list $code]
+            } else {
+                lappend o_codestack $code
+            }
+        }
+    }
+    # -- --- --- --- --- --- --- ---
+
+
+
+
+    set bs [format %c 0x08]
+    set idx 0 ;# line index  (cursor - 1)
+    set idx_over -1
+    foreach {pt code} $overmap {
+        set ptchars [split $pt ""] ;#for lookahead
+        #emit plaintext chars first using existing SGR codes from under/over stack as appropriate
+        #then check if the following code is a cursor movement within the line and adjust index if so
+        foreach ch $ptchars {
+            incr idx_over
+            if {$ch eq "\r"} {
+                set idx $opt_colstart
+            } elseif {$ch eq "\b"} {
+                #review - backspace effect on double-width chars
+                if {$idx > $opt_colstart} {
+                    incr idx -1
+                }
+            } elseif {($idx < $opt_colstart)} {
+                incr idx
+            } elseif {($do_transparency && [regexp $opt_transparent $ch])} {    
+                #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
+                set owidth [punk::char::string_width $ch]
+                if {$idx > [llength $out]-1} {
+                    lappend out " "
+                    dict set understacks $idx [list] ;#review - use idx-1 codestack?
+                    incr idx
+                } else {
+                    set uwidth [punk::char::string_width [lindex $out $idx]]
+                    if {[lindex $out $idx] eq ""} {
+                        #2nd col of 2-wide char in underlay 
+                        incr idx
+                    } elseif {$uwidth == 0} {
+                        #e.g combining diacritic
+                        incr idx
+                    } elseif {$uwidth == 1} {
+                        incr idx
+                        if {$owidth > 1} {
+                            incr idx
+                        } 
+                    } elseif {$uwidth > 1} {
+                        if {[punk::char::string_width $ch] == 1} {
+                            #normal singlewide transparency 
+                            set next_pt_overchar [string index $pt_overchars $idx_over+1] ;#lookahead of next plain-text char in overlay
+                            if {$next_pt_overchar eq ""} {
+                                #special-case trailing transparent - no next_pt_overchar
+                                incr idx
+                            } else {
+                                if {[regexp $opt_transparent $next_pt_overchar]} {
+                                    incr idx
+                                } else {
+                                    #next overlay char is not transparent.. first-half of underlying 2wide char is exposed 
+                                    priv::render_addchar $idx $opt_exposed1 [dict get $overstacks $idx_over]
+                                    incr idx
+                                }
+                            }
+                        } else {
+                            #2wide transparency over 2wide in underlay
+                            incr idx
+                        }
+                    }
+                }
+            } else {
+                #non-transparent char in overlay
+                set owidth [punk::char::string_width $ch]
+                set uwidth [punk::char::string_width [lindex $out $idx]]
+                if {[lindex $out $idx] eq ""} {
+                    #2nd col of 2wide char in underlay
+                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                    incr idx
+                } elseif {$uwidth == 0} {
+                    #e.g combining diacritic - increment before over char  REVIEW
+                    #arguably the previous overchar should have done this - ie lookahead for combiners?
+                    priv::render_addchar $idx "" [dict get $overstacks $idx_over]
+                    incr idx
+                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                    incr idx
+
+                } elseif {$uwidth == 1} {
+                    if {$owidth == 1} {
+                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                        incr idx
+                    } else {
+                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                        incr idx
+                        priv::render_addchar $idx ""  [dict get $overstacks $idx_over]
+                    }
+                } elseif {$uwidth > 1} {
+                    if {$owidth == 1} {
+                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                        incr idx
+                        priv::render_addchar $idx $opt_exposed2 [dict get $overstacks $idx_over]
+                        #don't incr idx - we are just putting a broken-indication in the underlay - which may get overwritten by next overlay char
+                    } else {
+                        #2wide over 2wide
+                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
+                        incr idx 
+                    }
+                }
+            }
+        } 
+        #check following code
+        if {![priv::is_sgr $code]} {
+
+        }
+    }
+
+    if {$opt_overflow == 0} {
+        #need to truncate to the width of the original undertext
+        #review - string_width vs printing_length here. undertext requirement to be already rendered therefore punk::char::string_width ok?
+        set num_under_columns [punk::char::string_width $pt_underchars] ;#plaintext underchars
+    }
+
+    #coalesce and replay codestacks for out char list
+    set outstring ""    
+    set remstring "" ;#remainder after overflow point reached
+    set i 0
+    set cstack [list]
+    set prevstack [list]
+    set out_rawchars ""; #for overflow counting 
+    set output_to "outstring" ;#var in effect depending on overflow
+    set in_overflow 0 ;#used to stop char-width scanning once in overflow
+    foreach ch $out {
+        append out_rawchars $ch
+        if {$opt_overflow == 0 && !$in_overflow} {
+            if {[set nextvisualwidth [punk::char::string_width $out_rawchars]] < $num_under_columns} {
+            } else {
+                #todo - check if we overflowed with a double-width char ? 
+                #store visualwidth which may be short
+                set in_overflow 1
+            }
+        }
+        set cstack [dict get $understacks $i]
+        if {$cstack ne $prevstack} {
+            if {[llength $prevstack]} {
+                append $output_to \033\[m
+            }
+            foreach code $cstack {
+                append $output_to $code
+            }
+        }
+        append $output_to $ch
+        set prevstack $cstack
+        incr i
+        if {$in_overflow} {
+            set output_to "remstring"
+        }
+    }
+    if {[dict size $understacks] > 0} {
+        append $output_to [join [dict get $understacks [expr {[dict size $understacks]-1}]] ""] ;#tail codes
+    }
+    if {[string length $remstring]} {
+        #puts stderr "remainder:$remstring"
+    }
+    #pdict $understacks
+    if {$opt_returnextra} {
+        return [list $outstring $visualwidth [string length $outstring] $remstring]
+    } else {
+        return $outstring
+    }
+    #return [join $out ""]
+}
+proc overtype::test_renderline {} {
+    set t \uFF5E ;#2-wide tilde
+    set u \uFF3F ;#2-wide underscore
+    set missing \uFFFD
+    return [list $t $u A${t}B]
+}
+
+#same as textblock::size - but we don't want that circular dependency
+proc overtype::blocksize {textblock} {
+    if {$textblock eq ""} {
+        return [dict create width 0 height 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
+    }
+    set textblock [textutil::tabify::untabify2 $textblock]
+    #stripansi on entire block in one go rather than line by line - result should be the same - review - make tests
+    set textblock [punk::ansi::stripansi $textblock]
+    if {[string first \n $textblock] >= 0} {
+        set width [tcl::mathfunc::max {*}[lmap v [lines_as_list -- $textblock] {::punk::char::string_width $v}]]
+    } else {
+        set width [punk::char::string_width $textblock] 
+    }
+    set num_le [expr {[string length $textblock]-[string length [string map [list \n {}] $textblock]]}] ;#faster than splitting into single-char list
+    #our concept of block-height is likely to be different to other line-counting mechanisms
+    set height [expr {$num_le + 1}] ;# one line if no le - 2 if there is one trailing le even if no data follows le
+
+    return [dict create width $width height $height] ;#maintain order in 'image processing' standard width then height - caller may use lassign [dict values [blocksize <data>]] width height
+}
+
+namespace eval overtype::priv {
+
+
+    #todo - move to punk::ansi::codetype
+    proc is_sgr {code} {
+        #SGR (Select Graphic Rendition) - codes ending in 'm' - e.g colour/underline 
+        #we will accept and pass through the less common colon separator (ITU Open Document Architecture) 
+        #Terminals should generally ignore it if they don't use it
+        regexp {\033\[[0-9;:]*m$} $code
+    }
+    proc is_cursor_move_in_line {code} {
+        #review - what about CSI n : m H where row n happens to be current line?
+        regexp {\033\[[0-9]*(:?C|D|G)$}
+    }
+    #pure SGR reset
+    proc is_sgr_reset {code} {
+        #todo 8-bit csi
+        regexp {\033\[0*m$} $code
+    }
+    #whether this code has 0 (or equivalently empty) parameter (but may set others)
+    #if an SGR code as a reset in it - we don't need to carry forward any previous SGR codes
+    #it generally only makes sense for the reset to be the first entry - otherwise the code has ineffective portions
+    #However - detecting zero or empty parameter in other positions requires knowing all other codes that may allow zero or empty params.
+    #We will only look at initial parameter as this is the well-formed normal case.  
+    #Review - consider normalizing sgr codes to remove other redundancies such as setting fg or bg color twice in same code
+    proc has_sgr_leadingreset {code} {
+        set params ""
+        regexp {\033\[(.*)m} $code _match params
+        set plist [split $params ";"]
+        if {[string trim [lindex $plist 0] 0] eq ""} {
+            #e.g \033\[m  \033\[0\;...m  \033\[0000...m
+            return 1
+        } else {
+            return 0
+        }
+    }
+    #has_sgr_reset  - rather than support this - create an sgr normalize function that removes dead params and brings reset to front of param list
+    proc render_addchar {i c stack} {
+        upvar out o
+        upvar understacks ustacks
+        set nxt [llength $o] 
+        if {$i < $nxt} {
+            lset o $i $c
+        } else {
+            lappend o $c
+        }
+        dict set ustacks $i $stack
+    }
+
+}
+
+
+# -- --- --- --- --- --- --- --- --- --- ---
+if 0 {
+namespace eval overtype::ta {
+    namespace path ::overtype
+    # *based* on but not identical to:
+    #https://github.com/perlancar/perl-Text-ANSI-Util/blob/master/lib/Text/ANSI/BaseUtil.pm
+
+    #handle both 7-bit and 8-bit csi 
+    #review - does codepage affect this? e.g ebcdic has 8bit csi in different position
+
+    #CSI
+    #variable re_csi_open {(?:\033\[|\u009b)[0-9;]+} ;#too specific - doesn't detect \033\[m
+    variable re_csi_open {(?:\033\[|\u009b])}
+
+    #colour and style
+    variable re_csi_colour {(?:\033\[|\u009b)[0-9;]*m} ;#e.g \033\[31m  \033\[m  \033\[0m \033\[m0000m
+    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
+    variable re_csi_code  {(?:\033\[|\u009b])[0-9;]*[a-zA-Z\\@^_|~`]}
+
+    #OSC - termnate with BEL (\a \007) or ST (string terminator \033\\)
+    #variable re_esc_osc1 {(?:\033\]|\u009c).*\007}
+    #variable re_esc_osc2 {(?:\033\]|\u009c).*\033\\}
+
+    #test - non-greedy
+    variable re_esc_osc1 {(?:\033\]|\u009c).*?\007}
+    variable re_esc_osc2 {(?:\033\]|\u009c).*?\033\\}
+
+    variable re_ansi_detect "${re_csi_open}|${re_esc_osc1}|${re_esc_osc2}"
+
+    #detect any ansi escapes
+    #review - only detect 'complete' codes - or just use the opening escapes for performance?
+    #proc detect {text} {
+    #    variable re_ansi_detect
+    #    #variable re_csi_open
+    #    #variable re_esc_osc1
+    #    #variable re_esc_osc2
+    #    #todo - other escape sequences
+    #    #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
+    #    expr {[regexp $re_ansi_detect $text]}
+    #}
+    #not in perl ta
+    #proc detect_csi {text} {
+    #    variable re_csi_colour
+    #    expr {[regexp $re_csi_colour $text]}
+    #}
+    proc strip {text} {
+        tailcall punk::ansi::stripansi $text
+    }
+    #note this is character length after stripping ansi codes - not the printing length
+    proc length {text} {
+        string length [punk::ansi::stripansi $text]
+    }
+
+    
+    # -- --- --- --- --- --- 
+    #Split $text to a list containing alternating ANSI color codes and text.
+    #ANSI color codes are always on the second element, fourth, and so on.
+    #(ie plaintext on odd list-indices ansi on even indices)
+    # Example:
+    #ta_split_codes ""              # => ""
+    #ta_split_codes "a"             # => "a"
+    #ta_split_codes "a\e[31m"       # => {"a"   "\e[31m"}
+    #ta_split_codes "\e[31ma"       # => {""    "\e[31m"       "a"}
+    #ta_split_codes "\e[31ma\e[0m"  # => {""    "\e[31m"       "a"  "\e[0m"}
+    #ta_split_codes "\e[31ma\e[0mb" # => {""    "\e[31m"       "a"  "\e[0m", "b"}
+    #ta_split_codes "\e[31m\e[0mb"  # => {""    "\e[31m\e[0m"  "b"}
+    #
+    #proc split_codes {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
+    #    return [_perlish_split $re $text]
+    #}
+    ##like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
+    #proc split_codes_single {text} {
+    #    variable re_esc_osc1
+    #    variable re_esc_osc2
+    #    variable re_csi_code
+    #    set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
+    #    return [_perlish_split $re $text]
+    #}
+
+    ##review - tcl greedy expressions may match multiple in one element
+    #proc _perlish_split {re text} {
+    #    if {[string length $text] == 0} {
+    #        return {}
+    #    }
+    #    set list [list]
+    #    set start 0
+    #    while {[regexp -start $start -indices -- $re $text match]} {
+    #        lassign $match      matchStart matchEnd
+    #        lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
+    #        set start [expr {$matchEnd+1}]
+    #    }
+    #    lappend list [string range $text $start end]
+    #    return $list
+    #}
+    ## -- --- --- --- --- --- 
+
+}
+} ;# end if 0
+
+# -- --- --- --- --- --- --- --- --- --- ---
+namespace eval overtype {
+	interp alias {} ::overtype::center {} ::overtype::centre
+}
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Ready   
+package provide overtype [namespace eval overtype {
+    variable version
+    set version 1.5.3 
+}]
+return
+
+#*** !doctools
+#[manpage_end]