diff --git a/src/bootsupport/modules/natsort-0.1.1.6.tm b/src/bootsupport/modules/natsort-0.1.1.6.tm
index 9d4f8a9..1d91b53 100644
--- a/src/bootsupport/modules/natsort-0.1.1.6.tm
+++ b/src/bootsupport/modules/natsort-0.1.1.6.tm
@@ -242,7 +242,7 @@ namespace eval natsort {
     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]
+        set largeHex [string map {_ {}} $largeHex]
         if {[string length $largeHex] <=7} {
             #scan can process up to FFFFFFF and does so quickly
             return [scan $largeHex %x]
@@ -392,7 +392,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]]}
+        expr {[tcl::string::length $str]-[tcl::string::length [tcl::string::map "$char {}" $str]]}
     }
     
     proc build_key {chunk  splitchars topdict tagconfig debug} {
@@ -856,10 +856,39 @@ namespace eval natsort {
         return [csv::join $line {*}$opts]
     }
     #----------------------------------------
+    variable sort_flagspecs
+    set sort_flagspecs [dict create\
+        -caller natsort::sort \
+        -return supplied|defaults \
+        -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 {}\
+    ]
+
     proc sort {stringlist args} {
         #puts stdout "natsort::sort args: $args"
         variable debug
+        variable sort_flagspecs
         if {![llength $stringlist]} return
+        if {[llength $stringlist] == 1} {
+            if {"-inputformat" ni $args && "-outputformat" ni $args} {
+                return $stringlist
+            }
+        }
         
         #allow pass through of the check_flags flag -debugargs so it can be set by the caller
         set debugargs 0
@@ -874,49 +903,43 @@ namespace eval natsort {
 
         #-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 
+        set opts [check_flags {*}$sort_flagspecs -debugargs $debugargs -values $args] 
+
+        #we can only shortcircuit input list of single element at this point if there aren't non-default -inputformat or -outputformat transformations
+        if {[llength $stringlist] == 1} {
+            set is_basic 1
+            foreach fname [list -inputformat -outputformat] {
+                if {[dict get $sort_flagspecs -defaults $fname] ne [dict get $opts $fname]} {
+                    set is_basic 0
+                    break
+                }
+            }
+            if {$is_basic} {
+                return $stringlist
+            }
+        }
+
+
+        set winlike                     [dict get $opts -winlike]
+        set topchars                    [dict get $opts -topchars]
+        set cols                        [dict get $opts -cols]
+        set debug                       [dict get $opts -debug]
+        set stacktrace                  [dict get $opts -stacktrace]
+        set showsplits                  [dict get $opts -showsplits]
+        set splits                      [dict get $opts -splits]
+        set sortmethod                  [dict get $opts -sortmethod]
+        set opt_collate                 [dict get $opts -collate]
+        set opt_inputformat             [dict get $opts -inputformat]
+        set opt_inputformatapply        [dict get $opts -inputformatapply]
+        set opt_inputformatoptions      [dict get $opts -inputformatoptions]
+        set opt_outputformat            [dict get $opts -outputformat]
+        set opt_outputformatoptions     [dict get $opts -outputformatoptions]
+
         if {$debug} {
-            puts stdout "natsort::sort processed_args: $args"
+            #dict unset opts -showsplits
+            #dict unset opts -splits 
+            puts stdout "natsort::sort processed_args: $opts"
             if {$debug == 1} {
                 puts stdout "natsort::sort - try also -debug 2, -debug 3"
             }
@@ -1427,24 +1450,27 @@ namespace eval natsort {
             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]"
 
+    if {![interp issafe]} {
+        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]"
+    } else {
+        #safe interp
+        set is_called_directly 0
+    }
 
-    #
 
     
     proc test_pass_fail_message {pass {additional ""}} {
@@ -1709,9 +1735,9 @@ namespace eval natsort {
 
       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 collate       [dict get $args -collate]
+      set db            [dict get $args -db]
+      set winlike       [dict get $args -winlike]
       set topchars      [dict get $args -topchars]
 
 
diff --git a/src/vendormodules/overtype-1.6.2.tm b/src/bootsupport/modules/overtype-1.6.4.tm
similarity index 83%
rename from src/vendormodules/overtype-1.6.2.tm
rename to src/bootsupport/modules/overtype-1.6.4.tm
index c254a53..4287632 100644
--- a/src/vendormodules/overtype-1.6.2.tm
+++ b/src/bootsupport/modules/overtype-1.6.4.tm
@@ -7,7 +7,7 @@
 # (C) Julian Noble 2003-2023
 #
 # @@ Meta Begin
-# Application overtype 1.6.2
+# Application overtype 1.6.4
 # Meta platform     tcl
 # Meta license      BSD 
 # @@ Meta End
@@ -17,7 +17,7 @@
 # doctools header
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 #*** !doctools
-#[manpage_begin overtype_module_overtype 0 1.6.2]
+#[manpage_begin overtype_module_overtype 0 1.6.4]
 #[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 --}] 
@@ -65,7 +65,15 @@ package require punk::assertion
 #*** !doctools
 #[list_end]
 
-
+#PERFORMANCE notes
+#overtype is very performance sensitive - used in ansi output all over the place ie needs to be optimised
+#NOTE use of tcl::dict::for tcl::string::range etc instead of ensemble versions. This is for the many tcl 8.6/8.7 interps which don't compile ensemble commands when in safe interps
+#similar for tcl::namespace::eval - but this is at least on some versions of Tcl - faster even in a normal interp. Review to see if that holds for Tcl 9.
+#for string map:  when there are exactly 2 elements - it is faster to use a literal which has a special case optimisation in the c code
+#ie use tcl::string::map {\n ""} ...  instead of tcl::string::map [list \n ""] ...
+#note that we can use unicode (e.g \uFF31) and other escapes such as \t within these curly braces - we don't have to use double quotes
+#generally using 'list' is preferred for the map as less error prone.
+#can also use: tcl::string::map "token $var" ..   but be careful regarding quoting and whitespace in var. This should be used sparingly if at all.
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
@@ -78,10 +86,10 @@ package require punk::assertion
 #
 #todo - ellipsis truncation indicator for center,right
 
-#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
+#v1.4 2023-07 - naive ansi color handling - todo - fix tcl::string::range 
 # - need to extract and replace ansi codes?
 
-namespace eval overtype {
+tcl::namespace::eval overtype {
     namespace import ::punk::assertion::assert
     punk::assertion::active true 
 
@@ -90,7 +98,7 @@ namespace eval overtype {
 	namespace export *
     variable default_ellipsis_horizontal "..." ;#fallback 
     variable default_ellipsis_vertical "..." 
-    namespace eval priv {
+    tcl::namespace::eval priv {
         proc _init {} {
             upvar ::overtype::default_ellipsis_horizontal e_h
             upvar ::overtype::default_ellipsis_vertical e_v
@@ -112,18 +120,18 @@ proc overtype::about {} {
 	return "Simple text formatting. Author JMN. BSD-License"
 }
 
-namespace eval overtype {
-    variable grapheme_widths [dict create]
+tcl::namespace::eval overtype {
+    variable grapheme_widths [tcl::dict::create]
 
     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 
+    tcl::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 "\{" "\}"]
+    #tcl::dict::set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
+    tcl::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\
+    set  ansi_2byte_codes_dict [tcl::dict::create\
         "reset_terminal"            "\u001bc"\
         "save_cursor_posn"          "\u001b7"\
         "restore_cursor_posn"       "\u001b8"\
@@ -166,7 +174,7 @@ namespace eval overtype {
 #            #2nd byte - done.
 #            set in_escapesequence 0
 #        } elseif {$in_escapesequence != 0} {
-#            set escseq [dict get $escape_terminals $in_escapesequence]
+#            set escseq [tcl::dict::get $escape_terminals $in_escapesequence]
 #            if {$u in $escseq} {
 #                set in_escapesequence 0
 #            } elseif {$uv in $escseq} {
@@ -206,7 +214,7 @@ proc overtype::string_columns {text} {
 #These have similar algorithms/requirements - and should be refactored to be argument-wrappers over a function called something like overtype::renderblock 
 #overtype::renderblock could render the input to a defined (possibly overflowing in x or y) rectangle overlapping the underlay.
 #(i.e not even necessariy having it's top left within the underlay)
-namespace eval overtype::priv {
+tcl::namespace::eval overtype::priv {
 }
 
 #could return larger than colwidth
@@ -232,7 +240,7 @@ proc _get_row_append_column {row} {
     }
 }
 
-namespace eval overtype {
+tcl::namespace::eval overtype {
     #*** !doctools
     #[subsection {Namespace overtype}]
     #[para] Core API functions for overtype 
@@ -240,16 +248,16 @@ namespace eval overtype {
 
 
 
-    #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
+    #tcl::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
     #render onto an already-rendered (ansi already processed) 'underlay' string, a possibly ansi-laden 'overlay' string.
     #The underlay and overlay can be multiline blocks of text of varying line lengths.
     #The overlay may just be an ansi-colourised block - or may contain ansi cursor movements and cursor save/restore calls - in which case the apparent length and width of the overlay can't be determined as if it was a block of text.
     #This is a single-shot rendering of strings - ie there is no way to chain another call containing a cursor-restore to previously rendered output and have it know about any cursor-saves in the first call.
     # a cursor start position other than top-left is a possible addition to consider.
     #see editbuf in punk::repl for a more stateful ansi-processor. Both systems use loops over overtype::renderline 
-    proc left {args} {
+    proc renderspace {args} {
         #*** !doctools
-        #[call [fun overtype::left] [arg args] ]
+        #[call [fun overtype::renderspace] [arg args] ]
         #[para]	usage: ?-transparent [lb]0|1[rb]? ?-overflow [lb]1|0[rb]? ?-ellipsis [lb]1|0[rb]? ?-ellipsistext ...? undertext overtext
 
         # @c overtype starting at left (overstrike) 
@@ -260,10 +268,11 @@ namespace eval overtype {
             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\
+        set opts [tcl::dict::create\
             -bias       ignored\
             -width      \uFFEF\
             -height     \uFFEF\
+            -startcolumn    1\
             -wrap       0\
             -ellipsis   0\
             -ellipsistext   $default_ellipsis_horizontal\
@@ -278,31 +287,33 @@ namespace eval overtype {
         ]
         #-ellipsis args not used if -wrap is true
         set argsflags [lrange $args 0 end-2]
-        dict for {k v} $argsflags {
+        foreach {k v} $argsflags {
             switch -- $k {
-                -looplimit - -width - -height - -bias - -wrap - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -appendlines - -transparent - -exposed1 - -exposed2 - -experimental {}
+                -looplimit - -width - -height - -startcolumn - -bias - -wrap - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -appendlines - -transparent - -exposed1 - -exposed2 - -experimental {
+                    tcl::dict::set opts $k $v
+                }
                 default {
-                    set known_opts [dict keys $defaults]
-                    error "overtype::left unknown option '$k'. Known options: $known_opts"
+                    error "overtype::renderspace unknown option '$k'. Known options: [tcl::dict::keys $opts]"
                 }
             }
         }
-        set opts [dict merge $defaults $argsflags]
+        #set opts [tcl::dict::merge $defaults $argsflags]
         # -- --- --- --- --- ---
-        set opt_overflow        [dict get $opts -overflow] 
+        set opt_overflow        [tcl::dict::get $opts -overflow] 
         #####
         # review -wrap should map onto DECAWM terminal mode - the wrap 2 idea may not fit in with this?.
-        set opt_wrap            [dict get $opts -wrap]  ;#wrap 1 is hard wrap cutting word at exact column, or 1 column early for 2w-glyph, wrap 2 is for language-based word-wrap algorithm (todo)
+        set opt_wrap            [tcl::dict::get $opts -wrap]  ;#wrap 1 is hard wrap cutting word at exact column, or 1 column early for 2w-glyph, wrap 2 is for language-based word-wrap algorithm (todo)
         #####
         #for repl - standard output line indicator is a dash - todo, add a different indicator for a continued line.
-        set opt_width           [dict get $opts -width]
-        set opt_height          [dict get $opts -height]
-        set opt_appendlines     [dict get $opts -appendlines]
-        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 opt_width           [tcl::dict::get $opts -width]
+        set opt_height          [tcl::dict::get $opts -height]
+        set opt_startcolumn     [tcl::dict::get $opts -startcolumn]
+        set opt_appendlines     [tcl::dict::get $opts -appendlines]
+        set opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1] ;#widechar_exposed_left  - todo
+        set opt_exposed2        [tcl::dict::get $opts -exposed2] ;#widechar_exposed_right - todo
         # -- --- --- --- --- ---
 
         # ----------------------------
@@ -312,7 +323,7 @@ namespace eval overtype {
         set test_mode 1
         set info_mode 0
         set edit_mode 0
-        set opt_experimental   [dict get $opts -experimental]
+        set opt_experimental   [tcl::dict::get $opts -experimental]
         foreach o $opt_experimental {
             switch -- $o {
                 test_mode {
@@ -334,6 +345,7 @@ namespace eval overtype {
                 }
             }
         }
+        set test_mode 1 ;#try to eliminate
         # ----------------------------
 
         #modes
@@ -342,9 +354,8 @@ namespace eval overtype {
         set reverse_mode 0
         
 
-        set norm [list \r\n \n]
-        set underblock [string map $norm $underblock]
-        set overblock  [string map $norm $overblock]
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $overblock]
 
 
         #set underlines [split $underblock \n]
@@ -353,19 +364,35 @@ namespace eval overtype {
         #colwidth & colheight were originally named with reference to rendering into a 'column' of output e.g  a table column - before cursor row/col was implemented.
         #The naming is now confusing. It should be something like renderwidth renderheight ?? review 
         
-        if {$opt_width eq "\uFFEF"} {
+        if {$opt_width eq "\uFFEF" || $opt_height eq "\uFFEF"} {
             lassign [blocksize $underblock] _w colwidth _h colheight
+            if {$opt_width ne "\uFFEF"} {
+                set colwidth $opt_width
+            }
+            if {$opt_height ne "\uFFEF"} {
+                set colheight $opt_height
+            }
         } else {
             set colwidth $opt_width
             set colheight $opt_height
         }
+
+        # -- --- --- --- 
+        #REVIEW - do we need ansi resets in the underblock?
         if {$underblock eq ""} {
-            set blank "\x1b\[0m\x1b\[0m"
-            #set underlines [list "\x1b\[0m\x1b\[0m"]
-            set underlines [lrepeat $colheight $blank]
+            set underlines [lrepeat $colheight ""]
         } else {
-            set underlines [lines_as_list -ansiresets 1 $underblock]
+            set underlines [split $underblock \n]
         }
+        #if {$underblock eq ""} {
+        #    set blank "\x1b\[0m\x1b\[0m"
+        #    #set underlines [list "\x1b\[0m\x1b\[0m"]
+        #    set underlines [lrepeat $colheight $blank]
+        #} else {
+        #    #lines_as_list -ansiresets 1 will do nothing if -ansiresets 1 isn't specified - REVIEW
+        #    set underlines [lines_as_list -ansiresets 1 $underblock]
+        #}
+        # -- --- --- --- 
 
         #todo - reconsider the 'line' as the natural chunking mechanism for the overlay.
         #In practice an overlay ANSI stream can be a single line with ansi moves/restores etc - or even have no moves or newlines, just relying on wrapping at the output colwidth
@@ -376,11 +403,11 @@ namespace eval overtype {
 
         #a hack until we work out how to avoid infinite loops... 
         #
-        set looplimit [dict get $opts -looplimit]
+        set looplimit [tcl::dict::get $opts -looplimit]
         if {$looplimit eq "\uFFEF"} {
             #looping for each char is worst case (all newlines?) - anything over that is an indication of something broken?
             #do we need any margin above the length? (telnet mapscii.me test)
-            set looplimit [expr {[string length $overblock] + 10}]
+            set looplimit [expr {[tcl::string::length $overblock] + 10}]
         }
 
         if {!$test_mode} {
@@ -407,7 +434,7 @@ namespace eval overtype {
                         }
                         set sequence_split [punk::ansi::ta::split_codes_single $ln]  ;#use split_codes Not split_codes_single?
                         set lastpt [lindex $inputchunks end]
-                        lset inputchunks end [string cat $lastpt [lindex $sequence_split 0]]
+                        lset inputchunks end [tcl::string::cat $lastpt [lindex $sequence_split 0]]
                         lappend inputchunks {*}[lrange $sequence_split 1 end]
                         incr i
                     }
@@ -421,7 +448,7 @@ namespace eval overtype {
                         lappend lflines $ln
                     }
                     if {[llength $lflines]} {
-                        lset lflines end [string range [lindex $lflines end] 0 end-1]
+                        lset lflines end [tcl::string::range [lindex $lflines end] 0 end-1]
                     }
                     set inputchunks $lflines[unset lflines]
 
@@ -434,11 +461,11 @@ namespace eval overtype {
         #lassign [blocksize $overblock] _w overblock_width _h overblock_height
 
 
-        set replay_codes_underlay [dict create 1 ""] 
+        set replay_codes_underlay [tcl::dict::create 1 ""] 
         #lappend replay_codes_overlay ""
         set replay_codes_overlay ""
         set unapplied ""
-        set cursor_saved_position [dict create] 
+        set cursor_saved_position [tcl::dict::create] 
         set cursor_saved_attributes ""
 
 
@@ -450,10 +477,10 @@ namespace eval overtype {
         if {$data_mode} {
             set col [_get_row_append_column $row] 
         } else {
-            set col 1
+            set col $opt_startcolumn 
         }
 
-        set instruction_stats [dict create]
+        set instruction_stats [tcl::dict::create]
 
         set loop 0
         #while {$overidx < [llength $inputchunks]} { }
@@ -461,7 +488,7 @@ namespace eval overtype {
         while {[llength $inputchunks]} {
             #set overtext  [lindex $inputchunks $overidx]; lset inputchunks $overidx ""
             set overtext [lpop inputchunks 0]
-            if {![string length $overtext]} {
+            if {![tcl::string::length $overtext]} {
                 incr loop
                 continue
             } 
@@ -472,10 +499,10 @@ namespace eval overtype {
             #renderline pads each underaly line to width with spaces and should track where end of data is
 
 
-            #set overtext [string cat [lindex $replay_codes_overlay $overidx] $overtext]
-            set overtext [string cat $replay_codes_overlay $overtext]
-            if {[dict exists $replay_codes_underlay $row]} {
-                set undertext [string cat [dict get $replay_codes_underlay $row] $undertext]
+            #set overtext [tcl::string::cat [lindex $replay_codes_overlay $overidx] $overtext]
+            set overtext [tcl::string::cat $replay_codes_overlay $overtext]
+            if {[tcl::dict::exists $replay_codes_underlay $row]} {
+                set undertext [tcl::string::cat [tcl::dict::get $replay_codes_underlay $row] $undertext]
             }
             #review insert_mode. As an 'overtype' function whose main function is not interactive keystrokes - insert is secondary - 
             #but even if we didn't want it as an option to the function call - to process ansi adequately we need to support IRM (insertion-replacement mode) ESC [ 4 h|l
@@ -495,37 +522,37 @@ namespace eval overtype {
                                      $undertext\
                                      $overtext\
                     ]
-            set instruction         [dict get $rinfo instruction]
-            set insert_mode         [dict get $rinfo insert_mode]
-            set autowrap_mode       [dict get $rinfo autowrap_mode] ;#
-            #set reverse_mode        [dict get $rinfo reverse_mode];#how to support in rendered linelist? we need to examine all pt/code blocks and flip each SGR stack?
-            set rendered            [dict get $rinfo result]
-            set overflow_right      [dict get $rinfo overflow_right]
-            set overflow_right_column      [dict get $rinfo overflow_right_column]
-            set unapplied           [dict get $rinfo unapplied]
-            set unapplied_list           [dict get $rinfo unapplied_list]
-            set post_render_col          [dict get $rinfo cursor_column]
-            set post_render_row          [dict get $rinfo cursor_row]
-            set c_saved_pos         [dict get $rinfo cursor_saved_position]
-            set c_saved_attributes  [dict get $rinfo cursor_saved_attributes]
-            set visualwidth         [dict get $rinfo visualwidth]
-            set insert_lines_above  [dict get $rinfo insert_lines_above]
-            set insert_lines_below  [dict get $rinfo insert_lines_below]
-            dict set replay_codes_underlay [expr {$renderedrow+1}] [dict get $rinfo replay_codes_underlay]
-            #lset replay_codes_overlay [expr $overidx+1] [dict get $rinfo replay_codes_overlay]
-            set replay_codes_overlay  [dict get $rinfo replay_codes_overlay]
+            set instruction                 [tcl::dict::get $rinfo instruction]
+            set insert_mode                 [tcl::dict::get $rinfo insert_mode]
+            set autowrap_mode               [tcl::dict::get $rinfo autowrap_mode] ;#
+            #set reverse_mode                [tcl::dict::get $rinfo reverse_mode];#how to support in rendered linelist? we need to examine all pt/code blocks and flip each SGR stack?
+            set rendered                    [tcl::dict::get $rinfo result]
+            set overflow_right              [tcl::dict::get $rinfo overflow_right]
+            set overflow_right_column       [tcl::dict::get $rinfo overflow_right_column]
+            set unapplied                   [tcl::dict::get $rinfo unapplied]
+            set unapplied_list              [tcl::dict::get $rinfo unapplied_list]
+            set post_render_col             [tcl::dict::get $rinfo cursor_column]
+            set post_render_row             [tcl::dict::get $rinfo cursor_row]
+            set c_saved_pos                 [tcl::dict::get $rinfo cursor_saved_position]
+            set c_saved_attributes          [tcl::dict::get $rinfo cursor_saved_attributes]
+            set visualwidth                 [tcl::dict::get $rinfo visualwidth]
+            set insert_lines_above          [tcl::dict::get $rinfo insert_lines_above]
+            set insert_lines_below          [tcl::dict::get $rinfo insert_lines_below]
+            tcl::dict::set replay_codes_underlay [expr {$renderedrow+1}] [tcl::dict::get $rinfo replay_codes_underlay]
+            #lset replay_codes_overlay [expr $overidx+1] [tcl::dict::get $rinfo replay_codes_overlay]
+            set replay_codes_overlay        [tcl::dict::get $rinfo replay_codes_overlay]
 
 
 
             #-- todo - detect looping properly
             if {$row > 1 && $overtext ne "" && $unapplied eq $overtext && $post_render_row == $row && $instruction eq ""} {
-                puts stderr "overtype::left loop?"
+                puts stderr "overtype::renderspace loop?"
                 puts [ansistring VIEW $rinfo]
                 break
             }
             #--
 
-            if {[dict size $c_saved_pos] >= 1} {
+            if {[tcl::dict::size $c_saved_pos] >= 1} {
                 set cursor_saved_position $c_saved_pos
                 set cursor_saved_attributes $c_saved_attributes
             }
@@ -540,7 +567,7 @@ namespace eval overtype {
 
                 #todo - handle potential insertion mode as above for cursor restore?
                 #keeping separate branches for debugging - review and merge as appropriate when stable
-                dict incr instruction_stats $instruction 
+                tcl::dict::incr instruction_stats $instruction 
                 switch -- $instruction {
                     {} {
                         if {$test_mode == 0} {
@@ -640,21 +667,21 @@ namespace eval overtype {
                         #testfile belinda.ans uses this
 
                         #puts stdout "[a+ blue bold]CURSOR_RESTORE[a]"
-                        if {[dict exists $cursor_saved_position row]} {
-                            set row [dict get $cursor_saved_position row]
-                            set col [dict get $cursor_saved_position column]
+                        if {[tcl::dict::exists $cursor_saved_position row]} {
+                            set row [tcl::dict::get $cursor_saved_position row]
+                            set col [tcl::dict::get $cursor_saved_position column]
                             #puts stdout "restoring: row $row col $col [ansistring VIEW $cursor_saved_attributes] [a] unapplied [ansistring VIEWCODES $unapplied]"
                             #set nextprefix $cursor_saved_attributes
                             #lset replay_codes_overlay [expr $overidx+1] $cursor_saved_attributes 
-                            set replay_codes_overlay [dict get $rinfo replay_codes_overlay]$cursor_saved_attributes
+                            set replay_codes_overlay [tcl::dict::get $rinfo replay_codes_overlay]$cursor_saved_attributes
                             #set replay_codes_overlay $cursor_saved_attributes
-                            set cursor_saved_position [dict create]
+                            set cursor_saved_position [tcl::dict::create]
                             set cursor_saved_attributes ""
                         } else {
                             #TODO
                             #?restore without save?
                             #should move to home position and reset ansi SGR?
-                            #puts stderr "overtype::left cursor_restore without save data available"
+                            #puts stderr "overtype::renderspace cursor_restore without save data available"
                         }
                         #If we were inserting prior to hitting the cursor_restore - there could be overflow_right data - generally the overtype functions aren't for inserting - but ansi can enable it
                         #if we were already in overflow when cursor_restore was hit - it shouldn't have been processed as an action - just stored.
@@ -667,10 +694,10 @@ namespace eval overtype {
 
                             puts stdout ">>>[a+ red bold]overflow_right during restore_cursor[a]"
 
-                            set sub_info [overtype::renderline -info 1 -width $colwidth -insert_mode $insert_mode -autowrap_mode $autowrap_mode  -overflow [dict get $opts -overflow] "" $overflow_right]
-                            set foldline [dict get $sub_info result]
-                            set insert_mode [dict get $sub_info insert_mode] ;#probably not needed.. 
-                            set autowrap_mode [dict get $sub_info autowrap_mode] ;#nor this..
+                            set sub_info [overtype::renderline -info 1 -width $colwidth -insert_mode $insert_mode -autowrap_mode $autowrap_mode  -overflow [tcl::dict::get $opts -overflow] "" $overflow_right]
+                            set foldline [tcl::dict::get $sub_info result]
+                            set insert_mode [tcl::dict::get $sub_info insert_mode] ;#probably not needed.. 
+                            set autowrap_mode [tcl::dict::get $sub_info autowrap_mode] ;#nor this..
                             linsert outputlines $renderedrow $foldline
                             #review - row & col set by restore - but not if there was no save..
                         }
@@ -709,7 +736,7 @@ namespace eval overtype {
                         if {$row > [llength $outputlines]} {
                             lappend outputlines ""
                         }
-                        set col 1
+                        set col $opt_startcolumn 
                         # ----------------------
                     }
                     lf_mid {
@@ -737,7 +764,7 @@ namespace eval overtype {
 
                                 set row $renderedrow
 
-                                set col 1
+                                set col $opt_startcolumn 
                                 incr row 
                                 #only add newline if we're at the bottom
                                 if {$row > [llength $outputlines]} {
@@ -751,7 +778,7 @@ namespace eval overtype {
                                     set unapplied ""
                                     set row $post_render_row
                                     #set col $post_render_col
-                                    set col 1
+                                    set col $opt_startcolumn 
                                     if {$row > [llength $outputlines]} {
                                         lappend outputlines {*}[lrepeat 1 ""]
                                     }
@@ -759,7 +786,7 @@ namespace eval overtype {
                                     append rendered $overflow_right
                                     set overflow_right ""
                                     set row $post_render_row
-                                    set col 1
+                                    set col $opt_startcolumn 
                                     if {$row > [llength $outputlines]} {
                                         lappend outputlines {*}[lrepeat 1 ""]
                                     }
@@ -787,7 +814,7 @@ namespace eval overtype {
                             if {$row > [llength $outputlines]} {
                                 lappend outputlines {*}[lrepeat 1 ""]
                             }
-                            set col 1
+                            set col $opt_startcolumn 
 
                     }
                     newlines_above {
@@ -818,7 +845,7 @@ namespace eval overtype {
                                     set row $renderedrow
                                     set outputlines [linsert $outputlines [expr {$renderedrow }] {*}[lrepeat $insert_lines_below ""]] ;#note - linsert can add to end too
                                     incr row $insert_lines_below
-                                    set col 1
+                                    set col $opt_startcolumn 
                                 } else {
                                     #set lhs [overtype::left -width 40 -wrap 1 "" [ansistring VIEWSTYLE -lf 1 -vt 1 $rendered]]
                                     #set lhs [textblock::frame -title rendered -subtitle "row-$renderedrow" $lhs]
@@ -841,7 +868,7 @@ namespace eval overtype {
                                         lappend outputlines {*}[lrepeat $insert_lines_below ""]
                                     }
                                     incr row $insert_lines_below
-                                    set col 1
+                                    set col $opt_startcolumn 
 
 
 
@@ -884,7 +911,7 @@ namespace eval overtype {
                                             lappend outputlines ""
                                         }
                                     }
-                                    set c 1
+                                    set c $opt_startcolumn 
                                 } else {
                                     incr c
                                 }    
@@ -935,12 +962,12 @@ namespace eval overtype {
                         set row $post_render_row  ;#renderline will not advance row when reporting overflow char
                         if {$autowrap_mode} {
                             incr row
-                            set col 1 ;#whether wrap or not - next data is at column 1  ??
+                            set col $opt_startcolumn ;#whether wrap or not - next data is at column 1  ??
                         } else {
                             #this works for test_mode (which should become the default) - but could give a bad result otherwise - review - add tests fix.
                             set col $post_render_col
                             #set unapplied ""             ;#this seems wrong?
-                            #set unapplied [string range $unapplied 1 end] 
+                            #set unapplied [tcl::string::range $unapplied 1 end] 
                             #The overflow can only be triggered by a grapheme (todo cluster?) - but our unapplied could contain SGR codes prior to the grapheme that triggered overflow - so we need to skip beyond any SGRs
                             #There may be more than one, because although the stack leading up to overflow may have been merged - codes between the last column and the overflowing grapheme will remain separate
                             #We don't expect any movement or other ANSI codes - as if they came before the grapheme, they would have triggered a different instruction to 'overflow'
@@ -981,7 +1008,7 @@ namespace eval overtype {
                                 }
                                 set unapplied [join [lreplace $unapplied_list $triggering_grapheme_index $triggering_grapheme_index $opt_exposed1] ""]
                             } else {
-                                set col 1
+                                set col  $opt_startcolumn
                                 incr row
                             }
                         } else {
@@ -1009,7 +1036,7 @@ namespace eval overtype {
                         set col $post_render_col
                     }
                     default {
-                        puts stderr "overtype::left unhandled renderline instruction '$instruction'"
+                        puts stderr "overtype::renderspace unhandled renderline instruction '$instruction'"
                     }
 
                 }
@@ -1017,7 +1044,7 @@ namespace eval overtype {
 
             if {!$opt_overflow && !$autowrap_mode} {
                 #not allowed to overflow column or wrap therefore we get overflow data to truncate 
-                if {[dict get $opts -ellipsis]} {
+                if {[tcl::dict::get $opts -ellipsis]} {
                     set show_ellipsis 1
                     if {!$opt_ellipsiswhitespace} {
                         #we don't want ellipsis if only whitespace was lost
@@ -1028,11 +1055,11 @@ namespace eval overtype {
                         if {$unapplied ne ""} {
                             append lostdata $unapplied
                         }
-                        if {[string trim $lostdata] eq ""} {
+                        if {[tcl::string::trim $lostdata] eq ""} {
                             set show_ellipsis 0
                         }
-                        #set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim [punk::ansi::stripansi $lostdata]] eq ""} {
+                        #set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[tcl::string::trim [punk::ansi::stripansi $lostdata]] eq ""} {
                             set show_ellipsis 0
                         }
                     }
@@ -1085,7 +1112,7 @@ namespace eval overtype {
             incr overidx
             incr loop
             if {$loop >= $looplimit} {
-                puts stderr "overtype::left looplimit reached ($looplimit)"
+                puts stderr "overtype::renderspace looplimit reached ($looplimit)"
                 lappend outputlines "[a+ red bold]<truncated> - looplimit $looplimit reached[a]"
                 set Y [a+ yellow bold]
                 set RST [a]
@@ -1096,9 +1123,9 @@ namespace eval overtype {
                 append debugmsg "test_mode:$test_mode\n"
                 append debugmsg "data_mode:$data_mode\n"
                 append debugmsg "opt_appendlines:$opt_appendlines\n"
-                append debugmsg "prev_row :[dict get $LASTCALL -cursor_row]\n"
-                append debugmsg "prev_col :[dict get $LASTCALL -cursor_column]\n"
-                dict for {k v} $rinfo {
+                append debugmsg "prev_row :[tcl::dict::get $LASTCALL -cursor_row]\n"
+                append debugmsg "prev_col :[tcl::dict::get $LASTCALL -cursor_column]\n"
+                tcl::dict::for {k v} $rinfo {
                     append debugmsg "${Y}$k   [ansistring VIEW -lf 1 -vt 1 $v]$RST" \n
                 }
                 append debugmsg "${Y}[string repeat - [string length $sep_header]]$RST" \n
@@ -1131,7 +1158,7 @@ namespace eval overtype {
         foreach {underblock overblock} [lrange $args end-1 end] break
 
         #todo - vertical vs horizontal overflow for blocks
-        set defaults [dict create\
+        set opts [tcl::dict::create\
             -bias       left\
             -ellipsis   0\
             -ellipsistext   $default_ellipsis_horizontal\
@@ -1142,29 +1169,30 @@ namespace eval overtype {
             -exposed2 \uFFFD\
         ]
         set argsflags [lrange $args 0 end-2]
-        dict for {k v} $argsflags {
+        foreach {k v} $argsflags {
             switch -- $k {
-                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 {}
+                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 {
+                    tcl::dict::set opts $k $v
+                }
                 default {
-                    set known_opts [dict keys $defaults]
+                    set known_opts [tcl::dict::keys $opts]
                     error "overtype::centre unknown option '$k'. Known options: $known_opts"
                 }
             }
         }
-        set opts [dict merge $defaults $argsflags]
+        #set opts [tcl::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 opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsis        [tcl::dict::get $opts -ellipsis]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1]
+        set opt_exposed2        [tcl::dict::get $opts -exposed2]
         # -- --- --- --- --- ---
 
 
-        set norm [list \r\n \n]
-        set underblock [string map $norm $underblock]
-        set overblock  [string map $norm $overblock]
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $overblock]
 
         set underlines [split $underblock \n]
         #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
@@ -1180,7 +1208,7 @@ namespace eval overtype {
                 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"} {
+                if {[tcl::string::tolower [tcl::dict::get $opts -bias]] eq "left"} {
                     set left_exposed $beforehalf
                 } else {
                     #bias to the right
@@ -1206,30 +1234,30 @@ namespace eval overtype {
                 set udiff [expr {$colwidth - $ulen}]
                 set undertext "$undertext[string repeat { } $udiff]"
             }
-            set undertext [string cat $replay_codes_underlay $undertext]
-            set overtext  [string cat $replay_codes_overlay $overtext]
+            set undertext [tcl::string::cat $replay_codes_underlay $undertext]
+            set overtext  [tcl::string::cat $replay_codes_overlay $overtext]
 
             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 rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -overflow [dict get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-                set rendered        [dict get $rinfo result]
-                set overflow_right  [dict get $rinfo overflow_right]
-                set unapplied       [dict get $rinfo unapplied]
+                set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -overflow [tcl::dict::get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+                set rendered        [tcl::dict::get $rinfo result]
+                set overflow_right  [tcl::dict::get $rinfo overflow_right]
+                set unapplied       [tcl::dict::get $rinfo unapplied]
                 #todo - get replay_codes from overflow_right instead of wherever it was truncated?
 
                 #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 {![tcl::dict::get $opts -overflow]} {
+                    #lappend outputlines [tcl::string::range $overtext 0 [expr {$colwidth - 1}]]
+                    #set overtext [tcl::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
-                            #don't use string range on ANSI data
-                            #set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                            #don't use tcl::string::range on ANSI data
+                            #set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
                             set lostdata ""
                             if {$overflow_right ne ""} {
                                 append lostdata $overflow_right
@@ -1237,7 +1265,7 @@ namespace eval overtype {
                             if {$unapplied ne ""} {
                                 append lostdata $unapplied
                             }
-                            if {[string trim $lostdata] eq ""} {
+                            if {[tcl::string::trim $lostdata] eq ""} {
                                 set show_ellipsis 0
                             }
                         }
@@ -1252,10 +1280,10 @@ namespace eval overtype {
                 #background block is wider than or equal to data for this line
                 #lappend outputlines [renderline -insert_mode 0 -startcolumn [expr {$left_exposed + 1}] -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
                 set rinfo [renderline -info 1 -insert_mode 0 -startcolumn [expr {$left_exposed + 1}] -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-                lappend outputlines  [dict get $rinfo result]
+                lappend outputlines  [tcl::dict::get $rinfo result]
             }
-            set replay_codes_underlay [dict get $rinfo replay_codes_underlay]
-            set replay_codes_overlay [dict get $rinfo replay_codes_overlay]
+            set replay_codes_underlay [tcl::dict::get $rinfo replay_codes_underlay]
+            set replay_codes_overlay [tcl::dict::get $rinfo replay_codes_overlay]
         }
         return [join $outputlines \n]
     }
@@ -1263,7 +1291,6 @@ namespace eval overtype {
     #overtype::right  is for a rendered ragged underblock and a rendered ragged overblock
     #ie we can determine the block width for bost by examining the lines and picking the longest.
     #
-    #todo - rename overtype::left  - which has morphed in capability and usage so that it bears less resemblance to overtype::right and overtype::centre
     proc right {args} {
         #NOT the same as align-right - which should be done to the overblock first if required
         variable default_ellipsis_horizontal
@@ -1274,7 +1301,7 @@ namespace eval overtype {
         }
         foreach {underblock overblock} [lrange $args end-1 end] break
 
-        set defaults [dict create\
+        set opts [tcl::dict::create\
             -bias       ignored\
             -ellipsis   0\
             -ellipsistext   $default_ellipsis_horizontal\
@@ -1286,30 +1313,31 @@ namespace eval overtype {
             -align  "left"\
         ]
         set argsflags [lrange $args 0 end-2]
-        dict for {k v} $argsflags {
+        tcl::dict::for {k v} $argsflags {
             switch -- $k {
-                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -align {}
+                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -align {
+                    tcl::dict::set opts $k $v
+                }
                 default {
-                    set known_opts [dict keys $defaults]
+                    set known_opts [tcl::dict::keys $opts]
                     error "overtype::centre unknown option '$k'. Known options: $known_opts"
                 }
             }
         }
-        set opts [dict merge $defaults $argsflags]
+        #set opts [tcl::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 opt_align           [dict get $opts -align]
+        set opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsis         [tcl::dict::get $opts -ellipsis]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_overflow        [tcl::dict::get $opts -overflow]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1]
+        set opt_exposed2        [tcl::dict::get $opts -exposed2]
+        set opt_align           [tcl::dict::get $opts -align]
         # -- --- --- --- --- ---
         
-        set norm [list \r\n \n]
-        set underblock [string map $norm $underblock]
-        set overblock  [string map $norm $overblock]
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $overblock]
 
         set underlines [split $underblock \n]
         #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
@@ -1359,27 +1387,27 @@ namespace eval overtype {
                 set startoffset 0 ;#negative?
             }
 
-            set undertext [string cat $replay_codes_underlay $undertext]
-            set overtext [string cat $replay_codes_overlay $overtext]
+            set undertext [tcl::string::cat $replay_codes_underlay $undertext]
+            set overtext [tcl::string::cat $replay_codes_overlay $overtext]
 
             set overflowlength [expr {$overtext_datalen - $colwidth}]
             if {$overflowlength > 0} {	
                 #raw overtext wider than undertext column
                 set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -startcolumn [expr {1 + $startoffset}] $undertext $overtext]
-                set replay_codes          [dict get $rinfo replay_codes]
-                set rendered [dict get $rinfo result]
+                set replay_codes          [tcl::dict::get $rinfo replay_codes]
+                set rendered [tcl::dict::get $rinfo result]
                 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 lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                            if {[tcl::string::trim $lostdata] eq ""} {
                                 set show_ellipsis 0
                             }
                         }
                         if {$show_ellipsis} {
-                            set ellipsis [string cat $replay_codes $opt_ellipsistext]
+                            set ellipsis [tcl::string::cat $replay_codes $opt_ellipsistext]
                             #todo - overflow on left if allign = right??
                             set rendered [overtype::right $rendered $ellipsis]
                         }
@@ -1391,16 +1419,218 @@ namespace eval overtype {
                 #lappend outputlines [renderline -insert_mode 0 -transparent $opt_transparent -startcolumn [expr {$left_exposed + 1}] $undertext $overtext]
                 #Note - we still need overflow here - as although the overtext is short - it may oveflow due to the startoffset
                 set rinfo [renderline -info 1  -insert_mode 0 -transparent $opt_transparent -overflow $opt_overflow -startcolumn [expr {$left_exposed + 1 + $startoffset}] $undertext $overtext]
-                lappend outputlines  [dict get $rinfo result]
+                lappend outputlines  [tcl::dict::get $rinfo result]
             }
-            set replay_codes          [dict get $rinfo replay_codes]
-            set replay_codes_underlay [dict get $rinfo replay_codes_underlay]
-            set replay_codes_overlay  [dict get $rinfo replay_codes_overlay]
+            set replay_codes          [tcl::dict::get $rinfo replay_codes]
+            set replay_codes_underlay [tcl::dict::get $rinfo replay_codes_underlay]
+            set replay_codes_overlay  [tcl::dict::get $rinfo replay_codes_overlay]
         }
 
         return [join $outputlines \n]
     }
 
+    proc left {args} {
+        overtype::block -blockalign left {*}$args
+    }
+    #overtype a (possibly ragged) underblock with a (possibly ragged) overblock
+    proc block {args} {
+        variable default_ellipsis_horizontal
+        # @d !todo - implement overflow, length checks etc
+
+        if {[llength $args] < 2} {
+            error {usage: ?-blockalign left|centre|right? ?-textalign left|centre|right?  ?-overflow [1|0]? ?-transparent 0|<char>? undertext overtext}
+        }
+        #foreach {underblock overblock} [lrange $args end-1 end] break
+        lassign [lrange $args end-1 end] underblock overblock
+
+        set opts [tcl::dict::create\
+            -ellipsis   0\
+            -ellipsistext   $default_ellipsis_horizontal\
+            -ellipsiswhitespace 0\
+            -overflow   0\
+            -transparent 0\
+            -exposed1 \uFFFD\
+            -exposed2 \uFFFD\
+            -textalign  "left"\
+            -textvertical "top"\
+            -blockalign "left"\
+            -blockalignbias left\
+            -blockvertical "top"\
+        ]
+        set argsflags [lrange $args 0 end-2]
+        tcl::dict::for {k v} $argsflags {
+            switch -- $k {
+                -blockalignbias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -textalign - -blockalign - -blockvertical {
+                    tcl::dict::set opts $k $v
+                }
+                default {
+                    error "overtype::block unknown option '$k'. Known options: [tcl::dict::keys $opts]"
+                }
+            }
+        }
+        # -- --- --- --- --- ---
+        set opt_transparent         [tcl::dict::get $opts -transparent]
+        set opt_ellipsis            [tcl::dict::get $opts -ellipsis]
+        set opt_ellipsistext        [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace  [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_overflow            [tcl::dict::get $opts -overflow]
+        set opt_exposed1            [tcl::dict::get $opts -exposed1]
+        set opt_exposed2            [tcl::dict::get $opts -exposed2]
+        set opt_textalign           [tcl::dict::get $opts -textalign]
+        set opt_blockalign          [tcl::dict::get $opts -blockalign]
+        if {$opt_blockalign eq "center"} {
+            set opt_blockalign "centre"
+        }
+        # -- --- --- --- --- ---
+        
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $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 {max(0,$colwidth - $overblock_width)}]
+
+        switch -- $opt_blockalign {
+            left {
+                set left_exposed 0
+            }
+            right {
+                set left_exposed $under_exposed_max 
+            }
+            centre {
+                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 {[tcl::string::tolower [tcl::dict::get $opts -blockalignbias]] eq "left"} {
+                            set left_exposed $beforehalf
+                        } else {
+                            #bias to the right
+                            set left_exposed [expr {$beforehalf + 1}]
+                        }
+                    }
+                } else {
+                    set left_exposed 0
+                }
+            }
+            default {
+                set left_exposed 0
+            }
+        }
+
+
+
+        set outputlines [list]
+        if {[punk::ansi::ta::detect_sgr [lindex $overlines 0]]} {
+            set replay_codes "[punk::ansi::a]"
+        } else {
+            set replay_codes ""
+        }
+        set replay_codes_underlay ""
+        set replay_codes_overlay ""
+        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
+                append undertext [string repeat { } $udiff]
+            }
+            if {$overtext_datalen < $overblock_width} {
+                set odiff [expr {$overblock_width - $overtext_datalen}]
+                switch -- $opt_textalign {
+                    left {
+                        set startoffset 0 
+                    }
+                    right {
+                        set startoffset  $odiff 
+                    }
+                    default {
+                        set half [expr {$odiff / 2}]
+                        #set lhs [string repeat { } $half]
+                        #set righthalf [expr {$odiff - $half}] ;#remainder - may be one more - so we are biased left
+                        #set rhs [string repeat { } $righthalf]
+                        set startoffset $half 
+                    }
+                }
+            } else {
+                set startoffset 0 ;#negative?
+            }
+
+            set undertext   [tcl::string::cat $replay_codes_underlay    $undertext]
+            set overtext    [tcl::string::cat $replay_codes_overlay     $overtext]
+
+            set overflowlength [expr {$overtext_datalen - $colwidth}]
+            if {$overflowlength > 0} {	
+                #raw overtext wider than undertext column
+                set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -startcolumn [expr {1 + $startoffset}] $undertext $overtext]
+                set replay_codes    [tcl::dict::get $rinfo replay_codes]
+                set rendered        [tcl::dict::get $rinfo result]
+                set overflow_right  [tcl::dict::get $rinfo overflow_right]
+                set unapplied       [tcl::dict::get $rinfo unapplied]
+                if {!$opt_overflow} {
+                    if {$opt_ellipsis} {
+                        set show_ellipsis 1
+                        if {!$opt_ellipsiswhitespace} {
+                            #we don't want ellipsis if only whitespace was lost
+                            #don't use tcl::string::range on ANSI data
+                            #set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                            set lostdata ""
+                            if {$overflow_right ne ""} {
+                                append lostdata $overflow_right
+                            }
+                            if {$unapplied ne ""} {
+                                append lostdata $unapplied
+                            }
+                            if {[tcl::string::trim $lostdata] eq ""} {
+                                set show_ellipsis 0
+                            }
+                        }
+                        if {$show_ellipsis} {
+                            set rendered [overtype::block -blockalign right $rendered $opt_ellipsistext]
+                        }
+                    }
+
+                    #if {$opt_ellipsis} {
+                    #    set show_ellipsis 1
+                    #    if {!$opt_ellipsiswhitespace} {
+                    #        #we don't want ellipsis if only whitespace was lost
+                    #        set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                    #        if {[tcl::string::trim $lostdata] eq ""} {
+                    #            set show_ellipsis 0
+                    #        }
+                    #    }
+                    #    if {$show_ellipsis} {
+                    #        set ellipsis [tcl::string::cat $replay_codes $opt_ellipsistext]
+                    #        #todo - overflow on left if allign = right??
+                    #        set rendered [overtype::right $rendered $ellipsis]
+                    #    }
+                    #}
+                }
+                lappend outputlines $rendered
+            } else {
+                #padded overtext 
+                #lappend outputlines [renderline -insert_mode 0 -transparent $opt_transparent -startcolumn [expr {$left_exposed + 1}] $undertext $overtext]
+                #Note - we still need overflow here - as although the overtext is short - it may oveflow due to the startoffset
+                set rinfo [renderline -info 1  -insert_mode 0 -transparent $opt_transparent -overflow $opt_overflow -startcolumn [expr {$left_exposed + 1 + $startoffset}] $undertext $overtext]
+                set overflow_right  [tcl::dict::get $rinfo overflow_right]
+                set unapplied       [tcl::dict::get $rinfo unapplied]
+                lappend outputlines [tcl::dict::get $rinfo result]
+            }
+            set replay_codes          [tcl::dict::get $rinfo replay_codes]
+            set replay_codes_underlay [tcl::dict::get $rinfo replay_codes_underlay]
+            set replay_codes_overlay  [tcl::dict::get $rinfo replay_codes_overlay]
+        }
+
+        return [join $outputlines \n]
+    }
     # ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
     # renderline written from a left-right line orientation perspective as a first-shot at getting something useful. 
     # ultimately right-to-left, top-to-bottom and bottom-to-top are probably needed. 
@@ -1443,7 +1673,8 @@ namespace eval overtype {
         #    error "overtype::renderline not allowed to contain newlines"
         #}
 
-        set defaults [dict create\
+        #generally faster to create a new dict in the proc than to use a namespace variable to create dict once and link to variable (2024 8.6/8.7)
+        set opts [tcl::dict::create\
             -etabs         0\
             -width         \uFFEF\
             -overflow      0\
@@ -1458,6 +1689,7 @@ namespace eval overtype {
             -exposed1      \uFFFD\
             -exposed2      \uFFFD\
             -cursor_restore_attributes ""\
+            -cp437         0\
             -experimental  {}\
         ]
         #-cursor_restore_attributes only - for replay stack - position and actual setting/restoring handled by throwback to caller
@@ -1469,41 +1701,41 @@ namespace eval overtype {
         #todo - return info about such grapheme 'cuts' in -info structure and/or create option to raise an error
 
         set argsflags [lrange $args 0 end-2]
-        dict for {k v} $argsflags {
+        tcl::dict::for {k v} $argsflags {
             switch -- $k {
-                -experimental - -width - -overflow - -transparent - -startcolumn - -cursor_column - -cursor_row - -insert_mode - -autowrap_mode - -reverse_mode - -info - -exposed1 - -exposed2 - -cursor_restore_attributes {}
+                -experimental - -cp437 - -width - -overflow - -transparent - -startcolumn - -cursor_column - -cursor_row - -insert_mode - -autowrap_mode - -reverse_mode - -info - -exposed1 - -exposed2 - -cursor_restore_attributes {
+                    tcl::dict::set opts $k $v
+                }
                 default {
-                    set known_opts [dict keys $defaults]
-                    error "overtype::renderline unknown option '$k'. Known options: $known_opts"
+                    error "overtype::renderline unknown option '$k'. Known options: [tcl::dict::keys $opts]"
                 }
             }
         }
-        set opts [dict merge $defaults $argsflags]
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_width               [dict get $opts -width]
-        set opt_etabs               [dict get $opts -etabs]
-        set opt_overflow            [dict get $opts -overflow]
-        set opt_colstart            [dict get $opts -startcolumn] ;#lhs limit for overlay - an offset to cursor_column  - first visible column is 1.  0 or < 0 are before the start of the underlay 
-        set opt_colcursor           [dict get $opts -cursor_column];#start cursor column relative to overlay
-        set opt_row_context         [dict get $opts -cursor_row]
+        set opt_width               [tcl::dict::get $opts -width]
+        set opt_etabs               [tcl::dict::get $opts -etabs]
+        set opt_overflow            [tcl::dict::get $opts -overflow]
+        set opt_colstart            [tcl::dict::get $opts -startcolumn] ;#lhs limit for overlay - an offset to cursor_column  - first visible column is 1.  0 or < 0 are before the start of the underlay 
+        set opt_colcursor           [tcl::dict::get $opts -cursor_column];#start cursor column relative to overlay
+        set opt_row_context         [tcl::dict::get $opts -cursor_row]
         if {[string length $opt_row_context]} {
-            if {![string is integer -strict $opt_row_context] || $opt_row_context <1 } {
+            if {![tcl::string::is integer -strict $opt_row_context] || $opt_row_context <1 } {
                 error "overtype::renderline -cursor_row must be empty for unspecified/unknown or a non-zero positive integer. received: '$opt_row_context'"
             }
         }
         # -- --- --- --- --- --- --- --- --- --- --- --- 
         #The _mode flags correspond to terminal modes that can be set/reset via escape sequences (e.g DECAWM wraparound mode)
-        set opt_insert_mode         [dict get $opts -insert_mode];#should usually be 1 for each new line in editor mode but must be initialised to 1 externally (review)
+        set opt_insert_mode         [tcl::dict::get $opts -insert_mode];#should usually be 1 for each new line in editor mode but must be initialised to 1 externally (review)
         #default is for overtype
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_autowrap_mode       [dict get $opts -autowrap_mode] ;#DECAWM - char or movement can go beyond leftmost/rightmost col to prev/next line
-        set opt_reverse_mode        [dict get $opts -reverse_mode]  ;#DECSNM
+        set opt_autowrap_mode       [tcl::dict::get $opts -autowrap_mode] ;#DECAWM - char or movement can go beyond leftmost/rightmost col to prev/next line
+        set opt_reverse_mode        [tcl::dict::get $opts -reverse_mode]  ;#DECSNM
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set temp_cursor_saved       [dict get $opts -cursor_restore_attributes]
+        set temp_cursor_saved       [tcl::dict::get $opts -cursor_restore_attributes]
 
         set test_mode 0
-        set cp437_glyphs 0
-        foreach e [dict get $opts -experimental] {
+        set cp437_glyphs [tcl::dict::get $opts -cp437] 
+        foreach e [tcl::dict::get $opts -experimental] {
             switch -- $e {
                 test_mode {
                     set test_mode 1
@@ -1511,16 +1743,17 @@ namespace eval overtype {
                 }
             }
         }
-        set cp437_map [dict create]
+        set test_mode 1  ;#try to elminate
+        set cp437_map [tcl::dict::create]
         if {$cp437_glyphs} {
             set cp437_map [set ::punk::ansi::cp437_map]
             #for cp437 images we need to map these *after* splitting ansi
             #some old files might use newline for its glyph.. but we can't easily support that.
             #Not sure how old files did it.. maybe cr lf in sequence was newline and any lone cr or lf were displayed as glyphs?
-            dict unset cp437_map \n
+            tcl::dict::unset cp437_map \n
         }
 
-        set opt_transparent         [dict get $opts -transparent]  
+        set opt_transparent         [tcl::dict::get $opts -transparent]  
         if {$opt_transparent eq "0"} {
             set do_transparency 0
         } else {
@@ -1530,10 +1763,10 @@ namespace eval overtype {
             }
         }
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_returnextra         [dict get $opts -info]
+        set opt_returnextra         [tcl::dict::get $opts -info]
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_exposed1            [dict get $opts -exposed1]
-        set opt_exposed2            [dict get $opts -exposed2]
+        set opt_exposed1            [tcl::dict::get $opts -exposed1]
+        set opt_exposed2            [tcl::dict::get $opts -exposed2]
         # -- --- --- --- --- --- --- --- --- --- --- ---
 
         if {$opt_row_context eq ""} {
@@ -1548,6 +1781,8 @@ namespace eval overtype {
         if {[info exists punk::console::tabwidth]} {
             #punk console is updated if punk::console::set_tabstop_width is used or rep is started/restarted
             #It is way too slow to test the current width by querying the terminal here - so it could conceivably get out of sync
+            #todo - we also need to handle the new threaded repl where console config is in a different thread.
+            # - also - concept of sub-regions being mini-consoles with their own settings - 'id' for console, or use in/out channels as id?
             set tw $::punk::console::tabwidth
         } else {
             set tw 8
@@ -1576,7 +1811,12 @@ namespace eval overtype {
 
         # -- --- --- --- --- --- --- ---
         if {$under ne ""} {
-            set undermap [punk::ansi::ta::split_codes_single $under]
+            if {[punk::ansi::ta::detect $under]} {
+                set undermap [punk::ansi::ta::split_codes_single $under]
+            } else {
+                #single plaintext part
+                set undermap [list $under]
+            }
         } else {
             set undermap [list]
         }
@@ -1594,7 +1834,7 @@ namespace eval overtype {
             #pt = plain text
             #append pt_underchars $pt
             if {$cp437_glyphs} {
-                set pt [string map $cp437_map $pt]
+                set pt [tcl::string::map $cp437_map $pt]
             }
             foreach grapheme [punk::char::grapheme_split $pt] {
                 #an ugly hack to serve *some* common case ascii quickly with byte-compiled literal switch - feels dirty.
@@ -1648,23 +1888,24 @@ namespace eval overtype {
 
             #only stack SGR (graphics rendition) codes - not title sets, cursor moves etc 
             if {$code ne ""} {
-                set c1c2 [string range $code 0 1]
-                set leadernorm [string range [string map [list\
-                    \x1b\[      7CSI\
-                    \x9b        8CSI\
-                    \x1b\(      7GFX\
-                    ] $c1c2] 0 3] ;#leadernorm is 1st 2 chars mapped to 4char normalised indicator - or is original 2 chars 
+                set c1c2 [tcl::string::range $code 0 1]
+
+                set leadernorm [tcl::string::range [tcl::string::map [list\
+                    \x1b\[          7CSI\
+                    \x9b            8CSI\
+                    \x1b\(          7GFX\
+                ] $c1c2] 0 3];# leadernorm is 1st 2 chars mapped to normalised indicator - or is original 2 chars
 
                 switch -- $leadernorm {
                     7CSI - 8CSI {
                         #need to exclude certain leaders after the lb e.g < for SGR 1006 mouse 
                         #REVIEW - what else could end in m but be mistaken as a normal SGR code here?
                         set maybemouse ""
-                        if {[string index $c1c2 0] eq "\x1b"} {
-                            set maybemouse [string index $code 2]
+                        if {[tcl::string::index $c1c2 0] eq "\x1b"} {
+                            set maybemouse [tcl::string::index $code 2]
                         }
                         
-                        if {$maybemouse ne "<" && [string index $code end] eq "m"} {
+                        if {$maybemouse ne "<" && [tcl::string::index $code end] eq "m"} {
                             if {[punk::ansi::codetype::is_sgr_reset $code]} {
                                 set u_codestack [list "\x1b\[m"]
                             } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
@@ -1678,7 +1919,7 @@ namespace eval overtype {
                         }
                     }
                     7GFX {
-                        switch -- [string index $code 2] {
+                        switch -- [tcl::string::index $code 2] {
                             "0" {
                                 set u_gx_stack [list gx0_on] ;#we'd better use a placeholder - or debugging will probably get into a big mess
                             }
@@ -1788,7 +2029,17 @@ namespace eval overtype {
         #this will be processed as transparent - and handle doublewidth underlay characters appropriately
         set startpad_overlay [string repeat " " [expr {$opt_colstart -1}]]
         append startpad_overlay $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_overlay]
+        if {$startpad_overlay ne ""} {
+            if {[punk::ansi::ta::detect $startpad_overlay]} {
+                set overmap  [punk::ansi::ta::split_codes_single $startpad_overlay]
+            } else {
+                #single plaintext part
+                set overmap [list $startpad_overlay]
+            }
+        } else {
+            set overmap [list]
+        }
+        #set overmap  [punk::ansi::ta::split_codes_single $startpad_overlay]
         ####
 
         #???
@@ -1815,7 +2066,7 @@ namespace eval overtype {
 
             #todo - wrap in test for empty pt (we used split_codes_single - and it may be common for sgr sequences to be unmerged and so have empty pts between)
             if {$cp437_glyphs} {
-                set pt [string map $cp437_map $pt]
+                set pt [tcl::string::map $cp437_map $pt]
             }
             append pt_overchars $pt
             #will get empty pt between adjacent codes
@@ -1879,8 +2130,8 @@ namespace eval overtype {
         #set replay_codes_overlay [join $o_codestack ""]
         set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}$o_codestack]
 
-        #if {[dict exists $overstacks $max_overlay_grapheme_index]} {
-        #    set replay_codes_overlay [join [dict get $overstacks $max_overlay_grapheme_index] ""]
+        #if {[tcl::dict::exists $overstacks $max_overlay_grapheme_index]} {
+        #    set replay_codes_overlay [join [tcl::dict::get $overstacks $max_overlay_grapheme_index] ""]
         #} else {
         #    set replay_codes_overlay ""
         #}
@@ -1941,6 +2192,17 @@ namespace eval overtype {
         set insert_mode $opt_insert_mode ;#default 1
         set autowrap_mode $opt_autowrap_mode ;#default 1
 
+        #set re_mode        {\x1b\[\?([0-9]*)(h|l)}   ;#e.g DECAWM 
+        #set re_col_move    {\x1b\[([0-9]*)(C|D|G)$}
+        #set re_row_move    {\x1b\[([0-9]*)(A|B)$}
+        #set re_both_move   {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)H$}  ;# or "f"  ?
+        #set re_vt_sequence {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)~$}
+        #set re_cursor_save          {\x1b\[s$}  ;#note probable incompatibility with DECSLRM (set left right margin)!
+        #set re_cursor_restore       {\x1b\[u$}
+        #set re_cursor_save_dec      {\x1b7$}
+        #set re_cursor_restore_dec   {\x1b8$}
+        #set re_other_single         {\x1b(D|M|E)$}
+        #set re_decstbm              {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)r$}  ;#DECSTBM set top and bottom margins
 
         #puts "-->$overlay_grapheme_control_list<--"
         #puts "-->overflow_idx: $overflow_idx"
@@ -1968,7 +2230,7 @@ namespace eval overtype {
                     #This is hard to process in any standard manner - but I think the Hyper behaviour of doing what it was intended is perhaps most reasonable
                     #We will map it to the same behaviour as lf here for now... but we need also to consider the equivalent ANSI sequence: \x1bE 
 
-                    set chtest [string map [list \n <lf> \x85 <lf> \b <bs> \r <cr> \v <vt> \x7f <del>] $ch]
+                    set chtest [tcl::string::map [list \n <lf> \x85 <lf> \b <bs> \r <cr> \v <vt> \x7f <del>] $ch]
                     #puts --->chtest:$chtest
                     #specials - each shoud have it's own test of what to do if it happens after overflow_idx reached
                     switch -- $chtest {
@@ -2056,7 +2318,7 @@ namespace eval overtype {
                                         #review split 2w overflow?
                                         #we don't want to make the decision here to split a 2w into replacement characters at end of line and beginning of next line
                                         #better to consider the overlay char as unable to be applied to the line
-                                        #render empty string to column(?) - and reduce overlay grapheme index by one so that the current ch goes into unapplied
+                                        #render empty  column(?) - and reduce overlay grapheme index by one so that the current ch goes into unapplied
                                         #throwing back to caller with instruction complicates its job - but is necessary to avoid making decsions for it here.
                                         priv::render_addchar $idx "" [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
                                         #change the overflow_idx
@@ -2095,7 +2357,7 @@ namespace eval overtype {
                                 #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
                                 if {$idx > [llength $outcols]-1} {
                                     lappend outcols " "
-                                    #dict set understacks $idx [list] ;#review - use idx-1 codestack?
+                                    #tcl::dict::set understacks $idx [list] ;#review - use idx-1 codestack?
                                     lset understacks $idx [list]
                                     incr idx
                                     incr cursor_column
@@ -2123,7 +2385,7 @@ namespace eval overtype {
                                         if {[grapheme_width_cached $ch] == 1} {
                                             if {!$insert_mode} {
                                                 #normal singlewide transparent overlay onto double-wide underlay 
-                                                set next_pt_overchar [string index $pt_overchars $idx_over+1] ;#lookahead of next plain-text char in overlay
+                                                set next_pt_overchar [tcl::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
@@ -2134,7 +2396,7 @@ namespace eval overtype {
                                                         incr cursor_column
                                                     } 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] [dict get $overstacks_gx $idx_over] $insert_mode
+                                                        #priv::render_addchar $idx $opt_exposed1 [tcl::dict::get $overstacks $idx_over] [tcl::dict::get $overstacks_gx $idx_over] $insert_mode
                                                         priv::render_addchar $idx $opt_exposed1 [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
                                                         incr idx
                                                         incr cursor_column
@@ -2277,35 +2539,23 @@ namespace eval overtype {
 
                 }
                 other {
-                    set code $item
+                    #todo - consider CSI s DECSLRM vs ansi.sys \x1b\[s  - we need \x1b\[s for oldschool ansi art - but may have to enable only for that.
+                    #we should probably therefore reverse this mapping so that x1b7 x1b8 are the primary codes for save/restore
+                    set code [tcl::string::map [list \x1b7 \x1b\[s \x1b8 \x1b\[u ] $item]
                     #since this element isn't a grapheme - advance idx_over to next grapheme overlay when about to fill 'unapplied'
 
-                    set re_mode        {\x1b\[\?([0-9]*)(h|l)}   ;#e.g DECAWM 
-                    set re_col_move    {\x1b\[([0-9]*)(C|D|G)$}
-                    set re_row_move    {\x1b\[([0-9]*)(A|B)$}
-                    set re_both_move   {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)H$}  ;# or "f"  ?
-                    set re_vt_sequence {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)~$}
-                    set re_cursor_save          {\x1b\[s$}  ;#note probable incompatibility with DECSLRM (set left right margin)!
-                    set re_cursor_restore       {\x1b\[u$}
-                    set re_cursor_save_dec      {\x1b7$}
-                    set re_cursor_restore_dec   {\x1b8$}
-                    set re_other_single         {\x1b(D|M|E)$}
-                    set re_decstbm              {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)r$}  ;#DECSTBM set top and bottom margins
                     set matchinfo [list]
 
                     #remap of DEC cursor_save/cursor_restore from ESC sequence to equivalent CSI
                     #probably not ideal - consider putting cursor_save/cursor_restore in functions so they can be called from the appropriate switch branch instead of using this mapping
                     #review - cost/benefit of function calls within these switch-arms instead of inline code?
 
-                    #todo - consider CSI s DECSLRM vs ansi.sys \x1b\[s  - we need \x1b\[s for oldschool ansi art - but may have to enable only for that.
-                    #we should probably therefore reverse this mapping so that x1b7 x1b8 are the primary codes for save/restore
-                    set code [string map [list \x1b7 \x1b\[s \x1b8 \x1b\[u ] $code]
-
-
-                    set c1 [string index $code 0]
-                    set c1c2c3 [string range $code 0 2]
+                    set c1 [tcl::string::index $code 0]
+                    set c1c2c3 [tcl::string::range $code 0 2]
                     #set re_ST_open {(?:\033P|\u0090|\033X|\u0098|\033\^|\u009e|\033_|\u009f)} 
-                    set leadernorm [string range [string map [list\
+                    #tcl 8.7 - faster to use inline list than to store it in a local var outside of loop. 
+                    #(surprising - but presumably )
+                    set leadernorm [tcl::string::range [tcl::string::map [list\
                         \x1b\[<     1006\
                         \x1b\[      7CSI\
                         \x9b        8CSI\
@@ -2319,16 +2569,16 @@ namespace eval overtype {
                         1006 {
                             #https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
                             #SGR (1006) CSI < followed by colon separated encoded-button-value,px,py ordinates and final M for button press m for button release
-                            set codenorm [string cat $leadernorm [string range $code 3 end]]
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 3 end]]
                         }
                         7CSI - 7OSC {
-                            set codenorm [string cat $leadernorm [string range $code 2 end]]
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 2 end]]
                         }
                         7ESC {
-                            set codenorm [string cat $leadernorm [string range $code 1 end]]
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 1 end]]
                         }
                         8CSI - 8OSC {
-                            set codenorm [string cat $leadernorm [string range $code 1 end]]
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 1 end]]
                         }
                         default {
                             #we haven't made a mapping for this
@@ -2341,7 +2591,7 @@ namespace eval overtype {
                         1006 {
                             #TODO
                             #
-                            switch -- [string index $codenorm end] {
+                            switch -- [tcl::string::index $codenorm end] {
                                 M {
                                     puts stderr "mousedown $codenorm"
                                 }
@@ -2352,9 +2602,9 @@ namespace eval overtype {
 
                         }
                         {7CSI} - {8CSI} {
-                            set param [string range $codenorm 4 end-1]
-                            #puts stdout "--> CSI [string index $leadernorm 0] bit param:$param"
-                            switch -- [string index $codenorm end] {
+                            set param [tcl::string::range $codenorm 4 end-1]
+                            #puts stdout "--> CSI [tcl::string::index $leadernorm 0] bit param:$param"
+                            switch -- [tcl::string::index $codenorm end] {
                                 D {
                                     #Col move
                                     #puts stdout "<-back"
@@ -2459,8 +2709,8 @@ namespace eval overtype {
                                                 #puts "idxstart:$idxstart idxend:$idxend outcols[llength $outcols] undercols:[llength $undercols]"
                                                 incr idx $moveend
                                                 incr cursor_column $moveend
-                                                #if {[dict exists $understacks $idx]} {
-                                                #    set stackinfo [dict get $understacks $idx] ;#use understack at end - which may or may not have already been replaced by stack from overtext
+                                                #if {[tcl::dict::exists $understacks $idx]} {
+                                                #    set stackinfo [tcl::dict::get $understacks $idx] ;#use understack at end - which may or may not have already been replaced by stack from overtext
                                                 #} else {
                                                 #    set stackinfo [list]
                                                 #}
@@ -2470,7 +2720,7 @@ namespace eval overtype {
                                                     set stackinfo [list]
                                                 }
                                                 if {$idx < [llength $understacks_gx]} {
-                                                    #set gxstackinfo [dict get $understacks_gx $idx]
+                                                    #set gxstackinfo [tcl::dict::get $understacks_gx $idx]
                                                     set gxstackinfo [lindex $understacks_gx $idx]
                                                 } else {
                                                     set gxstackinfo [list]
@@ -2780,8 +3030,8 @@ namespace eval overtype {
                                     #$re_mode if first after CSI is "?"  
                                     #some docs mention ESC=<mode>h|l  - not seen on windows terminals.. review
                                     #e.g https://www2.math.upenn.edu/~kazdan/210/computer/ansi.html
-                                    if {[string index $codenorm 4] eq "?"} {
-                                        set num [string range $codenorm 5 end-1] ;#param between ? and h|l
+                                    if {[tcl::string::index $codenorm 4] eq "?"} {
+                                        set num [tcl::string::range $codenorm 5 end-1] ;#param between ? and h|l
                                         #lassign $matchinfo _match num type
                                         switch -- $num {
                                             5 {
@@ -2842,7 +3092,7 @@ namespace eval overtype {
                         } 
                         7ESC {
                             #$re_other_single
-                            switch -- [string index $codenorm end] {
+                            switch -- [tcl::string::index $codenorm end] {
                                 D {
                                     #\x84
                                     #index (IND)
@@ -2938,7 +3188,7 @@ namespace eval overtype {
 
             set gxleader ""
             if {$i < [llength $understacks_gx]} {
-                #set g0 [dict get $understacks_gx $i]
+                #set g0 [tcl::dict::get $understacks_gx $i]
                 set g0 [lindex $understacks_gx $i]
                 if {$g0 ne $prev_g0} {
                     if {$g0 eq [list "gx0_on"]} {
@@ -2954,7 +3204,7 @@ namespace eval overtype {
 
             set sgrleader ""
             if {$i < [llength $understacks]} {
-                #set cstack [dict get $understacks $i]
+                #set cstack [tcl::dict::get $understacks $i]
                 set cstack [lindex $understacks $i]
                 if {$cstack ne $prevstack} {
                     if {[llength $prevstack] && ![llength $cstack]} {
@@ -3008,7 +3258,7 @@ namespace eval overtype {
                 append outstring $gxleader
                 append outstring $sgrleader
                 if {$idx+1 < $cursor_column} {
-                    append outstring [string map [list "\u0000" " "] $ch]
+                    append outstring [tcl::string::map {\u0000 " "} $ch]
                 } else {
                     append outstring $ch
                 }
@@ -3017,16 +3267,16 @@ namespace eval overtype {
         }
         #flower.ans good test for null handling - reverse line building
         if {![ansistring length $overflow_right]} {
-            set outstring [string trimright $outstring "\u0000"]
+            set outstring [tcl::string::trimright $outstring "\u0000"]
         }
-        set outstring [string map [list "\u0000" " "] $outstring] 
-        set overflow_right [string trimright $overflow_right "\u0000"]
-        set overflow_right [string map [list "\u0000" " "] $overflow_right] 
+        set outstring [tcl::string::map {\u0000 " "} $outstring] 
+        set overflow_right [tcl::string::trimright $overflow_right "\u0000"]
+        set overflow_right [tcl::string::map {\u0000 " "} $overflow_right] 
 
         set replay_codes ""
         if {[llength $understacks] > 0} {
             if {$overflow_idx == -1} {
-                #set tail_idx [dict size $understacks]
+                #set tail_idx [tcl::dict::size $understacks]
                 set tail_idx [llength $understacks]
             } else {
                 set tail_idx [llength $undercols]
@@ -3069,7 +3319,7 @@ namespace eval overtype {
             }  else {
                 set overflow_right_column [expr {$overflow_idx+1}]
             }
-            set result [dict create\
+            set result [tcl::dict::create\
                 result $outstring\
                 visualwidth [punk::ansi::printing_length $outstring]\
                 instruction $instruction\
@@ -3105,14 +3355,14 @@ namespace eval overtype {
                         set viewop VIEWSTYLE ;#ansi colorise the characters within the output with preceding codes, stacking codes only within each dict value - may not be same SGR effect as the effect in-situ. 
                     }
                 }
-                dict set result result                  [ansistring $viewop -lf 1 -vt 1 [dict get $result result]]
-                dict set result overflow_right          [ansistring VIEW -lf 1 -vt 1 [dict get $result overflow_right]]
-                dict set result unapplied               [ansistring VIEW -lf 1 -vt 1 [dict get $result unapplied]]
-                dict set result unapplied_list          [ansistring VIEW -lf 1 -vt 1 [dict get $result unapplied_list]]
-                dict set result replay_codes            [ansistring $viewop -lf 1 -vt 1 [dict get $result replay_codes]]
-                dict set result replay_codes_underlay   [ansistring $viewop -lf 1 -vt 1 [dict get $result replay_codes_underlay]]
-                dict set result replay_codes_overlay    [ansistring $viewop -lf 1 -vt 1 [dict get $result replay_codes_overlay]]
-                dict set result cursor_saved_attributes [ansistring $viewop -lf 1 -vt 1 [dict get $result cursor_saved_attributes]] 
+                tcl::dict::set result result                  [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result result]]
+                tcl::dict::set result overflow_right          [ansistring VIEW -lf 1 -vt 1 [tcl::dict::get $result overflow_right]]
+                tcl::dict::set result unapplied               [ansistring VIEW -lf 1 -vt 1 [tcl::dict::get $result unapplied]]
+                tcl::dict::set result unapplied_list          [ansistring VIEW -lf 1 -vt 1 [tcl::dict::get $result unapplied_list]]
+                tcl::dict::set result replay_codes            [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result replay_codes]]
+                tcl::dict::set result replay_codes_underlay   [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result replay_codes_underlay]]
+                tcl::dict::set result replay_codes_overlay    [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result replay_codes_overlay]]
+                tcl::dict::set result cursor_saved_attributes [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result cursor_saved_attributes]] 
                 return $result
             }
         } else {
@@ -3125,7 +3375,7 @@ namespace eval overtype {
     #[list_end] [comment {--- end definitions namespace overtype ---}]
 } 
 
-namespace eval overtype::piper {
+tcl::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}
@@ -3149,19 +3399,19 @@ namespace eval overtype::piper {
 proc overtype::transparentline {args} {
     foreach {under over} [lrange $args end-1 end] break
     set argsflags [lrange $args 0 end-2]
-    set defaults [dict create\
+    set defaults [tcl::dict::create\
         -transparent 1\
         -exposed 1 " "\
         -exposed 2 " "\
     ]
-    set newargs [dict merge $defaults $argsflags]
+    set newargs [tcl::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 {
+tcl::namespace::eval overtype::piper {
     proc renderline {args} {
         if {[llength $args] < 2} {
             error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
@@ -3178,11 +3428,11 @@ interp alias "" piper_renderline "" overtype::piper::renderline
 #(a cache of ansifreestring_width calls - as these are quite regex heavy)
 proc overtype::grapheme_width_cached {ch} {
     variable grapheme_widths
-    if {[dict exists $grapheme_widths $ch]} {
-        return [dict get $grapheme_widths $ch]
+    if {[tcl::dict::exists $grapheme_widths $ch]} {
+        return [tcl::dict::get $grapheme_widths $ch]
     }
     set width [punk::char::ansifreestring_width $ch]
-    dict set grapheme_widths $ch $width
+    tcl::dict::set grapheme_widths $ch $width
     return $width
 }
 
@@ -3200,9 +3450,9 @@ proc overtype::test_renderline {} {
 #block width and height can be tricky. e.g \v handled differently on different terminal emulators and can affect both
 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
+        return [tcl::dict::create width 0 height 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
     }
-    if {[string first \t $textblock] >= 0} {
+    if {[tcl::string::first \t $textblock] >= 0} {
         if {[info exists punk::console::tabwidth]} {
             set tw $::punk::console::tabwidth
         } else {
@@ -3214,8 +3464,8 @@ proc overtype::blocksize {textblock} {
     if {[punk::ansi::ta::detect $textblock]} {
         set textblock [punk::ansi::stripansi $textblock]
     }
-    if {[string first \n $textblock] >= 0} {
-        set num_le [expr {[string length $textblock]-[string length [string map [list \n {}] $textblock]]}] ;#faster than splitting into single-char list
+    if {[tcl::string::last \n $textblock] >= 0} {
+        set num_le [expr {[tcl::string::length $textblock]-[tcl::string::length [tcl::string::map {\n {}} $textblock]]}] ;#faster than splitting into single-char list
         set width [tcl::mathfunc::max {*}[lmap v [split $textblock \n] {::punk::char::ansifreestring_width $v}]]
     } else {
         set num_le 0
@@ -3224,22 +3474,22 @@ proc overtype::blocksize {textblock} {
     #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
+    return [tcl::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 {
-    variable cache_is_sgr [dict create]
+tcl::namespace::eval overtype::priv {
+    variable cache_is_sgr [tcl::dict::create]
 
     #we are likely to be asking the same question of the same ansi codes repeatedly
     #caching the answer saves some regex expense - possibly a few uS to lookup vs under 1uS
     #todo - test if still worthwhile after a large cache is built up. (limit cache size?)
     proc is_sgr {code} {
         variable cache_is_sgr
-        if {[dict exists $cache_is_sgr $code]} {
-            return [dict get $cache_is_sgr $code]
+        if {[tcl::dict::exists $cache_is_sgr $code]} {
+            return [tcl::dict::get $cache_is_sgr $code]
         } 
         set answer [punk::ansi::codetype::is_sgr $code]
-        dict set cache_is_sgr $code $answer
+        tcl::dict::set cache_is_sgr $code $answer
         return $answer
     }
     proc render_unapplied {overlay_grapheme_control_list gci} {
@@ -3344,7 +3594,7 @@ namespace eval overtype::priv {
         upvar understacks_gx gxstacks
         #ECH clears character attributes from erased character positions
         #ECH accepts 0 or empty parameter, which is equivalent to 1. Caller should do that mapping and only supply 1 or greater.
-        if {![string is integer -strict $count] || $count < 1} {
+        if {![tcl::string::is integer -strict $count] || $count < 1} {
             error "render_erasechar count must be integer >= 1"
         }
         set start $i
@@ -3419,15 +3669,15 @@ namespace eval overtype::priv {
 
 
 # -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype {
+tcl::namespace::eval overtype {
 	interp alias {} ::overtype::center {} ::overtype::centre
 }
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide overtype [namespace eval overtype {
+package provide overtype [tcl::namespace::eval overtype {
     variable version
-    set version 1.6.2 
+    set version 1.6.4 
 }]
 return
 
diff --git a/src/bootsupport/modules/punk/ansi-0.1.1.tm b/src/bootsupport/modules/punk/ansi-0.1.1.tm
index 647da08..fd14bca 100644
--- a/src/bootsupport/modules/punk/ansi-0.1.1.tm
+++ b/src/bootsupport/modules/punk/ansi-0.1.1.tm
@@ -68,8 +68,8 @@ package require punk::assertion
 #[section API]
 
 
-namespace eval punk::ansi::class {
-    if {![llength [info commands class_ansi]]} {
+tcl::namespace::eval punk::ansi::class {
+    if {![llength [tcl::info::commands class_ansi]]} {
 
         oo::class create class_ansi {
             variable o_ansistringobj 
@@ -141,27 +141,27 @@ namespace eval punk::ansi::class {
                 if {[llength $arglist] %2 != 0} {
                     puts stderr "render_to_input_line usage: ?-dimensions WxH? ?-minus charcount? x"
                 }
-                set opts [dict create\
+                set opts [tcl::dict::create\
                     -dimensions 80x24\
                     -minus 0\
                 ]
-                dict for {k v} $arglist {
+                foreach {k v} $arglist {
                     switch --  $k {
                         -dimensions - -minus {
-                            dict set opts $k $v
+                            tcl::dict::set opts $k $v
                         }
                         default {
                             puts stderr "render_to_input_line unexpected argument '$k' usage: ?-dimensions WxH? ?-minus charcount? x"
                         }
                     }
                 }
-                set opt_dimensions      [dict get $opts -dimensions]
-                set opt_minus           [dict get $opts -minus]
+                set opt_dimensions      [tcl::dict::get $opts -dimensions]
+                set opt_minus           [tcl::dict::get $opts -minus]
                 lassign [split $opt_dimensions x] w h
-                if {![string is integer -strict $w] || ![string is integer -strict $h] || $w < 1 || $h < 1} {
+                if {![tcl::string::is integer -strict $w] || ![tcl::string::is integer -strict $h] || $w < 1 || $h < 1} {
                     puts stderr "render_to_input_line WxH width & height must be positive integer values usage: ?-dimensions WxH? ?-minus charcount? x"
                 }
-                if {![string is integer -strict $opt_minus]} {
+                if {![tcl::string::is integer -strict $opt_minus]} {
                     puts stderr "render_to_input_line -minus must be positive integer value representing number of chars to exclude from end. usage: ?-dimensions WxH? ?-minus charcount? x"
                 }
 
@@ -174,7 +174,7 @@ namespace eval punk::ansi::class {
                 set chunk [::join $rlines \n] 
                 append chunk \n
                 if {$opt_minus ne "0"} {
-                   set chunk [string range $chunk 0 end-$opt_minus] 
+                   set chunk [tcl::string::range $chunk 0 end-$opt_minus] 
                 }
                 set rendered [overtype::renderspace -experimental {test_mode} -overflow 0 -wrap 1 -width $w -height $h -appendlines 1 "" $chunk]
                 set marker ""
@@ -190,12 +190,12 @@ namespace eval punk::ansi::class {
                 ::append rendered \n $marker
                 set xline [lindex $rlines $x]\n
                 set xlinev [ansistring VIEWSTYLE $xline]
-                set xlinev [string map $maplf $xlinev]
+                set xlinev [tcl::string::map $maplf $xlinev]
                 set xlinedisplay [overtype::renderspace -wrap 1 -width $w -height 1 "" $xlinev]
                 ::append rendered \n $xlinedisplay
 
                 set chunk [ansistring VIEWSTYLE $chunk]
-                set chunk [string map $maplf $chunk]
+                set chunk [tcl::string::map $maplf $chunk]
                 #keep chunkdisplay narrower - leave at 80 or it will get unwieldy for larger image widths 
                 set chunkdisplay [overtype::renderspace -wrap 1 -width 80 -height 1 "" $chunk]
                 set renderheight [llength [split $rendered \n]]
@@ -203,7 +203,7 @@ namespace eval punk::ansi::class {
                 set chunkdisplay_tail [lrange $chunkdisplay_lines end-$renderheight end]
                 set chunkdisplay_block [join $chunkdisplay_tail \n]
                 #the input chunk lines are often much longer than the output.. resulting in main content being way up the screen. It's often impractical to view more than the tail of the chunkdisplay.
-                textblock::join $rendered $chunkdisplay_block
+                textblock::join -- $rendered $chunkdisplay_block
             }
             
             method checksum {} {
@@ -226,23 +226,23 @@ namespace eval punk::ansi::class {
                 foreach {k v} $args {
                     switch -- $k {
                         -lf - -vt - -width {
-                            dict set opts $k $v
+                            tcl::dict::set opts $k $v
                         }
                         default {
-                            error "viewcodes unrecognised option '$k'. Known options [dict keys $defaults]"
+                            error "viewcodes unrecognised option '$k'. Known options [tcl::dict::keys $defaults]"
                         }
                     }
                 }
-                set opts_lf [dict get $opts -lf]
-                set opts_vt [dict get $opts -vt]
-                set opts_width [dict get $opts -width]
+                set opts_lf [tcl::dict::get $opts -lf]
+                set opts_vt [tcl::dict::get $opts -vt]
+                set opts_width [tcl::dict::get $opts -width]
                 if {$opts_width eq ""} {
                     return [ansistring VIEWCODES -lf $opts_lf -vt $opts_vt [$o_ansistringobj get]]
                 } elseif {$opts_width eq "auto"} {
                     lassign [punk::console::get_size] _cols columns _rows rows
                     set displaycols [expr {$columns -4}] ;#review
                     return [overtype::renderspace -width $displaycols -wrap 1 "" [ansistring VIEWCODES -lf $opts_lf -vt $opts_vt [$o_ansistringobj get]]]
-                } elseif {[string is integer -strict $opts_width] && $opts_width > 0} {
+                } elseif {[tcl::string::is integer -strict $opts_width] && $opts_width > 0} {
                     return [overtype::renderspace -width $opts_width -wrap 1 "" [ansistring VIEWCODES -lf $opts_lf -vt $opts_vt [$o_ansistringobj get]]]
                 } else {
                     error "viewcodes unrecognised value for -width. Try auto or a positive integer"
@@ -256,21 +256,21 @@ namespace eval punk::ansi::class {
                 foreach {k v} $args {
                     switch -- $k {
                         -width {
-                            dict set opts $k $v
+                            tcl::dict::set opts $k $v
                         }
                         default {
-                            error "viewchars unrecognised option '$k'. Known options [dict keys $defaults]"
+                            error "viewchars unrecognised option '$k'. Known options [tcl::dict::keys $defaults]"
                         }
                     }
                 }
-                set opts_width [dict get $opts -width]
+                set opts_width [tcl::dict::get $opts -width]
                 if {$opts_width eq ""} {
                     return [punk::ansi::stripansiraw [$o_ansistringobj get]]
                 } elseif {$opts_width eq "auto"} {
                     lassign [punk::console::get_size] _cols columns _rows rows
                     set displaycols [expr {$columns -4}] ;#review
                     return [overtype::renderspace -width $displaycols -wrap 1 "" [punk::ansi::stripansiraw [$o_ansistringobj get]]]
-                } elseif {[string is integer -strict $opts_width] && $opts_width > 0} {
+                } elseif {[tcl::string::is integer -strict $opts_width] && $opts_width > 0} {
                     return [overtype::renderspace -width $opts_width -wrap 1 "" [punk::ansi::stripansiraw [$o_ansistringobj get]]]
                 } else {
                     error "viewchars unrecognised value for -width. Try auto or a positive integer"
@@ -284,21 +284,21 @@ namespace eval punk::ansi::class {
                 foreach {k v} $args {
                     switch -- $k {
                         -width {
-                            dict set opts $k $v
+                            tcl::dict::set opts $k $v
                         }
                         default {
-                            error "viewstyle unrecognised option '$k'. Known options [dict keys $defaults]"
+                            error "viewstyle unrecognised option '$k'. Known options [tcl::dict::keys $defaults]"
                         }
                     }
                 }
-                set opts_width [dict get $opts -width]
+                set opts_width [tcl::dict::get $opts -width]
                 if {$opts_width eq ""} {
                     return [ansistring VIEWSTYLE [$o_ansistringobj get]]
                 } elseif {$opts_width eq "auto"} {
                     lassign [punk::console::get_size] _cols columns _rows rows
                     set displaycols [expr {$columns -4}] ;#review
                     return [overtype::renderspace -width $displaycols -wrap 1 "" [ansistring VIEWSTYLE [$o_ansistringobj get]]]
-                } elseif {[string is integer -strict $opts_width] && $opts_width > 0} {
+                } elseif {[tcl::string::is integer -strict $opts_width] && $opts_width > 0} {
                     return [overtype::renderspace -width $opts_width -wrap 1 "" [ansistring VIEWSTYLE [$o_ansistringobj get]]]
                 } else {
                     error "viewstyle unrecognised value for -width. Try auto or a positive integer"
@@ -321,7 +321,7 @@ namespace eval punk::ansi::class {
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::ansi {
+tcl::namespace::eval punk::ansi {
     #*** !doctools
     #[subsection {Namespace punk::ansi}]
     #[para] Core API functions for punk::ansi 
@@ -336,81 +336,81 @@ namespace eval punk::ansi {
     #by mapping these we can display regardless.
     #nul char - no cp437 image but commonly used as space in ansi graphics. 
     #(This is a potential conflict because we use nul as a filler to mean empty column in overtype rendering) REVIEW
-    dict set cp437_map \u0000 " "     ;#space
-    dict set cp437_map \u0001 \u263A  ;#smiley
-    dict set cp437_map \u0002 \u263B  ;#smiley-filled
-    dict set cp437_map \u0003 \u2665  ;#heart
-    dict set cp437_map \u0004 \u2666  ;#diamond
-    dict set cp437_map \u0005 \u2663  ;#club
-    dict set cp437_map \u0006 \u2660  ;#spade
-    dict set cp437_map \u0007 \u2022  ;#dot
-    dict set cp437_map \u0008 \u25D8  ;#square hollow dot
-    dict set cp437_map \u0009 \u25CB  ;#hollow dot
-    dict set cp437_map \u000A \u25D9  ;#square and dot  (\n)
-    dict set cp437_map \u000B \u2642  ;#male
-    dict set cp437_map \u000C \u2640  ;#female
-    dict set cp437_map \u000D \u266A  ;#note1   (\r)
-    dict set cp437_map \u000E \u266B  ;#note2
-    dict set cp437_map \u000F \u263C  ;#sun
-    dict set cp437_map \u0010 \u25BA  ;#right arrow triangle
-    dict set cp437_map \u0011 \u25CA  ;#left arrow triangle
-    dict set cp437_map \u0012 \u2195  ;#updown arrow
-    dict set cp437_map \u0013 \u203C  ;#double bang
-    dict set cp437_map \u0014 \u00B6  ;#pilcrow (paragraph mark / blind P)
-    dict set cp437_map \u0015 \u00A7  ;#Section Sign
-    dict set cp437_map \u0016 \u25AC  ;#Heavy horizontal?
-    dict set cp437_map \u0017 \u21A8  ;#updown arrow 2 ?
-    dict set cp437_map \u0018 \u2191  ;#up arrow 
-    dict set cp437_map \u0019 \u2193  ;#down arrow 
-    dict set cp437_map \u001A \u2192  ;#right arrow 
-    dict set cp437_map \u001B \u2190  ;#left arrow 
-    dict set cp437_map \u001C \u221F  ;#bottom left corner 
-    dict set cp437_map \u001D \u2194  ;#left-right arrow
-    dict set cp437_map \u001E \u25B2  ;#up arrow triangle
-    dict set cp437_map \u001F \u25BC  ;#down arrow triangle
+    tcl::dict::set cp437_map \u0000 " "     ;#space
+    tcl::dict::set cp437_map \u0001 \u263A  ;#smiley
+    tcl::dict::set cp437_map \u0002 \u263B  ;#smiley-filled
+    tcl::dict::set cp437_map \u0003 \u2665  ;#heart
+    tcl::dict::set cp437_map \u0004 \u2666  ;#diamond
+    tcl::dict::set cp437_map \u0005 \u2663  ;#club
+    tcl::dict::set cp437_map \u0006 \u2660  ;#spade
+    tcl::dict::set cp437_map \u0007 \u2022  ;#dot
+    tcl::dict::set cp437_map \u0008 \u25D8  ;#square hollow dot
+    tcl::dict::set cp437_map \u0009 \u25CB  ;#hollow dot
+    tcl::dict::set cp437_map \u000A \u25D9  ;#square and dot  (\n)
+    tcl::dict::set cp437_map \u000B \u2642  ;#male
+    tcl::dict::set cp437_map \u000C \u2640  ;#female
+    tcl::dict::set cp437_map \u000D \u266A  ;#note1   (\r)
+    tcl::dict::set cp437_map \u000E \u266B  ;#note2
+    tcl::dict::set cp437_map \u000F \u263C  ;#sun
+    tcl::dict::set cp437_map \u0010 \u25BA  ;#right arrow triangle
+    tcl::dict::set cp437_map \u0011 \u25CA  ;#left arrow triangle
+    tcl::dict::set cp437_map \u0012 \u2195  ;#updown arrow
+    tcl::dict::set cp437_map \u0013 \u203C  ;#double bang
+    tcl::dict::set cp437_map \u0014 \u00B6  ;#pilcrow (paragraph mark / blind P)
+    tcl::dict::set cp437_map \u0015 \u00A7  ;#Section Sign
+    tcl::dict::set cp437_map \u0016 \u25AC  ;#Heavy horizontal?
+    tcl::dict::set cp437_map \u0017 \u21A8  ;#updown arrow 2 ?
+    tcl::dict::set cp437_map \u0018 \u2191  ;#up arrow 
+    tcl::dict::set cp437_map \u0019 \u2193  ;#down arrow 
+    tcl::dict::set cp437_map \u001A \u2192  ;#right arrow 
+    tcl::dict::set cp437_map \u001B \u2190  ;#left arrow 
+    tcl::dict::set cp437_map \u001C \u221F  ;#bottom left corner 
+    tcl::dict::set cp437_map \u001D \u2194  ;#left-right arrow
+    tcl::dict::set cp437_map \u001E \u25B2  ;#up arrow triangle
+    tcl::dict::set cp437_map \u001F \u25BC  ;#down arrow triangle
 
     variable map_special_graphics
     #DEC Special Graphics set https://en.wikipedia.org/wiki/DEC_Special_Graphics
     #AKA IBM Code page 1090
-    dict set map_special_graphics _   \u00a0  ;#no-break space
-    dict set map_special_graphics "`" \u25c6  ;#black diamond
-    dict set map_special_graphics a \u2592    ;#shaded block (checkerboard stipple), medium shade - Block Elements
-    dict set map_special_graphics b \u2409    ;#symbol for HT
-    dict set map_special_graphics c \u240c    ;#symbol for FF
-    dict set map_special_graphics d \u240d    ;#symbol for CR
-    dict set map_special_graphics e \u240a    ;#symbol for LF
-    dict set map_special_graphics f \u00b0    ;#degree sign 
-    dict set map_special_graphics g \u00b1    ;#plus-minus sign
-    dict set map_special_graphics h \u2424    ;#symbol for NL
-    dict set map_special_graphics i \u240b    ;#symbol for VT
-    dict set map_special_graphics j \u2518    ;#brc, light up and left - box drawing
-    dict set map_special_graphics k \u2510    ;#trc, light down and left - box drawing
-    dict set map_special_graphics l \u250c    ;#tlc, light down and right - box drawing
-    dict set map_special_graphics m \u2514    ;#blc, light up and right - box drawing
-    dict set map_special_graphics n \u253c    ;#light vertical and horizontal - box drawing
-    dict set map_special_graphics o \u23ba    ;#horizontal scan line-1
-    dict set map_special_graphics p \u23bb    ;#horizontal scan line-3
-    dict set map_special_graphics q \u2500    ;#light horizontal - box drawing
-    dict set map_special_graphics r \u23bc    ;#horizontal scan line-7 
-    dict set map_special_graphics s \u23bd    ;#horizontal scan line-9 
-    dict set map_special_graphics t \u251c    ;#light vertical and right - box drawing
-    dict set map_special_graphics u \u2524    ;#light vertical and left - box drawing
-    dict set map_special_graphics v \u2534    ;#light up and horizontal - box drawing
-    dict set map_special_graphics w \u252c    ;#light down and horizontal - box drawing
-    dict set map_special_graphics x \u2502    ;#light vertical - box drawing
-    dict set map_special_graphics y \u2264    ;#less than or equal
-    dict set map_special_graphics z \u2265    ;#greater than or equal
-    dict set map_special_graphics "\{" \u03c0 ;#greek small letter pi
-    dict set map_special_graphics "|" \u2260  ;#not equal to
-    dict set map_special_graphics "\}" \u00a3 ;#pound sign 
-    dict set map_special_graphics ~ \u00b7    ;#middle dot
+    tcl::dict::set map_special_graphics _   \u00a0  ;#no-break space
+    tcl::dict::set map_special_graphics "`" \u25c6  ;#black diamond
+    tcl::dict::set map_special_graphics a \u2592    ;#shaded block (checkerboard stipple), medium shade - Block Elements
+    tcl::dict::set map_special_graphics b \u2409    ;#symbol for HT
+    tcl::dict::set map_special_graphics c \u240c    ;#symbol for FF
+    tcl::dict::set map_special_graphics d \u240d    ;#symbol for CR
+    tcl::dict::set map_special_graphics e \u240a    ;#symbol for LF
+    tcl::dict::set map_special_graphics f \u00b0    ;#degree sign 
+    tcl::dict::set map_special_graphics g \u00b1    ;#plus-minus sign
+    tcl::dict::set map_special_graphics h \u2424    ;#symbol for NL
+    tcl::dict::set map_special_graphics i \u240b    ;#symbol for VT
+    tcl::dict::set map_special_graphics j \u2518    ;#brc, light up and left - box drawing
+    tcl::dict::set map_special_graphics k \u2510    ;#trc, light down and left - box drawing
+    tcl::dict::set map_special_graphics l \u250c    ;#tlc, light down and right - box drawing
+    tcl::dict::set map_special_graphics m \u2514    ;#blc, light up and right - box drawing
+    tcl::dict::set map_special_graphics n \u253c    ;#light vertical and horizontal - box drawing
+    tcl::dict::set map_special_graphics o \u23ba    ;#horizontal scan line-1
+    tcl::dict::set map_special_graphics p \u23bb    ;#horizontal scan line-3
+    tcl::dict::set map_special_graphics q \u2500    ;#light horizontal - box drawing
+    tcl::dict::set map_special_graphics r \u23bc    ;#horizontal scan line-7 
+    tcl::dict::set map_special_graphics s \u23bd    ;#horizontal scan line-9 
+    tcl::dict::set map_special_graphics t \u251c    ;#light vertical and right - box drawing
+    tcl::dict::set map_special_graphics u \u2524    ;#light vertical and left - box drawing
+    tcl::dict::set map_special_graphics v \u2534    ;#light up and horizontal - box drawing
+    tcl::dict::set map_special_graphics w \u252c    ;#light down and horizontal - box drawing
+    tcl::dict::set map_special_graphics x \u2502    ;#light vertical - box drawing
+    tcl::dict::set map_special_graphics y \u2264    ;#less than or equal
+    tcl::dict::set map_special_graphics z \u2265    ;#greater than or equal
+    tcl::dict::set map_special_graphics "\{" \u03c0 ;#greek small letter pi
+    tcl::dict::set map_special_graphics "|" \u2260  ;#not equal to
+    tcl::dict::set map_special_graphics "\}" \u00a3 ;#pound sign 
+    tcl::dict::set map_special_graphics ~ \u00b7    ;#middle dot
 
     #see also ansicolour page on wiki https://wiki.tcl-lang.org/page/ANSI+color+control 
 
     variable test "blah\033\[1;33mETC\033\[0;mOK"
 
     #Note that a? is actually a pattern. We can't explicitly match it without also matcing a+ ab etc.  Presumably this won't matter here.
-    namespace export\
+    tcl::namespace::export\
         {a?} {a+} a \
         ansistring\
         convert*\
@@ -427,11 +427,11 @@ namespace eval punk::ansi {
 
     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\\ \u009c] ;#note mix of 1 and 2-byte terminals 
-    dict set escape_terminals DCS [list \007 \033\\ \u009c]
-    dict set escape_terminals MISC [list \007 \033\\ \u009c]
+    tcl::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 "\{" "\}"]
+    #tcl::dict::set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
+    tcl::dict::set escape_terminals OSC [list \007 \033\\ \u009c] ;#note mix of 1 and 2-byte terminals 
+    tcl::dict::set escape_terminals DCS [list \007 \033\\ \u009c]
+    tcl::dict::set escape_terminals MISC [list \007 \033\\ \u009c]
     #NOTE - we are assuming an OSC or DCS started with one type of sequence (7 or 8bit) can be terminated by either 7 or 8 bit ST (or BEL e.g wezterm ) 
     #This using a different type of ST to that of the opening sequence is presumably unlikely in the wild - but who knows?
 
@@ -439,7 +439,7 @@ namespace eval punk::ansi {
     # https://espterm.github.io/docs/VT100%20escape%20codes.html
 
     #self-contained 2 byte ansi escape sequences - review more?
-    set  ansi_2byte_codes_dict [dict create\
+    set  ansi_2byte_codes_dict [tcl::dict::create\
         "reset_terminal"            "\u001bc"\
         "save_cursor_posn"          "\u001b7"\
         "restore_cursor_posn"       "\u001b8"\
@@ -457,9 +457,9 @@ namespace eval punk::ansi {
     proc test_cat1 {ansi1 ansi2} {
         #make sure objects have splits
         set s1 [ansistring NEW $ansi1] 
-        namespace eval [info object namespace $s1] {my MakeSplit}
+        tcl::namespace::eval [info object namespace $s1] {my MakeSplit}
         set s2 [ansistring NEW $ansi2] 
-        namespace eval [info object namespace $s2] {my MakeSplit}
+        tcl::namespace::eval [info object namespace $s2] {my MakeSplit}
 
         #operation under test
         # --
@@ -474,9 +474,9 @@ namespace eval punk::ansi {
     proc test_cat2  {ansi1 ansi2} {
         #make sure objects have splits
         set s1 [ansistring NEW $ansi1] 
-        namespace eval [info object namespace $s1] {my MakeSplit}
+        tcl::namespace::eval [info object namespace $s1] {my MakeSplit}
         set s2 [ansistring NEW $ansi2] 
-        namespace eval [info object namespace $s2] {my MakeSplit}
+        tcl::namespace::eval [info object namespace $s2] {my MakeSplit}
 
         #operation under test
         # --
@@ -572,16 +572,16 @@ namespace eval punk::ansi {
         foreach f $fnames {
             if {![file exists $ansibase/$f]} {
                 set p [overtype::left $missingbase "[a+ red bold]\nMissing file\n$ansibase/$f[a]"]
-                lappend pics [dict create filename $f pic $p status missing]
+                lappend pics [tcl::dict::create filename $f pic $p status missing]
             } else {
                 set img [join [lines_as_list -line trimline -block trimtail [ansicat $ansibase/$f]] \n]
-                lappend pics [dict create filename $f pic $img status ok] 
+                lappend pics [tcl::dict::create filename $f pic $img status ok] 
             }
         }
 
         set termsize [punk::console:::get_size] 
         set margin 4
-        set freewidth [expr {[dict get $termsize columns]-$margin}]
+        set freewidth [expr {[tcl::dict::get $termsize columns]-$margin}]
         set per_row [expr {$freewidth / 80}]
 
         set rowlist [list]
@@ -589,11 +589,11 @@ namespace eval punk::ansi {
         set i 1 
         foreach picinfo $pics {
             set subtitle ""
-            if {[dict get $picinfo status] ne "ok"} {
-                set subtitle [dict get $picinfo status] 
+            if {[tcl::dict::get $picinfo status] ne "ok"} {
+                set subtitle [tcl::dict::get $picinfo status] 
             }
-            set title [dict get $picinfo filename]
-            lappend row [textblock::frame -subtitle $subtitle -title $title [dict get $picinfo pic]]
+            set title [tcl::dict::get $picinfo filename]
+            lappend row [textblock::frame -subtitle $subtitle -title $title [tcl::dict::get $picinfo pic]]
             if {$i % $per_row == 0} {
                 lappend rowlist $row
                 set row [list]
@@ -605,7 +605,7 @@ namespace eval punk::ansi {
 
         set result ""
         foreach r $rowlist {
-            append result [textblock::join {*}$r] \n
+            append result [textblock::join_basic -- {*}$r] \n
         }
 
 
@@ -658,30 +658,14 @@ namespace eval punk::ansi {
     #This doesn't change the output length - so support is tricky to detec. (terminal checksum report?)
 
     #candidate for zig/c implementation?
-    proc stripansi {text} {
-        #*** !doctools
-        #[call [fun stripansi] [arg text] ]
-        #[para]Return a string with ansi codes stripped out
-        #[para]Alternate graphics chars are replaced with modern unicode equivalents (e.g boxdrawing glyphs)
+    proc stripansi2 {text} {
 
-        #using detect costs us a couple of uS - but saves time on plain text 
-        #we should probably leave this for caller  - otherwise it ends up being called more than necessary
-        #if {![::punk::ansi::ta::detect $text]} { 
-        #    return $text
-        #}
 
         set text [convert_g0 $text];#Convert ansi borders to unicode line drawing instead of ascii letters 
         join [::punk::ansi::ta::split_at_codes $text] ""
     }
-    proc stripansiraw {text} {
-        #*** !doctools
-        #[call [fun stripansi] [arg text] ]
-        #[para]Return a string with ansi codes stripped out 
-        #[para]Alternate graphics modes will be stripped - exposing the raw characters as they appear without graphics mode.
-        #[para]ie instead of a horizontal line you may see: qqqqqq  
 
-        join [::punk::ansi::ta::split_at_codes $text] ""
-    }
+
     proc stripansi1 {text} {
 
         #todo - character set selection - SS2 SS3 - how are they terminated?  REVIEW
@@ -692,7 +676,7 @@ namespace eval punk::ansi {
         set text [convert_g0 $text] 
 
 
-        set text [string map $standalone_code_map $text]
+        set text [tcl::string::map $standalone_code_map $text]
         #e.g standalone 2 byte and 3 byte  VT100(?) sequences - some of these work in wezterm 
         #\x1b#3 double-height letters top half
         #\x1b#4 double-height letters bottom half
@@ -720,7 +704,7 @@ namespace eval punk::ansi {
                 #2nd byte - done.
                 set in_escapesequence 0
             } elseif {$in_escapesequence != 0} {
-                set endseq [dict get $escape_terminals $in_escapesequence]
+                set endseq [tcl::dict::get $escape_terminals $in_escapesequence]
                 if {$u in $endseq} {
                     set in_escapesequence 0
                 } elseif {$uv in $endseq} {
@@ -754,7 +738,7 @@ namespace eval punk::ansi {
         variable map_special_graphics
 
         #using not \033 inside to stop greediness - review how does it compare to ".*?"
-        #variable re_altg0_group {(?:\x1b\(0)(?:(?!\x1b\(B).)*\x1b\(B}
+        #variable re_g0_group {(?:\x1b\(0)(?:(?!\x1b\(B).)*\x1b\(B}
         #set re {\033\(0[^\033]*\033\(B} 
         #set re {(?:\x1b\(0)(?:(?!\x1b\(B).)*\x1b\(B}
         #set re2 {\033\(0(.*)\033\(B} ;#capturing
@@ -766,24 +750,25 @@ namespace eval punk::ansi {
         #mqj
         #m = boxd_lur
 
+        #don't call detect_g0 in here. Leave for caller. e.g stripansi uses detect_g0 to decide whether to call this.
 
         set re_g0_open_or_close {\x1b\(0|\x1b\(B} 
         set parts [::punk::ansi::ta::_perlish_split $re_g0_open_or_close $text]
-        set out ""
+        set out {} 
         set g0_on 0
         foreach {other g} $parts {
             if {$g0_on} {
                 #split for non graphics-set codes
                 set othersplits [punk::ansi::ta::split_codes $other] ;#we don't need single codes here
                 foreach {inner_plaintext inner_codes} $othersplits {
-                    append out [string map $map_special_graphics $inner_plaintext] $inner_codes
+                    lappend out [tcl::string::map $map_special_graphics $inner_plaintext] $inner_codes
                     #Simplifying assumption: no mapping required on any inner_codes - ST codes, titlesets etc don't require/use g0 content
                 }
             } else {
-                append out $other ;#may be a mix of plaintext and other ansi codes - put it all through.
+                lappend out $other ;#may be a mix of plaintext and other ansi codes - put it all through.
             }
             #trust our splitting regex has done the work to leave us with only \x1b\(0 or \x1b(B  - test last char rather than use punk::ansi::codetype::is_gx_open/is_gx_close
-            switch -- [string index $g end] {
+            switch -- [tcl::string::index $g end] {
                 0 {
                     set g0_on 1
                 }
@@ -792,13 +777,13 @@ namespace eval punk::ansi {
                 }
             }
         }
-        return $out
+        return [join $out ""]
     }
     proc convert_g0_wrong {text} {
         #Attempting to split on a group is wrong - because there could be other ansi codes while inside a g0 section
         #That will either stop us matching - so no conversion - or risk converting parts of the ansi codes
         #using not \033 inside to stop greediness - review how does it compare to ".*?"
-        #variable re_altg0_group {(?:\x1b\(0)(?:(?!\x1b\(B).)*\x1b\(B}
+        #variable re_g0_group {(?:\x1b\(0)(?:(?!\x1b\(B).)*\x1b\(B}
         set re {\033\(0[^\033]*\033\(B} 
         set re2 {\033\(0(.*)\033\(B} ;#capturing
 
@@ -818,7 +803,7 @@ namespace eval punk::ansi {
             if {$g ne ""} {
                 #puts --$g--
                 regexp $re2 $g _match contents
-                append out [string map $map $contents]
+                append out [tcl::string::map $map $contents]
             }
         }
         return $out
@@ -835,7 +820,7 @@ namespace eval punk::ansi {
             #e.g "\033)X" - where X is any char other than 0 to reset ??
             
             #return [convert_g0 $text]
-            return [string map [list "\x1b(0" "" \x1b(B" "" "\x1b)0" "" "\x1b)X" ""] $text]
+            return [tcl::string::map [list "\x1b(0" "" \x1b(B" "" "\x1b)0" "" "\x1b)X" ""] $text]
     }
 
 
@@ -857,7 +842,7 @@ brightblack  90   brightred  91   brightgreen  92   brightyellow  93   brightblu
 Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblue 104   Brightpurple 105   Brightcyan 106   Brightwhite 107
     }
     variable SGR_map ;#public - part of interface - review 
-    set SGR_map [dict merge $SGR_colour_map $SGR_setting_map]
+    set SGR_map [tcl::dict::merge $SGR_colour_map $SGR_setting_map]
 
     #we use prefixes e.g  web-white and/or x11-white
     #Only a leading capital letter will indicate the colour target is background vs lowercase for foreground
@@ -874,197 +859,197 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     #css 1-2.0 HTML 3.2-4 Basic colours eg web-silver for fg Web-silver for bg
     #
     variable WEB_colour_map_basic
-    dict set WEB_colour_map_basic white       255-255-255     ;#  #FFFFFF
-    dict set WEB_colour_map_basic silver      192-192-192     ;#  #C0C0C0 
-    dict set WEB_colour_map_basic gray        128-128-128     ;#  #808080
-    dict set WEB_colour_map_basic black       0-0-0           ;#  #000000
-    dict set WEB_colour_map_basic red         255-0-0         ;#  #FF0000
-    dict set WEB_colour_map_basic maroon      128-0-0         ;#  #800000
-    dict set WEB_colour_map_basic yellow      255-255-0       ;#  #FFFF00
-    dict set WEB_colour_map_basic olive       128-128-0       ;#  #808000
-    dict set WEB_colour_map_basic lime        0-255-0         ;#  #00FF00
-    dict set WEB_colour_map_basic green       0-128-0         ;#  #008000
-    dict set WEB_colour_map_basic aqua        0-255-255       ;#  #00FFFF
-    dict set WEB_colour_map_basic teal        0-128-128       ;#  #008080
-    dict set WEB_colour_map_basic blue        0-0-255         ;#  #0000FF
-    dict set WEB_colour_map_basic navy        0-0-128         ;#  #000080
-    dict set WEB_colour_map_basic fuchsia     255-0-255       ;#  #FF00FF
-    dict set WEB_colour_map_basic purple      128-0-128       ;#  #800080
+    tcl::dict::set WEB_colour_map_basic white       255-255-255     ;#  #FFFFFF
+    tcl::dict::set WEB_colour_map_basic silver      192-192-192     ;#  #C0C0C0 
+    tcl::dict::set WEB_colour_map_basic gray        128-128-128     ;#  #808080
+    tcl::dict::set WEB_colour_map_basic black       0-0-0           ;#  #000000
+    tcl::dict::set WEB_colour_map_basic red         255-0-0         ;#  #FF0000
+    tcl::dict::set WEB_colour_map_basic maroon      128-0-0         ;#  #800000
+    tcl::dict::set WEB_colour_map_basic yellow      255-255-0       ;#  #FFFF00
+    tcl::dict::set WEB_colour_map_basic olive       128-128-0       ;#  #808000
+    tcl::dict::set WEB_colour_map_basic lime        0-255-0         ;#  #00FF00
+    tcl::dict::set WEB_colour_map_basic green       0-128-0         ;#  #008000
+    tcl::dict::set WEB_colour_map_basic aqua        0-255-255       ;#  #00FFFF
+    tcl::dict::set WEB_colour_map_basic teal        0-128-128       ;#  #008080
+    tcl::dict::set WEB_colour_map_basic blue        0-0-255         ;#  #0000FF
+    tcl::dict::set WEB_colour_map_basic navy        0-0-128         ;#  #000080
+    tcl::dict::set WEB_colour_map_basic fuchsia     255-0-255       ;#  #FF00FF
+    tcl::dict::set WEB_colour_map_basic purple      128-0-128       ;#  #800080
     # -- --- --- 
     #Pink colours
     variable WEB_colour_map_pink
-    dict set WEB_colour_map_pink mediumvioletred      199-21-133     ;#  #C71585
-    dict set WEB_colour_map_pink deeppink             255-20-147     ;#  #FF1493
-    dict set WEB_colour_map_pink palevioletred        219-112-147    ;#  #DB7093
-    dict set WEB_colour_map_pink hotpink              255-105-180    ;#  #FF69B4
-    dict set WEB_colour_map_pink lightpink            255-182-193    ;#  #FFB6C1
-    dict set WEB_colour_map_pink pink                 255-192-203    ;#  #FFCOCB
+    tcl::dict::set WEB_colour_map_pink mediumvioletred      199-21-133     ;#  #C71585
+    tcl::dict::set WEB_colour_map_pink deeppink             255-20-147     ;#  #FF1493
+    tcl::dict::set WEB_colour_map_pink palevioletred        219-112-147    ;#  #DB7093
+    tcl::dict::set WEB_colour_map_pink hotpink              255-105-180    ;#  #FF69B4
+    tcl::dict::set WEB_colour_map_pink lightpink            255-182-193    ;#  #FFB6C1
+    tcl::dict::set WEB_colour_map_pink pink                 255-192-203    ;#  #FFCOCB
     # -- --- --- 
     #Red colours
     variable WEB_colour_map_red
-    dict set WEB_colour_map_red darkred              139-0-0        ;#  #8B0000
-    dict set WEB_colour_map_red red                  255-0-0         ;#  #FF0000
-    dict set WEB_colour_map_red firebrick            178-34-34      ;#  #B22222
-    dict set WEB_colour_map_red crimson              220-20-60      ;#  #DC143C
-    dict set WEB_colour_map_red indianred            205-92-92      ;#  #CD5C5C
-    dict set WEB_colour_map_red lightcoral           240-128-128    ;#  #F08080
-    dict set WEB_colour_map_red salmon               250-128-114    ;#  #FA8072
-    dict set WEB_colour_map_red darksalmon           233-150-122    ;#  #E9967A
-    dict set WEB_colour_map_red lightsalmon          255-160-122    ;#  #FFA07A
+    tcl::dict::set WEB_colour_map_red darkred              139-0-0        ;#  #8B0000
+    tcl::dict::set WEB_colour_map_red red                  255-0-0         ;#  #FF0000
+    tcl::dict::set WEB_colour_map_red firebrick            178-34-34      ;#  #B22222
+    tcl::dict::set WEB_colour_map_red crimson              220-20-60      ;#  #DC143C
+    tcl::dict::set WEB_colour_map_red indianred            205-92-92      ;#  #CD5C5C
+    tcl::dict::set WEB_colour_map_red lightcoral           240-128-128    ;#  #F08080
+    tcl::dict::set WEB_colour_map_red salmon               250-128-114    ;#  #FA8072
+    tcl::dict::set WEB_colour_map_red darksalmon           233-150-122    ;#  #E9967A
+    tcl::dict::set WEB_colour_map_red lightsalmon          255-160-122    ;#  #FFA07A
     # -- --- --- 
     #Orange colours
     variable WEB_colour_map_orange
-    dict set WEB_colour_map_orange orangered            255-69-0       ;#  #FF4500
-    dict set WEB_colour_map_orange tomato               255-99-71      ;#  #FF6347
-    dict set WEB_colour_map_orange darkorange           255-140-0      ;#  #FF8C00
-    dict set WEB_colour_map_orange coral                255-127-80     ;#  #FF7F50
-    dict set WEB_colour_map_orange orange               255-165-0      ;#  #FFA500
+    tcl::dict::set WEB_colour_map_orange orangered            255-69-0       ;#  #FF4500
+    tcl::dict::set WEB_colour_map_orange tomato               255-99-71      ;#  #FF6347
+    tcl::dict::set WEB_colour_map_orange darkorange           255-140-0      ;#  #FF8C00
+    tcl::dict::set WEB_colour_map_orange coral                255-127-80     ;#  #FF7F50
+    tcl::dict::set WEB_colour_map_orange orange               255-165-0      ;#  #FFA500
     # -- --- --- 
     #Yellow colours
     variable WEB_colour_map_yellow
-    dict set WEB_colour_map_yellow darkkhaki             189-183-107    ;#  #BDB76B
-    dict set WEB_colour_map_yellow gold                  255-215-0      ;#  #FFD700
-    dict set WEB_colour_map_yellow khaki                 240-230-140    ;#  #F0E68C
-    dict set WEB_colour_map_yellow peachpuff             255-218-185    ;#  #FFDAB9
-    dict set WEB_colour_map_yellow yellow                255-255-0      ;#  #FFFF00
-    dict set WEB_colour_map_yellow palegoldenrod         238-232-170    ;#  #EEE8AA
-    dict set WEB_colour_map_yellow moccasin              255-228-181    ;#  #FFE4B5
-    dict set WEB_colour_map_yellow papayawhip            255-239-213    ;#  #FFEFD5
-    dict set WEB_colour_map_yellow lightgoldenrodyeallow 250-250-210 ;#  #FAFAD2
-    dict set WEB_colour_map_yellow lemonchiffon          255-250-205    ;#  #FFFACD
-    dict set WEB_colour_map_yellow lightyellow           255-255-224    ;#  #FFFFE0
+    tcl::dict::set WEB_colour_map_yellow darkkhaki             189-183-107    ;#  #BDB76B
+    tcl::dict::set WEB_colour_map_yellow gold                  255-215-0      ;#  #FFD700
+    tcl::dict::set WEB_colour_map_yellow khaki                 240-230-140    ;#  #F0E68C
+    tcl::dict::set WEB_colour_map_yellow peachpuff             255-218-185    ;#  #FFDAB9
+    tcl::dict::set WEB_colour_map_yellow yellow                255-255-0      ;#  #FFFF00
+    tcl::dict::set WEB_colour_map_yellow palegoldenrod         238-232-170    ;#  #EEE8AA
+    tcl::dict::set WEB_colour_map_yellow moccasin              255-228-181    ;#  #FFE4B5
+    tcl::dict::set WEB_colour_map_yellow papayawhip            255-239-213    ;#  #FFEFD5
+    tcl::dict::set WEB_colour_map_yellow lightgoldenrodyeallow 250-250-210 ;#  #FAFAD2
+    tcl::dict::set WEB_colour_map_yellow lemonchiffon          255-250-205    ;#  #FFFACD
+    tcl::dict::set WEB_colour_map_yellow lightyellow           255-255-224    ;#  #FFFFE0
     # -- --- --- 
     #Brown colours
     #maroon as above
     variable WEB_colour_map_brown
-    dict set WEB_colour_map_brown brown                165-42-42      ;#  #A52A2A
-    dict set WEB_colour_map_brown saddlebrown          139-69-19      ;#  #8B4513
-    dict set WEB_colour_map_brown sienna               160-82-45      ;#  #A0522D
-    dict set WEB_colour_map_brown chocolate            210-105-30     ;#  #D2691E
-    dict set WEB_colour_map_brown darkgoldenrod        184-134-11     ;#  #B8860B
-    dict set WEB_colour_map_brown peru                 205-133-63     ;#  #CD853F
-    dict set WEB_colour_map_brown rosybrown            188-143-143    ;#  #BC8F8F
-    dict set WEB_colour_map_brown goldenrod            218-165-32     ;#  #DAA520
-    dict set WEB_colour_map_brown sandybrown           244-164-96     ;#  #F4A460
-    dict set WEB_colour_map_brown tan                  210-180-140    ;#  #D2B48C
-    dict set WEB_colour_map_brown burlywood            222-184-135    ;#  #DEB887
-    dict set WEB_colour_map_brown wheat                245-222-179    ;#  #F5DEB3
-    dict set WEB_colour_map_brown navajowhite          255-222-173    ;#  #FFDEAD
-    dict set WEB_colour_map_brown bisque               255-228-196    ;#  #FFEfC4
-    dict set WEB_colour_map_brown blanchedalmond       255-228-196    ;#  #FFEfC4
-    dict set WEB_colour_map_brown cornsilk             255-248-220    ;#  #FFF8DC
+    tcl::dict::set WEB_colour_map_brown brown                165-42-42      ;#  #A52A2A
+    tcl::dict::set WEB_colour_map_brown saddlebrown          139-69-19      ;#  #8B4513
+    tcl::dict::set WEB_colour_map_brown sienna               160-82-45      ;#  #A0522D
+    tcl::dict::set WEB_colour_map_brown chocolate            210-105-30     ;#  #D2691E
+    tcl::dict::set WEB_colour_map_brown darkgoldenrod        184-134-11     ;#  #B8860B
+    tcl::dict::set WEB_colour_map_brown peru                 205-133-63     ;#  #CD853F
+    tcl::dict::set WEB_colour_map_brown rosybrown            188-143-143    ;#  #BC8F8F
+    tcl::dict::set WEB_colour_map_brown goldenrod            218-165-32     ;#  #DAA520
+    tcl::dict::set WEB_colour_map_brown sandybrown           244-164-96     ;#  #F4A460
+    tcl::dict::set WEB_colour_map_brown tan                  210-180-140    ;#  #D2B48C
+    tcl::dict::set WEB_colour_map_brown burlywood            222-184-135    ;#  #DEB887
+    tcl::dict::set WEB_colour_map_brown wheat                245-222-179    ;#  #F5DEB3
+    tcl::dict::set WEB_colour_map_brown navajowhite          255-222-173    ;#  #FFDEAD
+    tcl::dict::set WEB_colour_map_brown bisque               255-228-196    ;#  #FFEfC4
+    tcl::dict::set WEB_colour_map_brown blanchedalmond       255-228-196    ;#  #FFEfC4
+    tcl::dict::set WEB_colour_map_brown cornsilk             255-248-220    ;#  #FFF8DC
     # -- --- --- 
     #Purple, violet, and magenta colours
     variable WEB_colour_map_purple
-    dict set WEB_colour_map_purple indigo               75-0-130       ;#  #4B0082
-    dict set WEB_colour_map_purple purple               128-0-128       ;#  #800080
-    dict set WEB_colour_map_purple darkmagenta          139-0-139      ;#  #8B008B
-    dict set WEB_colour_map_purple darkviolet           148-0-211      ;#  #9400D3
-    dict set WEB_colour_map_purple darkslateblue        72-61-139      ;#  #9400D3
-    dict set WEB_colour_map_purple blueviolet           138-43-226     ;#  #8A2BE2
-    dict set WEB_colour_map_purple darkorchid           153-50-204     ;#  #9932CC
-    dict set WEB_colour_map_purple fuchsia              255-0-255      ;#  #FF00FF 
-    dict set WEB_colour_map_purple magenta              255-0-255      ;#  #FF00FF  - same as fuchsia
-    dict set WEB_colour_map_purple slateblue            106-90-205     ;#  #6A5ACD
-    dict set WEB_colour_map_purple mediumslateblue      123-104-238    ;#  #7B68EE
-    dict set WEB_colour_map_purple mediumorchid         186-85-211     ;#  #BA5503
-    dict set WEB_colour_map_purple mediumpurple         147-112-219    ;#  #9370DB
-    dict set WEB_colour_map_purple orchid               218-112-214    ;#  #DA70D6
-    dict set WEB_colour_map_purple violet               238-130-238    ;#  #EE82EE
-    dict set WEB_colour_map_purple plum                 221-160-221    ;#  #DDA0DD
-    dict set WEB_colour_map_purple thistle              216-191-216    ;#  #D88FD8
-    dict set WEB_colour_map_purple lavender             230-230-250    ;#  #E6E6FA
+    tcl::dict::set WEB_colour_map_purple indigo               75-0-130       ;#  #4B0082
+    tcl::dict::set WEB_colour_map_purple purple               128-0-128       ;#  #800080
+    tcl::dict::set WEB_colour_map_purple darkmagenta          139-0-139      ;#  #8B008B
+    tcl::dict::set WEB_colour_map_purple darkviolet           148-0-211      ;#  #9400D3
+    tcl::dict::set WEB_colour_map_purple darkslateblue        72-61-139      ;#  #9400D3
+    tcl::dict::set WEB_colour_map_purple blueviolet           138-43-226     ;#  #8A2BE2
+    tcl::dict::set WEB_colour_map_purple darkorchid           153-50-204     ;#  #9932CC
+    tcl::dict::set WEB_colour_map_purple fuchsia              255-0-255      ;#  #FF00FF 
+    tcl::dict::set WEB_colour_map_purple magenta              255-0-255      ;#  #FF00FF  - same as fuchsia
+    tcl::dict::set WEB_colour_map_purple slateblue            106-90-205     ;#  #6A5ACD
+    tcl::dict::set WEB_colour_map_purple mediumslateblue      123-104-238    ;#  #7B68EE
+    tcl::dict::set WEB_colour_map_purple mediumorchid         186-85-211     ;#  #BA5503
+    tcl::dict::set WEB_colour_map_purple mediumpurple         147-112-219    ;#  #9370DB
+    tcl::dict::set WEB_colour_map_purple orchid               218-112-214    ;#  #DA70D6
+    tcl::dict::set WEB_colour_map_purple violet               238-130-238    ;#  #EE82EE
+    tcl::dict::set WEB_colour_map_purple plum                 221-160-221    ;#  #DDA0DD
+    tcl::dict::set WEB_colour_map_purple thistle              216-191-216    ;#  #D88FD8
+    tcl::dict::set WEB_colour_map_purple lavender             230-230-250    ;#  #E6E6FA
     # -- --- --- 
     #Blue colours
     variable WEB_colour_map_blue
-    dict set WEB_colour_map_blue midnightblue         25-25-112      ;#  #191970
-    dict set WEB_colour_map_blue navy                 0-0-128         ;#  #000080
-    dict set WEB_colour_map_blue darkblue             0-0-139        ;#  #00008B
-    dict set WEB_colour_map_blue mediumblue           0-0-205        ;#  #0000CD
-    dict set WEB_colour_map_blue blue                 0-0-255         ;#  #0000FF
-    dict set WEB_colour_map_blue royalblue            65-105-225     ;#  #4169E1
-    dict set WEB_colour_map_blue steelblue            70-130-180     ;#  #4682B4
-    dict set WEB_colour_map_blue dodgerblue           30-144-255     ;#  #1E90FF
-    dict set WEB_colour_map_blue deepskyblue          0-191-255      ;#  #00BFFF
-    dict set WEB_colour_map_blue cornflowerblue       100-149-237    ;#  #6495ED
-    dict set WEB_colour_map_blue skyblue              135-206-235    ;#  #87CEEB
-    dict set WEB_colour_map_blue lightskyblue         135-206-250    ;#  #87CEFA
-    dict set WEB_colour_map_blue lightsteelblue       176-196-222    ;#  #B0C4DE
-    dict set WEB_colour_map_blue lightblue            173-216-230    ;#  #ADD8E6
-    dict set WEB_colour_map_blue powderblue           176-224-230    ;#  #B0E0E6
+    tcl::dict::set WEB_colour_map_blue midnightblue         25-25-112      ;#  #191970
+    tcl::dict::set WEB_colour_map_blue navy                 0-0-128         ;#  #000080
+    tcl::dict::set WEB_colour_map_blue darkblue             0-0-139        ;#  #00008B
+    tcl::dict::set WEB_colour_map_blue mediumblue           0-0-205        ;#  #0000CD
+    tcl::dict::set WEB_colour_map_blue blue                 0-0-255         ;#  #0000FF
+    tcl::dict::set WEB_colour_map_blue royalblue            65-105-225     ;#  #4169E1
+    tcl::dict::set WEB_colour_map_blue steelblue            70-130-180     ;#  #4682B4
+    tcl::dict::set WEB_colour_map_blue dodgerblue           30-144-255     ;#  #1E90FF
+    tcl::dict::set WEB_colour_map_blue deepskyblue          0-191-255      ;#  #00BFFF
+    tcl::dict::set WEB_colour_map_blue cornflowerblue       100-149-237    ;#  #6495ED
+    tcl::dict::set WEB_colour_map_blue skyblue              135-206-235    ;#  #87CEEB
+    tcl::dict::set WEB_colour_map_blue lightskyblue         135-206-250    ;#  #87CEFA
+    tcl::dict::set WEB_colour_map_blue lightsteelblue       176-196-222    ;#  #B0C4DE
+    tcl::dict::set WEB_colour_map_blue lightblue            173-216-230    ;#  #ADD8E6
+    tcl::dict::set WEB_colour_map_blue powderblue           176-224-230    ;#  #B0E0E6
     # -- --- --- 
     #Cyan colours
     #teal as above
     variable WEB_colour_map_cyan
-    dict set WEB_colour_map_cyan darkcyan             0-139-139      ;#  #008B8B
-    dict set WEB_colour_map_cyan lightseagreen        32-178-170     ;#  #20B2AA
-    dict set WEB_colour_map_cyan cadetblue            95-158-160     ;#  #5F9EA0
-    dict set WEB_colour_map_cyan darkturquoise        0-206-209      ;#  #00CED1
-    dict set WEB_colour_map_cyan mediumturquoise      72-209-204     ;#  #48D1CC
-    dict set WEB_colour_map_cyan turquoise            64-224-208     ;#  #40E0D0
-    dict set WEB_colour_map_cyan aqua                 0-255-255       ;#  #00FFFF
-    dict set WEB_colour_map_cyan cyan                 0-255-255      ;#  #00FFFF  - same as aqua 
-    dict set WEB_colour_map_cyan aquamarine           127-255-212    ;#  #7FFFD4
-    dict set WEB_colour_map_cyan paleturquoise        175-238-238    ;#  #AFEEEE
-    dict set WEB_colour_map_cyan lightcyan            224-255-255    ;#  #E0FFFF
+    tcl::dict::set WEB_colour_map_cyan darkcyan             0-139-139      ;#  #008B8B
+    tcl::dict::set WEB_colour_map_cyan lightseagreen        32-178-170     ;#  #20B2AA
+    tcl::dict::set WEB_colour_map_cyan cadetblue            95-158-160     ;#  #5F9EA0
+    tcl::dict::set WEB_colour_map_cyan darkturquoise        0-206-209      ;#  #00CED1
+    tcl::dict::set WEB_colour_map_cyan mediumturquoise      72-209-204     ;#  #48D1CC
+    tcl::dict::set WEB_colour_map_cyan turquoise            64-224-208     ;#  #40E0D0
+    tcl::dict::set WEB_colour_map_cyan aqua                 0-255-255       ;#  #00FFFF
+    tcl::dict::set WEB_colour_map_cyan cyan                 0-255-255      ;#  #00FFFF  - same as aqua 
+    tcl::dict::set WEB_colour_map_cyan aquamarine           127-255-212    ;#  #7FFFD4
+    tcl::dict::set WEB_colour_map_cyan paleturquoise        175-238-238    ;#  #AFEEEE
+    tcl::dict::set WEB_colour_map_cyan lightcyan            224-255-255    ;#  #E0FFFF
     # -- --- --- 
     #Green colours
     variable WEB_colour_map_green
-    dict set WEB_colour_map_green darkgreen            0-100-0        ;#  #006400
-    dict set WEB_colour_map_green green                0-128-0         ;#  #008000
-    dict set WEB_colour_map_green darkolivegreen       85-107-47      ;#  #55682F
-    dict set WEB_colour_map_green forestgreen          34-139-34      ;#  #228B22
-    dict set WEB_colour_map_green seagreen             46-139-87      ;#  #2E8B57
-    dict set WEB_colour_map_green olive                128-128-0       ;#  #808000
-    dict set WEB_colour_map_green olivedrab            107-142-35     ;#  #6B8E23
-    dict set WEB_colour_map_green mediumseagreen       60-179-113     ;#  #3CB371
-    dict set WEB_colour_map_green limegreen            50-205-50      ;#  #32CD32
-    dict set WEB_colour_map_green lime                 0-255-0         ;#  #00FF00
-    dict set WEB_colour_map_green springgreen          0-255-127      ;#  #00FF7F
-    dict set WEB_colour_map_green mediumspringgreen    0-250-154      ;#  #00FA9A
-    dict set WEB_colour_map_green darkseagreen         143-188-143    ;#  #8FBC8F
-    dict set WEB_colour_map_green mediumaquamarine     102-205-170    ;#  #66CDAA
-    dict set WEB_colour_map_green yellowgreen          154-205-50     ;#  #9ACD32
-    dict set WEB_colour_map_green lawngreen            124-252-0      ;#  #7CFC00
-    dict set WEB_colour_map_green chartreuse           127-255-0      ;#  #7FFF00
-    dict set WEB_colour_map_green lightgreen           144-238-144    ;#  #90EE90
-    dict set WEB_colour_map_green greenyellow          173-255-47     ;#  #ADFF2F
-    dict set WEB_colour_map_green palegreen            152-251-152    ;#  #98FB98
+    tcl::dict::set WEB_colour_map_green darkgreen            0-100-0        ;#  #006400
+    tcl::dict::set WEB_colour_map_green green                0-128-0         ;#  #008000
+    tcl::dict::set WEB_colour_map_green darkolivegreen       85-107-47      ;#  #55682F
+    tcl::dict::set WEB_colour_map_green forestgreen          34-139-34      ;#  #228B22
+    tcl::dict::set WEB_colour_map_green seagreen             46-139-87      ;#  #2E8B57
+    tcl::dict::set WEB_colour_map_green olive                128-128-0       ;#  #808000
+    tcl::dict::set WEB_colour_map_green olivedrab            107-142-35     ;#  #6B8E23
+    tcl::dict::set WEB_colour_map_green mediumseagreen       60-179-113     ;#  #3CB371
+    tcl::dict::set WEB_colour_map_green limegreen            50-205-50      ;#  #32CD32
+    tcl::dict::set WEB_colour_map_green lime                 0-255-0         ;#  #00FF00
+    tcl::dict::set WEB_colour_map_green springgreen          0-255-127      ;#  #00FF7F
+    tcl::dict::set WEB_colour_map_green mediumspringgreen    0-250-154      ;#  #00FA9A
+    tcl::dict::set WEB_colour_map_green darkseagreen         143-188-143    ;#  #8FBC8F
+    tcl::dict::set WEB_colour_map_green mediumaquamarine     102-205-170    ;#  #66CDAA
+    tcl::dict::set WEB_colour_map_green yellowgreen          154-205-50     ;#  #9ACD32
+    tcl::dict::set WEB_colour_map_green lawngreen            124-252-0      ;#  #7CFC00
+    tcl::dict::set WEB_colour_map_green chartreuse           127-255-0      ;#  #7FFF00
+    tcl::dict::set WEB_colour_map_green lightgreen           144-238-144    ;#  #90EE90
+    tcl::dict::set WEB_colour_map_green greenyellow          173-255-47     ;#  #ADFF2F
+    tcl::dict::set WEB_colour_map_green palegreen            152-251-152    ;#  #98FB98
     # -- --- --- 
     #White colours
     variable WEB_colour_map_white
-    dict set WEB_colour_map_white mistyrose            255-228-225    ;#  #FFE4E1
-    dict set WEB_colour_map_white antiquewhite         250-235-215    ;#  #FAEBD7
-    dict set WEB_colour_map_white linen                250-240-230    ;#  #FAF0E6
-    dict set WEB_colour_map_white beige                245-245-220    ;#  #F5F5DC
-    dict set WEB_colour_map_white whitesmoke           245-245-245    ;#  #F5F5F5
-    dict set WEB_colour_map_white lavenderblush        255-240-245    ;#  #FFF0F5
-    dict set WEB_colour_map_white oldlace              253-245-230    ;#  #FDF5E6
-    dict set WEB_colour_map_white aliceblue            240-248-255    ;#  #F0F8FF
-    dict set WEB_colour_map_white seashell             255-245-238    ;#  #FFF5EE
-    dict set WEB_colour_map_white ghostwhite           248-248-255    ;#  #F8F8FF
-    dict set WEB_colour_map_white honeydew             240-255-240    ;#  #F0FFF0
-    dict set WEB_colour_map_white floralwhite          255-250-240    ;#  #FFFAF0
-    dict set WEB_colour_map_white azure                240-255-255    ;#  #F0FFFF
-    dict set WEB_colour_map_white mintcream            245-255-250    ;#  #F5FFFA
-    dict set WEB_colour_map_white snow                 255-250-250    ;#  #FFFAFA
-    dict set WEB_colour_map_white ivory                255-255-240    ;#  #FFFFF0
-    dict set WEB_colour_map_white white                255-255-255     ;#  #FFFFFF
+    tcl::dict::set WEB_colour_map_white mistyrose            255-228-225    ;#  #FFE4E1
+    tcl::dict::set WEB_colour_map_white antiquewhite         250-235-215    ;#  #FAEBD7
+    tcl::dict::set WEB_colour_map_white linen                250-240-230    ;#  #FAF0E6
+    tcl::dict::set WEB_colour_map_white beige                245-245-220    ;#  #F5F5DC
+    tcl::dict::set WEB_colour_map_white whitesmoke           245-245-245    ;#  #F5F5F5
+    tcl::dict::set WEB_colour_map_white lavenderblush        255-240-245    ;#  #FFF0F5
+    tcl::dict::set WEB_colour_map_white oldlace              253-245-230    ;#  #FDF5E6
+    tcl::dict::set WEB_colour_map_white aliceblue            240-248-255    ;#  #F0F8FF
+    tcl::dict::set WEB_colour_map_white seashell             255-245-238    ;#  #FFF5EE
+    tcl::dict::set WEB_colour_map_white ghostwhite           248-248-255    ;#  #F8F8FF
+    tcl::dict::set WEB_colour_map_white honeydew             240-255-240    ;#  #F0FFF0
+    tcl::dict::set WEB_colour_map_white floralwhite          255-250-240    ;#  #FFFAF0
+    tcl::dict::set WEB_colour_map_white azure                240-255-255    ;#  #F0FFFF
+    tcl::dict::set WEB_colour_map_white mintcream            245-255-250    ;#  #F5FFFA
+    tcl::dict::set WEB_colour_map_white snow                 255-250-250    ;#  #FFFAFA
+    tcl::dict::set WEB_colour_map_white ivory                255-255-240    ;#  #FFFFF0
+    tcl::dict::set WEB_colour_map_white white                255-255-255     ;#  #FFFFFF
     # -- --- --- 
     #Gray and black colours
     variable WEB_colour_map_gray
-    dict set WEB_colour_map_gray black                0-0-0           ;#  #000000
-    dict set WEB_colour_map_gray darkslategray        47-79-79       ;#  #2F4F4F
-    dict set WEB_colour_map_gray dimgray              105-105-105    ;#  #696969
-    dict set WEB_colour_map_gray slategray            112-128-144    ;#  #708090
-    dict set WEB_colour_map_gray gray                 128-128-128     ;#  #808080
-    dict set WEB_colour_map_gray lightslategray       119-136-153    ;#  #778899
-    dict set WEB_colour_map_gray darkgray             169-169-169    ;#  #A9A9A9
-    dict set WEB_colour_map_gray silver               192-192-192    ;#  #C0C0C0
-    dict set WEB_colour_map_gray lightgray            211-211-211    ;#  #D3D3D3
-    dict set WEB_colour_map_gray gainsboro            220-220-220    ;#  #DCDCDC
-
-    set WEB_colour_map [dict merge\
+    tcl::dict::set WEB_colour_map_gray black                0-0-0           ;#  #000000
+    tcl::dict::set WEB_colour_map_gray darkslategray        47-79-79       ;#  #2F4F4F
+    tcl::dict::set WEB_colour_map_gray dimgray              105-105-105    ;#  #696969
+    tcl::dict::set WEB_colour_map_gray slategray            112-128-144    ;#  #708090
+    tcl::dict::set WEB_colour_map_gray gray                 128-128-128     ;#  #808080
+    tcl::dict::set WEB_colour_map_gray lightslategray       119-136-153    ;#  #778899
+    tcl::dict::set WEB_colour_map_gray darkgray             169-169-169    ;#  #A9A9A9
+    tcl::dict::set WEB_colour_map_gray silver               192-192-192    ;#  #C0C0C0
+    tcl::dict::set WEB_colour_map_gray lightgray            211-211-211    ;#  #D3D3D3
+    tcl::dict::set WEB_colour_map_gray gainsboro            220-220-220    ;#  #DCDCDC
+
+    set WEB_colour_map [tcl::dict::merge\
         $WEB_colour_map_basic\
         $WEB_colour_map_pink\
         $WEB_colour_map_red\
@@ -1081,13 +1066,13 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
 
     #we should be able to use WEB_colour_map as a base and override only the conflicts for X11 colours  ? Review - check if this is true
     variable X11_colour_map_diff ;#maintain the difference as a separate dict so we can display in a? x11
-    dict set X11_colour_map_diff gray        190-190-190     ;#  #BEBEBE
-    dict set X11_colour_map_diff green       0-255-0         ;#  #00FF00
-    dict set X11_colour_map_diff maroon      176-48-96       ;#  #B03060
-    dict set X11_colour_map_diff purple      160-32-240      ;#  #A020F0
+    tcl::dict::set X11_colour_map_diff gray        190-190-190     ;#  #BEBEBE
+    tcl::dict::set X11_colour_map_diff green       0-255-0         ;#  #00FF00
+    tcl::dict::set X11_colour_map_diff maroon      176-48-96       ;#  #B03060
+    tcl::dict::set X11_colour_map_diff purple      160-32-240      ;#  #A020F0
 
     variable X11_colour_map
-    set X11_colour_map [dict merge $WEB_colour_map $X11_colour_map_diff]
+    set X11_colour_map [tcl::dict::merge $WEB_colour_map $X11_colour_map_diff]
 
 
     #Xterm colour names (256 colours)
@@ -1369,21 +1354,21 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         grey93\
     ]
     variable TERM_colour_map
-    set TERM_colour_map [dict create]
+    set TERM_colour_map [tcl::dict::create]
     variable TERM_colour_map_reverse
-    set TERM_colour_map_reverse [dict create]
+    set TERM_colour_map_reverse [tcl::dict::create]
     set cidx 0
     foreach cname $xterm_names {
-        if {![dict exists $TERM_colour_map $cname]} {
-            dict set TERM_colour_map $cname $cidx
-            dict set TERM_colour_map_reverse $cidx $cname
+        if {![tcl::dict::exists $TERM_colour_map $cname]} {
+            tcl::dict::set TERM_colour_map $cname $cidx
+            tcl::dict::set TERM_colour_map_reverse $cidx $cname
         } else {
             set did_rename 0
             #start suffixes at '-b'. The base name could be considered the '-a' version - but we don't create it.
             foreach {suffix} {b c} {
-                if {![dict exists $TERM_colour_map $cname-$suffix]} {
-                    dict set TERM_colour_map $cname-$suffix $cidx
-                    dict set TERM_colour_map_reverse $cidx $cname-$suffix
+                if {![tcl::dict::exists $TERM_colour_map $cname-$suffix]} {
+                    tcl::dict::set TERM_colour_map $cname-$suffix $cidx
+                    tcl::dict::set TERM_colour_map_reverse $cidx $cname-$suffix
                     set did_rename 1
                     break
                 }
@@ -1405,7 +1390,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     #dict for {k v} $WEB_colour_map {
     #    set dectriple [split $v -]
     #    set webhex [::join [format %02X%02X%02X {*}$dectriple] ;# e.g 808080, FFFFFF, 000000
-    #    dict set HEX_colour_map $webhex  [join $dectriple {;}]
+    #    tcl::dict::set HEX_colour_map $webhex  [join $dectriple {;}]
     #}
     proc colour_hex2ansidec {hex6} {
         return [join [::scan $hex6 %2X%2X%2X] {;}]
@@ -1415,11 +1400,11 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     # eg dec-dec-dec <-> #HHHHHH
     #allow  hex to be specified with or without leading #
     proc colour_hex2dec {hex6} {
-        set hex6 [string map [list # ""] $hex6]
+        set hex6 [tcl::string::map {# ""} $hex6]
         return [join [::scan $hex6 %2X%2X%2X] {-}]
     }
     proc colour_dec2hex {decimalcolourstring} {
-        set dec [string map [list {;} - , -] $decimalcolourstring]
+        set dec [tcl::string::map [list {;} - , -] $decimalcolourstring]
         set declist [split $dec -]
         set hex #[format %02X%02X%02X {*}$declist]
     }
@@ -1434,19 +1419,19 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         foreach {k v} $args {
             switch -- $k {
                 -bg - -forcecolour {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "colourmap1 unrecognised option $k. Known-options: [dict keys $opts]
+                    error "colourmap1 unrecognised option $k. Known-options: [tcl::dict::keys $opts]
                 }
             }
         }
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         } else {
             set fc ""
         }
-        set bgname [dict get $opts -bg]
+        set bgname [tcl::dict::get $opts -bg]
 
         package require textblock
         set bg [textblock::block 33 3 "[a+ {*}$fc $bgname] [a]"]
@@ -1461,12 +1446,12 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     }
     proc colourmap2 {args} {
         set defaults {-forcecolour 0 -bg Web-white}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
-        set bgname [dict get $opts -bg]
+        set bgname [tcl::dict::get $opts -bg]
 
         package require textblock
         set bg [textblock::block 39 3 "[a+ {*}$fc $bgname] [a]"]
@@ -1485,9 +1470,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     }
     proc colourtable_216 {args} {
         set defaults {-forcecolour 0}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
         package require textblock
@@ -1504,7 +1489,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
             lappend clist "[a+ {*}$fc {*}$fg Term$i][format %3s $i]"
         }
 
-        set t [textblock::list_as_table 36 $clist -return object]
+        set t [textblock::list_as_table -columns 36 -return tableobject $clist]
         $t configure -show_hseps 0
         #return [$t print]
         return $t
@@ -1513,9 +1498,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     #1st 16 colours of 256 - match SGR colours
     proc colourblock_16 {args} {
         set defaults {-forcecolour 0}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
         set out ""
@@ -1531,9 +1516,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     }
     proc colourtable_16_names {args} {
         set defaults {-forcecolour 0}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
         variable TERM_colour_map_reverse 
@@ -1543,7 +1528,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         set t [textblock::class::table new]
         $t configure -show_seps 0 -show_edge 0
         for {set i 0} {$i <=15} {incr i} {
-            set cname [dict get $TERM_colour_map_reverse $i] ;#use term-$i etc instead of term-$name? 
+            set cname [tcl::dict::get $TERM_colour_map_reverse $i] ;#use term-$i etc instead of term-$name? 
             if {[llength $row]== 8} {
                 lappend rows $row
                 set row [list]
@@ -1563,15 +1548,15 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         append out [$t print]
         $t destroy
         append out [a]
-        return [string trimleft $out \n]
+        return [tcl::string::trimleft $out \n]
 
     }
     #216 colours of 256
     proc colourblock_216 {args} {
         set defaults {-forcecolour 0}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
         set out ""
@@ -1590,18 +1575,18 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
             append out "$br[a+ {*}$fc {*}$fg Term$i][format %3s $i] "
         }
         append out [a]
-        return [string trimleft $out \n]
+        return [tcl::string::trimleft $out \n]
     }
 
     #x6 is reasonable from a width (124 screen cols) and colour viewing perspective
     proc colourtable_216_names {args} {
         set defaults {-forcecolour 0 -columns 6}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
-        set cols [dict get $opts -columns]
+        set cols [tcl::dict::get $opts -columns]
 
         set out ""
         #use the reverse lookup dict - the original xterm_names list has duplicates - we want the disambiguated (potentially suffixed) names
@@ -1612,7 +1597,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         set t [textblock::class::table new]
         $t configure -show_seps 0 -show_edge 0
         for {set i 16} {$i <=231} {incr i} {
-            set cname [dict get $TERM_colour_map_reverse $i] ;#use term-cname etc instead of term$i - may as well let a+ cache the call by name as the preferred? option
+            set cname [tcl::dict::get $TERM_colour_map_reverse $i] ;#use term-cname etc instead of term$i - may as well let a+ cache the call by name as the preferred? option
             if {[llength $row]== $cols} {
                 lappend rows $row
                 set row [list]
@@ -1633,13 +1618,13 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         append out [$t print]
         $t destroy
         append out [a]
-        return [string trimleft $out \n]
+        return [tcl::string::trimleft $out \n]
     }
     proc colourtable_term_pastel {args} {
         set defaults {-forcecolour 0}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
         set out ""
@@ -1688,9 +1673,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     }
     proc colourtable_term_rainbow {args} {
         set defaults {-forcecolour 0}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
         set out ""
@@ -1756,9 +1741,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     #24 greys of 256
     proc colourblock_24 {args} {
         set defaults {-forcecolour 0}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
 
@@ -1775,9 +1760,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     }
     proc colourtable_24_names {args} {
         set defaults {-forcecolour 0}
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
 
@@ -1788,7 +1773,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         set t [textblock::class::table new]
         $t configure -show_hseps 0 -show_edge 0
         for {set i 232} {$i <=255} {incr i} {
-            set cname [dict get $TERM_colour_map_reverse $i] ;#use term-cname etc instead of term$i - may as well let a+ cache the call by name as the preferred? option
+            set cname [tcl::dict::get $TERM_colour_map_reverse $i] ;#use term-cname etc instead of term$i - may as well let a+ cache the call by name as the preferred? option
             if {[llength $row]== 8} {
                 lappend rows $row
                 set row [list]
@@ -1805,10 +1790,10 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         append out [$t print]
         $t destroy
         append out [a]
-        return [string trimleft $out \n]
+        return [tcl::string::trimleft $out \n]
 
     }
-    #set WEB_colour_map [dict merge\
+    #set WEB_colour_map [tcl::dict::merge\
     #    $WEB_colour_map_basic\
     #    $WEB_colour_map_pink\
     #    $WEB_colour_map_red\
@@ -1827,18 +1812,18 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         foreach {k v} $args {
             switch -- $k {
                 -groups - -forcecolour {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "colourtable_web unrecognised option '$k'. Known-options: [dict keys $defaults]"
+                    error "colourtable_web unrecognised option '$k'. Known-options: [tcl::dict::keys $defaults]"
                 }
             }
         }
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
-        set groups [dict get $opts -groups]
+        set groups [tcl::dict::get $opts -groups]
 
         #set all_groupnames [list basic pink red orange yellow brown purple blue cyan green white gray]
         set all_groupnames [list basic brown yellow red pink orange purple blue cyan green white gray]
@@ -1875,7 +1860,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
             variable WEB_colour_map_$g
             set t [textblock::class::table new]
             $t configure -show_edge 0 -show_seps 0 -show_header 1
-            dict for {cname cdec} [set WEB_colour_map_$g] {
+            tcl::dict::for {cname cdec} [set WEB_colour_map_$g] {
                 $t add_row [list "$cname " "[colour_dec2hex $cdec] " $cdec]
                 if {$cname in $white_fg_list} {
                     set fg "web-white"
@@ -1886,14 +1871,14 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 $t configure_row [expr {[$t row_count]-1}] -ansibase [a+ {*}$fc $fg Web-$cname]
             }
             $t configure -frametype {} 
-            $t configure_column 0 -headers [list "[string totitle $g] colours"]
+            $t configure_column 0 -headers [list "[tcl::string::totitle $g] colours"]
             $t configure_column 0 -header_colspans [list all]
             $t configure -ansibase_header [a+ {*}$fc web-black Web-white]
             lappend grouptables [$t print]
             $t destroy
         }
         #set displaytable [textblock::class::table new]
-        set displaytable [textblock::list_as_table 3 $grouptables -return object]
+        set displaytable [textblock::list_as_table -columns 3 -return tableobject $grouptables]
         $displaytable configure -show_header 0 -show_vseps 0
         #return $displaytable
         set result [$displaytable print]
@@ -1903,22 +1888,22 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     proc colourtable_x11diff {args} {
         variable X11_colour_map_diff
         variable WEB_colour_map
-        set opts [dict create\
+        set opts [tcl::dict::create\
             -forcecolour 0\
             -return "string"\
         ]
         foreach {k v} $args {
             switch -- $k {
                 -return - -forcecolour {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "colourtable_x11diff unrecognised option '$k'. Known options [dict keys $opts]"
+                    error "colourtable_x11diff unrecognised option '$k'. Known options [tcl::dict::keys $opts]"
                 }
             }
         }
         set fc ""
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc "forcecolour"
         }
 
@@ -1927,7 +1912,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         # -- --- ---
         set t [textblock::class::table new]
         $t configure -show_edge 0 -show_seps 0 -show_header 1
-        dict for {cname cdec} [set X11_colour_map_diff] {
+        tcl::dict::for {cname cdec} [set X11_colour_map_diff] {
             $t add_row [list "$cname " "[colour_dec2hex $cdec] " $cdec]
             set fg "web-white"
             $t configure_row [expr {[$t row_count]-1}] -ansibase [a+ {*}$fc $fg X11-$cname]
@@ -1940,15 +1925,15 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         $t destroy
         # -- --- ---
 
-        set WEB_map_subset [dict create]
-        dict for {k v} $X11_colour_map_diff {
-            dict set WEB_map_subset $k [dict get $WEB_colour_map $k]
+        set WEB_map_subset [tcl::dict::create]
+        tcl::dict::for {k v} $X11_colour_map_diff {
+            tcl::dict::set WEB_map_subset $k [tcl::dict::get $WEB_colour_map $k]
         }
 
         # -- --- ---
         set t [textblock::class::table new]
         $t configure -show_edge 0 -show_seps 0 -show_header 1
-        dict for {cname cdec} [set WEB_map_subset] {
+        tcl::dict::for {cname cdec} [set WEB_map_subset] {
             $t add_row [list "$cname " "[colour_dec2hex $cdec] " $cdec]
             set fg "web-white"
             $t configure_row [expr {[$t row_count]-1}] -ansibase [a+ {*}$fc $fg Web-$cname]
@@ -1961,10 +1946,10 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         $t destroy
         # -- --- ---
 
-        set displaytable [textblock::list_as_table 2 $comparetables -return object]
+        set displaytable [textblock::list_as_table -columns 2 -return tableobject $comparetables]
         $displaytable configure -show_header 0 -show_vseps 0
 
-        if {[dict get $opts -return] eq "string"} {
+        if {[tcl::dict::get $opts -return] eq "string"} {
             set result [$displaytable print]
             $displaytable destroy
             return $result
@@ -2006,7 +1991,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
             append out "[a+ {*}$fc web-white]Standard SGR colours and attributes $RST" \n
             set settings_applied $SGR_setting_map 
             set strmap [list]
-            dict for {k v} $SGR_setting_map {
+            #safe jumptable test
+            #dict for {k v} $SGR_setting_map {}
+            tcl::dict::for {k v} $SGR_setting_map {
                 switch -- $k {
                     bold - dim - italic - doubleunderline - blink - fastblink - strike - overline - framecircle {
                         lappend strmap " $k " " [a+ $k]$k$RST "
@@ -2021,20 +2008,20 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                     }
                 }
             }
-            set settings_applied [string trim $SGR_setting_map \n]
+            set settings_applied [tcl::string::trim $SGR_setting_map \n]
             try {
                 package require overtype ;# circular dependency - many components require overtype. Here we only need it for nice layout in the a? query proc - so we'll do a soft-dependency by only loading when needed and also wrapping in a try
                 package require textblock
 
-                append out  [textblock::join $indent [string map $strmap $settings_applied]] \n 
-                append out  [textblock::join $indent [string trim $SGR_colour_map \n]] \n
+                append out  [textblock::join $indent [tcl::string::map $strmap $settings_applied]] \n 
+                append out  [textblock::join $indent [tcl::string::trim $SGR_colour_map \n]] \n
                 append out  [textblock::join $indent "Example: \[a+ bold red White underline\]text\[a] -> [a+ bold red White underline]text[a]"] \n \n
                 set bgname "Web-white"
                 set map1 [colourmap1 -bg $bgname -forcecolour $opt_forcecolour]
                 set map1 [overtype::centre -transparent 1 $map1 "[a {*}$fc black $bgname]Standard colours[a]"]
                 set map2 [colourmap2 -bg $bgname -forcecolour $opt_forcecolour]
                 set map2 [overtype::centre -transparent 1 $map2 "[a {*}$fc black $bgname]High-intensity colours[a]"]
-                append out  [textblock::join $indent [textblock::join $map1 $map2]] \n
+                append out  [textblock::join $indent [textblock::join -- $map1 $map2]] \n
                 append out "[a+ {*}$fc web-white]216 colours of 256 terminal colours (To see names, use: a? term ?pastel? ?rainbow?)[a]" \n
                 append out  [textblock::join $indent [colourblock_216 -forcecolour $opt_forcecolour]] \n
                 append out "[a+ {*}$fc web-white]24 Greyscale colours[a]" \n
@@ -2045,7 +2032,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 append out  [textblock::join $indent "Example: \[a+ term-lightsteelblue Term-gold1\]text\[a] -> [a+ {*}$fc term-lightsteelblue Term-gold1]text[a]"] \n
                 append out \n
                 append out "[a+ {*}$fc web-white]16 Million colours[a]" \n
-                #dict set WEB_colour_map mediumvioletred      199-21-133     ;#  #C71585
+                #tcl::dict::set WEB_colour_map mediumvioletred      199-21-133     ;#  #C71585
                 append out  [textblock::join $indent "Example: \[a+ rgb-199-21-133\]text\[a] -> [a+ {*}$fc rgb-199-21-133]text[a]"] \n
                 append out  [textblock::join $indent "Example: \[a+ Rgb#C71585\]text\[a] -> [a+ {*}$fc Rgb#C71585]text[a]"] \n
                 append out  [textblock::join $indent "Examine a sequence: a? bold rgb-46-139-87 Rgb#C71585 "] \n
@@ -2060,7 +2047,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 append out "[a+ {*}$fc web-white]X11 colours[a] - mostly match Web colours" \n
                 append out  [textblock::join $indent "To see differences: a? x11"] \n
 
-                if {[info exists ::punk::console::colour_disabled] && $::punk::console::colour_disabled} {
+                if {[tcl::info::exists ::punk::console::colour_disabled] && $::punk::console::colour_disabled} {
                     append out \n
                     if {$fc ne ""} {
                         append out  "[a+ {*}$fc web-white]Colour is currently disabled - returning with colour anyway because 'forcecolour' argument was supplied[a]" \n
@@ -2130,13 +2117,13 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
 
             set resultlist [list]
             foreach i $args {
-                set f4 [string range $i 0 3]
+                set f4 [tcl::string::range $i 0 3]
                 set s [a+ {*}$fc $i]sample
                 switch -- $f4 {
                     web- - Web- - WEB- {
-                        set tail [string tolower [string trim [string range $i 4 end] -]]
-                        if {[dict exists $WEB_colour_map $tail]} {
-                            set dec [dict get $WEB_colour_map $tail]
+                        set tail [tcl::string::tolower [tcl::string::trim [tcl::string::range $i 4 end] -]]
+                        if {[tcl::dict::exists $WEB_colour_map $tail]} {
+                            set dec [tcl::dict::get $WEB_colour_map $tail]
                             set hex [colour_dec2hex $dec]
                             set descr "$hex $dec"
                         } else {
@@ -2145,17 +2132,17 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                         $t add_row [list $i $descr $s [ansistring VIEW $s]]
                     }
                     term - Term - undt {
-                        set tail [string trim [string range $i 4 end] -]
-                        if {[string is integer -strict $tail]} {
+                        set tail [tcl::string::trim [tcl::string::range $i 4 end] -]
+                        if {[tcl::string::is integer -strict $tail]} {
                             if {$tail < 256} {
-                                set descr "[dict get $TERM_colour_map_reverse $tail]"
+                                set descr "[tcl::dict::get $TERM_colour_map_reverse $tail]"
                             } else {
                                 set descr "Invalid (> 255)"
                             }
                         } else {
-                            set tail [string tolower $tail]
-                            if {[dict exists $TERM_colour_map $tail]} {
-                                set descr [dict get $TERM_colour_map $tail]
+                            set tail [tcl::string::tolower $tail]
+                            if {[tcl::dict::exists $TERM_colour_map $tail]} {
+                                set descr [tcl::dict::get $TERM_colour_map $tail]
                             } else {
                                 set descr "UNKNOWN colour for term" 
                             }
@@ -2163,9 +2150,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                         $t add_row [list $i $descr $s [ansistring VIEW $s]]
                     }
                     x11- - X11- {
-                        set tail [string tolower [string trim [string range $i 4 end] -]]
-                        if {[dict exists $X11_colour_map $tail]} {
-                            set dec [dict get $X11_colour_map $tail]
+                        set tail [tcl::string::tolower [tcl::string::trim [tcl::string::range $i 4 end] -]]
+                        if {[tcl::dict::exists $X11_colour_map $tail]} {
+                            set dec [tcl::dict::get $X11_colour_map $tail]
                             set hex [colour_dec2hex $dec]
                             set descr "$hex $dec"
                         } else {
@@ -2179,13 +2166,13 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                     RGB0 - RGB1 - RGB2 - RGB3 - RGB4 - RGB5 - RGB6 - RGB7 - RGB8 - RGB9 - 
                     rgb# - Rgb# - RGB# - 
                     und# - und- {
-                        if {[string index $i 3] eq "#"} {
-                            set tail [string range $i 4 end]
+                        if {[tcl::string::index $i 3] eq "#"} {
+                            set tail [tcl::string::range $i 4 end]
                             set hex $tail
                             set dec [colour_hex2dec $hex]
                             set info $dec ;#show opposite type as first line of info col
                         } else {
-                            set tail [string trim [string range $i 3 end] -]
+                            set tail [tcl::string::trim [tcl::string::range $i 3 end] -]
                             set dec $tail
                             set hex [colour_dec2hex $dec]
                             set info $hex
@@ -2226,12 +2213,12 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                         }
                     }
                     default {
-                        if {[string is integer -strict $i]} {
+                        if {[tcl::string::is integer -strict $i]} {
                             set rmap [lreverse $SGR_map]
-                            $t add_row [list $i "SGR [dict get $rmap $i]" $s [ansistring VIEW $s]]
+                            $t add_row [list $i "SGR [tcl::dict::get $rmap $i]" $s [ansistring VIEW $s]]
                         } else {
-                            if {[dict exists $SGR_map $i]} {
-                                $t add_row [list $i "SGR [dict get $SGR_map $i]" $s [ansistring VIEW $s]]
+                            if {[tcl::dict::exists $SGR_map $i]} {
+                                $t add_row [list $i "SGR [tcl::dict::get $SGR_map $i]" $s [ansistring VIEW $s]]
                             } else {
                                 $t add_row [list $i UNKNOWN $s [ansistring VIEW $s]]
                             }
@@ -2247,7 +2234,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
             #lappend resultlist "RESULT: [a+ {*}$args]sample[a]"
             $t add_row [list RESULT "" $s [ansistring VIEW $s]]
             if {$ansi ne $merged} {
-                if {[string length $merged] < [string length $ansi]} {
+                if {[tcl::string::length $merged] < [tcl::string::length $ansi]} {
                     #only refer to redundancies if shorter - merge may reorder - REVIEW
                     set warning "[a+ web-red Web-yellow]REDUNDANCIES FOUND"
                 } else {
@@ -2271,7 +2258,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     # On wezterm - we can get cells changing colour as we scroll after a pallette change - so something appears to be caching colours
 
     variable sgr_cache
-    set sgr_cache [dict create]
+    set sgr_cache [tcl::dict::create]
 
     #sgr_cache clear called by punk::console::ansi when set to off
     proc sgr_cache {{action ""}} {
@@ -2280,11 +2267,11 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
             error "sgr_cache action '$action' not understood. Valid actions: clear"
         }
         if {$action eq "clear"} {
-            set sgr_cache [dict create]
+            set sgr_cache [tcl::dict::create]
             return "sgr_cache cleared"
         }
         if {[catch {
-            set termwidth [dict get [punk::console::get_size] columns]
+            set termwidth [tcl::dict::get [punk::console::get_size] columns]
         } errM]} {
             set termwidth 80
         }
@@ -2295,8 +2282,8 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         set lines [list]
         set line ""
         #todo - terminal width? table?
-        dict for {key ansi} $sgr_cache {
-            set thislen [expr {[string length $key]+1}]
+        tcl::dict::for {key ansi} $sgr_cache {
+            set thislen [expr {[tcl::string::length $key]+1}]
             if {$linelen + $thislen >= $termwidth-1} {
                 lappend lines $line
                 set line "$ansi$key$RST "
@@ -2306,7 +2293,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 incr linelen $thislen 
             }
         }
-        if {[string length $line]} {
+        if {[tcl::string::length $line]} {
             lappend lines $line
         }
         return [join $lines \n] 
@@ -2325,8 +2312,8 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         #function name part of cache-key because a and a+ return slightly different results (a has leading reset)
         variable sgr_cache
         set cache_key a+$args ;#ensure cache_key static - we may remove for example 'forcecolour' from args - but it needs to remain part of cache_key
-        if {[dict exists $sgr_cache $cache_key]} {
-            return [dict get $sgr_cache $cache_key]
+        if {[tcl::dict::exists $sgr_cache $cache_key]} {
+            return [tcl::dict::get $sgr_cache $cache_key]
         }
 
         #don't disable ansi here.
@@ -2337,7 +2324,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
 
         set colour_disabled 0
         #whatever function disables or re-enables colour should have made a call to punk::ansi::sgr_cache clear
-        if {[info exists ::punk::console::colour_disabled] && $::punk::console::colour_disabled} {
+        if {[tcl::info::exists ::punk::console::colour_disabled] && $::punk::console::colour_disabled} {
             set colour_disabled 1
         }
         #allow a mechanism to override the colour_disabled terminal preference - for code that is generating colour for something else - don't let no_color ruin everything.
@@ -2351,16 +2338,16 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         set t [list] 
         set e [list] ;#extended codes needing to go in own escape sequence
         foreach i $args {
-            set f4 [string range $i 0 3]
+            set f4 [tcl::string::range $i 0 3]
             switch -- $f4 {
                 web- {
                     #variable WEB_colour_map
                     #upvar ::punk::ansi::WEB_colour_map WEB_colour_map
                     #foreground web colour
-                    set cname [string tolower [string range $i 4 end]]
-                    if {[dict exists $WEB_colour_map $cname]} {
-                        set rgbdash [dict get $WEB_colour_map $cname] 
-                        set rgb [string map { - ;} $rgbdash]
+                    set cname [tcl::string::tolower [tcl::string::range $i 4 end]]
+                    if {[tcl::dict::exists $WEB_colour_map $cname]} {
+                        set rgbdash [tcl::dict::get $WEB_colour_map $cname] 
+                        set rgb [tcl::string::map { - ;} $rgbdash]
                         lappend t "38;2;$rgb"
                     } else {
                         puts stderr "ansi web colour unmatched: '$i' in call 'a+ $args'"
@@ -2370,9 +2357,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                     #variable WEB_colour_map
                     #upvar ::punk::ansi::WEB_colour_map WEB_colour_map
                     #background web colour
-                    set cname [string tolower [string range $i 4 end]]
-                    if {[dict exists $WEB_colour_map $cname]} {
-                        lappend t "48;2;[string map {- ;} [dict get $WEB_colour_map $cname]]"
+                    set cname [tcl::string::tolower [tcl::string::range $i 4 end]]
+                    if {[tcl::dict::exists $WEB_colour_map $cname]} {
+                        lappend t "48;2;[tcl::string::map {- ;} [tcl::dict::get $WEB_colour_map $cname]]"
                     } else {
                         puts stderr "ansi Web colour unmatched: '$i' in call 'a+ $args'"
                     }
@@ -2404,7 +2391,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                                         }
                                         underextendedoff {
                                             #lremove any existing 4:1 etc
-                                            set e [struct::set difference $e [list 4:1 4:2 4:3 4:4 4:5]]
+                                            #NOTE struct::set result order can differ depending on whether tcl/critcl imp used
+                                            #set e [struct::set difference $e [list 4:1 4:2 4:3 4:4 4:5]]
+                                            set e [punk::lib::ldiff $e [list 4:1 4:2 4:3 4:4 4:5]]
                                             lappend e 4:0
                                         }
                                         undersingle {
@@ -2510,12 +2499,12 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                     #variable TERM_colour_map
                     #256 colour foreground by Xterm name or by integer
                     #name is xterm name or colour index from 0 - 255
-                    set cc [string trim [string tolower [string range $i 4 end]] -]
-                    if {[string is integer -strict $cc] & $cc < 256} {
+                    set cc [tcl::string::trim [tcl::string::tolower [tcl::string::range $i 4 end]] -]
+                    if {[tcl::string::is integer -strict $cc] & $cc < 256} {
                         lappend t "38;5;$cc" 
                     } else {
-                        if {[dict exists $TERM_colour_map $cc]} {
-                            lappend t "38;5;[dict get $TERM_colour_map $cc]" 
+                        if {[tcl::dict::exists $TERM_colour_map $cc]} {
+                            lappend t "38;5;[tcl::dict::get $TERM_colour_map $cc]" 
                         } else {
                             puts stderr "ansi term colour unmatched: '$i' in call 'a+ $args'"
                         }
@@ -2524,12 +2513,12 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 Term - TERM {
                     #variable TERM_colour_map
                     #256 colour background by Xterm name or by integer
-                    set cc [string trim [string tolower [string range $i 4 end]] -]
-                    if {[string is integer -strict $cc] && $cc < 256} {
+                    set cc [tcl::string::trim [tcl::string::tolower [tcl::string::range $i 4 end]] -]
+                    if {[tcl::string::is integer -strict $cc] && $cc < 256} {
                         lappend t "48;5;$cc" 
                     } else {
-                        if {[dict exists $TERM_colour_map $cc]} {
-                            lappend t "48;5;[dict get $TERM_colour_map $cc]" 
+                        if {[tcl::dict::exists $TERM_colour_map $cc]} {
+                            lappend t "48;5;[tcl::dict::get $TERM_colour_map $cc]" 
                         } else {
                             puts stderr "ansi Term colour unmatched: '$i' in call 'a+ $args'"
                         }
@@ -2538,38 +2527,38 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 rgb- - rgb0 - rgb1 - rgb2 - rgb3 - rgb4 - rgb5 - rgb6 - rgb7 - rgb8 - rgb9  {
                     #decimal rgb foreground
                     #allow variants rgb-xxx-xxx-xxx and rgbxxx-xxx-xxx 
-                    set rgbspec [string trim [string range $i 3 end] -]
-                    set rgb [string map [list - {;} , {;}] $rgbspec]
+                    set rgbspec [tcl::string::trim [tcl::string::range $i 3 end] -]
+                    set rgb [tcl::string::map [list - {;} , {;}] $rgbspec]
                     lappend t "38;2;$rgb"
                 }
                 Rgb- - RGB- - Rgb0 - Rgb1 - Rgb2 - Rgb3 - Rgb4 - Rgb5 - Rgb6 - Rgb7 - Rgb8 - Rgb9 - RGB0 - RGB1 - RGB2 - RGB3 - RGB4 - RGB5 - RGB6 - RGB7 - RGB8 - RGB9 {
                     #decimal rgb background
-                    set rgbspec [string trim [string range $i 3 end] -]
-                    set rgb [string map [list - {;} , {;}] $rgbspec]
+                    set rgbspec [tcl::string::trim [tcl::string::range $i 3 end] -]
+                    set rgb [tcl::string::map [list - {;} , {;}] $rgbspec]
                     lappend t "48;2;$rgb"
                 }
                 "rgb#" {
                     #hex rgb foreground
-                    set hex6 [string trim [string range $i 4 end] -]
+                    set hex6 [tcl::string::trim [tcl::string::range $i 4 end] -]
                     set rgb [join [::scan $hex6 %2X%2X%2X] {;}]
                     lappend t "38;2;$rgb"
                 }
                 "Rgb#" - "RGB#" {
                     #hex rgb background
-                    set hex6 [string trim [string range $i 4 end] -]
+                    set hex6 [tcl::string::trim [tcl::string::range $i 4 end] -]
                     set rgb [join [::scan $hex6 %2X%2X%2X] {;}]
                     lappend t "48;2;$rgb"
                 }
                 und- - und0 - und1 - und2 - und3 - und4 - und5 - und6 - und7 - und8 - und9  {
                     #decimal rgb underline 
                     #allow variants und-xxx-xxx-xxx and undxxx-xxx-xxx 
-                    set rgbspec [string trim [string range $i 3 end] -]
-                    set rgb [string map [list - {:} , {:}] $rgbspec]
+                    set rgbspec [tcl::string::trim [tcl::string::range $i 3 end] -]
+                    set rgb [tcl::string::map [list - {:} , {:}] $rgbspec]
                     lappend e "58:2::$rgb"
                 }
                 "und#" {
                     #hex rgb underline - (e.g kitty, wezterm) - uses colons as separators 
-                    set hex6 [string trim [string range $i 4 end] -]
+                    set hex6 [tcl::string::trim [tcl::string::range $i 4 end] -]
                     set rgb [join [::scan $hex6 %2X%2X%2X] {:}]
                     lappend e "58:2::$rgb"
                 }
@@ -2577,12 +2566,12 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                     #variable TERM_colour_map
                     #256 colour underline by Xterm name or by integer
                     #name is xterm name or colour index from 0 - 255
-                    set cc [string trim [string tolower [string range $i 4 end]] -]
-                    if {[string is integer -strict $cc] & $cc < 256} {
+                    set cc [tcl::string::trim [tcl::string::tolower [tcl::string::range $i 4 end]] -]
+                    if {[tcl::string::is integer -strict $cc] & $cc < 256} {
                         lappend e "58:5:$cc" 
                     } else {
-                        if {[dict exists $TERM_colour_map $cc]} {
-                            lappend e "58:5:[dict get $TERM_colour_map $cc]" 
+                        if {[tcl::dict::exists $TERM_colour_map $cc]} {
+                            lappend e "58:5:[tcl::dict::get $TERM_colour_map $cc]" 
                         } else {
                             puts stderr "ansi term underline colour unmatched: '$i' in call 'a $args'"
                         }
@@ -2591,10 +2580,10 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 x11- {
                     variable X11_colour_map
                     #foreground X11 names
-                    set cname [string tolower [string range $i 4 end]]
-                    if {[dict exists $X11_colour_map $cname]} {
-                        set rgbdash [dict get $X11_colour_map $cname] 
-                        set rgb [string map [list - {;}] $rgbdash]
+                    set cname [tcl::string::tolower [tcl::string::range $i 4 end]]
+                    if {[tcl::dict::exists $X11_colour_map $cname]} {
+                        set rgbdash [tcl::dict::get $X11_colour_map $cname] 
+                        set rgb [tcl::string::map [list - {;}] $rgbdash]
                         lappend t "38;2;$rgb"
                     } else {
                         puts stderr "ansi x11 colour unmatched: '$i' in call 'a+ $args'"
@@ -2603,19 +2592,19 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 X11- {
                     variable X11_colour_map
                     #background X11 names
-                    set cname [string tolower [string range $i 4 end]]
-                    if {[dict exists $X11_colour_map $cname]} {
-                        set rgbdash [dict get $X11_colour_map $cname] 
-                        set rgb [string map [list - {;}] $rgbdash]
+                    set cname [tcl::string::tolower [tcl::string::range $i 4 end]]
+                    if {[tcl::dict::exists $X11_colour_map $cname]} {
+                        set rgbdash [tcl::dict::get $X11_colour_map $cname] 
+                        set rgb [tcl::string::map [list - {;}] $rgbdash]
                         lappend t "48;2;$rgb"
                     } else {
                         puts stderr "ansi X11 colour unmatched: '$i'"
                     }
                 }
                 default {
-                    if {[string is integer -strict $i] || [string first ";" $i] > 0} {
+                    if {[tcl::string::is integer -strict $i] || [tcl::string::first ";" $i] > 0} {
                         lappend t $i
-                    } elseif {[string first : $i] > 0} {
+                    } elseif {[tcl::string::first : $i] > 0} {
                         lappend e $i
                     } else {
                         puts stderr "ansi name unmatched: '$i' in call 'a+ $args' Perhaps missing prefix? e.g web- x11- term- rgb# rgb-"
@@ -2664,7 +2653,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 set result "\x1b\[[join $t {;}]m\x1b\[[join $e {;}]m"
             }
         }
-        dict set sgr_cache $cache_key $result
+        tcl::dict::set sgr_cache $cache_key $result
         return $result
     }
 
@@ -2682,8 +2671,8 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         #It's important to put the functionname in the cache-key because a and a+ return slightly different results
         variable sgr_cache
         set cache_key a_$args
-        if {[dict exists $sgr_cache $cache_key]} {
-            return [dict get $sgr_cache $cache_key]
+        if {[tcl::dict::exists $sgr_cache $cache_key]} {
+            return [tcl::dict::get $sgr_cache $cache_key]
         }
 
         #don't disable ansi here.
@@ -2693,7 +2682,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
 
         set colour_disabled 0
         #whatever function disables or re-enables colour should have made a call to punk::ansi::sgr_cache clear
-        if {[info exists ::punk::console::colour_disabled] && $::punk::console::colour_disabled} {
+        if {[tcl::info::exists ::punk::console::colour_disabled] && $::punk::console::colour_disabled} {
             set colour_disabled 1
         }
         #allow a mechanism to override the colour_disabled terminal preference - for code that is generating colour for something else - don't let no_color ruin everything.
@@ -2707,16 +2696,16 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         set t [list] 
         set e [list] ;#extended codes will suppress standard SGR colours and attributes if merged in same escape sequence
         foreach i $args {
-            set f4 [string range $i 0 3]
+            set f4 [tcl::string::range $i 0 3]
             switch -- $f4 {
                 web- {
                     #variable WEB_colour_map
                     #upvar ::punk::ansi::WEB_colour_map WEB_colour_map
                     #foreground web colour
-                    set cname [string tolower [string range $i 4 end]]
-                    if {[dict exists $WEB_colour_map $cname]} {
-                        set rgbdash [dict get $WEB_colour_map $cname] 
-                        set rgb [string map { - ;} $rgbdash]
+                    set cname [tcl::string::tolower [tcl::string::range $i 4 end]]
+                    if {[tcl::dict::exists $WEB_colour_map $cname]} {
+                        set rgbdash [tcl::dict::get $WEB_colour_map $cname] 
+                        set rgb [tcl::string::map { - ;} $rgbdash]
                         lappend t "38;2;$rgb"
                     } else {
                         puts stderr "ansi web colour unmatched: '$i' in call 'a $args'"
@@ -2726,9 +2715,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                     #variable WEB_colour_map
                     #upvar ::punk::ansi::WEB_colour_map WEB_colour_map
                     #background web colour
-                    set cname [string tolower [string range $i 4 end]]
-                    if {[dict exists $WEB_colour_map $cname]} {
-                        lappend t "48;2;[string map {- ;} [dict get $WEB_colour_map $cname]]"
+                    set cname [tcl::string::tolower [tcl::string::range $i 4 end]]
+                    if {[tcl::dict::exists $WEB_colour_map $cname]} {
+                        lappend t "48;2;[tcl::string::map {- ;} [tcl::dict::get $WEB_colour_map $cname]]"
                     } else {
                         puts stderr "ansi Web colour unmatched: '$i' in call 'a $args'"
                     }
@@ -2757,7 +2746,9 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                                         }
                                         underextendedoff {
                                             #lremove any existing 4:1 etc
-                                            set e [struct::set difference $e [list 4:1 4:2 4:3 4:4 4:5]]
+                                            #use of struct::set with critcl is fast, but will reorder e (with differences depending on tcl vs critcl)
+                                            #set e [struct::set difference $e [list 4:1 4:2 4:3 4:4 4:5]]
+                                            set e [punk::lib::ldiff $e [list 4:1 4:2 4:3 4:4 4:5]]
                                             lappend e 4:0
                                         }
                                         undersingle {
@@ -2863,12 +2854,12 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                     #variable TERM_colour_map
                     #256 colour foreground by Xterm name or by integer
                     #name is xterm name or colour index from 0 - 255
-                    set cc [string trim [string tolower [string range $i 4 end]] -]
-                    if {[string is integer -strict $cc] & $cc < 256} {
+                    set cc [tcl::string::trim [tcl::string::tolower [tcl::string::range $i 4 end]] -]
+                    if {[tcl::string::is integer -strict $cc] & $cc < 256} {
                         lappend t "38;5;$cc" 
                     } else {
-                        if {[dict exists $TERM_colour_map $cc]} {
-                            lappend t "38;5;[dict get $TERM_colour_map $cc]" 
+                        if {[tcl::dict::exists $TERM_colour_map $cc]} {
+                            lappend t "38;5;[tcl::dict::get $TERM_colour_map $cc]" 
                         } else {
                             puts stderr "ansi term colour unmatched: '$i' in call 'a $args'"
                         }
@@ -2877,12 +2868,12 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 Term - TERM {
                     #variable TERM_colour_map
                     #256 colour background by Xterm name or by integer
-                    set cc [string trim [string tolower [string range $i 4 end]] -]
-                    if {[string is integer -strict $cc] && $cc < 256} {
+                    set cc [tcl::string::trim [tcl::string::tolower [tcl::string::range $i 4 end]] -]
+                    if {[tcl::string::is integer -strict $cc] && $cc < 256} {
                         lappend t "48;5;$cc" 
                     } else {
-                        if {[dict exists $TERM_colour_map $cc]} {
-                            lappend t "48;5;[dict get $TERM_colour_map $cc]" 
+                        if {[tcl::dict::exists $TERM_colour_map $cc]} {
+                            lappend t "48;5;[tcl::dict::get $TERM_colour_map $cc]" 
                         } else {
                             puts stderr "ansi Term colour unmatched: '$i' in call 'a $args'"
                         }
@@ -2891,38 +2882,38 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 rgb- - rgb0 - rgb1 - rgb2 - rgb3 - rgb4 - rgb5 - rgb6 - rgb7 - rgb8 - rgb9  {
                     #decimal rgb foreground
                     #allow variants rgb-xxx-xxx-xxx and rgbxxx-xxx-xxx 
-                    set rgbspec [string trim [string range $i 3 end] -]
-                    set rgb [string map [list - {;} , {;}] $rgbspec]
+                    set rgbspec [tcl::string::trim [tcl::string::range $i 3 end] -]
+                    set rgb [tcl::string::map [list - {;} , {;}] $rgbspec]
                     lappend t "38;2;$rgb"
                 }
                 Rgb- - RGB- - Rgb0 - Rgb1 - Rgb2 - Rgb3 - Rgb4 - Rgb5 - Rgb6 - Rgb7 - Rgb8 - Rgb9 - RGB0 - RGB1 - RGB2 - RGB3 - RGB4 - RGB5 - RGB6 - RGB7 - RGB8 - RGB9 {
                     #decimal rgb background
-                    set rgbspec [string trim [string range $i 3 end] -]
-                    set rgb [string map [list - {;} , {;}] $rgbspec]
+                    set rgbspec [tcl::string::trim [tcl::string::range $i 3 end] -]
+                    set rgb [tcl::string::map [list - {;} , {;}] $rgbspec]
                     lappend t "48;2;$rgb"
                 }
                 "rgb#" {
                     #hex rgb foreground
-                    set hex6 [string trim [string range $i 4 end] -]
+                    set hex6 [tcl::string::trim [tcl::string::range $i 4 end] -]
                     set rgb [join [::scan $hex6 %2X%2X%2X] {;}]
                     lappend t "38;2;$rgb"
                 }
                 "Rgb#" - "RGB#" {
                     #hex rgb background
-                    set hex6 [string trim [string range $i 4 end] -]
+                    set hex6 [tcl::string::trim [tcl::string::range $i 4 end] -]
                     set rgb [join [::scan $hex6 %2X%2X%2X] {;}]
                     lappend t "48;2;$rgb"
                 }
                 und- - und0 - und1 - und2 - und3 - und4 - und5 - und6 - und7 - und8 - und9  {
                     #decimal rgb underline 
                     #allow variants und-xxx-xxx-xxx and undxxx-xxx-xxx 
-                    set rgbspec [string trim [string range $i 3 end] -]
-                    set rgb [string map [list - {:} , {:}] $rgbspec]
+                    set rgbspec [tcl::string::trim [tcl::string::range $i 3 end] -]
+                    set rgb [tcl::string::map [list - {:} , {:}] $rgbspec]
                     lappend e "58:2::$rgb"
                 }
                 "und#" {
                     #hex rgb underline - (e.g kitty, wezterm) - uses colons as separators 
-                    set hex6 [string trim [string range $i 4 end] -]
+                    set hex6 [tcl::string::trim [tcl::string::range $i 4 end] -]
                     set rgb [join [::scan $hex6 %2X%2X%2X] {:}]
                     lappend e "58:2::$rgb"
                 }
@@ -2930,12 +2921,12 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                     #variable TERM_colour_map
                     #256 colour underline by Xterm name or by integer
                     #name is xterm name or colour index from 0 - 255
-                    set cc [string trim [string tolower [string range $i 4 end]] -]
-                    if {[string is integer -strict $cc] & $cc < 256} {
+                    set cc [tcl::string::trim [tcl::string::tolower [tcl::string::range $i 4 end]] -]
+                    if {[tcl::string::is integer -strict $cc] & $cc < 256} {
                         lappend e "58:5:$cc" 
                     } else {
-                        if {[dict exists $TERM_colour_map $cc]} {
-                            lappend e "58:5:[dict get $TERM_colour_map $cc]" 
+                        if {[tcl::dict::exists $TERM_colour_map $cc]} {
+                            lappend e "58:5:[tcl::dict::get $TERM_colour_map $cc]" 
                         } else {
                             puts stderr "ansi term underline colour unmatched: '$i' in call 'a $args'"
                         }
@@ -2944,10 +2935,10 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 x11- {
                     variable X11_colour_map
                     #foreground X11 names
-                    set cname [string tolower [string range $i 4 end]]
-                    if {[dict exists $X11_colour_map $cname]} {
-                        set rgbdash [dict get $X11_colour_map $cname] 
-                        set rgb [string map [list - {;}] $rgbdash]
+                    set cname [tcl::string::tolower [tcl::string::range $i 4 end]]
+                    if {[tcl::dict::exists $X11_colour_map $cname]} {
+                        set rgbdash [tcl::dict::get $X11_colour_map $cname] 
+                        set rgb [tcl::string::map [list - {;}] $rgbdash]
                         lappend t "38;2;$rgb"
                     } else {
                         puts stderr "ansi x11 colour unmatched: '$i'"
@@ -2956,19 +2947,19 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
                 X11- {
                     variable X11_colour_map
                     #background X11 names
-                    set cname [string tolower [string range $i 4 end]]
-                    if {[dict exists $X11_colour_map $cname]} {
-                        set rgbdash [dict get $X11_colour_map $cname] 
-                        set rgb [string map [list - {;}] $rgbdash]
+                    set cname [tcl::string::tolower [tcl::string::range $i 4 end]]
+                    if {[tcl::dict::exists $X11_colour_map $cname]} {
+                        set rgbdash [tcl::dict::get $X11_colour_map $cname] 
+                        set rgb [tcl::string::map [list - {;}] $rgbdash]
                         lappend t "48;2;$rgb"
                     } else {
                         puts stderr "ansi X11 colour unmatched: '$i'"
                     }
                 }
                 default {
-                    if {[string is integer -strict $i] || [string first ";" $i] > 0} {
+                    if {[tcl::string::is integer -strict $i] || [tcl::string::first ";" $i] > 0} {
                         lappend t $i
-                    } elseif {[string first : $i] > 0} {
+                    } elseif {[tcl::string::first : $i] > 0} {
                         lappend e $i
                     } else {
                         puts stderr "ansi name unmatched: '$i' in call 'a $args' Perhaps missing prefix? e.g web- x11- term- rgb# rgb-"
@@ -3008,7 +2999,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         } else {
             set result "\x1b\[[join $t {;}]m\x1b\[[join $e {;}]m"
         }
-        dict set sgr_cache $cache_key $result
+        tcl::dict::set sgr_cache $cache_key $result
         return $result
     }
 
@@ -3028,7 +3019,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         set res [list]
         foreach i [split $code ";"] {
             set ix [lsearch -exact $SGR_map $i]
-            if {[string is digit -strict $code]} {
+            if {[tcl::string::is digit -strict $code]} {
                 if {$ix>-1} {lappend res [lindex $SGR_map [incr ix -1]]}
             } else {
                 #reverse lookup code from name
@@ -3380,7 +3371,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     #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} {
         #string last faster than string first for long strings anyway
-        if {[string last \n $line] >= 0} {
+        if {[tcl::string::last \n $line] >= 0} {
             error "line_print_length must not contain newline characters"
         }
         #what if line has \v (vertical tab) ie more than one logical screen line?
@@ -3406,8 +3397,8 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         #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
-        if {[string last \t $line] >= 0} {
-            if {[info exists punk::console::tabwidth]} {
+        if {[tcl::string::last \t $line] >= 0} {
+            if {[tcl::info::exists punk::console::tabwidth]} {
                 set tw $::punk::console::tabwidth
             } else {
                 set tw 8
@@ -3420,8 +3411,8 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         #This means for example that abc\b  has a length of 3. Trailing or leading backslashes have no effect
 
         #set bs [format %c 0x08]
-        #set line [string map [list "\r\b" "\r"] $line] ;#backsp following a \r will have no effect
-        set line [string trim $line \b] ;#take off at start and tail only
+        #set line [tcl::string::map [list "\r\b" "\r"] $line] ;#backsp following a \r will have no effect
+        set line [tcl::string::trim $line \b] ;#take off at start and tail only
 
         #counterintuitively "x\b" still shows the x ie length is still one. The backspace just moves the position. There must be a char following \b for it to affect the length.
         #(we are not interested in the destructive backspace case present in editors,terminals etc - that is a different context)
@@ -3489,7 +3480,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
 
         set currPos 0
         while { 1 } {
-        set currPos [string first \t $line $currPos]
+        set currPos [tcl::string::first \t $line $currPos]
         if { $currPos == -1 } {
             # no more tabs
             break
@@ -3498,7 +3489,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
         # 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 line [tcl::string::replace $line $currPos $currPos $Spaces($dist)]
 
         # set up for next round (not absolutely necessary but maybe a trifle
         # more efficient)
@@ -3513,7 +3504,7 @@ Brightblack 100   Brightred 101   Brightgreen 102   Brightyellow 103   Brightblu
     #[list_end] [comment {--- end definitions namespace punk::ansi ---}]
 }
 
-namespace eval punk::ansi {
+tcl::namespace::eval punk::ansi {
 
 
     # -- --- --- --- --- ---
@@ -3546,7 +3537,7 @@ namespace eval punk::ansi {
         set payload [join $hexkeys ";"]
         return "\u0090+q$payload\u009c"
     }
-    namespace eval codetype {
+    tcl::namespace::eval codetype {
         #*** !doctools
         #[subsection {Namespace punk::ansi::codetype}]
         #[para] API functions for punk::ansi::codetype
@@ -3569,9 +3560,9 @@ namespace eval punk::ansi {
             if {[regexp {\033\[[0-9]*(:?C|D|G)$} $code]} {
                 return 1
             }
-            if {[string is integer -strict $knownline]} {
+            if {[tcl::string::is integer -strict $knownline]} {
                 #CSI n : m H where row n happens to be current line - review/test
-                set re [string map [list %n% $knownline] {\x1b\[%n%:[0-9]*H$}]
+                set re [tcl::string::map [list %n% $knownline] {\x1b\[%n%:[0-9]*H$}]
                 if {[regexp $re $code]} {
                     return 1
                 }
@@ -3607,7 +3598,7 @@ namespace eval punk::ansi {
             if {[regexp {^\033\[([^m]*)m} $code _match params]} {
                 #must match trailing m to be the type of reset we're looking for
                 set plist [split $params ";"]
-                if {[string trim [lindex $plist 0] 0] eq ""} {
+                if {[tcl::string::trim [lindex $plist 0] 0] eq ""} {
                     #e.g \033\[m  \033\[0\;...m  \033\[0000...m
                     return 1
                 } else {
@@ -3636,50 +3627,50 @@ namespace eval punk::ansi {
         #This is not order-preserving if non-sgr codes are present as they are tacked on to the end even if they initially were before all SGR codes
 
         variable codestate_empty
-        set codestate_empty [dict create]
-        dict set codestate_empty rst ""        ;#0 (or empty)
-        dict set codestate_empty intensity ""  ;#1 bold, 2 dim, 22 normal
-        dict set codestate_empty italic ""     ;#3 on 23 off
-        dict set codestate_empty underline ""  ;#4 on 24 off 
+        set codestate_empty [tcl::dict::create]
+        tcl::dict::set codestate_empty rst ""        ;#0 (or empty)
+        tcl::dict::set codestate_empty intensity ""  ;#1 bold, 2 dim, 22 normal
+        tcl::dict::set codestate_empty italic ""     ;#3 on 23 off
+        tcl::dict::set codestate_empty underline ""  ;#4 on 24 off 
 
         #nonstandard/extended 4:0,4:1,4:2,4:3,4:4,4:5
         #4:1 single underline and 4:2 double underline deliberately kept separate to standard SGR versions
         #The extended codes are merged separately allowing fallback SGR to be specified for terminals which don't support extended underlines 
-        dict set codestate_empty underextended ""  ;#4:0 for no extended underline 4:1 etc for underline styles
-        #dict set codestate_empty undersingle ""
-        #dict set codestate_empty underdouble ""
-        #dict set codestate_empty undercurly ""
-        #dict set codestate_empty underdottedn ""
-        #dict set codestate_empty underdashed ""
-
-        dict set codestate_empty blink   ""    ;#5 or 6 for slow/fast, 25 for off
-        dict set codestate_empty reverse ""    ;#7 on 27 off
-        dict set codestate_empty hide  ""      ;#8 on 28 off
-        dict set codestate_empty strike ""     ;#9 on 29 off
-        dict set codestate_empty font ""       ;#10, 11-19  10 being primary
-        dict set codestate_empty gothic ""     ;#20
-        dict set codestate_empty doubleunderline "" ;#21  (standard SGR double as opposed to underdouble)
-        dict set codestate_empty proportional "" ;#26 - see note below
-        dict set codestate_empty frame_or_circle ""       ;#51,52 on - 54 off (54 off) (not generally used - mintty has repurposed for emoji variation selector)
+        tcl::dict::set codestate_empty underextended ""  ;#4:0 for no extended underline 4:1 etc for underline styles
+        #tcl::dict::set codestate_empty undersingle ""
+        #tcl::dict::set codestate_empty underdouble ""
+        #tcl::dict::set codestate_empty undercurly ""
+        #tcl::dict::set codestate_empty underdottedn ""
+        #tcl::dict::set codestate_empty underdashed ""
+
+        tcl::dict::set codestate_empty blink   ""    ;#5 or 6 for slow/fast, 25 for off
+        tcl::dict::set codestate_empty reverse ""    ;#7 on 27 off
+        tcl::dict::set codestate_empty hide  ""      ;#8 on 28 off
+        tcl::dict::set codestate_empty strike ""     ;#9 on 29 off
+        tcl::dict::set codestate_empty font ""       ;#10, 11-19  10 being primary
+        tcl::dict::set codestate_empty gothic ""     ;#20
+        tcl::dict::set codestate_empty doubleunderline "" ;#21  (standard SGR double as opposed to underdouble)
+        tcl::dict::set codestate_empty proportional "" ;#26 - see note below
+        tcl::dict::set codestate_empty frame_or_circle ""       ;#51,52 on - 54 off (54 off) (not generally used - mintty has repurposed for emoji variation selector)
 
         #ideogram rarely supported - this implementation untested - each attribute kept separate as they presumably can be applied simultaneously
-        dict set codestate_empty ideogram_underline ""
-        dict set codestate_empty ideogram_doubleunderline ""
-        dict set codestate_empty ideogram_overline ""
-        dict set codestate_empty ideogram_doubleoverline ""
-        dict set codestate_empty ideogram_clear ""
+        tcl::dict::set codestate_empty ideogram_underline ""
+        tcl::dict::set codestate_empty ideogram_doubleunderline ""
+        tcl::dict::set codestate_empty ideogram_overline ""
+        tcl::dict::set codestate_empty ideogram_doubleoverline ""
+        tcl::dict::set codestate_empty ideogram_clear ""
 
-        dict set codestate_empty overline ""    ;#53 on 55 off - probably not supported - pass through. Seem to be ok to merge with other SGR even if not supported.
-        dict set codestate_empty underlinecolour "" ;#58 - same arguments as 256colour and rgb (nonstandard - in Kitty ,VTE,mintty and iTerm2)
+        tcl::dict::set codestate_empty overline ""    ;#53 on 55 off - probably not supported - pass through. Seem to be ok to merge with other SGR even if not supported.
+        tcl::dict::set codestate_empty underlinecolour "" ;#58 - same arguments as 256colour and rgb (nonstandard - in Kitty ,VTE,mintty and iTerm2)
 
         # -- mintty?
-        dict set codestate_empty superscript "" ;#73
-        dict set codestate_empty subscript ""   ;#74
-        dict set codestate_empty nosupersub ""  ;#75
+        tcl::dict::set codestate_empty superscript "" ;#73
+        tcl::dict::set codestate_empty subscript ""   ;#74
+        tcl::dict::set codestate_empty nosupersub ""  ;#75
         # -- 
 
-        dict set codestate_empty fg ""        ;#30-37 + 90-97
-        dict set codestate_empty bg ""        ;#40-47 + 100-107 
+        tcl::dict::set codestate_empty fg ""        ;#30-37 + 90-97
+        tcl::dict::set codestate_empty bg ""        ;#40-47 + 100-107 
 
 
         #misnomer should have been sgr_merge_args ? :/
@@ -3700,30 +3691,34 @@ namespace eval punk::ansi {
             }
             sgr_merge_singles $allparts {*}$args
         }
+
+        variable defaultopts_sgr_merge_singles
+        set defaultopts_sgr_merge_singles [tcl::dict::create\
+            -filter_fg 0\
+            -filter_bg 0\
+            -filter_reset 0\
+        ]
+
         #codes *must* already have been split so that one esc per element in codelist
         #e.g codelist [a+ Yellow Red underline] [a+ blue] [a+ red]  is ok
         #but codelist "[a+ Yellow Red underline][a+ blue]" [a+ red]  is not
         #(use punk::ansi::ta::split_codes_single)
         proc sgr_merge_singles {codelist args} {
             variable codestate_empty
-            set othercodes [list]
-
-            set opts [dict create\
-                -filter_fg 0\
-                -filter_bg 0\
-                -filter_reset 0\
-            ]
-            dict for {k v} $args {
+            variable defaultopts_sgr_merge_singles
+            set opts $defaultopts_sgr_merge_singles
+            foreach {k v} $args {
                 switch -- $k {
                     -filter_fg - -filter_bg - -filter_reset {
-                        dict set opts $k $v
+                        tcl::dict::set opts $k $v
                     }
                     default {
-                        error "sgr_merge unknown option '$k'. Known options [dict keys $opts]"
+                        error "sgr_merge unknown option '$k'. Known options [tcl::dict::keys $opts]"
                     }
                 }
             }
 
+            set othercodes [list]
             set codestate $codestate_empty
             set codestate_initial $codestate_empty ;#keep a copy for resets.
             set did_reset 0
@@ -3741,19 +3736,19 @@ namespace eval punk::ansi {
             foreach c $codelist {
                 #normalize 8bit to a token of the same length so our string operations on the code are the same and we can maintain a switch statement with literals rather than escapes
                 #.. but preserve original c
-                #set cnorm [string map [list \x9b {8[} ] $c]
-                #switch -- [string index $cnorm 1][string index $cnorm end] {}
+                #set cnorm [tcl::string::map [list \x9b {8[} ] $c]
+                #switch -- [tcl::string::index $cnorm 1][string index $cnorm end] {}
                 #  {[m}
 
-                set cnorm [string map [list \x9b 8CSI "\x1b\[" 7CSI ] $c]
-                switch -- [string range $cnorm 0 3][string index $cnorm end] {
+                set cnorm [tcl::string::map [list \x9b 8CSI "\x1b\[" 7CSI ] $c]
+                switch -- [tcl::string::range $cnorm 0 3][tcl::string::index $cnorm end] {
                     7CSIm - 8CSIm {
-                        #set params [string range $cnorm 2 end-1] ;#strip leading esc lb and trailing m
-                        set params [string range $cnorm 4  end-1] ;#string leading XCSI and trailing m
+                        #set params [tcl::string::range $cnorm 2 end-1] ;#strip leading esc lb and trailing m
+                        set params [tcl::string::range $cnorm 4  end-1] ;#string leading XCSI and trailing m
 
                         #some systems use colon for 256 colours or RGB or nonstandard subparameters
                         #- it is therefore probably not ok to map to semicolon within SGR codes and treat the same.
-                        # - will break mintty? set params [string map [list : {;}] $params]
+                        # - will break mintty? set params [tcl::string::map [list : {;}] $params]
                         set plist [split $params {;}]
                         if {![llength $plist]} {
                             #if there was nothing - it must be a reset - we need it in the list
@@ -3772,10 +3767,10 @@ namespace eval punk::ansi {
 
                             #review - what about \x1b\[000m
                             #we need to accept/ignore leading zeros - we can't just pass to expr - as some tcl versions still see leading zero as octal
-                            set codeint [string trimleft [lindex $paramsplit 0] 0]
+                            set codeint [tcl::string::trimleft [lindex $paramsplit 0] 0]
                             switch -- $codeint {
                                 "" - 0 {
-                                    if {![dict get $opts -filter_reset]} {
+                                    if {![tcl::dict::get $opts -filter_reset]} {
                                         set codestate $codestate_initial
                                         set did_reset 1
                                     }
@@ -3783,117 +3778,117 @@ namespace eval punk::ansi {
                                 1 {
                                     #bold
                                     if {[llength $paramsplit] == 1} {
-                                        dict set codestate intensity $p
+                                        tcl::dict::set codestate intensity $p
                                     } else {
                                         if {[lindex $paramsplit 1] eq "2"} {
-                                            dict set codestate shadowed "1:2" ;#turn off also with 22
+                                            tcl::dict::set codestate shadowed "1:2" ;#turn off also with 22
                                         }
                                     }
                                 }
                                 2 {
                                     #dim
-                                    dict set codestate intensity 2
+                                    tcl::dict::set codestate intensity 2
                                 }
                                 3 {
-                                    dict set codestate italic 3
+                                    tcl::dict::set codestate italic 3
                                 }
                                 4 {
                                     #REVIEW - merging extended (e.g 4:4) underline attributes suppresses all other SGR attributes on at least some terminals which don't support extended underlines
                                     if {[llength $paramsplit] == 1} {
-                                        dict set codestate underline  4 
+                                        tcl::dict::set codestate underline  4 
                                     } else {
                                         switch -- [lindex $paramsplit 1] {
                                             0 {
                                                 #no *extended* underline
-                                                #dict set codestate underline 24
-                                                dict set codestate underextended 4:0  ;#will not turn off SGR standard underline if term doesn't support extended
+                                                #tcl::dict::set codestate underline 24
+                                                tcl::dict::set codestate underextended 4:0  ;#will not turn off SGR standard underline if term doesn't support extended
                                             }
                                             1 {
-                                                dict set codestate underextended 4:1 
+                                                tcl::dict::set codestate underextended 4:1 
                                             }
                                             2 {
-                                                dict set codestate underextended 4:2 
+                                                tcl::dict::set codestate underextended 4:2 
                                             }
                                             3 {
-                                                dict set codestate underextended "4:3"
+                                                tcl::dict::set codestate underextended "4:3"
                                             }
                                             4 {
-                                                dict set codestate underextended "4:4"
+                                                tcl::dict::set codestate underextended "4:4"
                                             }
                                             5 {
-                                                dict set codestate underextended "4:5"
+                                                tcl::dict::set codestate underextended "4:5"
                                             }
                                         }
 
                                     }
                                 }
                                 5 - 6 {
-                                    dict set codestate blink $p
+                                    tcl::dict::set codestate blink $p
                                 }
                                 7 {
-                                    dict set codestate reverse 7
+                                    tcl::dict::set codestate reverse 7
                                 }
                                 8 {
-                                    dict set codestate hide 8 
+                                    tcl::dict::set codestate hide 8 
                                 }
                                 9 {
-                                    dict set codestate strike 9
+                                    tcl::dict::set codestate strike 9
                                 }
                                 10 - 11 - 12 - 13 - 14 - 15 - 16 - 17 - 18 - 19 {
-                                    dict set codestate font $p
+                                    tcl::dict::set codestate font $p
                                 }
                                 20 {
-                                    dict set codestate gothic 20
+                                    tcl::dict::set codestate gothic 20
                                 }
                                 21 {
                                     #ECMA-48 double underline - some terminals use as not-bold. For now we won't support that.
-                                    dict set codestate doubleunderline 21
+                                    tcl::dict::set codestate doubleunderline 21
                                 }
                                 22 {
                                     #normal intensity
-                                    dict set codestate intensity 22
-                                    dict set codestate shadowed ""
+                                    tcl::dict::set codestate intensity 22
+                                    tcl::dict::set codestate shadowed ""
                                 }
                                 23 {
                                     #? wikipedia mentions blackletter - review
-                                    dict set codestate italic 23 
+                                    tcl::dict::set codestate italic 23 
                                 }
                                 24 {
-                                    dict set codestate underline 24 ;#off
-                                    dict set codestate underextended "4:0"  ;#review
+                                    tcl::dict::set codestate underline 24 ;#off
+                                    tcl::dict::set codestate underextended "4:0"  ;#review
                                 }
                                 25 {
-                                    dict set codestate blink 25 ;#off
+                                    tcl::dict::set codestate blink 25 ;#off
                                 }
                                 26 {
                                     #not known to be used in terminals.. could it be used with elastic tabstops? - review
-                                    dict set codestate proportional 26
+                                    tcl::dict::set codestate proportional 26
                                 }
                                 27 {
-                                    dict set codestate reverse 27 ;#off
+                                    tcl::dict::set codestate reverse 27 ;#off
                                 }
                                 28 {
-                                    dict set codestate hide 28 ;#reveal
+                                    tcl::dict::set codestate hide 28 ;#reveal
                                 }
                                 29 {
-                                    dict set codestate strike 29;#off
+                                    tcl::dict::set codestate strike 29;#off
                                 }
                                 30 - 31 - 32 - 33 - 34 - 35 - 36 - 37 {
-                                    dict set codestate fg $p  ;#foreground colour
+                                    tcl::dict::set codestate fg $p  ;#foreground colour
                                 }
                                 38 {
                                     #256 colour or rgb
                                     #check if subparams supplied as colon separated
-                                    if {[string first : $p] < 0} { 
+                                    if {[tcl::string::first : $p] < 0} { 
                                         switch -- [lindex $plist $i+1] {
                                             5 {
                                                 #256 - 1 more param
-                                                dict set codestate fg "38\;5\;[lindex $plist $i+2]" 
+                                                tcl::dict::set codestate fg "38\;5\;[lindex $plist $i+2]" 
                                                 incr i 2
                                             }
                                             2 {
                                                 #rgb
-                                                dict set codestate fg "38\;2\;[lindex $plist $i+2]\;[lindex $plist $i+3]\;[lindex $plist $i+4]"
+                                                tcl::dict::set codestate fg "38\;2\;[lindex $plist $i+2]\;[lindex $plist $i+3]\;[lindex $plist $i+4]"
                                                 incr i 4
                                             }
                                         }
@@ -3901,124 +3896,124 @@ namespace eval punk::ansi {
                                         #apparently subparameters can be left empty - and there are other subparams like transparency and colour-space 
                                         #we should only need to  pass it all through for the terminal to understand
                                         #review  
-                                        dict set codestate fg $p
+                                        tcl::dict::set codestate fg $p
                                     }
                                 }
                                 39 {
-                                    dict set codestate fg 39 ;#default foreground
+                                    tcl::dict::set codestate fg 39 ;#default foreground
                                 }
                                 40 - 41 - 42 - 43 - 44 - 45 - 46 - 47 {
-                                    dict set codestate bg $p ;#background colour
+                                    tcl::dict::set codestate bg $p ;#background colour
                                 }
                                 48 {
                                     #256 colour or rgb
-                                    if {[string first : $p] < 0} {
+                                    if {[tcl::string::first : $p] < 0} {
                                         switch -- [lindex $plist $i+1] {
                                             5 {
                                                 #256 - 1 more param
-                                                dict set codestate bg "48\;5\;[lindex $plist $i+2]" 
+                                                tcl::dict::set codestate bg "48\;5\;[lindex $plist $i+2]" 
                                                 incr i 2
                                             }
                                             2 {
                                                 #rgb
-                                                dict set codestate bg "48\;2\;[lindex $plist $i+2]\;[lindex $plist $i+3]\;[lindex $plist $i+4]"
+                                                tcl::dict::set codestate bg "48\;2\;[lindex $plist $i+2]\;[lindex $plist $i+3]\;[lindex $plist $i+4]"
                                                 incr i 4
                                             }
                                         }
                                     } else {
-                                        dict set codestate bg $p
+                                        tcl::dict::set codestate bg $p
                                     }
                                 }
                                 49 {
-                                    dict set codestate bg 49 ;#default background
+                                    tcl::dict::set codestate bg 49 ;#default background
                                 }
                                 50 {
-                                    dict set codestate proportional 50 ;#off - see 26
+                                    tcl::dict::set codestate proportional 50 ;#off - see 26
                                 }
                                 51 - 52 {
-                                    dict set codestate frame_or_circle 51 
+                                    tcl::dict::set codestate frame_or_circle 51 
                                 }
                                 53 {
-                                    dict set codestate overline 53  ;#not supported in terminals? pass through anyway
+                                    tcl::dict::set codestate overline 53  ;#not supported in terminals? pass through anyway
                                 }
                                 54 {
-                                    dict set codestate frame_or_circle 54 ;#off
+                                    tcl::dict::set codestate frame_or_circle 54 ;#off
                                 }
                                 55 {
-                                    dict set codestate overline 55; #off
+                                    tcl::dict::set codestate overline 55; #off
                                 }
                                 58 {
                                     #nonstandard 
                                     #256 colour or rgb
-                                    if {[string first : $p] < 0} {
+                                    if {[tcl::string::first : $p] < 0} {
                                         switch -- [lindex $plist $i+1] {
                                             5 {
                                                 #256 - 1 more param
-                                                dict set codestate underlinecolour "58\;5\;[lindex $plist $i+2]" 
+                                                tcl::dict::set codestate underlinecolour "58\;5\;[lindex $plist $i+2]" 
                                                 incr i 2
                                             }
                                             2 {
                                                 #rgb
-                                                dict set codestate underlinecolour "58\;2\;[lindex $plist $i+2]\;[lindex $plist $i+3]\;[lindex $plist $i+4]"
+                                                tcl::dict::set codestate underlinecolour "58\;2\;[lindex $plist $i+2]\;[lindex $plist $i+3]\;[lindex $plist $i+4]"
                                                 incr i 4
                                             }
                                         }
                                     } else {
-                                        dict set codestate underlinecolour $p
+                                        tcl::dict::set codestate underlinecolour $p
                                     }
                                 }
                                 59 {
                                     #nonstandard - default underlinecolour
-                                    dict set codestate underlinecolour 59
+                                    tcl::dict::set codestate underlinecolour 59
                                 }
                                 60 {
-                                    dict set codestate ideogram_underline 60
-                                    dict set codestate ideogram_clear ""
+                                    tcl::dict::set codestate ideogram_underline 60
+                                    tcl::dict::set codestate ideogram_clear ""
                                 }
                                 61 {
-                                    dict set codestate ideogram_doubleunderline 61
-                                    dict set codestate ideogram_clear ""
+                                    tcl::dict::set codestate ideogram_doubleunderline 61
+                                    tcl::dict::set codestate ideogram_clear ""
                                 }
                                 62 {
-                                    dict set codestate ideogram_overline 62
-                                    dict set codestate ideogram_clear ""
+                                    tcl::dict::set codestate ideogram_overline 62
+                                    tcl::dict::set codestate ideogram_clear ""
                                 }
                                 63 {
-                                    dict set codestate ideogram_doubleoverline 63
-                                    dict set codestate ideogram_clear ""
+                                    tcl::dict::set codestate ideogram_doubleoverline 63
+                                    tcl::dict::set codestate ideogram_clear ""
                                 }
                                 64 {
-                                    dict set codestate ideogram_stress 64
-                                    dict set codestate ideogram_clear ""
+                                    tcl::dict::set codestate ideogram_stress 64
+                                    tcl::dict::set codestate ideogram_clear ""
                                 }
                                 65 {
-                                    dict set codestate ideogram_clear 65
+                                    tcl::dict::set codestate ideogram_clear 65
                                     #review - we still need to pass through the ideogram_clear in case something understands it
-                                    dict set codestate ideogram_underline ""
-                                    dict set codestate ideogram_doubleunderline ""
-                                    dict set codestate ideogram_overline ""
-                                    dict set codestate ideogram_doubleoverline ""
+                                    tcl::dict::set codestate ideogram_underline ""
+                                    tcl::dict::set codestate ideogram_doubleunderline ""
+                                    tcl::dict::set codestate ideogram_overline ""
+                                    tcl::dict::set codestate ideogram_doubleoverline ""
                                 }
                                 73 {
                                     #mintty only?
                                     #can be combined with subscript
-                                    dict set codestate superscript 73
-                                    dict set codestate nosupersub ""
+                                    tcl::dict::set codestate superscript 73
+                                    tcl::dict::set codestate nosupersub ""
                                 }
                                 74 {
-                                    dict set codestate subscript 74
-                                    dict set codestate nosupersub ""
+                                    tcl::dict::set codestate subscript 74
+                                    tcl::dict::set codestate nosupersub ""
                                 }
                                 75 {
-                                    dict set codestate nosupersub 75
-                                    dict set codestate superscript ""
-                                    dict set codestate subcript ""
+                                    tcl::dict::set codestate nosupersub 75
+                                    tcl::dict::set codestate superscript ""
+                                    tcl::dict::set codestate subcript ""
                                 }
                                 90 - 91 - 92 - 93 - 94 - 95 - 96 - 97 {
-                                    dict set codestate fg $p
+                                    tcl::dict::set codestate fg $p
                                 }
                                 100 - 101 - 102 - 103 - 104 - 105 - 106 - 107 {
-                                    dict set codestate bg $p
+                                    tcl::dict::set codestate bg $p
                                 }
 
                             }
@@ -4033,20 +4028,22 @@ namespace eval punk::ansi {
 
             set codemerge ""
             set unmergeable "" ;# can merge with each other but not main set (for terminals not supporting extended codes)
-            if {[dict get $opts -filter_fg] || [dict get $opts -filter_bg]} {
-                dict for {k v} $codestate {
+            if {[tcl::dict::get $opts -filter_fg] || [tcl::dict::get $opts -filter_bg]} {
+                #safe jumptable test
+                #dict for {k v} $codestate {}
+                tcl::dict::for {k v} $codestate {
                     switch -- $v {
                         "" { 
                         }
                         default {
                             switch -- $k {
                                 bg {
-                                    if {![dict get $opts -filter_bg]} {
+                                    if {![tcl::dict::get $opts -filter_bg]} {
                                         append codemerge "${v}\;"
                                     }
                                 }
                                 fg {
-                                    if {![dict get $opts -filter_fg]} {
+                                    if {![tcl::dict::get $opts -filter_fg]} {
                                         append codemerge "${v}\;"
                                     }
                                 }
@@ -4061,7 +4058,9 @@ namespace eval punk::ansi {
                     }
                 }
             } else {
-                dict for {k v} $codestate {
+                #safe jumptable test
+                #dict for {k v} $codestate {}
+                tcl::dict::for {k v} $codestate {
                     switch -- $v {
                         "" {}
                         default {
@@ -4086,9 +4085,9 @@ namespace eval punk::ansi {
             }
             #puts "+==> codelist:[ansistring VIEW $codelist] did_reset:$did_reset codemerge:[ansistring VIEW $codemerge] unmergeable:[ansistring VIEW $unmergeable]"
             if {$codemerge ne ""} {
-                set codemerge [string trimright $codemerge {;}]
+                set codemerge [tcl::string::trimright $codemerge {;}]
                 if {$unmergeable ne ""} {
-                    set unmergeable [string trimright $unmergeable {;}]
+                    set unmergeable [tcl::string::trimright $unmergeable {;}]
                     return "\x1b\[${codemerge}m\x1b\[${unmergeable}m[join $othercodes ""]"
                 } else {
                     return "\x1b\[${codemerge}m[join $othercodes ""]"
@@ -4098,7 +4097,7 @@ namespace eval punk::ansi {
                     #there were no SGR codes - not even resets
                     return [join $othercodes ""]
                 } else {
-                    set unmergeable [string trimright $unmergeable {;}]
+                    set unmergeable [tcl::string::trimright $unmergeable {;}]
                     return "\x1b\[${unmergeable}m[join $othercodes ""]"
                 }
             }
@@ -4109,7 +4108,7 @@ namespace eval punk::ansi {
         #*** !doctools
         #[list_end] [comment {--- end definitions namespace punk::ansi::codetype ---}]
     }
-    namespace eval sequence_type {
+    tcl::namespace::eval sequence_type {
         proc is_Fe {code} {
             # C1 control codes
             if {[regexp {^\033\[[\u0040-\u005F]}]} {
@@ -4134,14 +4133,14 @@ namespace eval punk::ansi {
 }
 
 
-namespace eval punk::ansi::ta {
+tcl::namespace::eval punk::ansi::ta {
     #*** !doctools
     #[subsection {Namespace punk::ansi::ta}]
     #[para] text ansi functions 
     #[para] based on but not identical to the Perl Text Ansi module:
     #[para] https://github.com/perlancar/perl-Text-ANSI-Util/blob/master/lib/Text/ANSI/BaseUtil.pm
     #[list_begin definitions]
-    namespace path ::punk::ansi
+    tcl::namespace::path ::punk::ansi
 
     #handle both 7-bit and 8-bit csi 
     #review - does codepage affect this? e.g ebcdic has 8bit csi in different position
@@ -4174,9 +4173,9 @@ namespace eval punk::ansi::ta {
     variable re_standalones {(?:\x1bc|\x1b7|\x1b8|\x1bM|\x1bE|\x1bD|\x1bD|\x1bH|\x1b=|\x1b>|\x1b#3|\x1b#4|\x1b#5|\x1b#6|\x1b#8)}
 
     #if we don't split on altgraphics too and separate them out - it's easy to get into a horrible mess
-    variable re_altg0_group {(?:\x1b\(0)(?:(?!\x1b\(B).)*\x1b\(B}
-    variable re_altg0_open  {(?:\x1b\(0)}
-    variable re_altg0_close {(?:\x1b\(B)}
+    variable re_g0_group {(?:\x1b\(0)(?:(?!\x1b\(B).)*\x1b\(B}
+    variable re_g0_open  {(?:\x1b\(0)}
+    variable re_g0_close {(?:\x1b\(B)}
 
     # DCS "ESC P" or "0x90" is also terminated by ST
     set re_ST_open {(?:\033P|\u0090|\033X|\u0098|\033\^|\u009e|\033_|\u009f)} 
@@ -4198,7 +4197,7 @@ namespace eval punk::ansi::ta {
 
     #default for regexes is non-newline-sensitive matching - ie matches can span lines
     # -- --- --- ---
-    variable re_ansi_detect1 "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}|${re_esc_osc3}|${re_standalones}|${re_ST}|${re_altg0_open}|${re_altg0_close}"
+    variable re_ansi_detect1 "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}|${re_esc_osc3}|${re_standalones}|${re_ST}|${re_g0_open}|${re_g0_close}"
     # -- --- --- ---
     #handrafted TRIE version of above. Somewhat difficult to construct and maintain. TODO - find a regext TRIE generator that works with Tcl regexes
     #This does make things quicker - but it's too early to finalise the detect/split regexes (e.g missing \U0090 ) - will need to be redone.
@@ -4207,28 +4206,47 @@ namespace eval punk::ansi::ta {
 
 
 
-    variable re_ansi_detect_open "${re_csi_open}|${re_osc_open}|${re_standalones}|${re_ST_open}|${re_altg0_open}" 
+    variable re_ansi_detect_open "${re_csi_open}|${re_osc_open}|${re_standalones}|${re_ST_open}|${re_g0_open}" 
     
     #may be same as detect - kept in case detect needs to diverge
-    #variable re_ansi_split "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}|${re_esc_osc3}|${re_standalones}|${re_ST}|${re_altg0_open}|${re_altg0_close}"
+    #variable re_ansi_split "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}|${re_esc_osc3}|${re_standalones}|${re_ST}|${re_g0_open}|${re_g0_close}"
     set re_ansi_split $re_ansi_detect
 
     #detect any ansi escapes
     #review - only detect 'complete' codes - or just use the opening escapes for performance?
-    proc detect {text} {
+    proc detect {text} [string map [list <re> [list $re_ansi_detect]] {
         #*** !doctools
         #[call [fun detect] [arg text]]
         #[para]Return a boolean indicating whether Ansi codes were detected in text
-        #[para]
-
-        variable re_ansi_detect
-        expr {[regexp $re_ansi_detect $text]}
+        #[para]Important caveat:
+        #[para] When text is a tcl list made from splitting (or lappending) some ansi string - individual elements may be braced or have certain chars escaped. (one example is if a list element contains an unbalanced brace)
+        #[para] This can cause square brackets that form part of the ansi being backslash escaped  - and the regexp can fail to match
+        regexp <re> $text
+    }]
+
+    #can be used on dicts - but will check keys too. keys could also contain ansi and have escapes
+    proc detect_in_list {list} {
+        detect [join $list " "]
+    }
+    proc detect_in_list2 {list} {
+        foreach item $list {
+            if {[detect $item]} {
+                return 1
+            }
+        }
+        return 0
     }
+    proc detect_g0 {text} [string map [list <re> [list $re_g0_group]] {
+        regexp <re> $text
+    }]
+    #note - micro optimisation of inlining <re> gives us *almost* nothing extra. 
+    #left in place for a few such as detect/detect_g0  as we want them as fast as possible 
+    # in general the technique doesn't seem particularly worthwhile for this set of functions.
+    #the performance is dominated by the complexity of the regexp
     proc detect2 {text} {
-        variable re_ansi_detect2
-        expr {[regexp $re_ansi_detect2 $text]}
+        variable re_ansi_detect
+        expr {[regexp $re_ansi_detect $text]}
     }
-    
 
     proc detect_open {text} {
         variable re_ansi_detect_open
@@ -4270,7 +4288,9 @@ namespace eval punk::ansi::ta {
         #*** !doctools
         #[call [fun length] [arg text]]
         #[para]Return the character length after stripping ansi codes - not the printing length
-        string length [stripansi $text]
+        
+        #we can use stripansiraw to avoid g0 conversion - as the length should remain the same
+        tcl::string::length [stripansiraw $text]
     }
     #todo - handle newlines
     #not in perl ta
@@ -4284,10 +4304,92 @@ namespace eval punk::ansi::ta {
 
     #not in perl ta
     #returns just the plaintext portions in a list
-    proc split_at_codes {text} {
-        variable re_ansi_split
-        punk::ansi::internal::splitx $text ${re_ansi_split}
+    proc split_at_codes {str} [string map [list <re> $re_ansi_split]  {
+        #variable re_ansi_split
+        #punk::ansi::internal::splitx $str ${re_ansi_split}
+        punk::ansi::ta::Do_split_at_codes $str {<re>} 
+    }]
+    #it is faster to split this function out than to inline it into split_at_codes in tcl 8.7 - something to do with the use of the variable vs argument for the regexp
+    #literal inlining of the re in the main proc-body was slower too - but inlining it into the wrapper seems to work (a tiny bit)
+    #the difference is not often apparent when comparing timerate results from split_at_codes vs split_at_codes2 - 
+    # - but in aggregate for something like textblock::periodic - we can get a bit over 5% faster (e.g 136ms vs 149ms)
+    proc Do_split_at_codes {str regexp} {
+        if {$str eq ""} {
+            return {}
+        }
+        #no infinite loop check on regexp like splitx does because we should have tested re_ansi_split during development
+        set list  {}
+        set start 0
+        while {[regexp -start $start -indices -- $regexp $str match submatch]} {
+            lassign $submatch subStart subEnd
+            lassign $match matchStart matchEnd
+            incr matchStart -1
+            incr matchEnd
+            lappend list [tcl::string::range $str $start $matchStart]
+            if {$subStart >= $start} {
+                lappend list [tcl::string::range $str $subStart $subEnd]
+            }
+            set start $matchEnd
+        }
+        lappend list [tcl::string::range $str $start end]
+        return $list
+
+    }
+    proc Do_split_at_codes_join {str regexp} {
+        if {$str eq ""} {
+            return {}
+        }
+        #no infinite loop check on regexp like splitx does because we should have tested re_ansi_split during development
+        set list  {}
+        set start 0
+        while {[regexp -start $start -indices -- $regexp $str match submatch]} {
+            lassign $submatch subStart subEnd
+            lassign $match matchStart matchEnd
+            incr matchStart -1
+            incr matchEnd
+            lappend list [tcl::string::range $str $start $matchStart]
+            if {$subStart >= $start} {
+                lappend list [tcl::string::range $str $subStart $subEnd]
+            }
+            set start $matchEnd
+        }
+        lappend list [tcl::string::range $str $start end]
+        return [join $list ""]
     }
+    proc split_at_codes2 {str} [string map [list <re> $re_ansi_split]  {
+        #variable re_ansi_split
+        #punk::ansi::internal::splitx $str ${re_ansi_split}
+
+        #set regexp $re_ansi_split
+        #set regexp {<re>}
+
+        #inline splitx to avoid regex checks
+        #from textutil::split::splitx
+        # Bugfix 476988
+        if {$str eq ""} {
+            return {}
+        }
+        #if {[regexp $regexp {}]} {
+        #    return -code error \
+        #    "splitting on regexp \"$re_ansi_split\" would cause infinite loop"
+        #}
+        #no infinite loop check on regexp like splitx does because we should have tested re_ansi_split during development
+        set list  {}
+        set start 0
+        while {[regexp -start $start -indices -- {<re>} $str match submatch]} {
+            lassign $submatch subStart subEnd
+            lassign $match matchStart matchEnd
+            incr matchStart -1
+            incr matchEnd
+            lappend list [tcl::string::range $str $start $matchStart]
+            if {$subStart >= $start} {
+                lappend list [tcl::string::range $str $subStart $subEnd]
+            }
+            set start $matchEnd
+        }
+        lappend list [tcl::string::range $str $start end]
+        return $list
+    }]
     
     # -- --- --- --- --- --- 
     #Split $text to a list containing alternating ANSI colour codes and text.
@@ -4307,7 +4409,10 @@ namespace eval punk::ansi::ta {
         set re "(?:${re_ansi_split})+"
         return [_perlish_split $re $text]
     }
+    #micro optimisations on split_codes to avoid function calls and make re var local tend to yield very little benefit (sub uS diff on calls that commonly take 10s/100s of uSeconds) 
+
     #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)
+    #- the slightly simpler regex than split_codes means that it will be slightly faster than keeping the codes grouped.
     proc split_codes_single {text} {
         variable re_ansi_split
         return [_perlish_split $re_ansi_split $text]
@@ -4315,7 +4420,7 @@ namespace eval punk::ansi::ta {
 
     #review - tcl greedy expressions may match multiple in one element
     proc _perlish_split {re text} {
-        if {[string length $text] == 0} {
+        if {$text eq ""} {
             return {}
         }
         set list [list]
@@ -4326,26 +4431,26 @@ namespace eval punk::ansi::ta {
             lassign $match      matchStart matchEnd
             #puts "->start $start ->match $matchStart $matchEnd"
             if {$matchEnd < $matchStart} {
-                lappend list [string range $text $start $matchStart-1] [string index $text $matchStart] 
+                lappend list [tcl::string::range $text $start $matchStart-1] [tcl::string::index $text $matchStart] 
                 incr start 
-                if {$start >= [string length $text]} {
+                if {$start >= [tcl::string::length $text]} {
                     break
                 }
                 continue
             }
-            lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
+            lappend list [tcl::string::range $text $start $matchStart-1] [tcl::string::range $text $matchStart $matchEnd] 
             set start [expr {$matchEnd+1}]
             #?
-            if {$start >= [string length $text]} {
+            if {$start >= [tcl::string::length $text]} {
                 break
             }
         }
-        return [lappend list [string range $text $start end]]
+        return [lappend list [tcl::string::range $text $start end]]
     }
 
     #experiment for coroutine generator
     proc _perlish_split_yield {re text} {
-        if {[string length $text] == 0} {
+        if {[tcl::string::length $text] == 0} {
             yield {}
         }
         set list [list]
@@ -4356,27 +4461,27 @@ namespace eval punk::ansi::ta {
             lassign $match      matchStart matchEnd
             #puts "->start $start ->match $matchStart $matchEnd"
             if {$matchEnd < $matchStart} {
-                yield [string range $text $start $matchStart-1]
-                yield [string index $text $matchStart] 
+                yield [tcl::string::range $text $start $matchStart-1]
+                yield [tcl::string::index $text $matchStart] 
                 incr start 
-                if {$start >= [string length $text]} {
+                if {$start >= [tcl::string::length $text]} {
                     break
                 }
                 continue
             }
-            yield [string range $text $start $matchStart-1]
-            yield [string range $text $matchStart $matchEnd] 
+            yield [tcl::string::range $text $start $matchStart-1]
+            yield [tcl::string::range $text $matchStart $matchEnd] 
             set start [expr {$matchEnd+1}]
             #?
-            if {$start >= [string length $text]} {
+            if {$start >= [tcl::string::length $text]} {
                 break
             }
         }
-        #return [lappend list [string range $text $start end]]
-        yield [string range $text $start end]
+        #return [lappend list [tcl::string::range $text $start end]]
+        yield [tcl::string::range $text $start end]
     }
     proc _perlish_split2 {re text} {
-        if {[string length $text] == 0} {
+        if {[tcl::string::length $text] == 0} {
             return {}
         }
         set list [list]
@@ -4386,17 +4491,17 @@ namespace eval punk::ansi::ta {
             lassign $match      matchStart matchEnd
             #puts "->start $start ->match $matchStart $matchEnd"
             if {$matchEnd < $matchStart} {
-                lappend list [string range $text $start $matchStart-1] [string index $text $matchStart] 
+                lappend list [tcl::string::range $text $start $matchStart-1] [tcl::string::index $text $matchStart] 
                 incr start 
             } else {
-                lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
+                lappend list [tcl::string::range $text $start $matchStart-1] [tcl::string::range $text $matchStart $matchEnd] 
                 set start [expr {$matchEnd+1}]
             }
-            if {$start >= [string length $text]} {
+            if {$start >= [tcl::string::length $text]} {
                 break
             }
         }
-        return [lappend list [string range $text $start end]]
+        return [lappend list [tcl::string::range $text $start end]]
     }
     proc _ws_split {text} {
         regexp -all -inline {(?:\S+)|(?:\s+)} $text
@@ -4407,15 +4512,15 @@ namespace eval punk::ansi::ta {
     #[list_end] [comment {--- end definitions namespace punk::ansi::ta ---}]
 }
 # -- --- --- --- --- --- --- --- --- --- ---
-namespace eval punk::ansi::class {
+tcl::namespace::eval punk::ansi::class {
     #assertions specifically for punk::ansi::class namespace
-    if {![llength [info commands ::punk::ansi::class::assert]]} {
-        namespace import ::punk::assertion::assert
+    if {![llength [tcl::info::commands ::punk::ansi::class::assert]]} {
+        tcl::namespace::import ::punk::assertion::assert
         punk::assertion::active 1
     }
 
-    namespace eval renderer {
-        if {[llength [info commands ::punk::ansi::class::renderer::base_renderer]]} {
+    tcl::namespace::eval renderer {
+        if {[llength [tcl::info::commands ::punk::ansi::class::renderer::base_renderer]]} {
             #Can happen if package forget was used and we're reloading (a possibly different version) ?  review
             ::punk::ansi::class::renderer::base_renderer destroy ;#will automatically destroy other classes such as class_cp437 that use this as a superclass
         }
@@ -4433,17 +4538,17 @@ namespace eval punk::ansi::class {
                 #-- make assert available --
                 # By pointing it to the assert imported into ::punk::ansi::class
                 # (we could alternatively import assert *directly* from ::punk::assertion::assert - but we can't chain imports as setting active flag renames the command, breaking chained imports)
-                set nspath [namespace path]
+                set nspath [tcl::namespace::path]
                 if {"::punk::ansi::class" ni $nspath} {
                     lappend nspath ::punk::ansi::class
                 }
-                namespace path $nspath 
+                tcl::namespace::path $nspath 
                 #--                      --
                 if {[llength $args] < 2} {
 		            error {usage: ?-width <int>? ?-wrap [1|0]? ?-overflow [1|0]? from_ansistring to_ansistring}
 	            }
                 lassign [lrange $args end-1 end] from_ansistring to_ansistring
-                set opts [dict create\
+                set opts [tcl::dict::create\
                     -width      \uFFEF\
                     -wrap       1\
                     -overflow   0\
@@ -4458,21 +4563,21 @@ namespace eval punk::ansi::class {
                 foreach {k v} $argsflags {
                     switch -- $k {
                         -width - -wrap - -overflow - -appendlines - -looplimit - -experimental {
-                            dict set opts $k $v
+                            tcl::dict::set opts $k $v
                         }
                         default {
                             #don't use [self class] - or we'll get the superclass
-                            error "[info object class [self]] unknown option '$k'. Known options: [dict keys $opts]"
+                            error "[info object class [self]] unknown option '$k'. Known options: [tcl::dict::keys $opts]"
                         }
                     }
                 }
-                set o_width         [dict get $opts -width]
-                set o_wrap          [dict get $opts -wrap]
-                set o_overflow      [dict get $opts -overflow]
-                set o_appendlines   [dict get $opts -appendlines]
-                set o_looplimit     [dict get $opts -looplimit]
-                set o_cursor_column [dict get $opts -cursor_column]
-                set o_cursor_row    [dict get $opts -cursor_row]
+                set o_width         [tcl::dict::get $opts -width]
+                set o_wrap          [tcl::dict::get $opts -wrap]
+                set o_overflow      [tcl::dict::get $opts -overflow]
+                set o_appendlines   [tcl::dict::get $opts -appendlines]
+                set o_looplimit     [tcl::dict::get $opts -looplimit]
+                set o_cursor_column [tcl::dict::get $opts -cursor_column]
+                set o_cursor_row    [tcl::dict::get $opts -cursor_row]
 
                 set o_from_ansistring $from_ansistring
                 set o_ns_from   [info object namespace $o_from_ansistring]
@@ -4513,7 +4618,7 @@ namespace eval punk::ansi::class {
 
                 #if {![llength $from_ansisplits]} {$o_from_ansistring eval_in {my MakeSplit}} ;#!!todo - a better way to keep this method semi hidden but call from a 'friend'
                 if {![llength $from_ansisplits]} {
-                    namespace eval $o_ns_from {my MakeSplit}
+                    tcl::namespace::eval $o_ns_from {my MakeSplit}
                 }
 
                 set eidx [llength $o_rendereditems]
@@ -4526,7 +4631,7 @@ namespace eval punk::ansi::class {
                 }
                 if {$eidx == [llength $from_elements]} {
                     #nothing new available
-                    return [dict create type "" rendercount 0 start_count_unrendered 0 end_count_unrendered 0]
+                    return [tcl::dict::create type "" rendercount 0 start_count_unrendered 0 end_count_unrendered 0]
                 }
 
                 set start_elements_unrendered [expr {[llength $from_elements] - [llength $o_rendereditems]}]
@@ -4577,7 +4682,7 @@ namespace eval punk::ansi::class {
                 if 0 {
                 while {[llength $inputchunks]} {
                     set overtext [lpop inputchunks 0]
-                    if {![string length $overtext]} {
+                    if {![tcl::string::length $overtext]} {
                         continue
                     }
                     #set rinfo [overtype::renderline -info 1 -insert_mode 0 -autowrap_mode 1 -width $o_width -overflow 0 -cursor_column $col -cursor_row $row $undertext $overtext] 
@@ -4586,7 +4691,7 @@ namespace eval punk::ansi::class {
 
                 $o_to_ansistring append $newtext
 
-                return [dict create type $type_rendered rendercount $rendercount start_count_unrendered $start_elements_unrendered end_count_unrendered $end_elements_unrendered]
+                return [tcl::dict::create type $type_rendered rendercount $rendercount start_count_unrendered $start_elements_unrendered end_count_unrendered $end_elements_unrendered]
             }
 
         }
@@ -4599,7 +4704,7 @@ namespace eval punk::ansi::class {
         }
     }
 
-    if {[llength [info commands ::punk::ansi::class::class_ansistring]]} {
+    if {[llength [tcl::info::commands ::punk::ansi::class::class_ansistring]]} {
         ::punk::ansi::class::class_ansistring destroy
     }
     #As this is intended for column-based terminals - it has a different notion of string length, string index etc than for a plain string.
@@ -4635,11 +4740,11 @@ namespace eval punk::ansi::class {
             #-- make assert available --
             # By pointing it to the assert imported into ::punk::ansi::class
             # (we could alternatively import assert *directly* from ::punk::assertion::assert - but we can't chain imports as setting active flag renames the command, breaking imports)
-            set nspath [namespace path]
+            set nspath [tcl::namespace::path]
             if {"::punk::ansi::class" ni $nspath} {
                 lappend nspath ::punk::ansi::class
             }
-            namespace path $nspath 
+            tcl::namespace::path $nspath 
             #--                      --
 
             #we choose not to generate an internal split-state for the initial string - which may potentially be large.
@@ -4691,14 +4796,14 @@ namespace eval punk::ansi::class {
             if {![llength $o_ansisplits]} {
                 append result "No internal splits. "
                 append result \n    "has ansi                    : [my has_ansi]"
-                append result \n    "Tcl string length raw string: [string length $o_string]" 
+                append result \n    "Tcl string length raw string: [tcl::string::length $o_string]" 
             } else {
                 append result \n    "has ansi                    : [my has_ansi]"
                 append result \n    "ansisplit list len: [llength $o_ansisplits]" 
                 append result \n    "plaintext list len: [llength $o_ptlist]"
                 append result \n    "cached count      : $o_count"
-                append result \n    "Tcl string length raw string     : [string length $o_string]" 
-                append result \n    "Tcl string length plaintext parts: [string length [join $o_ptlist ""]]"
+                append result \n    "Tcl string length raw string     : [tcl::string::length $o_string]" 
+                append result \n    "Tcl string length plaintext parts: [tcl::string::length [join $o_ptlist ""]]"
                 if {[llength $o_ansisplits] %2 == 0} {
                     append result \n --------------------------------------------------
                     append result \n Warning - ansisplits appears to be invalid length
@@ -4816,7 +4921,7 @@ namespace eval punk::ansi::class {
             set re_diacritics {[\u0300-\u036f]+|[\u1ab0-\u1aff]+|[\u1dc0-\u1dff]+|[\u20d0-\u20ff]+|[\ufe20-\ufe2f]+} 
 
             #we want length to return number of glyphs + normal controls such as newline.. not screen width. Has to be consistent with index function  
-            return [string length  [regsub -all $re_diacritics $plaintext ""]]
+            return [tcl::string::length  [regsub -all $re_diacritics $plaintext ""]]
         }
 
         #This is the count of visible graphemes + non-ansi control chars. Not equal to column width or to the Tcl string length of the ansistripped string!!! 
@@ -4838,16 +4943,16 @@ namespace eval punk::ansi::class {
                 if {[punk::ansi::ta::detect $o_string]} {
                     my MakeSplit
                 } else {
-                    return [string length $o_string]
+                    return [tcl::string::length $o_string]
                 }
             } elseif {[llength $o_ansisplits] == 1} {
                 #single split always means no ansi
-                return string length $o_string
+                return [tcl::string::length $o_string]
             }
-            return [string length [join $o_ptlist ""]]
+            return [tcl::string::length [join $o_ptlist ""]]
         }
         method length_raw {} {
-            return [string length $o_string]
+            return [tcl::string::length $o_string]
         }
 
         #channels for stream in/out.. these are vaguely analogous to the input/output between a shell and a PTY Slave  - but this is not intended to be a full pseudoterminal
@@ -4856,9 +4961,9 @@ namespace eval punk::ansi::class {
         #renderstream_from_render  (public?)
 
         method rendertypes {} {
-            set classes [info commands ::punk::ansi::class::renderer::class_*]
+            set classes [tcl::info::commands ::punk::ansi::class::renderer::class_*]
             #strip off class_
-            set ctypes [lmap v $classes {string range [namespace tail $v] 6 end}]
+            set ctypes [lmap v $classes {tcl::string::range [tcl::namespace::tail $v] 6 end}]
         }
         method rendertype {{rtype ""}} {
             if {$rtype eq ""} {
@@ -4874,8 +4979,8 @@ namespace eval punk::ansi::class {
             }
             if {$o_renderer ne ""} {
                 set oinfo [info object class $o_renderer]
-                set tail [namespace tail $oinfo]
-                set currenttype [string range $tail 6 end]
+                set tail [tcl::namespace::tail $oinfo]
+                set currenttype [tcl::string::range $tail 6 end]
                 if {$rtype ne $currenttype} {
                     puts "switch rendertype from $currenttype to $rtype - destroying renderer and creating a new one"
                     $o_renderer destroy ;#what happens to data in target ansistring obj? when does it make sense to keep output and keep rendering vs clearing?
@@ -4926,7 +5031,7 @@ namespace eval punk::ansi::class {
             if {$o_renderer eq ""} {
                 error "No renderer. Call render methods first"
             }
-            return [dict create row [$o_renderer cursor_row] column [$o_renderer cursor_column]]
+            return [tcl::dict::create row [$o_renderer cursor_row] column [$o_renderer cursor_column]]
         }
         #---
 
@@ -4971,8 +5076,8 @@ namespace eval punk::ansi::class {
                     #assertion - if o_ptlist is empty so is o_ansisplits
                     lappend o_ansisplits $catstr
                 } else {
-                    lset o_ptlist end       [string cat [lindex $o_ptlist end] $catstr] 
-                    lset o_ansisplits end   [string cat [lindex $o_ansisplits end] $catstr]
+                    lset o_ptlist end       [tcl::string::cat [lindex $o_ptlist end] $catstr] 
+                    lset o_ansisplits end   [tcl::string::cat [lindex $o_ansisplits end] $catstr]
                 }
                 set last_codestack [lindex $o_sgrstacks end]
                 set last_gx0state  [lindex $o_gx0states end]
@@ -5046,9 +5151,9 @@ namespace eval punk::ansi::class {
                             incr current_split_index ;#increment 2 of 2
                         }
                     }
-                    lset o_ptlist end [string cat [lindex $o_ptlist end] [lindex $new_pt_list 0]]
+                    lset o_ptlist end [tcl::string::cat [lindex $o_ptlist end] [lindex $new_pt_list 0]]
                     lappend o_ptlist {*}[lrange $new_pt_list 1 end]
-                    lset o_ansisplits end [string cat [lindex $o_ansisplits end] [lindex $newsplits 0]]
+                    lset o_ansisplits end [tcl::string::cat [lindex $o_ansisplits end] [lindex $newsplits 0]]
                     lappend o_ansisplits {*}[lrange $newsplits 1 end]
 
                     #if {$o_count eq ""} {
@@ -5075,7 +5180,7 @@ namespace eval punk::ansi::class {
                 upvar ${ns}::o_ansisplits new_ansisplits
                 upvar ${ns}::o_count new_count
                 if {![llength $new_ansisplits] || $new_count eq ""} {
-                    namespace eval $ns {my MakeSplit}
+                    tcl::namespace::eval $ns {my MakeSplit}
                 }
                 upvar ${ns}::o_ptlist     new_ptlist
                 upvar ${ns}::o_string     new_string
@@ -5084,9 +5189,9 @@ namespace eval punk::ansi::class {
                 upvar ${ns}::o_gx0states  new_gx0states
                 upvar ${ns}::o_splitindex new_splitindex
 
-                lset o_ansisplits end [string cat [lindex $o_ansisplits end] [lindex $new_ansisplits 0]]
+                lset o_ansisplits end [tcl::string::cat [lindex $o_ansisplits end] [lindex $new_ansisplits 0]]
                 lappend o_ansisplits {*}[lrange $new_ansisplits 1 end]
-                lset o_ptlist end [string cat [lindex $o_ptlist end] [lindex $new_ptlist 0]]
+                lset o_ptlist end [tcl::string::cat [lindex $o_ptlist end] [lindex $new_ptlist 0]]
                 lappend o_ptlist {*}[lrange $new_ptlist 1 end]
 
                 append o_string $new_string
@@ -5124,7 +5229,7 @@ namespace eval punk::ansi::class {
             if {$o_string eq ""} {
                 return ""
             }
-            #ansistring VIEW relies only on the raw ansi input as it is essentially just a string map.
+            #ansistring VIEW relies only on the raw ansi input as it is essentially just a tcl::string::map.
             #We don't need to force an ansisplit if we happen to have an unsplit initial string
             ansistring VIEW $o_string
         }
@@ -5170,13 +5275,13 @@ namespace eval punk::ansi::class {
                 append output [ansistring VIEW {*}$args $pt]
 
                 #map DEC cursor_save/restore to CSI version
-                set code [string map [list \x1b7 \x1b\[s \x1b8 \x1b\[u ] $code]
+                set code [tcl::string::map [list \x1b7 \x1b\[s \x1b8 \x1b\[u ] $code]
 
 
-                set c1 [string index $code 0]
-                set c1c2 [string range $code 0 1]
+                set c1 [tcl::string::index $code 0]
+                set c1c2 [tcl::string::range $code 0 1]
                 #set re_ST_open {(?:\033P|\u0090|\033X|\u0098|\033\^|\u009e|\033_|\u009f)} 
-                set leadernorm [string range [string map [list\
+                set leadernorm [tcl::string::range [tcl::string::map [list\
                     \x1b\[      7CSI\
                     \x9b        8CSI\
                     \x1b\]      7OSC\
@@ -5188,13 +5293,13 @@ namespace eval punk::ansi::class {
                 #we leave the tail of the code unmapped for now 
                 switch -- $leadernorm {
                     7CSI - 7OSC {
-                        set codenorm [string cat $leadernorm [string range $code 2 end]]
+                        set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 2 end]]
                     }
                     7ESC {
-                        set codenorm [string cat $leadernorm [string range $code 1 end]]
+                        set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 1 end]]
                     }
                     8CSI - 8OSC {
-                        set codenorm [string cat $leadernorm [string range $code 1 end]]
+                        set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 1 end]]
                     }
                     default {
                         #we haven't made a mapping for this
@@ -5204,9 +5309,9 @@ namespace eval punk::ansi::class {
 
                 switch -- $leadernorm  {
                     {7CSI} - {8CSI} {
-                        set param [string range $codenorm 4 end-1]
-                        #puts stdout "--> CSI [string index $leadernorm 0] bit param:$param"
-                        switch -- [string index $codenorm end] {
+                        set param [tcl::string::range $codenorm 4 end-1]
+                        #puts stdout "--> CSI [tcl::string::index $leadernorm 0] bit param:$param"
+                        switch -- [tcl::string::index $codenorm end] {
                             m {
                                 if {[punk::ansi::codetype::is_sgr_reset $code]} {
                                     set displaycode [ansistring VIEW  $code]
@@ -5215,8 +5320,8 @@ namespace eval punk::ansi::class {
                                     set displaycode [ansistring VIEW  $code]
                                     if {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
                                         #highlight the esc & leftbracket in white as indication there is a leading reset
-                                        set cposn [string first ";" $displaycode]
-                                        append output ${whiteb}[string range $displaycode 0 $cposn]$RST${greenb}[string range $displaycode $cposn+1 end]$RST
+                                        set cposn [tcl::string::first ";" $displaycode]
+                                        append output ${whiteb}[tcl::string::range $displaycode 0 $cposn]$RST${greenb}[tcl::string::range $displaycode $cposn+1 end]$RST
                                     } else {
                                         append output ${greenb}$displaycode$RST
                                     }
@@ -5225,18 +5330,18 @@ namespace eval punk::ansi::class {
                             A - B {
                                 #row move
                                 set displaycode [ansistring VIEW $code]
-                                set displaycode [string map [list A "A$arrow_up" B "B$arrow_down"] $displaycode]
+                                set displaycode [tcl::string::map [list A "A$arrow_up" B "B$arrow_down"] $displaycode]
                                 append output ${cyanb}$displaycode$RST
 
                             }
                             C - D - G {
-                                #set num [string range $codenorm 4 end-1]
+                                #set num [tcl::string::range $codenorm 4 end-1]
                                 set displaycode [ansistring VIEW $code]
-                                set displaycode [string map [list C "C$arrow_right" D "D$arrow_left" G "G$arrow_lr"] $displaycode]
+                                set displaycode [tcl::string::map [list C "C$arrow_right" D "D$arrow_left" G "G$arrow_lr"] $displaycode]
                                 append output ${cyanb}$displaycode$RST
                             }
                             H - f {
-                                set params [string range $codenorm 4 end-1]
+                                set params [tcl::string::range $codenorm 4 end-1]
                                 lassign [split $params {;}] row col
                                 #lassign $matchinfo _match row col 
                                 set displaycode [ansistring VIEW $code]
@@ -5247,7 +5352,7 @@ namespace eval punk::ansi::class {
                                     #row and col move
                                     set map [list H "H${arrow_lr}${arrow_du}" f "${arrow_lr}${arrow_du}"]
                                 }
-                                set displaycode [string map $map $displaycode]
+                                set displaycode [tcl::string::map $map $displaycode]
                                 append output ${cyanb}$displaycode$RST
                             }
                             s {
@@ -5262,7 +5367,7 @@ namespace eval punk::ansi::class {
                         }
                     }    
                     7GFX {
-                        switch -- [string index $codenorm 4] {
+                        switch -- [tcl::string::index $codenorm 4] {
                             "0" {
                                 append output ${GX}GX+$RST
                             }
@@ -5333,7 +5438,40 @@ namespace eval punk::ansi::class {
         }
     }
 }
-namespace eval punk::ansi::ansistring {
+tcl::namespace::eval punk::ansi {
+    proc stripansi {text} [string map [list <re> $::punk::ansi::ta::re_ansi_split]  {
+        #*** !doctools
+        #[call [fun stripansi] [arg text] ]
+        #[para]Return a string with ansi codes stripped out
+        #[para]Alternate graphics chars are replaced with modern unicode equivalents (e.g boxdrawing glyphs)
+
+        #using detect costs us a couple of uS - but saves time on plain text 
+        #we should probably leave this for caller  - otherwise it ends up being called more than necessary
+        #if {![::punk::ansi::ta::detect $text]} { 
+        #    return $text
+        #}
+
+        #alternate graphics codes are not the norm
+        # - so save a few uS in the common case by only calling convert_g0 if we detect 
+        if {[punk::ansi::ta::detect_g0 $text]} {
+            set text [convert_g0 $text];#Convert ansi borders to unicode line drawing instead of ascii letters 
+        }
+        punk::ansi::ta::Do_split_at_codes_join $text {<re>} 
+    }]
+
+    proc stripansiraw {text} [string map [list <re> $::punk::ansi::ta::re_ansi_split] {
+        #*** !doctools
+        #[call [fun stripansi] [arg text] ]
+        #[para]Return a string with ansi codes stripped out 
+        #[para]Alternate graphics modes will be stripped rather than converted to unicode - exposing the raw ascii characters as they appear without graphics mode.
+        #[para]ie instead of a horizontal line you may see: qqqqqq  
+
+        #join [::punk::ansi::ta::split_at_codes $text] ""
+        punk::ansi::ta::Do_split_at_codes_join $text {<re>} 
+    }]
+}
+
+tcl::namespace::eval punk::ansi::ansistring {
     #*** !doctools
     #[subsection {Namespace punk::ansi::ansistring}]
     #[para]punk::ansi::ansistring ensemble  - ansi-aware string operations
@@ -5341,9 +5479,9 @@ namespace eval punk::ansi::ansistring {
     #[para]Just as working with other forms of markup such as HTML - you simply need to be aware of the tradeoffs and design accordingly.
     #[list_begin definitions]
 
-    namespace path [list ::punk::ansi ::punk::ansi::ta]
-    namespace ensemble create
-    namespace export length trim trimleft trimright INDEX COUNT VIEW VIEWCODES VIEWSTYLE INDEXABSOLUTE INDEXCOLUMNS COLUMNINDEX NEW
+    tcl::namespace::path [list ::punk::ansi ::punk::ansi::ta]
+    tcl::namespace::ensemble create
+    tcl::namespace::export length trim trimleft trimright INDEX COUNT VIEW VIEWCODES VIEWSTYLE INDEXABSOLUTE INDEXCOLUMNS COLUMNINDEX NEW
     #todo - expose _splits_ methods so caller can work efficiently with the splits themselves
     #we need to consider whether these can be agnostic towards splits from split_codes vs split_codes_single 
 
@@ -5461,14 +5599,14 @@ namespace eval punk::ansi::ansistring {
     #modern (c0 seem to have more terminal/font support - C1 can show 8bit c1 codes - but also seems to be limited support)
     
     #Goal is not to map every control character?
-    #Map of which elements we want to convert - done this way so we can see names of control's that are included: - ease of maintenance compared to just creating the string map directly
+    #Map of which elements we want to convert - done this way so we can see names of control's that are included: - ease of maintenance compared to just creating the tcl::string::map directly
     #ETX -ctrl-c
     #EOT  ctrl-d  (EOF?)
     #SYN  ctrl-v
     #SUB  ctrl-z
     #CAN  ctrl-x
     #FS   ctrl-\  (SIGQUIT)
-    set visuals_interesting [dict create\
+    set visuals_interesting [tcl::dict::create\
         NUL [list \x00 \u2400]\
         ETX [list \x03 \u2403]\
         EOT [list \x04 \u2404]\
@@ -5484,7 +5622,7 @@ namespace eval punk::ansi::ansistring {
         APC [list \x9f \ue03f]\
     ]
     #it turns out we need pretty much everything for debugging
-    set visuals_c0 [dict create\
+    set visuals_c0 [tcl::dict::create\
         NUL [list \x00 \u2400]\
         SOH [list \x01 \u2401]\
         STX [list \x02 \u2402]\
@@ -5548,7 +5686,7 @@ namespace eval punk::ansi::ansistring {
     set obm \u27e6 ;set cbm \u27e7  ;#square double brackets from Miscellaneous Mathematical Symbols-A
 
     #this private range so rarely supported in fonts - and visuals are unknown, so we will make up some 2-letter codes for now 
-    #set visuals_c1 [dict create\
+    #set visuals_c1 [tcl::dict::create\
     #    BPH [list \x82 "${ob8}\ue022 $cb8"]\
     #    NBH [list \x83 "${ob8}\ue023 $cb8"]\
     #    IND [list \x84 "${ob8}\ue024 $cb8"]\
@@ -5582,7 +5720,7 @@ namespace eval punk::ansi::ansistring {
 
     #these 2 letter codes only need to disambiguate within the c1 set - they're not great.
     #these sit within the Latin-1 Supplement block
-    set visuals_c1 [dict create\
+    set visuals_c1 [tcl::dict::create\
         PAD [list \x80 "${ob8}PD$cb8"]\
         HOP [list \x81 "${ob8}HP$cb8"]\
         BPH [list \x82 "${ob8}BP$cb8"]\
@@ -5617,19 +5755,19 @@ namespace eval punk::ansi::ansistring {
     ]
     
 
-    set hack [dict create]
-    dict set hack BOM1 [list \uFEFF "${obm}\U1f4a3$cbm"]    ;#byte order mark/ ZWNBSP (ZWNBSP usage generally deprecated) - a picture of a bomb(2wide glyph)
+    set hack [tcl::dict::create]
+    tcl::dict::set hack BOM1 [list \uFEFF "${obm}\U1f4a3$cbm"]    ;#byte order mark/ ZWNBSP (ZWNBSP usage generally deprecated) - a picture of a bomb(2wide glyph)
     #review - other boms? Encoding dependent?
 
-    dict set hack DCS  [list \x90   "${ob8}\u2328 $cb8"]    ;#keyboard from Miscellaneous Technical - 1 wide + pad.
-    dict set hack SOS  [list \x98   "${ob8}\u2380 $cb8"]    ;#Insertion Symbol from Miscellaneous Technical - 1 wide + pad
-    dict set hack ST   [list \x9c   "${ob8}\u2383 $cb8"]    ;#Emphasis Symbol from Miscellaneous Technical - 1 wide + pad (graphically related to \u2380)
-    dict set hack CSI  [list \x9b   "${ob8}\u2386 $cb8"]    ;#Enter Symbol from Miscellaneous Technical - 1 wide + pad
-    dict set hack OSC  [list \x9d   "${ob8}\u2b55$cb8"]     ;#bright red ring from Miscellaneous Symbols and Arrows - 2 wide (OSC could be used for clipboard or other potentially security sensitive functions)    
-    dict set hack PM   [list \x9e   "${ob8}PM$cb8"]
-    dict set hack APC  [list \x9f   "${ob8}\U1f534$cb8"]    ;#bright red ball from Miscellaneoust Symbols and Pictographs - 2 wide (APC also noted as a potential security risk)
+    tcl::dict::set hack DCS  [list \x90   "${ob8}\u2328 $cb8"]    ;#keyboard from Miscellaneous Technical - 1 wide + pad.
+    tcl::dict::set hack SOS  [list \x98   "${ob8}\u2380 $cb8"]    ;#Insertion Symbol from Miscellaneous Technical - 1 wide + pad
+    tcl::dict::set hack ST   [list \x9c   "${ob8}\u2383 $cb8"]    ;#Emphasis Symbol from Miscellaneous Technical - 1 wide + pad (graphically related to \u2380)
+    tcl::dict::set hack CSI  [list \x9b   "${ob8}\u2386 $cb8"]    ;#Enter Symbol from Miscellaneous Technical - 1 wide + pad
+    tcl::dict::set hack OSC  [list \x9d   "${ob8}\u2b55$cb8"]     ;#bright red ring from Miscellaneous Symbols and Arrows - 2 wide (OSC could be used for clipboard or other potentially security sensitive functions)    
+    tcl::dict::set hack PM   [list \x9e   "${ob8}PM$cb8"]
+    tcl::dict::set hack APC  [list \x9f   "${ob8}\U1f534$cb8"]    ;#bright red ball from Miscellaneoust Symbols and Pictographs - 2 wide (APC also noted as a potential security risk)
 
-    set debug_visuals [dict merge $visuals_c0 $visuals_c1 $hack]
+    set debug_visuals [tcl::dict::merge $visuals_c0 $visuals_c1 $hack]
 
     #for repeated interaction with the same ANSI string - a mechanism to store state is more efficient 
     proc NEW {string} {
@@ -5650,7 +5788,7 @@ namespace eval punk::ansi::ansistring {
         }
 
         set string [lindex $args end]
-        set defaults [dict create\
+        set defaults [tcl::dict::create\
             -esc 1\
             -cr 1\
             -lf 0\
@@ -5661,57 +5799,58 @@ namespace eval punk::ansi::ansistring {
         ]
         set argopts [lrange $args 0 end-1]
         if {[llength $argopts] % 2 != 0} {
-            error "ansistring VIEW options must be option-value pairs, received '$argopts'. Known opts [dict keys $defaults]"
+            error "ansistring VIEW options must be option-value pairs, received '$argopts'. Known opts [tcl::dict::keys $defaults]"
         }
-        set opts [dict merge $defaults $argopts]
+        set opts [tcl::dict::merge $defaults $argopts]
         # -- --- --- --- ---
-        set opt_esc     [dict get $opts -esc]
-        set opt_cr      [dict get $opts -cr]
-        set opt_lf      [dict get $opts -lf]
-        set opt_vt      [dict get $opts -vt]
-        set opt_ht      [dict get $opts -ht]
-        set opt_bs      [dict get $opts -bs]
-        set opt_sp      [dict get $opts -sp]
+        set opt_esc     [tcl::dict::get $opts -esc]
+        set opt_cr      [tcl::dict::get $opts -cr]
+        set opt_lf      [tcl::dict::get $opts -lf]
+        set opt_vt      [tcl::dict::get $opts -vt]
+        set opt_ht      [tcl::dict::get $opts -ht]
+        set opt_bs      [tcl::dict::get $opts -bs]
+        set opt_sp      [tcl::dict::get $opts -sp]
         # -- --- --- --- ---
 
 
 
-        set visuals_opt [dict create]
+        set visuals_opt $debug_visuals 
         if {$opt_esc} {
-            dict set visuals_opt ESC [list \x1b \u241b]
+            tcl::dict::set visuals_opt ESC [list \x1b \u241b]
         }
         if {$opt_cr} {
-            dict set visuals_opt CR [list \x0d \u240d]
+            tcl::dict::set visuals_opt CR [list \x0d \u240d]
         }
         if {$opt_lf == 1} {
-            dict set visuals_opt LF [list \x0a \u240a]
+            tcl::dict::set visuals_opt LF [list \x0a \u240a]
         }
         if {$opt_lf == 2} {
-            dict set visuals_opt LF [list \x0a \u240a\n]
+            tcl::dict::set visuals_opt LF [list \x0a \u240a\n]
         }
         if {$opt_vt} {
-            dict set visuals_opt VT [list \x0b \u240b]
+            tcl::dict::set visuals_opt VT [list \x0b \u240b]
         }
         if {$opt_ht} {
-            dict set visuals_opt HT [list \x09 \u2409]
+            tcl::dict::set visuals_opt HT [list \x09 \u2409]
         }
         if {$opt_bs} {
-            dict set visuals_opt BS [list \x08 \u2408]
+            tcl::dict::set visuals_opt BS [list \x08 \u2408]
         }
         if {$opt_sp} {
-            dict set visuals_opt SP [list \x20 \u2420]
+            tcl::dict::set visuals_opt SP [list \x20 \u2420]
         }
 
-        set visuals [dict merge $visuals_opt $debug_visuals]
-        set  charmap [list]
-        dict for {nm chars} $visuals {
-            lappend charmap {*}$chars
-        }
-        return [string map $charmap $string]
+        #set visuals [tcl::dict::merge $visuals_opt $debug_visuals]
+        #set  charmap [list]
+        #tcl::dict::for {nm chars} $visuals_opt {
+        #    lappend charmap {*}$chars
+        #}
+        #return [tcl::string::map $charmap $string]
+        return [tcl::string::map [concat {*}[dict values $visuals_opt]] $string]
 
 
         #test of ISO2047 - 7bit - limited set, limited support, somewhat obscure glyphs
-        #return [string map [list \033 \U2296 \007 \U237E] $string]
+        #return [tcl::string::map [list \033 \U2296 \007 \U237E] $string]
     }
 
     #The implementation of viewcodes,viewstyle is more efficiently done in an object for the case where repeated calls of various methods can re-use the internal splits.
@@ -5763,7 +5902,7 @@ namespace eval punk::ansi::ansistring {
         set string [regsub -all $re_diacritics $string ""]
 
         #we want length to return number of glyphs.. not screen width. Has to be consistent with index function  
-        string length [stripansi $string]
+        tcl::string::length [stripansi $string]
     }
     #included as a test/verification  - slightly slower.
     #grapheme split version may end up being used once it supports unicode grapheme clusters
@@ -5773,7 +5912,7 @@ namespace eval punk::ansi::ansistring {
     }
 
     proc length {string} {
-        string length [stripansi $string]
+        tcl::string::length [stripansi $string]
     }
 
     proc _splits_trimleft {sclist} {
@@ -5785,7 +5924,7 @@ namespace eval punk::ansi::ansistring {
                     if {$pt eq "" || [regexp {^\s+$} $pt]} {
                         lappend outlist "" $ansiblock
                     } else {
-                        lappend outlist [string trimleft $pt] $ansiblock
+                        lappend outlist [tcl::string::trimleft $pt] $ansiblock
                         set intext 1
                     }
                 } else {
@@ -5796,7 +5935,7 @@ namespace eval punk::ansi::ansistring {
                     if {$pt eq "" || [regexp {^\s+$} $pt]} {
                         lappend outlist ""
                     } else {
-                        lappend outlist [string trimleft $pt]
+                        lappend outlist [tcl::string::trimleft $pt]
                         set intext 1
                     }
                 } else {
@@ -5816,7 +5955,7 @@ namespace eval punk::ansi::ansistring {
                     if {$pt eq "" || [regexp {^\s+$} $pt]} {
                         lappend outlist "" $ansiblock
                     } else {
-                        lappend outlist [string trimright $pt] $ansiblock
+                        lappend outlist [tcl::string::trimright $pt] $ansiblock
                         set intext 1
                     }
                 } else {
@@ -5827,7 +5966,7 @@ namespace eval punk::ansi::ansistring {
                     if {$pt eq "" || [regexp {^\s+$} $pt]} {
                         lappend outlist ""
                     } else {
-                        lappend outlist [string trimright $pt]
+                        lappend outlist [tcl::string::trimright $pt]
                         set intext 1
                     }
                 } else {
@@ -5853,7 +5992,7 @@ namespace eval punk::ansi::ansistring {
                 if {$pt eq "" || [regexp {^\s+$} $pt]} {
                     append out $ansiblock
                 } else {
-                    append out [string trimleft $pt]$ansiblock
+                    append out [tcl::string::trimleft $pt]$ansiblock
                     set intext 1
                 }
             } else {
@@ -5900,20 +6039,20 @@ namespace eval punk::ansi::ansistring {
         #todo - end-x  +/-x+/-x etc
         set original_index $index
 
-        set index [string map [list _ ""] $index]
+        set index [tcl::string::map [list _ ""] $index]
         #short-circuit some trivial cases
-        if {[string is integer -strict $index]} {
+        if {[tcl::string::is integer -strict $index]} {
             if {$index < 0} {return ""}
             #this only short-circuits an index greater than length including ansi-chars
             #we don't want to spend cycles stripping ansi for this test so code below will still have to handle index just larger than content-length but still less than entire length
-            if {$index > [string length $string]} {return ""}
+            if {$index > [tcl::string::length $string]} {return ""}
         } else {
-            if {[string match end* $index]} {
+            if {[tcl::string::match end* $index]} {
                 #for end- we will probably have to blow a few cycles stripping first and calculate the length
                 if {$index ne "end"} {
-                    set op [string index $index 3]
-                    set offset [string range $index 4 end]
-                    if {$op ni {+ -} || ![string is integer -strict $offset]} {error "bad index '$index': must be integer?\[+-\]integer? or end?\[+-\]integer?"}
+                    set op [tcl::string::index $index 3]
+                    set offset [tcl::string::range $index 4 end]
+                    if {$op ni {+ -} || ![tcl::string::is integer -strict $offset]} {error "bad index '$index': must be integer?\[+-\]integer? or end?\[+-\]integer?"}
                     if {$op eq "+" && $offset != 0} {
                         return ""
                     }
@@ -5934,7 +6073,7 @@ namespace eval punk::ansi::ansistring {
             } else {
                 #we are trying to avoid evaluating unbraced expr of potentially insecure origin
                 regexp {^([+-]{0,1})(.*)} $index _match sign tail ;#should always match - even empty string
-                if {[string is integer -strict $tail]} {
+                if {[tcl::string::is integer -strict $tail]} {
                     #plain +-<int>
                     if {$op eq "-"} {
                         #return nothing for negative indices as per Tcl's lindex etc
@@ -5943,7 +6082,7 @@ namespace eval punk::ansi::ansistring {
                     set index $tail
                 } else {
                     if {[regexp {(.*)([+-])(.*)} $index _match a op b]} {
-                        if {[string is integer -strict $a] && [string is integer -strict $b]} {
+                        if {[tcl::string::is integer -strict $a] && [tcl::string::is integer -strict $b]} {
                             if {$op eq "-"} {
                                 set index [expr {$a - $b}]
                             } else {
@@ -5976,13 +6115,13 @@ namespace eval punk::ansi::ansistring {
             if {$pt ne ""} {
                 set graphemes [punk::char::grapheme_split $pt]
                 set low [expr {$high + 1}] ;#last high 
-                #incr high [string length $pt] 
+                #incr high [tcl::string::length $pt] 
                 incr high [llength $graphemes]
             }
 
             if {$pt ne "" && ($index >= $low && $index <= $high)} {
                 set pt_found $pt_index
-                #set char [string index $pt $index-$low]
+                #set char [tcl::string::index $pt $index-$low]
                 set char [lindex $graphemes $index-$low]
                 break
             }
@@ -6019,10 +6158,10 @@ namespace eval punk::ansi::ansistring {
         set payload_len -1 ;# -1 as token to indicate we haven't calculated it yet (only want to call it once at most)
         set testindices [list]
         foreach index $args {
-            if {[string is integer -strict $index]} {
+            if {[tcl::string::is integer -strict $index]} {
                 if {$index < 0} {
                     lappend testindices ""
-                } elseif {$index > [string length $string]} {
+                } elseif {$index > [tcl::string::length $string]} {
                     #this only short-circuits an index greater than length including ansi-chars
                     #we don't want to spend cycles stripping ansi for this test so code below will still have to handle index just larger than content-length but still less than entire length
                     lappend testindices ""
@@ -6030,12 +6169,12 @@ namespace eval punk::ansi::ansistring {
                     lappend testindices $index
                 }
             } else {
-                if {[string match end* $index]} {
+                if {[tcl::string::match end* $index]} {
                     #for end- we will probably have to blow a few cycles stripping first and calculate the length
                     if {$index ne "end"} {
-                        set op [string index $index 3]
-                        set offset [string range $index 4 end]
-                        if {$op ni {+ -} || ![string is integer -strict $offset]} {error "bad index '$index': must be integer?\[+-\]integer? or end?\[+-\]integer?"}
+                        set op [tcl::string::index $index 3]
+                        set offset [tcl::string::range $index 4 end]
+                        if {$op ni {+ -} || ![tcl::string::is integer -strict $offset]} {error "bad index '$index': must be integer?\[+-\]integer? or end?\[+-\]integer?"}
                         if {$op eq "+" && $offset != 0} {
                             lappend testindices ""
                             continue
@@ -6060,7 +6199,7 @@ namespace eval punk::ansi::ansistring {
                 } else {
                     #we are trying to avoid evaluating unbraced expr of potentially insecure origin
                     regexp {^([+-]{0,1})(.*)} $index _match sign tail ;#should always match - even empty string
-                    if {[string is integer -strict $tail]} {
+                    if {[tcl::string::is integer -strict $tail]} {
                         #plain +-<int>
                         if {$op eq "-"} {
                             #return nothing for negative indices as per Tcl's lindex etc
@@ -6071,7 +6210,7 @@ namespace eval punk::ansi::ansistring {
                         lappend testindices $index
                     } else {
                         if {[regexp {(.*)([+-])(.*)} $index _match a op b]} {
-                            if {[string is integer -strict $a] && [string is integer -strict $b]} {
+                            if {[tcl::string::is integer -strict $a] && [tcl::string::is integer -strict $b]} {
                                 if {$op eq "-"} {
                                     set index [expr {$a - $b}]
                                 } else {
@@ -6199,7 +6338,7 @@ namespace eval punk::ansi::ansistring {
         set col2 ""
         foreach {pt code} $ansisplits {
             if {$pt ne ""} {
-                if {[string last \n $pt] < 0} {
+                if {[tcl::string::last \n $pt] < 0} {
                     set graphemes [punk::char::grapheme_split $pt]
                     set lowindex [expr {$highindex + 1}] ;#last high 
                     set lowc [expr {$highc + 1}]
@@ -6238,7 +6377,7 @@ namespace eval punk::ansi::ansistring {
     #[list_end] [comment {--- end definitions namespace punk::ansi::ta ---}]
 }
 
-namespace eval punk::ansi::internal {
+tcl::namespace::eval punk::ansi::internal {
     proc splitn {str {len 1}} {
         #from textutil::split::splitn
         if {$len <= 0} {
@@ -6248,11 +6387,11 @@ namespace eval punk::ansi::internal {
             return [split $str {}]
         }
         set result [list]
-        set max [string length $str]
+        set max [tcl::string::length $str]
         set i 0
         set j [expr {$len -1}]
         while {$i < $max} {
-            lappend result [string range $str $i $j]
+            lappend result [tcl::string::range $str $i $j]
             incr i $len
             incr j $len
         }
@@ -6261,10 +6400,10 @@ namespace eval punk::ansi::internal {
     proc splitx {str {regexp {[\t \r\n]+}}} {
         #from textutil::split::splitx
         # Bugfix 476988
-        if {[string length $str] == 0} {
+        if {$str eq ""} {
             return {}
         }
-        if {[string length $regexp] == 0} {
+        if {$regexp eq ""} {
             return [::split $str ""]
         }
         if {[regexp $regexp {}]} {
@@ -6274,17 +6413,19 @@ namespace eval punk::ansi::internal {
         set list  {}
         set start 0
         while {[regexp -start $start -indices -- $regexp $str match submatch]} {
-            foreach {subStart subEnd} $submatch break
-            foreach {matchStart matchEnd} $match break
+            #foreach {subStart subEnd} $submatch break
+            lassign $submatch subStart subEnd
+            #foreach {matchStart matchEnd} $match break
+            lassign $match matchStart matchEnd
             incr matchStart -1
             incr matchEnd
-            lappend list [string range $str $start $matchStart]
+            lappend list [tcl::string::range $str $start $matchStart]
             if {$subStart >= $start} {
-                lappend list [string range $str $subStart $subEnd]
+                lappend list [tcl::string::range $str $subStart $subEnd]
             }
             set start $matchEnd
         }
-        lappend list [string range $str $start end]
+        lappend list [tcl::string::range $str $start end]
         return $list
     }
 
@@ -6308,11 +6449,11 @@ namespace eval punk::ansi::internal {
         return $2hex
     }
     proc hex2str {2digithexchars} {
-        set 2digithexchars [string map [list _ ""] $2digithexchars] ;#compatibility with  tcl tip 551 (compatibility in the sense that users might expect to be able to use underscores and it's nice to support the syntax here too - not that it's required)
+        set 2digithexchars [tcl::string::map [list _ ""] $2digithexchars] ;#compatibility with  tcl tip 551 (compatibility in the sense that users might expect to be able to use underscores and it's nice to support the syntax here too - not that it's required)
         if {$2digithexchars eq ""} {
             return ""
         }
-        if {[string length $2digithexchars] % 2 != 0} {
+        if {[tcl::string::length $2digithexchars] % 2 != 0} {
             error "hex2str requires an even number of hex digits (2 per character)"
         }
         set 2str ""
@@ -6325,7 +6466,7 @@ namespace eval punk::ansi::internal {
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide punk::ansi [namespace eval punk::ansi {
+package provide punk::ansi [tcl::namespace::eval punk::ansi {
     variable version
     set version 0.1.1 
 }]
diff --git a/src/bootsupport/modules/punk/args-0.1.0.tm b/src/bootsupport/modules/punk/args-0.1.0.tm
index cd4a9fa..e148a2a 100644
--- a/src/bootsupport/modules/punk/args-0.1.0.tm
+++ b/src/bootsupport/modules/punk/args-0.1.0.tm
@@ -186,11 +186,20 @@
 ##  Requirements
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 
+
+#All ensemble commands are slower in a safe interp as they aren't compiled the same way
+#https://core.tcl-lang.org/tcl/tktview/1095bf7f75 
+#as this is needed in safe interps too, and the long forms tcl::dict::for tcl::string::map are no slower in a normal interp - we use the long form here.
+#(As at 2024-06 There are many tcl8.6/8.7 interps in use which are affected by this and it's unknown when/whether it will be fixed)
+#ensembles: array binary clock dict info namespace string
+#possibly file too, although that is generally hidden/modified in a safe interp
+#chan,encoding always seems to use invokeStk1 anyway - yet there are performance improvements using ::tcl::chan::names etc
+#interestingly in tcl8.7 at least - tcl::namespace::eval $somens $somescript is slightly faster than namespace eval even in unsafe interp
+
 #*** !doctools
 #[subsection dependencies]
 #[para] packages used by punk::args
 #[list_begin itemized]
-
 package require Tcl 8.6-
 #*** !doctools
 #[item] [package {Tcl 8.6-}]
@@ -210,11 +219,11 @@ package require Tcl 8.6-
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # oo::class namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::args::class {
+tcl::namespace::eval punk::args::class {
     #*** !doctools
     #[subsection {Namespace punk::args::class}]
     #[para] class definitions
-    if {[info commands [namespace current]::interface_sample1] eq ""} {
+    if {[tcl::info::commands [tcl::namespace::current]::interface_sample1] eq ""} {
         #*** !doctools
         #[list_begin enumerated]
 
@@ -243,13 +252,13 @@ namespace eval punk::args::class {
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # Base namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::args {
-    namespace export {[a-z]*} 
+tcl::namespace::eval punk::args {
+    tcl::namespace::export {[a-z]*} 
     variable argspec_cache
     variable argspecs
     variable id_counter
-    set argspec_cache [dict create]
-    set argspecs [dict create]
+    set argspec_cache [tcl::dict::create]
+    set argspecs [tcl::dict::create]
     set id_counter 0
 
     #*** !doctools
@@ -257,20 +266,24 @@ namespace eval punk::args {
     #[para] Core API functions for punk::args 
     #[list_begin definitions]
 
+
     proc Get_argspecs {optionspecs args} {
         variable argspec_cache
         variable argspecs
+        variable initial_optspec_defaults
+        variable initial_valspec_defaults
         #ideally we would use a fast hash algorithm to produce a short key with low collision probability.
         #something like md5 would be ok (this is non cryptographic) - but md5 uses open and isn't usable by default in a safe interp.
         #review - check if there is a built-into-tcl way to do this quickly
         #for now we will just key using the whole string
         set cache_key $optionspecs 
-        if {[dict exists $argspec_cache $cache_key]} {
-            return [dict get $argspec_cache $cache_key]
+        if {[tcl::dict::exists $argspec_cache $cache_key]} {
+            return [tcl::dict::get $argspec_cache $cache_key]
         }
 
-        set optionspecs [string map [list \r\n \n] $optionspecs]
-        set optspec_defaults [dict create\
+        set optionspecs [tcl::string::map [list \r\n \n] $optionspecs]
+        #probably faster to inline a literal dict create in the proc than to use a namespace variable
+        set optspec_defaults [tcl::dict::create\
             -type string\
             -optional 1\
             -allow_ansi 1\
@@ -279,7 +292,7 @@ namespace eval punk::args {
             -nocase 0\
             -multiple 0\
         ] 
-        set valspec_defaults [dict create\
+        set valspec_defaults [tcl::dict::create\
             -type string\
             -optional 0\
             -allow_ansi 1\
@@ -287,6 +300,7 @@ namespace eval punk::args {
             -strip_ansi 0\
             -multiple 0\
         ]
+
         #checks with no default 
         #-minlen -maxlen -range
 
@@ -295,10 +309,11 @@ namespace eval punk::args {
         #todo - detect if anything in the spec uses -allow_ansi 0, -validate_without_ansi 1 or -strip_ansi 1 and set a flag indicating if punk::ansi::ta::detect should be run on the argslist
         set opt_required [list]
         set val_required [list]
-        set arg_info [dict create]
-        set opt_defaults [dict create]
+        set arg_info [tcl::dict::create]
+        set arg_checks [tcl::dict::create]
+        set opt_defaults [tcl::dict::create]
         set opt_names [list] ;#defined opts
-        set val_defaults [dict create]
+        set val_defaults [tcl::dict::create]
         set opt_solos [list]
         #first process dashed and non-dashed argspecs without regard to whether non-dashed are at the beginning or end
         set val_names [list]
@@ -309,21 +324,21 @@ namespace eval punk::args {
         set linelist [split $optionspecs \n]
         set lastindent ""
         foreach ln $linelist {
-            if {[string trim $ln] eq ""} {continue}
+            if {[tcl::string::trim $ln] eq ""} {continue}
             regexp {(\s*).*} $ln _all lastindent
             break ;#break at first non-empty
         }
         #puts "indent1:[ansistring VIEW $lastindent]"
         set in_record 0
         foreach rawline $linelist {
-            set recordsofar [string cat $linebuild $rawline]
-            if {![info complete $recordsofar]} {
+            set recordsofar [tcl::string::cat $linebuild $rawline]
+            if {![tcl::info::complete $recordsofar]} {
                 #append linebuild [string trimleft $rawline] \n
                 if {$in_record} {
-                    if {[string length $lastindent]} {
+                    if {[tcl::string::length $lastindent]} {
                         #trim only the whitespace corresponding to last indent - not all whitespace on left
-                        if {[string first $lastindent $rawline] == 0} {
-                            set trimmedline [string range $rawline [string length $lastindent] end]
+                        if {[tcl::string::first $lastindent $rawline] == 0} {
+                            set trimmedline [tcl::string::range $rawline [tcl::string::length $lastindent] end]
                             append linebuild $trimmedline \n
                         } else {
                             append linebuild $rawline \n
@@ -340,10 +355,10 @@ namespace eval punk::args {
                 }
             } else {
                 set in_record 0
-                if {[string length $lastindent]} {
+                if {[tcl::string::length $lastindent]} {
                     #trim only the whitespace corresponding to last indent - not all whitespace on left
-                    if {[string first $lastindent $rawline] == 0} {
-                        set trimmedline [string range $rawline [string length $lastindent] end]
+                    if {[tcl::string::first $lastindent $rawline] == 0} {
+                        set trimmedline [tcl::string::range $rawline [tcl::string::length $lastindent] end]
                         append linebuild $trimmedline 
                     } else {
                         append linebuild $rawline
@@ -361,19 +376,19 @@ namespace eval punk::args {
         set val_max -1  ;#-1 for no limit 
         set spec_id ""
         foreach ln $records {
-            set trimln [string trim $ln]
-            switch -- [string index $trimln 0] {
+            set trimln [tcl::string::trim $ln]
+            switch -- [tcl::string::index $trimln 0] {
                 "" - # {continue}
             }
             set linespecs [lassign $trimln argname]
             if {$argname ne "*id" && [llength $linespecs] %2 != 0} {
                 error "punk::args::get_dict - bad optionspecs line for record '$argname' Remaining items on line must be in paired option-value format - received '$linespecs'"
             }
-            set firstchar [string index $argname 0]
-            set secondchar [string index $argname 1]
+            set firstchar [tcl::string::index $argname 0]
+            set secondchar [tcl::string::index $argname 1]
             if {$firstchar eq "*" && $secondchar ne "*"} {
                 set starspecs $linespecs
-                switch -- [string range $argname 1 end] {
+                switch -- [tcl::string::range $argname 1 end] {
                     id   {
                         #id line must have single entry - a unique id assigned by the user - an id will be allocated if no id line present or the value is "auto"
                         if {[llength $starspecs] != 1} {
@@ -386,7 +401,7 @@ namespace eval punk::args {
                         set spec_id $starspecs
                     }
                     proc {
-                        #allow arbitrary 
+                        #allow arbitrary - review 
                         set proc_info $starspecs
                     }
                     opts {
@@ -398,22 +413,50 @@ namespace eval punk::args {
                                 }
                                 -minlen - -maxlen - -range - -choices - -choicelabels {
                                     #review - only apply to certain types?
-                                    dict set optspec_defaults $k $v
+                                    tcl::dict::set optspec_defaults $k $v
                                 }
                                 -nominlen - -nomaxlen - -norange - -nochoices - -nochoicelabels {
-                                    dict unset optspec_defaults $k
+                                    if {$v} {
+                                        tcl::dict::unset optspec_defaults $k
+                                    }
+                                }
+                                -type  {
+                                    switch -- $v {
+                                        int - integer {
+                                            set v int
+                                        }
+                                        char - character {
+                                            set v char
+                                        }
+                                        bool - boolean {
+                                            set v bool
+                                        }
+                                        dict - dictionary {
+                                            set v dict
+                                        }
+                                        none - any - ansistring {
+
+                                        }
+                                        default {
+                                            #todo - disallow unknown types unless prefixed with custom-
+                                        }
+                                    }
+                                    tcl::dict::set optspec_defaults $k $v
                                 }
-                                -type -
                                 -optional -
                                 -allow_ansi -
                                 -validate_without_ansi -
                                 -strip_ansi -
                                 -multiple {
                                     #allow overriding of defaults for options that occur later
-                                    dict set optspec_defaults $k $v
+                                    tcl::dict::set optspec_defaults $k $v
                                 }
                                 default {
-                                    error "punk::args::Get_argspecs - unrecognised key '$k' in *opts line.  Known keys: -anyopts"
+                                    set known   {   -any -anyopts -minlen -maxlen -range -choices -choicelabels\
+                                                    -nominlen -nomaxlen -norange -nochoices -nochoicelabels\
+                                                    -type -optional -allow_ansi -validate_without_ansi -strip_ansi -multiple\
+                                                }
+                                    error "punk::args::Get_argspecs - unrecognised key '$k' in *opts line.  Known keys: $known"
                                 }
                             }
                         }
@@ -431,80 +474,119 @@ namespace eval punk::args {
                                 }
                                 -minlen - -maxlen - -range - -choices - -choicelabels {
                                     #review - only apply to certain types?
-                                    dict set valspec_defaults $k $v
+                                    tcl::dict::set valspec_defaults $k $v
                                 }
                                 -nominlen - -nomaxlen - -norange - -nochoices - -nochoicelabels {
-                                    dict unset valspec_defaults $k
+                                    if {$v} {
+                                        tcl::dict::unset valspec_defaults $k
+                                    }
                                 }
-                                -type -
+                                -type  {
+                                    switch -- $v {
+                                        int - integer {
+                                            set v int
+                                        }
+                                        char - character {
+                                            set v char
+                                        }
+                                        bool - boolean {
+                                            set v bool
+                                        }
+                                        dict - dictionary {
+                                            set v dict
+                                        }
+                                        default {
+                                            #todo - disallow unknown types unless prefixed with custom-
+                                        }
+                                    }
+                                    tcl::dict::set valspec_defaults $k $v
+                                }
+                                -optional -
                                 -allow_ansi -
                                 -validate_without_ansi -
                                 -strip_ansi -
                                 -multiple {
-                                    dict set valspec_defaults $k $v
+                                    tcl::dict::set valspec_defaults $k $v
                                 }
                                 default {
-                                    error "punk::args::Get_argspecs - unrecognised key '$k' in *opts line.  Known keys: -anyopts"
+                                    set known   {   -min -minvalues -max -maxvalues\
+                                                    -minlen -maxlen -range -choices -choicelabels\
+                                                    -nominlen -nomaxlen -norange -nochoices -nochoicelabels\
+                                                    -type -optional -allow_ansi -validate_without_ansi -strip_ansi -multiple\
+                                                }
+                                    error "punk::args::Get_argspecs - unrecognised key '$k' in *values line.  Known keys: $known"
                                 }
                             }
                         }
 
                     }
                     default {
-                        error "punk::args::Get_argspecs - unrecognised * line in. Expected *proc *opts or *values - use **name if paramname needs to be *name"
+                        error "punk::args::Get_argspecs - unrecognised * line in '$ln'. Expected *proc *opts or *values - use **name if paramname needs to be *name"
                     }
                 }
                 continue
             } elseif {$firstchar eq "-"} {
                 set argspecs $linespecs
-                dict set argspecs -ARGTYPE option
+                tcl::dict::set argspecs -ARGTYPE option
                 lappend opt_names $argname
                 set is_opt 1
             } else {
                 if {$firstchar eq "*"} {
                     #allow basic ** escaping for literal argname that begins with *
-                    set argname [string range $argname 1 end]
+                    set argname [tcl::string::range $argname 1 end]
                 }
                 set argspecs $linespecs
-                dict set argspecs -ARGTYPE value 
+                tcl::dict::set argspecs -ARGTYPE value 
                 lappend val_names $argname
                 set is_opt 0
             }
             #assert - we only get here if it is a value or flag specification line.
             #assert argspecs has been set to the value of linespecs
-            set merged $optspec_defaults
+            if {$is_opt} {
+                set spec_merged $optspec_defaults
+            } else {
+                set spec_merged $valspec_defaults
+            }
             foreach {spec specval} $argspecs {
                 #literal-key switch - bytecompiled to jumpTable
                 switch -- $spec {
                     -type {
                         #normalize here so we don't have to test during actual args parsing in main function
-                        switch -- [string tolower $specval] {
+                        switch -- [tcl::string::tolower $specval] {
                             int - integer {
-                                dict set merged -type int
+                                tcl::dict::set spec_merged -type int
                             }
                             bool - boolean {
-                                dict set merged -type bool 
+                                tcl::dict::set spec_merged -type bool 
                             }
                             char - character {
-                                dict set merged -type char
+                                tcl::dict::set spec_merged -type char
+                            }
+                            dict - dictionary {
+                                tcl::dict::set spec_merged -type dict
                             }
                             "" - none {
                                 if {$is_opt} {
-                                    dict set merged -type none
-                                    dict set merged -default 0   ;#-default 0 can still be overridden if -default appears after -type - we'll allow it.
+                                    tcl::dict::set spec_merged -type none
+                                    tcl::dict::set spec_merged -default 0   ;#-default 0 can still be overridden if -default appears after -type - we'll allow it.
                                     lappend opt_solos $argname
                                 } else {
                                     #-solo only valid for flags 
                                     error "punk::args::get_dict - invalid -type 'none' for positional argument positional argument '$argname'"
                                 }
                             }
+                            any - ansistring {
+                                tcl::dict::set spec_merged -type any
+                            }
                             default {
-                                dict set merged -type [string tolower $specval]
+                                #allow custom unknown types through for now. Todo - require unknown types to begin with custom- REVIEW
+                                tcl::dict::set spec_merged -type [tcl::string::tolower $specval]
                             }
                         }
                     }
                     -default - -solo - -range - -choices - -choicelabels - -minlen - -maxlen - -nocase - -optional - -multiple - -validate_without_ansi - -allow_ansi - -strip_ansi - -help - -ARGTYPE {
-                        dict set merged $spec $specval
+                        #review -solo 1 vs -type none ?
+                        tcl::dict::set spec_merged $spec $specval
                     }
                     default {
                         set known_argspecs [list -default -type -range -choices -nocase -optional -multiple -validate_without_ansi -allow_ansi -strip_ansi -help]
@@ -512,42 +594,47 @@ namespace eval punk::args {
                     }
                 }
             }
-            set argspecs $merged
-            #if {$is_opt} {
-                set argchecks [dict remove $argspecs -type -default -multiple -strip_ansi -validate_without_ansi -allow_ansi] ;#leave things like -range -minlen 
-            #} else {
-            #    set argchecks [dict remove $argspecs -type -default -multiple -strip_ansi -validate_without_ansi -allow_ansi] ;#leave things like -range -minlen 
-            #}
-            dict set arg_info   $argname $argspecs
-            dict set arg_checks $argname $argchecks
-            if {![dict get $argspecs -optional]} {
+            set argspecs $spec_merged
+            if {$is_opt} {
+                set argchecks [tcl::dict::remove $argspecs -type -default -multiple -strip_ansi -validate_without_ansi -allow_ansi] ;#leave things like -range -minlen 
+            } else {
+                set argchecks [tcl::dict::remove $argspecs -type -default -multiple -strip_ansi -validate_without_ansi -allow_ansi] ;#leave things like -range -minlen 
+            }
+            tcl::dict::set arg_info   $argname $argspecs
+            tcl::dict::set arg_checks $argname $argchecks
+            #review existence of -default overriding -optional
+            if {![tcl::dict::get $argspecs -optional] && ![tcl::dict::exists $argspecs -default]} {
                 if {$is_opt} {
                     lappend opt_required $argname
                 } else {
                     lappend val_required $argname
                 }
             }
-            if {[dict exists $argspecs -default]} {
+            if {[tcl::dict::exists $argspecs -default]} {
                 if {$is_opt} {
-                    dict set opt_defaults $argname [dict get $argspecs -default]
+                    tcl::dict::set opt_defaults $argname [tcl::dict::get $argspecs -default]
                 } else {
-                    dict set val_defaults $argname [dict get $argspecs -default]
+                    tcl::dict::set val_defaults $argname [tcl::dict::get $argspecs -default]
                 }
             }
         }
 
         #confirm any valnames before last don't have -multiple key
         foreach valname [lrange $val_names 0 end-1] {
-            if {[dict get $arg_info $valname -multiple]} {
+            if {[tcl::dict::get $arg_info $valname -multiple]} {
                 error "bad key -multiple on argument spec for '$valname'. Only the last value argument specification can be marked -multiple"
             }
         }
-        if {$spec_id eq "" || [string tolower $spec_id] eq "auto"} {
+        if {$spec_id eq "" || [tcl::string::tolower $spec_id] eq "auto"} {
             variable id_counter
             set spec_id "autoid_[incr id_counter]"
         }
 
-        set result [dict create\
+
+        set opt_checks_defaults [tcl::dict::remove $optspec_defaults -type -default -multiple -strip_ansi -validate_without_ansi -allow_ansi] ;#leave things like -range -minlen 
+        set val_checks_defaults [tcl::dict::remove $valspec_defaults -type -default -multiple -strip_ansi -validate_without_ansi -allow_ansi] ;#leave things like -range -minlen 
+
+        set result [tcl::dict::create\
             id $spec_id\
             arg_info $arg_info\
             arg_checks $arg_checks\
@@ -557,49 +644,161 @@ namespace eval punk::args {
             opt_any $opt_any\
             opt_solos $opt_solos\
             optspec_defaults $optspec_defaults\
-            valspec_defaults $valspec_defaults\
+            opt_checks_defaults $opt_checks_defaults\
             val_defaults $val_defaults\
             val_required $val_required\
             val_names $val_names\
             val_min $val_min\
             val_max $val_max\
             valspec_defaults $valspec_defaults\
+            val_checks_defaults $val_checks_defaults\
             proc_info $proc_info\
         ]
-        dict set argspec_cache $cache_key $result
-        dict set argspecs $spec_id $optionspecs
+        tcl::dict::set argspec_cache $cache_key $result
+        tcl::dict::set argspecs $spec_id $optionspecs
+        #puts "xxx:$result"
         return $result
     }
 
     proc get_spec {id} {
         variable argspecs
-        if {[dict exists $argspecs $id]} {
-            return [dict get $argspecs $id]
+        if {[tcl::dict::exists $argspecs $id]} {
+            return [tcl::dict::get $argspecs $id]
         }
         return
     }
     proc get_spec_ids {{match *}} {
         variable argspecs
-        return [dict keys $argspecs $match]
+        return [tcl::dict::keys $argspecs $match]
     }
 
     #for use within get_dict only
     #This mechanism gets less-than-useful results for oo methods
     #e.g {$obj}
     proc Get_caller {} {
-        set cmdinfo [dict get [info frame -3] cmd]
+        set cmdinfo [tcl::dict::get [tcl::info::frame -3] cmd]
         #puts "-->$cmdinfo"
+        #puts "-->[tcl::info::frame -3]"
         set caller [regexp -inline {\S+} $cmdinfo]
         if {$caller eq "namespace"} {
-            set caller "punk::args::get_dict called from namespace"
+            set cmdinfo "punk::args::get_dict called from namespace"
         }
-        return $caller
+        return $cmdinfo
     }
 
-    proc err {msg args} {
+    proc arg_error {msg spec_dict {badarg ""}} {
+        set errmsg $msg
+        if {![catch {package require textblock}]} {
+            if {[catch  {
+                append errmsg \n
+                set procname [punk::lib::dict_getdef $spec_dict proc_info -name ""]
+                set prochelp [punk::lib::dict_getdef $spec_dict proc_info -help ""]
 
-    }
+                set t [textblock::class::table new [a+ web-yellow]Usage[a]]
+
+                set blank_header_col [list ""]
+                if {$procname ne ""} {
+                    lappend blank_header_col ""
+                    set procname_display [a+ web-white]$procname[a]
+                } else {
+                    set procname_display ""
+                }
+                if {$prochelp ne ""} {
+                    lappend blank_header_col ""
+                    set prochelp_display [a+ web-white]$prochelp[a]
+                } else {
+                    set prochelp_display ""
+                }
+                $t add_column -headers $blank_header_col -minwidth 3 
+                $t add_column -headers $blank_header_col 
+                $t add_column -headers $blank_header_col 
+                $t add_column -headers $blank_header_col 
+                $t add_column -headers $blank_header_col 
+                if {"$procname$prochelp" eq ""} {
+                    $t configure_header 0 -values {Arg Type Default Multiple Help}
+                } elseif {$procname eq ""} {
+                    $t configure_header 0 -colspans {1 4 0 0 0} -values [list Description: $prochelp_display]
+                    $t configure_header 1 -values {Arg Type Default Multiple Help}
+                } elseif {$prochelp eq ""} {
+                    $t configure_header 0 -colspans {1 4 0 0 0} -values [list PROC/METHOD: $procname_display]
+                    $t configure_header 1 -values {Arg Type Default Multiple Help}
+                } else {
+                    $t configure_header 0 -colspans {1 4 0 0 0} -values [list PROC/METHOD: $procname_display]
+                    $t configure_header 1 -colspans {1 4 0 0 0} -values [list Description: $prochelp_display]
+                    $t configure_header 2 -values {Arg Type Default Multiple Help}
+                }
 
+                set c_default [a+ web-white Web-limegreen]
+                set c_badarg [a+ web-crimson]
+                set greencheck [a+ web-limegreen]\u2713[a]
+
+                foreach arg [dict get $spec_dict opt_names] {
+                    set arginfo [dict get $spec_dict arg_info $arg]
+                    if {[dict exists $arginfo -default]} {
+                        #set default $c_default[dict get $arginfo -default]
+                        set default [dict get $arginfo -default]
+                    } else {
+                        set default ""
+                    }
+                    set help [punk::lib::dict_getdef $arginfo -help ""]
+                    if {[dict exists $arginfo -choices]} {
+                        if {$help ne ""} {append help \n}
+                        append help "Choices: [dict get $arginfo -choices]"
+                    }
+                    if {[punk::lib::dict_getdef $arginfo -multiple 0]} {
+                        set multiple $greencheck 
+                    } else {
+                        set multiple ""
+                    }
+                    $t add_row [list $arg [dict get $arginfo -type] $default $multiple $help]
+                    if {$arg eq $badarg} {
+                        $t configure_row [expr {[$t row_count]-1}] -ansibase $c_badarg
+                    }
+                }
+                foreach arg [dict get $spec_dict val_names] {
+                    set arginfo [dict get $spec_dict arg_info $arg]
+                    if {[dict exists $arginfo -default]} {
+                        set default [dict get $arginfo -default]
+                    } else {
+                        set default ""
+                    }
+                    set help [punk::lib::dict_getdef $arginfo -help ""]
+                    if {[dict exists $arginfo -choices]} {
+                        if {$help ne ""} {append help \n}
+                        append help "Choices: [dict get $arginfo -choices]"
+                    }
+                    if {[punk::lib::dict_getdef $arginfo -multiple 0]} {
+                        set multiple $greencheck 
+                    } else {
+                        set multiple ""
+                    }
+                    $t add_row [list $arg [dict get $arginfo -type] $default $multiple $help]
+                    if {$arg eq $badarg} {
+                        $t configure_row [expr {[$t row_count]-1}] -ansibase $c_badarg
+                    }
+                }
+
+
+                $t configure -show_hseps 0 -show_header 1 -ansibase_body [a+ web-white] -ansibase_header [a+ brightyellow] -ansiborder_header [a+ brightyellow] -ansiborder_body [a+ brightyellow]
+                $t configure -maxwidth 80
+                append errmsg [$t print]
+                $t destroy
+            } errM]} {
+                catch {$t destroy}
+                append errmsg \n
+                append errmsg "(additional error in punk::args::arg_error when attempting to display usage)" \n
+                append errmsg "$errM" \n
+                append errmsg "$::errorInfo"
+
+            }
+        } else {
+            #todo - something boring 
+        }
+        #add PUNK to the tail end of the more usual -errorcode {TCL WRONGARGS} so we maintain reasonable compat with things looking for TCL WRONGARGS - but also differentiate it. 
+        #Also,we're polite enough in the errorInfo, nothing wrong with a Clint Eastwood style errorCode  ;)
+        return -code error -errorcode {TCL WRONGARGS PUNK} $errmsg
+    }
+ 
     #generally we expect values to contain leading dashes only if -- specified. Otherwise no reliable way determine difference between bad flags and values
     #If no eopts (--) specified we stop looking for opts at the first nondash encountered in a position we'd expect a dash - so without eopt, values could contain dashes - but not in first position after flags.
     #only supports -flag val pairs, not solo options
@@ -681,9 +880,12 @@ namespace eval punk::args {
 
 
         set argspecs [Get_argspecs $optionspecs]
-        dict with argspecs {} ;#turn keys into vars
+        tcl::dict::with argspecs {} ;#turn keys into vars
         #puts "-arg_info->$arg_info"
-        set flagsreceived [list]
+        set flagsreceived [list] ;#for checking if required flags satisfied
+        #secondary purpose:
+        #for -multple true, we need to ensure we can differentiate between a default value and a first of many that happens to match the default.
+        #-default value must not be appended to if argname not yet in flagsreceived 
 
         set opts $opt_defaults
         if {[set eopts [lsearch -exact $rawargs "--"]] >= 0} {
@@ -692,17 +894,80 @@ namespace eval punk::args {
             set maxidx [expr {[llength $arglist]-1}]
             for {set i 0} {$i <= $maxidx} {incr i} {
                 set a [lindex $arglist $i]
-                if {![string match -* $a]} {
+                if {![tcl::string::match -* $a]} {
                     #we can't treat as first positional arg - as it comes before the eopt indicator --
-                    error "punk::args::get_dict bad options for [Get_caller]. Expected flag (leading -) at position $i got:$rawargs"
+                    arg_error "punk::args::get_dict bad options for [Get_caller]. Expected flag (leading -) at position $i got:$rawargs" $argspecs
                 }
-                #TODO!
-                if {[dict get $arg_info $a -type] ne "none"} {
-                    if {[incr i] > $maxidx} {
-                        error "punk::args::get_dict bad options for [Get_caller]. No value supplied for last option $a which is not marked with -solo 1"
+
+                if {![catch {tcl::prefix match -message "options for %caller%. Unexpected option" $opt_names $a } fullopt]} {
+                    if {[tcl::dict::get $arg_info $fullopt -type] ne "none"} { 
+                        #non-solo
+                        set flagval [lindex $arglist $i+1]
+                        if {[dict get $arg_info $fullopt -multiple]} {
+                            #don't lappend to default - we need to replace if there is a default
+                            #review - what if user sets first value that happens to match a default?
+                            if {$fullopt ni $flagsreceived && [tcl::dict::exists $opt_defaults $fullopt] && ([tcl::dict::get $opt_defaults $fullopt] eq [tcl::dict::get $opts $fullopt])} {
+                                #first occurrence of this flag, whilst stored value matches default
+                                tcl::dict::set opts $fullopt $flagval
+                            } else {
+                                tcl::dict::lappend opts $fullopt $flagval 
+                            }
+                        } else {
+                            tcl::dict::set opts $fullopt $flagval 
+                        }
+                        #incr i to skip flagval
+                        if {[incr i] > $maxidx} {
+                            arg_error "punk::args::get_dict bad options for [Get_caller]. No value supplied for last option $fullopt at index [expr {$i-1}] which is not marked with -type none" $argspecs $fullopt
+                        }
+                    } else {
+                        #type none (solo-flag)
+                        if {[tcl::dict::get $arg_info $fullopt -multiple]} {
+                            if {[tcl::dict::get $opts $fullopt] == 0} {
+                                #review - what if default at time opt was specified is not zero? we will end up with more items in the list than the number of times the flag was specified
+                                tcl::dict::set opts $fullopt 1
+                            } else {
+                                tcl::dict::lappend opts $fullopt 1
+                            }
+                        } else {
+                            tcl::dict::set opts $fullopt 1
+                        }
+                    }
+                    lappend flagsreceived $fullopt ;#dups ok
+                } else {
+                    if {$opt_any} {
+                        set newval [lindex $arglist $i+1]
+                        #opt was unspecified but is allowed due to *opt -any 1 -  'adhoc/passthrough' option  
+                        tcl::dict::set arg_info $a $optspec_defaults ;#use default settings for unspecified opt
+                        tcl::dict::set arg_checks $a $opt_checks_defaults
+                        if {[tcl::dict::get $arg_info $a -type] ne "none"} {
+                            if {[tcl::dict::get $arg_info $a -multiple]} {
+                                tcl::dict::lappend opts $a $newval
+                            } else {
+                                tcl::dict::set opts $a $newval 
+                            }
+                            lappend flagsreceived $a ;#adhoc flag as supplied
+                            if {[incr i] > $maxidx} {
+                                arg_error "punk::args::get_dict bad options for [Get_caller]. No value supplied for last adhoc option $a at index [expr {$i-1}] which is not marked with -type none" $argspecs $a
+                            }
+                        } else {
+                            #review -we can't provide a way to allow unspecified -type none flags through reliably/unambiguously unless all remaining unspecified options are -type none 
+                            if {[tcl::dict::get $arg_info $a -multiple]} {
+                                if {![tcl::dict::exists $opts $a]} {
+                                    tcl::dict::set opts $a 1
+                                } else {
+                                    tcl::dict::lappend opts $a 1
+                                }
+                            } else {
+                                tcl::dict::set opts $a 1
+                            }
+                        }
+                    } else {
+                        #delay Get_caller so only called in the unhappy path
+                        set errmsg [tcl::string::map [list %caller% [Get_caller]] $fullopt] 
+                        arg_error $errmsg $argspecs $fullopt
                     }
                 }
-                lappend flagsreceived $a ;#dups ok
+
             }
         } else {
             if {[lsearch $rawargs -*] >= 0} {
@@ -714,36 +979,46 @@ namespace eval punk::args {
                 set maxidx [expr {[llength $rawargs]-1}]
                 for {set i 0} {$i <= $maxidx} {incr i} {
                     set a [lindex $rawargs $i]
-                    if {![string match -* $a]} {
+                    #we can automatically rule out arguments containing whitespace from the set of simple flags beginning with a dash
+                    #This helps for example when first value is a dict or list in which the first item happens to begin with a dash
+                    #explicit -- still safer in many cases, but this is a reasonable and fast enough test
+                    if {![tcl::string::match -* $a] || [regexp {\s+} $a]} {
                         #assume beginning of positional args
                         incr i -1
                         break
                     }
                     
                     if {![catch {tcl::prefix match -message "options for %caller%. Unexpected option" $opt_names $a } fullopt]} {
-                        if {[dict get $arg_info $fullopt -type] ne "none"} { 
+                        if {[tcl::dict::get $arg_info $fullopt -type] ne "none"} { 
                             #non-solo
                             set flagval [lindex $rawargs $i+1]
                             if {[dict get $arg_info $fullopt -multiple]} {
-                                dict lappend opts $fullopt $flagval 
+                                #don't lappend to default - we need to replace if there is a default
+                                #review - what if user sets first value that happens to match a default?
+                                if {$fullopt ni $flagsreceived && [tcl::dict::exists $opt_defaults $fullopt] && ([tcl::dict::get $opt_defaults $fullopt] eq [tcl::dict::get $opts $fullopt])} {
+                                    #first occurrence of this flag, whilst stored value matches default
+                                    tcl::dict::set opts $fullopt $flagval
+                                } else {
+                                    tcl::dict::lappend opts $fullopt $flagval 
+                                }
                             } else {
-                                dict set opts $fullopt $flagval 
+                                tcl::dict::set opts $fullopt $flagval 
                             }
                             #incr i to skip flagval
                             if {[incr i] > $maxidx} {
-                                error "punk::args::get_dict bad options for [Get_caller]. No value supplied for last option $fullopt at index [expr {$i-1}] which is not marked with -type none"
+                                arg_error "punk::args::get_dict bad options for [Get_caller]. No value supplied for last option $fullopt at index [expr {$i-1}] which is not marked with -type none" $argspecs $fullopt
                             }
                         } else {
                             #type none (solo-flag)
-                            if {[dict get $arg_info $fullopt -multiple]} {
-                                if {[dict get $opts $fullopt] == 0} {
+                            if {[tcl::dict::get $arg_info $fullopt -multiple]} {
+                                if {[tcl::dict::get $opts $fullopt] == 0} {
                                     #review - what if default at time opt was specified is not zero? we will end up with more items in the list than the number of times the flag was specified
-                                    dict set opts $fullopt 1
+                                    tcl::dict::set opts $fullopt 1
                                 } else {
-                                    dict lappend opts $fullopt 1
+                                    tcl::dict::lappend opts $fullopt 1
                                 }
                             } else {
-                                dict set opts $fullopt 1
+                                tcl::dict::set opts $fullopt 1
                             }
                         }
                         lappend flagsreceived $fullopt ;#dups ok
@@ -751,33 +1026,34 @@ namespace eval punk::args {
                         if {$opt_any} {
                             set newval [lindex $rawargs $i+1]
                             #opt was unspecified but is allowed due to *opt -any 1 -  'adhoc/passthrough' option  
-                            dict set arg_info $a $optspec_defaults ;#use default settings for unspecified opt
-                            if {[dict get $arg_info $a -type] ne "none"} {
-                                if {[dict get $arg_info $a -multiple]} {
-                                    dict lappend opts $a $newval
+                            tcl::dict::set arg_info $a $optspec_defaults ;#use default settings for unspecified opt
+                            tcl::dict::set arg_checks $a $opt_checks_defaults
+                            if {[tcl::dict::get $arg_info $a -type] ne "none"} {
+                                if {[tcl::dict::get $arg_info $a -multiple]} {
+                                    tcl::dict::lappend opts $a $newval
                                 } else {
-                                    dict set opts $a $newval 
+                                    tcl::dict::set opts $a $newval 
                                 }
                                 lappend flagsreceived $a ;#adhoc flag as supplied
                                 if {[incr i] > $maxidx} {
-                                    error "punk::args::get_dict bad options for [Get_caller]. No value supplied for last adhoc option $a at index [expr {$i-1}] which is not marked with -type none"
+                                    arg_error "punk::args::get_dict bad options for [Get_caller]. No value supplied for last adhoc option $a at index [expr {$i-1}] which is not marked with -type none" $argspecs $a
                                 }
                             } else {
                                 #review -we can't provide a way to allow unspecified -type none flags through reliably/unambiguously unless all remaining unspecified options are -type none 
-                                if {[dict get $arg_info $a -multiple]} {
-                                    if {![dict exists $opts $a]} {
-                                        dict set opts $a 1
+                                if {[tcl::dict::get $arg_info $a -multiple]} {
+                                    if {![tcl::dict::exists $opts $a]} {
+                                        tcl::dict::set opts $a 1
                                     } else {
-                                        dict lappend opts $a 1
+                                        tcl::dict::lappend opts $a 1
                                     }
                                 } else {
-                                    dict set opts $a 1
+                                    tcl::dict::set opts $a 1
                                 }
                             }
                         } else {
                             #delay Get_caller so only called in the unhappy path
-                            set errmsg [string map [list %caller% [Get_caller]] $fullopt] 
-                            error $errmsg
+                            set errmsg [tcl::string::map [list %caller% [Get_caller]] $fullopt] 
+                            arg_error $errmsg $argspecs $fullopt
                         }
                     }
                 }
@@ -800,20 +1076,26 @@ namespace eval punk::args {
                 break
             }
             if {$valname ne ""} {
-                if {[dict get $arg_info $valname -multiple]} {
-                    dict lappend values_dict $valname $val
+                if {[tcl::dict::get $arg_info $valname -multiple]} {
+                    if {[tcl::dict::exists $val_defaults $valname] && ([tcl::dict::get $val_defaults $valname] eq [tcl::dict::get $values_dict $valname])} {
+                        #current stored val equals defined default - don't include default in the list we build up
+                        tcl::dict::set values_dict $valname $val
+                    } else {
+                        tcl::dict::lappend values_dict $valname $val
+                    }
                     set in_multiple $valname 
                 } else {
-                    dict set values_dict $valname $val 
+                    tcl::dict::set values_dict $valname $val 
                 }
                 lappend valnames_received $valname
             } else {
                 if {$in_multiple ne ""} {
-                    dict lappend values_dict $in_multiple $val
+                    tcl::dict::lappend values_dict $in_multiple $val
                     #name already seen
                 } else {
-                    dict set values_dict $validx $val
-                    dict set arg_info $validx $valspec_defaults
+                    tcl::dict::set values_dict $validx $val
+                    tcl::dict::set arg_info $validx $valspec_defaults
+                    tcl::dict::set arg_checks $validx $val_checks_defaults
                     lappend valnames_received $validx
                 }
             }
@@ -823,14 +1105,14 @@ namespace eval punk::args {
         if {$val_max == -1} {
             #only check min
             if {$num_values < $val_min} {
-                error "bad number of trailing values for [Get_caller]. Got $num_values values. Expected at least $val_min"
+                arg_error "bad number of trailing values for [Get_caller]. Got $num_values values. Expected at least $val_min" $argspecs
             }
         } else {
             if {$num_values < $val_min || $num_values > $val_max} {
                 if {$val_min == $val_max} {
-                    error "bad number of trailing values for [Get_caller]. Got $num_values values. Expected exactly $val_min"
+                    arg_error "bad number of trailing values for [Get_caller]. Got $num_values values. Expected exactly $val_min" $argspecs
                 } else {
-                    error "bad number of trailing values for [Get_caller]. Got $num_values values. Expected between $val_min and $val_max inclusive"
+                    arg_error "bad number of trailing values for [Get_caller]. Got $num_values values. Expected between $val_min and $val_max inclusive" $argspecs
                 }
             }
         }
@@ -844,33 +1126,48 @@ namespace eval punk::args {
         #The aim is to allow a wrapper function to specify a default value for an option (and/or other changes/restrictions to a particular option or two) - without having to re-specify all the options for the underlying function.
         #without full respecification in the wrapper - we can't know that a supplied prefix is unambiguous at the next level 
         #For this reason we need to pass on full-length opts for any defined options in the wrapper even if anyopts is true
-        if {[llength [set missing [struct::set difference $opt_required $flagsreceived]]]} {
-            error "Required option missing for [Get_caller]. missing flags $missing  are marked with -optional false - so must be present in full-length form" 
+
+        #safe interp note - cannot avoid struct::set difference ensemble as it could be c or tcl implementation and we don't have an option to call directly?
+        #example timing difference:
+        #struct::set difference {x} {a b}
+        #normal interp 0.18 u2   vs safe interp 9.4us
+        #if {[llength [set missing [struct::set difference $opt_required $flagsreceived]]]} {
+        #    error "Required option missing for [Get_caller]. missing flags $missing  are marked with -optional false - so must be present in full-length form" 
+        #}
+        #if {[llength [set missing [struct::set difference $val_required $valnames_received]]]} {
+        #       error "Required value missing for [Get_caller]. missing values $missing marked with -optional false - so must be present" 
+        #}
+        #for now (2024-06) punk::lib::ldiff is a better compromise across normal/safe interps e.g 0.7/0.8us
+        if {[llength [set missing [punk::lib::ldiff $opt_required $flagsreceived]]]} {
+            arg_error "Required option missing for [Get_caller]. missing flags: '$missing'  are marked with -optional false - so must be present in full-length form" $argspecs
         }
-        if {[llength [set missing [struct::set difference $val_required $valnames_received]]]} {
-               error "Required value missing for [Get_caller]. missing values $missing marked with -optional false - so must be present" 
+        if {[llength [set missing [punk::lib::ldiff $val_required $valnames_received]]]} {
+               arg_error "Required value missing for [Get_caller]. missing values: '$missing' marked with -optional false - so must be present" $argspecs
         }
+
+
+
         #todo - allow defaults outside of choices/ranges
 
         #check types,ranges,choices
-        set opts_and_values [dict merge $opts $values_dict]
-        #set combined_defaults [dict merge $val_defaults $opt_defaults] ;#can be no key collisions - we don't allow a value key beginning with dash - opt names must begin with dash
+        set opts_and_values [tcl::dict::merge $opts $values_dict]
+        #set combined_defaults [tcl::dict::merge $val_defaults $opt_defaults] ;#can be no key collisions - we don't allow a value key beginning with dash - opt names must begin with dash
         #puts "---opts_and_values:$opts_and_values"
         #puts "---arg_info:$arg_info"
-        dict for {argname v} $opts_and_values {
-            set thisarg [dict get $arg_info $argname]
-            #set thisarg_keys [dict keys $thisarg]
-            set thisarg_checks [dict get $arg_checks $argname]
-            set is_multiple [dict get $thisarg -multiple]
-            set is_allow_ansi [dict get $thisarg -allow_ansi]
-            set is_validate_without_ansi [dict get $thisarg -validate_without_ansi]
-            set is_strip_ansi [dict get $thisarg -strip_ansi]
-            set has_default [dict exists $thisarg -default]
+        tcl::dict::for {argname v} $opts_and_values {
+            set thisarg [tcl::dict::get $arg_info $argname]
+            #set thisarg_keys [tcl::dict::keys $thisarg]
+            set thisarg_checks [tcl::dict::get $arg_checks $argname]
+            set is_multiple [tcl::dict::get $thisarg -multiple]
+            set is_allow_ansi [tcl::dict::get $thisarg -allow_ansi]
+            set is_validate_without_ansi [tcl::dict::get $thisarg -validate_without_ansi]
+            set is_strip_ansi [tcl::dict::get $thisarg -strip_ansi]
+            set has_default [tcl::dict::exists $thisarg -default]
             if {$has_default} {
-                set defaultval [dict get $thisarg -default]
+                set defaultval [tcl::dict::get $thisarg -default]
             }
-            set type [dict get $thisarg -type]
-            set has_choices [dict exists $thisarg -choices]
+            set type [tcl::dict::get $thisarg -type]
+            set has_choices [tcl::dict::exists $thisarg -choices]
 
             if {$is_multiple} {
                 set vlist $v
@@ -880,6 +1177,7 @@ namespace eval punk::args {
             if {!$is_allow_ansi} {
                 #allow_ansi 0
                 package require punk::ansi
+                #do not run ta::detect on a list
                 foreach e $vlist {
                     if {[punk::ansi::ta::detect $e]} {
                         error "Option $argname for [Get_caller] contains ansi - but -allow_ansi is false. Received: '$e'"
@@ -912,24 +1210,27 @@ namespace eval punk::args {
             #puts "argname:$argname v:$v  is_default:$is_default"
             #we want defaults to pass through - even if they don't pass the checks that would be required for a specified value
             #If the caller manually specified a value that happens to match the default - we don't detect that as any different from an unspecified value - Review.
+            #arguments that are at their default are not subject to type and other checks
             if {$is_default == 0} {
                 switch -- $type {
                     any {}
                     string {
-                        if {[dict size $thisarg_checks]} {
+                        if {[tcl::dict::size $thisarg_checks]} {
                             foreach e_check $vlist_check {
-                                dict for {checkopt checkval} $thisarg_checks {
+                                #safe jumptable test
+                                #dict for {checkopt checkval} $thisarg_checks {}
+                                tcl::dict::for {checkopt checkval} $thisarg_checks {
                                     switch -- $checkopt {
                                         -minlen {
                                             # -1 for disable is as good as zero
-                                            if {[string length $e_check] < $checkval} {
-                                                error "Option $argname for [Get_caller] requires string with -minlen $checkval. Received len:[string length $e_check] value:'$e_check'"
+                                            if {[tcl::string::length $e_check] < $checkval} {
+                                                arg_error "Option $argname for [Get_caller] requires string with -minlen $checkval. Received len:[tcl::string::length $e_check] value:'$e_check'" $argspecs $argname
                                             }
                                         }
                                         -maxlen {
                                             if {$checkval ne "-1"} {
-                                                if {[string length $e_check] > $checkval} {
-                                                    error "Option $argname for [Get_caller] requires string with -maxlen $checkval. Received len:[string length $e_check] value:'$e_check'"
+                                                if {[tcl::string::length $e_check] > $checkval} {
+                                                    arg_error "Option $argname for [Get_caller] requires string with -maxlen $checkval. Received len:[tcl::string::length $e_check] value:'$e_check'" $argspecs $argname
                                                 }
                                             }
                                         }
@@ -942,37 +1243,39 @@ namespace eval punk::args {
                         package require ansi
                     }
                     int  {
-                        if {[dict exists $thisarg -range]} {
-                            lassign [dict get $thisarg -range] low high
+                        if {[tcl::dict::exists $thisarg -range]} {
+                            lassign [tcl::dict::get $thisarg -range] low high
                             foreach e $vlist e_check $vlist_check {
-                                if {![string is integer -strict $e_check]} {
-                                    error "Option $argname for [Get_caller] requires type 'integer'. Received: '$e'"
+                                if {![tcl::string::is integer -strict $e_check]} {
+                                    arg_error "Option $argname for [Get_caller] requires type 'integer'. Received: '$e'" $argspecs $argname
                                 }
                                 if {$e_check < $low || $e_check > $high} {
-                                    error "Option $argname for [Get_caller] must be integer between $low and $high. Received: '$e'"
+                                    arg_error "Option $argname for [Get_caller] must be integer between $low and $high. Received: '$e'" $argspecs $argname
                                 }
                             }
                         } else {
                             foreach e_check $vlist_check {
-                                if {![string is integer -strict $e_check]} {
-                                    error "Option $argname for [Get_caller] requires type 'integer'. Received: '$e_check'"
+                                if {![tcl::string::is integer -strict $e_check]} {
+                                    arg_error "Option $argname for [Get_caller] requires type 'integer'. Received: '$e_check'" $argspecs $argname
                                 }
                             } 
                         }
                     }
                     double {
                         foreach e $vlist e_check $vlist_check {
-                            if {![string is double -strict $e_check]} {
+                            if {![tcl::string::is double -strict $e_check]} {
                                 error "Option $argname for [Get_caller] requires type 'double'. Received: '$e'"
                             }
-                            if {[dict size $thisarg_checks]} {
-                                dict for {checkopt checkval} $thisarg_checks {
+                            if {[tcl::dict::size $thisarg_checks]} {
+                                #safe jumptable test
+                                #dict for {checkopt checkval} $thisarg_checks {}
+                                tcl::dict::for {checkopt checkval} $thisarg_checks {
                                     switch -- $checkopt {
                                         -range {
                                             #todo - small-value double comparisons with error-margin? review
                                             lassign $checkval low high
                                             if {$e_check < $low || $e_check > $high} {
-                                                error "Option $argname for [Get_caller] must be between $low and $high. Received: '$e'"
+                                                arg_error "Option $argname for [Get_caller] must be between $low and $high. Received: '$e'" $argspecs $argname
                                             }
                                         }
                                     }
@@ -982,8 +1285,15 @@ namespace eval punk::args {
                     }
                     bool {
                         foreach e_check $vlist_check {
-                            if {![string is boolean -strict $e_check]} {
-                                error "Option $argname for [Get_caller] requires type 'boolean'. Received: '$e_check'"
+                            if {![tcl::string::is boolean -strict $e_check]} {
+                                arg_error "Option $argname for [Get_caller] requires type 'boolean'. Received: '$e_check'" $argspecs $argname
+                            }
+                        }
+                    }
+                    dict {
+                        foreach e_check $vlist_check {
+                            if {[llength $e_check] %2 != 0} {
+                                arg_error "Option $argname for [Get_caller] requires type 'dict' - must be key value pairs. Received: '$e_check'" $argspecs $argname
                             }
                         }
                     }
@@ -1001,8 +1311,8 @@ namespace eval punk::args {
                     wordchar -
                     xdigit {
                         foreach e $vlist e_check $vlist_check {
-                            if {![string is $type $e_check]} {
-                                error "Option $argname for [Get_caller] requires type '$type'. Received: '$e'"
+                            if {![tcl::string::is $type $e_check]} {
+                                arg_error "Option $argname for [Get_caller] requires type '$type'. Received: '$e'" $argspecs $argname
                             }
                         }
                     }
@@ -1011,73 +1321,73 @@ namespace eval punk::args {
                     existingfile -
                     existingdirectory {
                         foreach e $vlist e_check $vlist_check {
-                            if {!([string length $e_check]>0 && ![regexp {[\"*?<>\;]} $e_check])} {
+                            if {!([tcl::string::length $e_check]>0 && ![regexp {[\"*?<>\;]} $e_check])} {
                                 #what about special file names e.g on windows NUL ?
-                                error "Option $argname for [Get_caller] requires type '$type'. Received: '$e' which doesn't look like it could be a file or directory"
+                                arg_error "Option $argname for [Get_caller] requires type '$type'. Received: '$e' which doesn't look like it could be a file or directory" $argspecs $argname
                             }
                         }
                         if {$type eq "existingfile"} {
                             foreach e $vlist e_check $vlist_check {
                                 if {![file exists $e_check]} {
-                                    error "Option $argname for [Get_caller] requires type '$type'. Received: '$e' which is not an existing file"
+                                    arg_error "Option $argname for [Get_caller] requires type '$type'. Received: '$e' which is not an existing file" $argspecs $argname
                                 }
                             }
                         } elseif {$type eq "existingdirectory"} {
                             foreach e $vlist e_check $vlist_check {
                                 if {![file isdirectory $e_check]} {
-                                    error "Option $argname for [Get_caller] requires type '$type'. Received: '$e' which is not an existing directory"
+                                    arg_error "Option $argname for [Get_caller] requires type '$type'. Received: '$e' which is not an existing directory" $argspecs $argname
                                 }
                             }
                         }
                     }
                     char {
                         foreach e $vlist e_check $vlist_check {
-                            if {[string length $e_check] != 1} {
-                                error "Option $argname for [Get_caller] requires type 'character'. Received: '$e' which is not a single character"
+                            if {[tcl::string::length $e_check] != 1} {
+                                arg_error "Option $argname for [Get_caller] requires type 'character'. Received: '$e' which is not a single character" $argspecs $argname
                             }
                         }
                     }
                 }
                 if {$has_choices} {
                     #todo -choicelabels
-                    set choices [dict get $thisarg -choices]
-                    set nocase  [dict get $thisarg -nocase]
+                    set choices [tcl::dict::get $thisarg -choices]
+                    set nocase  [tcl::dict::get $thisarg -nocase]
                     foreach e $vlist e_check $vlist_check {
                         if {$nocase} {
                             set casemsg "(case insensitive)"
-                            set choices_test [string tolower $choices]
-                            set v_test [string tolower $e_check]
+                            set choices_test [tcl::string::tolower $choices]
+                            set v_test [tcl::string::tolower $e_check]
                         } else {
                             set casemsg "(case sensitive)"
                             set v_test $e_check
                             set choices_test $choices
                         }
                         if {$v_test ni $choices_test} {
-                            error "Option $argname for [Get_caller] must be one of the listed values $choices $casemsg. Received: '$e'"
+                            arg_error "Option $argname for [Get_caller] must be one of the listed values $choices $casemsg. Received: '$e'" $argspecs $argname
                         }
                     }
                 }
             }
             if {$is_strip_ansi} {
                 set stripped_list [lmap e $vlist {punk::ansi::stripansi $e}] ;#no faster or slower, but more concise than foreach
-                if {[dict get $thisarg -multiple]} {
-                    if {[dict get $thisarg -ARGTYPE] eq "option"} {
-                        dict set opts $argname $stripped_list                        
+                if {[tcl::dict::get $thisarg -multiple]} {
+                    if {[tcl::dict::get $thisarg -ARGTYPE] eq "option"} {
+                        tcl::dict::set opts $argname $stripped_list                        
                     } else {
-                        dict set values_dict $argname $stripped_list
+                        tcl::dict::set values_dict $argname $stripped_list
                     }
                 } else {
-                    if {[dict get $thisarg -ARGTYPE] eq "option"} {
-                        dict set opts $argname [lindex $stripped_list 0]
+                    if {[tcl::dict::get $thisarg -ARGTYPE] eq "option"} {
+                        tcl::dict::set opts $argname [lindex $stripped_list 0]
                     } else {
-                        dict set values_dict [lindex $stripped_list 0]
+                        tcl::dict::set values_dict [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 [tcl::dict::create opts $opts values $values_dict]
     }
 
     #proc sample1 {p1 args} {
@@ -1099,9 +1409,9 @@ namespace eval punk::args {
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # Secondary API namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::args::lib {
-    namespace export *
-    namespace path [namespace parent]
+tcl::namespace::eval punk::args::lib {
+    tcl::namespace::export *
+    tcl::namespace::path [tcl::namespace::parent]
     #*** !doctools
     #[subsection {Namespace punk::args::lib}]
     #[para] Secondary functions that are part of the API 
@@ -1126,7 +1436,7 @@ namespace eval punk::args::lib {
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 #*** !doctools
 #[section Internal]
-namespace eval punk::args::system {
+tcl::namespace::eval punk::args::system {
     #*** !doctools
     #[subsection {Namespace punk::args::system}]
     #[para] Internal functions that are not part of the API 
@@ -1136,7 +1446,7 @@ namespace eval punk::args::system {
 }
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide punk::args [namespace eval punk::args {
+package provide punk::args [tcl::namespace::eval punk::args {
     variable pkg punk::args
     variable version
     set version 0.1.0 
diff --git a/src/bootsupport/modules/punk/assertion-0.1.0.tm b/src/bootsupport/modules/punk/assertion-0.1.0.tm
index 64ecbbd..bee5a41 100644
--- a/src/bootsupport/modules/punk/assertion-0.1.0.tm
+++ b/src/bootsupport/modules/punk/assertion-0.1.0.tm
@@ -69,11 +69,11 @@ package require Tcl 8.6-
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # oo::class namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::assertion::class {
+tcl::namespace::eval punk::assertion::class {
     #*** !doctools
     #[subsection {Namespace punk::assertion::class}]
     #[para] class definitions
-    if {[info commands [namespace current]::interface_sample1] eq ""} {
+    if {[tcl::info::commands [tcl::namespace::current]::interface_sample1] eq ""} {
         #*** !doctools
         #[list_begin enumerated]
 
@@ -100,16 +100,16 @@ namespace eval punk::assertion::class {
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 
 #keep 2 namespaces for assertActive and assertInactive so there is introspection available via namespace origin 
-namespace eval punk::assertion::primary {
-
-    namespace export *
+tcl::namespace::eval punk::assertion::primary {
+    #tcl::namespace::export {[a-z]*} 
+    tcl::namespace::export assertActive assertInactive
     proc assertActive {expr args} {
 
         set code [catch {uplevel 1 [list expr $expr]} res]
         if {$code} {
             return -code $code $res
         }
-        if {![string is boolean -strict $res]} {
+        if {![tcl::string::is boolean -strict $res]} {
             return -code error "invalid boolean expression: $expr"
         }
         
@@ -124,28 +124,40 @@ namespace eval punk::assertion::primary {
 
         upvar ::punk::assertion::CallbackCmd CallbackCmd
         # Might want to catch this
-        namespace eval :: $CallbackCmd [list $msg]
+        tcl::namespace::eval :: $CallbackCmd [list $msg]
     }
     proc assertInactive args {}
 
 }
-namespace eval punk::assertion::secondary {
-    namespace export * 
+tcl::namespace::eval punk::assertion::secondary {
+    tcl::namespace::export * 
     #we need to actually define these procs here, (not import then re-export) - or namespace origin will report the original source namespace - which isn't what we want.
-    proc assertActive {expr args} [info body ::punk::assertion::primary::assertActive] 
+    proc assertActive {expr args} [tcl::info::body ::punk::assertion::primary::assertActive] 
     proc assertInactive args {}
 }
 
-
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # Base namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::assertion {
+tcl::namespace::eval punk::assertion {
     variable CallbackCmd [list return -code error]
-    namespace import ::punk::assertion::primary::assertActive
+
+    #puts --------AAA
+    #*very* slow in safe interp - why?
+    #tcl::namespace::import ::punk::assertion::primary::assertActive
+
+    proc do_ns_import {} {
+        uplevel 1 [list tcl::namespace::import ::punk::assertion::primary::assertActive]
+    }
+    do_ns_import
+    #puts --------BBB
     rename assertActive assert 
 
-    namespace export *
+}
+
+
+tcl::namespace::eval punk::assertion {
+    tcl::namespace::export *
     #variable xyz
 
     #*** !doctools
@@ -177,7 +189,7 @@ namespace eval punk::assertion {
 	    set n [llength $args]
 	    if {$n > 1} {
 		return -code error "wrong # args: should be\
-			\"[lindex [info level 0] 0] ?command?\""
+			\"[lindex [tcl::info::level 0] 0] ?command?\""
 	    }
 	    if {$n} {
             set  cb [lindex $args 0]
@@ -187,41 +199,41 @@ namespace eval punk::assertion {
 	}
 
     proc active {{on_off ""}} {
-        set nscaller [uplevel 1 [list namespace current]]
-        set which_assert [namespace eval $nscaller {namespace which assert}]
+        set nscaller [uplevel 1 [list tcl::namespace::current]]
+        set which_assert [tcl::namespace::eval $nscaller {tcl::namespace::which assert}]
         #puts "nscaller:'$nscaller'"
         #puts "which_assert: $which_assert"
 
         if {$on_off eq ""} {
             if {$which_assert eq ""} {return 0}
-            set assertorigin [namespace origin $which_assert]
+            set assertorigin [tcl::namespace::origin $which_assert]
             #puts "ns which assert:        $which_assert"
             #puts "ns origin assert:       $assertorigin"
-            return [expr {"assertActive" eq [namespace tail $assertorigin]}]
+            return [expr {"assertActive" eq [tcl::namespace::tail $assertorigin]}]
         }
-        if {![string is boolean -strict $on_off]} {
+        if {![tcl::string::is boolean -strict $on_off]} {
             error "invalid boolean value : $on_off"
         } else {
-            set info_command [namespace eval $nscaller {info commands assert}]
+            set info_command [tcl::namespace::eval $nscaller {tcl::info::commands assert}]
             if {$on_off} {
                 #Enable it in calling namespace
                 if {"assert" eq $info_command} {
                     #There is an assert command reachable - due to namespace path etc, it could be in another namespace entirely - (not necessarily in an ancestor namespace of the namespace's tree structure) 
                     if {$which_assert eq [punk::assertion::system::nsjoin ${nscaller} assert]} {
-                        namespace eval $nscaller {
-                            set assertorigin [namespace origin assert]
+                        tcl::namespace::eval $nscaller {
+                            set assertorigin [tcl::namespace::origin assert]
                             set assertorigin_ns [punk::assertion::system::nsprefix $assertorigin]
                             switch -- $assertorigin_ns {
                                 ::punk::assertion {
                                     #original import - switch to primary origin
                                     rename assert {}
-                                    namespace import ::punk::assertion::primary::assertActive
+                                    tcl::namespace::import ::punk::assertion::primary::assertActive
                                     rename assertActive assert
                                 }
                                 ::punk::assertion::primary - ::punk::assertion::secondary {
                                     #keep using from same origin ns
                                     rename assert {}
-                                    namespace import ${assertorigin_ns}::assertActive
+                                    tcl::namespace::import ${assertorigin_ns}::assertActive
                                     rename assertActive assert
                                 }
                                 default {
@@ -232,10 +244,10 @@ namespace eval punk::assertion {
                         return 1
                     } else {
                         #assert is available, but isn't in the calling namespace - we should enable it in a way that is distinguishable from case where assert was explicitly imported to this namespace 
-                        namespace eval $nscaller {
-                            set assertorigin [namespace origin assert]
-                            if {[string match ::punk::assertion::* $assertorigin]} {
-                                namespace import ::punk::assertion::secondary::assertActive
+                        tcl::namespace::eval $nscaller {
+                            set assertorigin [tcl::namespace::origin assert]
+                            if {[tcl::string::match ::punk::assertion::* $assertorigin]} {
+                                tcl::namespace::import ::punk::assertion::secondary::assertActive
                                 rename assertActive assert
                             } else {
                                 error "The reachable assert command at '$which_assert' is not from punk::assertion package. Import punk::assertion::assert - or use the enable mechanism from the package associated with $assertorigin"
@@ -254,20 +266,20 @@ namespace eval punk::assertion {
                 if {"assert" eq $info_command} {
                     if {$which_assert eq [punk::assertion::system::nsjoin ${nscaller} assert]} {
                         #assert is present in callers NS
-                        namespace eval $nscaller {
-                            set assertorigin [namespace origin assert]
+                        tcl::namespace::eval $nscaller {
+                            set assertorigin [tcl::namespace::origin assert]
                             set assertorigin_ns [punk::assertion::system::nsprefix $assertorigin]
                             switch -glob -- $assertorigin_ns {
                                 ::punk::assertion {
                                     #original import
                                     rename assert {}
-                                    namespace import punk::assertion::primary::assertInactive
+                                    tcl::namespace::import punk::assertion::primary::assertInactive
                                     rename assertInactive assert
                                 }
                                 ::punk::assertion::primary - ::punk::assertion::secondary {
                                     #keep using from same origin ns
                                     rename assert {}
-                                    namespace import ${assertorigin_ns}::assertInactive
+                                    tcl::namespace::import ${assertorigin_ns}::assertInactive
                                     rename assertInactive assert
                                 }
                                 default {
@@ -278,11 +290,11 @@ namespace eval punk::assertion {
                         return 0
                     } else {
                         #assert not present in callers NS - first install of secondary (if assert is from punk::assertion::*)
-                        namespace eval $nscaller {
-                            set assertorigin [namespace origin assert]
+                        tcl::namespace::eval $nscaller {
+                            set assertorigin [tcl::namespace::origin assert]
                             set assertorigin_ns [punk::assertion::system::nsprefix $assertorigin]
-                            if {[string match ::punk::assertion::* $assertorigin]} {
-                                namespace import ::punk::assertion::secondary::assertInactive
+                            if {[tcl::string::match ::punk::assertion::* $assertorigin]} {
+                                tcl::namespace::import ::punk::assertion::secondary::assertInactive
                                 rename assertInactive assert
                             } else {
                                 error "The reachable assert command at '$which_assert' is not from punk::assertion package. Import punk::assertion::assert - or use the enable mechanism from the package associated with $assertorigin"
@@ -310,9 +322,9 @@ namespace eval punk::assertion {
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # Secondary API namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::assertion::lib {
-    namespace export *
-    namespace path [namespace parent]
+tcl::namespace::eval punk::assertion::lib {
+    tcl::namespace::export *
+    tcl::namespace::path [tcl::namespace::parent]
     #*** !doctools
     #[subsection {Namespace punk::assertion::lib}]
     #[para] Secondary functions that are part of the API 
@@ -337,7 +349,7 @@ namespace eval punk::assertion::lib {
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 #*** !doctools
 #[section Internal]
-namespace eval punk::assertion::system {
+tcl::namespace::eval punk::assertion::system {
     #*** !doctools
     #[subsection {Namespace punk::assertion::system}]
     #[para] Internal functions that are not part of the API 
@@ -346,33 +358,33 @@ namespace eval punk::assertion::system {
     #nsprefix/nstail are string functions - they do not concern themselves with what namespaces are present in the system
     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]]]
+        set nspath [tcl::string::map [list :::: ::] $nspath]
+        set rawprefix [tcl::string::range $nspath 0 end-[tcl::string::length [nstail $nspath]]]
         if {$rawprefix eq "::"} {
             return $rawprefix
         } else {
-            if {[string match *:: $rawprefix]} {
-                return  [string range $rawprefix 0 end-2]
+            if {[tcl::string::match *:: $rawprefix]} {
+                return  [tcl::string::range $rawprefix 0 end-2]
             } else {
                 return $rawprefix
             }
-            #return [string trimright $rawprefix :]
+            #return [tcl::string::trimright $rawprefix :]
         }
     }
     #see also punk::ns - keep in sync
     proc nstail {nspath args} {
         #normalize the common case of ::::
-        set nspath [string map [list :::: ::] $nspath]
-        set mapped [string map [list :: \u0FFF] $nspath] 
+        set nspath [tcl::string::map [list :::: ::] $nspath]
+        set mapped [tcl::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]
+        set opts [tcl::dict::merge $defaults $args]
+        set strict [tcl::dict::get $opts -strict]
 
         if {$strict} {
             foreach p $parts {
-                if {[string match :* $p]} {
+                if {[tcl::string::match :* $p]} {
                     error "nstail unpaired colon ':' in $nspath"
                 }
             }
@@ -381,7 +393,7 @@ namespace eval punk::assertion::system {
         return [lindex $parts end]
     }
     proc nsjoin {prefix name} {
-        if {[string match ::* $name]} {
+        if {[tcl::string::match ::* $name]} {
             if {"$prefix" ne ""} {
                 error "nsjoin: won't join non-empty prefix to absolute namespace path '$name'"
             }
@@ -400,7 +412,7 @@ namespace eval punk::assertion::system {
 }
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide punk::assertion [namespace eval punk::assertion {
+package provide punk::assertion [tcl::namespace::eval punk::assertion {
     variable pkg punk::assertion
     variable version
     set version 0.1.0 
diff --git a/src/bootsupport/modules/punk/cap-0.1.0.tm b/src/bootsupport/modules/punk/cap-0.1.0.tm
index 8488bbc..68d3252 100644
--- a/src/bootsupport/modules/punk/cap-0.1.0.tm
+++ b/src/bootsupport/modules/punk/cap-0.1.0.tm
@@ -48,12 +48,12 @@ package require oolib
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::cap {
-    variable pkgcapsdeclared [dict create] 
-    variable pkgcapsaccepted [dict create]
-    variable caps [dict create]
+tcl::namespace::eval punk::cap {
+    variable pkgcapsdeclared [tcl::dict::create] 
+    variable pkgcapsaccepted [tcl::dict::create]
+    variable caps [tcl::dict::create]
     namespace eval class {
-        if {[info commands [namespace current]::interface_caphandler.registry] eq ""} {
+        if {[tcl::info::commands ::punk::cap::class::interface_caphandler.registry] eq ""} {
             #*** !doctools
             #[subsection {Namespace punk::cap::class}]
             #[para] class definitions
@@ -62,7 +62,7 @@ namespace eval punk::cap {
             #  [para] [emph {handler_classes}]
             #  [list_begin enumerated]
 
-            oo::class create [namespace current]::interface_caphandler.registry {
+            oo::class create ::punk::cap::class::interface_caphandler.registry {
                 #*** !doctools
                 #[enum] CLASS [class interface_caphandler.registry]
                 #[list_begin definitions]
@@ -83,7 +83,7 @@ namespace eval punk::cap {
                 #[list_end]
             }
 
-            oo::class create [namespace current]::interface_caphandler.sysapi {
+            oo::class create ::punk::cap::class::interface_caphandler.sysapi {
                 #*** !doctools
                 #[enum] CLASS [class interface_caphandler.sysapi]
                 #[list_begin definitions]
@@ -103,7 +103,7 @@ namespace eval punk::cap {
             #  [list_begin enumerated]
 
             #Provider classes
-            oo::class create [namespace current]::interface_capprovider.registration {
+            oo::class create ::punk::cap::class::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. 
@@ -140,7 +140,7 @@ namespace eval punk::cap {
                 #    [list_end]
             }
 
-            oo::class create [namespace current]::interface_capprovider.provider {
+            oo::class create ::punk::cap::class::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}] 
@@ -157,7 +157,7 @@ namespace eval punk::cap {
                     #*** !doctools
                     #[call class::interface_capprovider.provider [method constructor] [arg providerpkg]]
                     variable provider_pkg
-                    if {$providerpkg in [list "" "::"]} {
+                    if {$providerpkg in {"" "::"}} {
                         error "interface_capprovider.provider constructor error. Invalid provider '$providerpkg'"
                     }
                     if {![namespace exists ::$providerpkg]} {
@@ -165,12 +165,12 @@ namespace eval punk::cap {
                     }
 
                     set registrationobj ::${providerpkg}::capsystem::capprovider.registration
-                    if {[info commands $registrationobj] eq ""} {
+                    if {[tcl::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 ""]
-
+                    #review - what are we trying to achieve here?
+                    set provider_pkg [tcl::string::trim $providerpkg ""]
                 }
                 method register {{capabilityname_glob *}} {
                     #*** !doctools
@@ -232,13 +232,13 @@ 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"
+        #puts stderr "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]} {
+            if {![tcl::string::match ::* $capnamespace]} {
                 set capnamespace ::$capnamespace
             }
         }
@@ -250,20 +250,21 @@ namespace eval punk::cap {
             return
         }
         #assertion: 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]
+        tcl::dict::set caps $capname handler $capnamespace
+        if {![tcl::dict::exists $caps $capname providers]} {
+            tcl::dict::set caps $capname providers [list]
         }
-        if {[llength [set providers [dict get $caps $capname providers]]]} {
+        if {[llength [set providers [tcl::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 {
+                    set fullcapabilitylist [tcl::dict::get $pkgcapsdeclared $pkg]
+                    set capname_capabilitylist [lsearch -all -inline -index 0 $fullcapabilitylist $capname]
+                    foreach capspec $capname_capabilitylist {
                         lassign $capspec cn capdict
-                        if {$cn ne $capname} {
-                            continue
-                        }
+                        #if {$cn ne $capname} {
+                        #    continue
+                        #}
                         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:"
@@ -271,22 +272,22 @@ namespace eval punk::cap {
                             set do_register 0
                         }
 
-                        set list_accepted [dict get $pkgcapsaccepted $pkg]
+                        set list_accepted [tcl::dict::get $pkgcapsaccepted $pkg]
                         if {$do_register} {
                             if {$capspec ni $list_accepted} {
-                                dict lappend pkgcapsaccepted $pkg $capspec
+                                tcl::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
+                                tcl::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] {
+                    foreach accepted_capspec [tcl::dict::get $pkgcapsaccepted $pkg] {
                         if {[lindex $accepted_capspec 0] eq $capname} {
                             incr count
                         }
@@ -295,7 +296,7 @@ namespace eval punk::cap {
                         set pkgposn [lsearch $providers $pkg]
                         if {$pkgposn >= 0} {
                            set updated_providers [lreplace $providers $posn $posn] 
-                           dict set caps $capname providers $updated_providers
+                           tcl::dict::set caps $capname providers $updated_providers
                         }
                     }
                 }
@@ -309,14 +310,14 @@ namespace eval punk::cap {
         # [call [fun capability_exists] [arg capname]]
         # Return a boolean indicating if the named capability exists  (0|1)
         variable caps
-        return [dict exists $caps $capname]
+        return [tcl::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 ""}]
+        return [expr {[tcl::dict::exists $caps $capname handler] && [tcl::dict::get $caps $capname handler] ne ""}]
     }
     proc capability_get_handler {capname} {
         #*** !doctools
@@ -324,8 +325,8 @@ namespace eval punk::cap {
         #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]
+        if {[tcl::dict::exists $caps $capname]} {
+            return [tcl::dict::get $caps $capname handler]
         }
         return "" 
     }
@@ -338,8 +339,8 @@ namespace eval punk::cap {
     }
     proc get_providers {capname} {
         variable caps
-        if {[dict exists $caps $capname]} {
-            return [dict get $caps $capname providers]
+        if {[tcl::dict::exists $caps $capname]} {
+            return [tcl::dict::get $caps $capname providers]
         }
         return [list]
     }
@@ -356,26 +357,26 @@ namespace eval punk::cap {
         foreach {k v} $args {
             switch -- $k {
                 -nowarnings {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "Unrecognized option $k. Known options [dict keys $opts]"
+                    error "Unrecognized option $k. Known options [tcl::dict::keys $opts]"
                 }
             }
         }
-        set warnings [expr {! [dict get $opts -nowarnings]}]
+        set warnings [expr {! [tcl::dict::get $opts -nowarnings]}]
 
-        if {[string match ::* $pkg]} {
-            set pkg [string range $pkg 2 end]
+        if {[tcl::string::match ::* $pkg]} {
+            set pkg [tcl::string::range $pkg 2 end]
         }
-        if {[dict exists $pkgcapsaccepted $pkg]} {
-            set pkg_already_accepted [dict get $pkgcapsaccepted $pkg]
+        if {[tcl::dict::exists $pkgcapsaccepted $pkg]} {
+            set pkg_already_accepted [tcl::dict::get $pkgcapsaccepted $pkg]
         } else {
             set pkg_already_accepted [list]
         }
         package require $pkg
         set providerapi ::${pkg}::provider
-        if {[info commands $providerapi] eq ""} {
+        if {[tcl::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]
@@ -397,13 +398,13 @@ namespace eval punk::cap {
             if {[llength $capname] !=1} {
                 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]
+                lappend errorlist [tcl::dict::create msg $reason capspec $capspec]
                 continue
             }
             if {[expr {[llength $capdict] %2 != 0}]} {
                 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]
+                lappend errorlist [tcl::dict::create msg $reason capspec $capspec]
                 continue
             }
             if {$capspec in $pkg_already_accepted} {
@@ -411,13 +412,13 @@ namespace eval punk::cap {
                 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]
+                lappend warninglist [tcl::dict::create msg "pkg $pkg already has this capspec marked as accepted" capspec $capspec]
                 continue
             }
-            if {[dict exists $caps $capname]} {
-                set cap_pkgs [dict get $caps $capname providers]
+            if {[tcl::dict::exists $caps $capname]} {
+                set cap_pkgs [tcl::dict::get $caps $capname providers]
             } else {
-                dict set caps $capname [dict create handler "" providers [list]]
+                dict set caps $capname [tcl::dict::create handler "" providers [list]]
                 set cap_pkgs [list]
             }
             #todo  - if there's a caphandler - call it's init/validation callback for the pkg
@@ -429,31 +430,31 @@ namespace eval punk::cap {
             if {$do_register} {
                 if {$pkg ni $cap_pkgs} {
                     lappend cap_pkgs $pkg
-                    dict set caps $capname providers $cap_pkgs
+                    tcl::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
+                tcl::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]} {
+        if {[tcl::dict::exists $pkgcapsdeclared $pkg]} {
             #review - untested
-            set mergecapspecs [dict get $pkgcapsdeclared $pkg]
+            set mergecapspecs [tcl::dict::get $pkgcapsdeclared $pkg]
             foreach spec $capabilitylist {
                 if {$spec ni $mergecapspecs} {
                     lappend mergecapspecs $spec
                 }
             }
-            dict set pkgcapsdeclared $pkg $mergecapspecs
+            tcl::dict::set pkgcapsdeclared $pkg $mergecapspecs
         } else {
-            dict set pkgcapsdeclared $pkg $capabilitylist
+            tcl::dict::set pkgcapsdeclared $pkg $capabilitylist
         }
         set resultdict [list num_capabilities $capabilitylist_count num_accepted $accepted_count]
         if {[llength $errorlist]} {
-            dict set resultdict errors $errorlist
+            tcl::dict::set resultdict errors $errorlist
         }
         if {[llength $warninglist]} {
-            dict set resultdict warnings $warninglist
+            tcl::dict::set resultdict warnings $warninglist
         }
         return $resultdict
     }
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 ab101e1..2926b23 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
@@ -61,7 +61,7 @@ namespace eval punk::cap::handlers::templates {
 
                     set path [dict get $capdict path]
 
-                    set cname [string map [list . _] $capname]
+                    set cname [string map {. _} $capname]
 
                     set multivendor_package_whitelist [list punk::mix::templates]
 
@@ -85,8 +85,19 @@ namespace eval punk::cap::handlers::templates {
                         module {
                             set provide_statement [package ifneeded $pkg [package require $pkg]]
                             set tmfile [lindex $provide_statement end]
+                            if {[interp issafe]} {
+                                #default safe interp can't use file exists/normalize etc.. but safe interp may have a policy/alias set allowing file access to certain paths - so test if file exists is usable
+                                if {[catch {file exists $tmfile} tm_exists]} {
+                                    puts stderr "punk::cap::handlers::templates::capsystem::pkg_register WARNING (expected in most safe interps) - unable to determine base folder for package '$pkg' which is attempting to register with punk::cap as a provider of '$capname' capability"
+                                    flush stderr
+                                    return 0
+                                }
+                            } else {
+                                set tm_exists [file exists $tmfile]
+                            }
                             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"
+                                flush stderr
                                 return 0
                             }
 
@@ -215,7 +226,7 @@ namespace eval punk::cap::handlers::templates {
                 method pkg_unregister {pkg} {
                     upvar ::punk::cap::handlers::templates::handled_caps hcaps
                     foreach capname $hcaps {
-                        set cname [string map [list . _] $capname]
+                        set cname [string map {. _} $capname]
                         upvar ::punk::cap::handlers::templates::provider_info_$cname my_provider_info 
                         dict unset my_provider_info $pkg
                         #destroy api objects?
@@ -238,7 +249,7 @@ namespace eval punk::cap::handlers::templates {
             constructor {capname} {
                 variable capabilityname
                 variable cname
-                set cname [string map [list . _] $capname]
+                set cname [string map {. _} $capname]
                 set capabilityname $capname
             }
             method folders {args} {
@@ -635,6 +646,7 @@ namespace eval punk::cap::handlers::templates {
             #and a name determining command -command_get_item_name
             method _get_itemdict {args} {
                 set argd [punk::args::get_dict { 
+                    *proc -name _get_itemdict
                     *opts  -anyopts 0
                     -startdir                       -default ""
                     -templatefolder_subdir          -optional 0
@@ -646,6 +658,7 @@ namespace eval punk::cap::handlers::templates {
                 } $args]
                 set opts [dict get $argd opts]
                 set globsearches [dict get $argd 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
+                #puts stderr "=-=============>globsearches:$globsearches"
                 # -- --- --- --- --- --- --- --- ---
                 set opt_startdir [dict get $opts -startdir]
                 set opt_templatefolder_subdir   [dict get $opts -templatefolder_subdir]
diff --git a/src/bootsupport/modules/punk/char-0.1.0.tm b/src/bootsupport/modules/punk/char-0.1.0.tm
index d4bd4c4..e8752c0 100644
--- a/src/bootsupport/modules/punk/char-0.1.0.tm
+++ b/src/bootsupport/modules/punk/char-0.1.0.tm
@@ -71,10 +71,10 @@ package require textutil::wcswidth
 #Note that ansi escapes can begin with \033\[ (\u001b\[)  or the single character "Control Sequence Introducer" 0x9b
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::char {
-    namespace export *
+tcl::namespace::eval punk::char {
+    tcl::namespace::export *
 
-    variable grapheme_widths [dict create]
+    variable grapheme_widths [tcl::dict::create]
     # -- --------------------------------------------------------------------------
     variable encmimens  ;#namespace of mime package providing reversemapencoding and mapencoding functions
     #tcllib mime requires tcl::chan::memchan,events,core and/or Trf
@@ -115,23 +115,23 @@ namespace eval punk::char {
         set out ""
         set i 1
         append out "        "
-        dict for {k v} $dict {
+        tcl::dict::for {k v} $dict {
             #single chars are wrapped with \033(0  and \033(B  ie total length 7
-            if {[string length $v] == 7} {
+            if {[tcl::string::length $v] == 7} {
                 set v " $v "
-            } elseif {[string length $v] == 2} {
+            } elseif {[tcl::string::length $v] == 2} {
                 set v "$v "
-            } elseif {[string length $v] == 0} {
+            } elseif {[tcl::string::length $v] == 0} {
                 set v "   "
             }
             append out "$k $v  " 
             if {$i > 0 && $i % 8 == 0} {
-                set out [string range $out 0 end-2]
+                set out [tcl::string::range $out 0 end-2]
                 append out \n "        "
             }
             incr i
         }
-        set out [string trimright $out " "]
+        set out [tcl::string::trimright $out " "]
         return $out
     }
 
@@ -146,18 +146,18 @@ namespace eval punk::char {
         
         append out "        "
         set i 1
-        dict for {k charinfo} $unicode_dict {
-            set char [dict get $charinfo char]
-            if {[string length $char] == 0} {
+        tcl::dict::for {k charinfo} $unicode_dict {
+            set char [tcl::dict::get $charinfo char]
+            if {[tcl::string::length $char] == 0} {
                 set displayv "   "
-            } elseif {[string length $char] == 1} {
+            } elseif {[tcl::string::length $char] == 1} {
                 set displayv " $char "
             } else {
                 set displayv $char
             }
             append out "$k $displayv  " 
             if {$i > 0 && $i % 8 == 0} {
-                set out [string range $out 0 end-2]
+                set out [tcl::string::range $out 0 end-2]
                 append out \n "        "
             }
             incr i
@@ -167,7 +167,7 @@ namespace eval punk::char {
     proc page_names {{search *}} {
         set all_names [list]
         set d [page_names_dict $search]
-        dict for {k v} $d {
+        tcl::dict::for {k v} $d {
             if {$k ni $all_names} {
                 lappend all_names $k
             }
@@ -183,7 +183,7 @@ namespace eval punk::char {
         set d [page_names_dict $namesearch]
 
         set out ""
-        dict for {k v} $d {
+        tcl::dict::for {k v} $d {
             append out "$k $v" \n
         }
         return [linesort $out]
@@ -194,32 +194,32 @@ namespace eval punk::char {
         }
         set encnames [encoding names]
         foreach enc $encnames {
-            dict set d $enc [list]
+            tcl::dict::set d $enc [list]
         }
         variable encmimens
         set mimenames [array get ${encmimens}::reversemap]
-        dict for {mname encname} $mimenames {
+        tcl::dict::for {mname encname} $mimenames {
             if {$encname in $encnames} {
-                set enclist [dict get $d $encname]
+                set enclist [tcl::dict::get $d $encname]
                 if {$mname ni $enclist} {
-                    dict lappend d $encname $mname
+                    tcl::dict::lappend d $encname $mname
                 }
             }
         } 
         foreach enc [lsort $encnames] {
             set mime_enc [${encmimens}::mapencoding $enc]
             if {$mime_enc ne ""} {
-                set enclist [dict get $d $enc]
+                set enclist [tcl::dict::get $d $enc]
                 if {$mime_enc ni $enclist} {
-                    dict lappend d $enc $mime_enc
+                    tcl::dict::lappend d $enc $mime_enc
                 }
             }
         }
-        set dresult [dict create]
+        set dresult [tcl::dict::create]
         if {$search ne "*"} {
-            dict for {k v} $d {
-                if {[string match -nocase $search $k] || ([lsearch -nocase $v $search]) >= 0} {
-                    dict set dresult $k $v
+            tcl::dict::for {k v} $d {
+                if {[tcl::string::match -nocase $search $k] || ([lsearch -nocase $v $search]) >= 0} {
+                    tcl::dict::set dresult $k $v
                 }
             }
         } else {
@@ -228,11 +228,11 @@ namespace eval punk::char {
         return $dresult
     }
     proc page8 {encname args} {
-        dict set args -cols 8
+        tcl::dict::set args -cols 8
         tailcall page $encname {*}$args
     }
     proc page16 {encname args} {
-        dict set args -cols 16
+        tcl::dict::set args -cols 16
         tailcall page $encname {*}$args
     }
 
@@ -246,9 +246,9 @@ namespace eval punk::char {
             -range {0 256}\
             -cols 16\
         ]
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         # -- --- --- --- --- --- --- --- ---
-        set cols            [dict get $opts -cols]
+        set cols            [tcl::dict::get $opts -cols]
         # -- --- --- --- --- --- --- --- ---
 
         set d_bytedisplay [basedict_display]
@@ -263,28 +263,28 @@ namespace eval punk::char {
         set out ""
         set i 1
         append out "        "
-        dict for {k rawchar} $d_page {
+        tcl::dict::for {k rawchar} $d_page {
             set num [expr {"0x$k"}]
             #see if ascii equivalent exists and has a name
             if {$rawchar eq $invalid} {
                 set displayv "$invalid"
             } else {
                 set bytedisplay ""
-                if {[dict exists $d_asciiposn $rawchar]} {
-                    set asciiposn [dict get $d_asciiposn $rawchar]
-                    set bytedisplay [dict get $d_bytedisplay $asciiposn]
+                if {[tcl::dict::exists $d_asciiposn $rawchar]} {
+                    set asciiposn [tcl::dict::get $d_asciiposn $rawchar]
+                    set bytedisplay [tcl::dict::get $d_bytedisplay $asciiposn]
                 }
                 if {$bytedisplay eq $invalid} {
                     #
                     set displayv " $rawchar "
                 } else {
-                    set displaylen [string length $bytedisplay]
+                    set displaylen [tcl::string::length $bytedisplay]
                     if {$displaylen == 2} {
                         set displayv "$bytedisplay "
                     } elseif {$displaylen == 3} {
                         set displayv $bytedisplay
                     } else {
-                        if {[string length $rawchar] == 0} {
+                        if {[tcl::string::length $rawchar] == 0} {
                             set displayv "   " 
                         } else {
                             #presumed 1
@@ -296,12 +296,12 @@ namespace eval punk::char {
 
             append out "$k $displayv  " 
             if {$i > 0 && $i % $cols == 0} {
-                set out [string range $out 0 end-2]
+                set out [tcl::string::range $out 0 end-2]
                 append out \n "        "
             }
             incr i
         }
-        set out [string trimright $out " "]
+        set out [tcl::string::trimright $out " "]
         return $out
     }
 
@@ -357,8 +357,8 @@ namespace eval punk::char {
         set out ""
         set mimenamesdict [page_names_dict]
         foreach encname [encoding names] {
-            if {[dict exists $mimenamesdict $encname]} {
-                set alt "([dict get $mimenamesdict $encname])"
+            if {[tcl::dict::exists $mimenamesdict $encname]} {
+                set alt "([tcl::dict::get $mimenamesdict $encname])"
             } else {
                 set alt ""
             }
@@ -383,43 +383,43 @@ namespace eval punk::char {
     proc pagedict_raw {encname} {
         variable invalid ;# ="???" 
         set encname [encname $encname]
-        set d [dict create]
+        set d [tcl::dict::create]
         for {set i 0} {$i < 256} {incr i} {
             set k [format %02x $i]
-            #dict set d $k [encoding convertfrom $encname [format %c $i]]
+            #tcl::dict::set d $k [encoding convertfrom $encname [format %c $i]]
             set ch [format %c $i] ;
             #jmn
             if {[decodable $ch $encname]} {
                 #set encchar [encoding convertto $encname $ch]
-                #dict set d $k [encoding convertfrom $encchar]
-                dict set d $k [encoding convertfrom $encname $ch]
+                #tcl::dict::set d $k [encoding convertfrom $encchar]
+                tcl::dict::set d $k [encoding convertfrom $encname $ch]
             } else {
-                dict set d $k $invalid ;#use replacement so we can detect difference from actual "?"
+                tcl::dict::set d $k $invalid ;#use replacement so we can detect difference from actual "?"
             }
         }
         return $d
     }
     proc asciidict {} {
         variable invalid
-        set d [dict create]
+        set d [tcl::dict::create]
         set a128 [asciidict128]
         for {set i 0} {$i < 256} {incr i} {
             set k [format %02x $i]
             if {$i <= 127} {
-                dict set d $k [dict get $a128 $k]
+                tcl::dict::set d $k [tcl::dict::get $a128 $k]
             } else {
                 #
-                dict set d $k $invalid 
+                tcl::dict::set d $k $invalid 
             }
 
             if {$i <=32} {
                 #no point emitting the lower control characters raw to screen - emit the short-names defined in the 'ascii' proc
-                dict set d $k [dict get $a128 $k]
+                tcl::dict::set d $k [tcl::dict::get $a128 $k]
             } else {
                 if {$i == 0x9b} {
-                    dict set d $k CSI ;#don't emit the ansi 'Control Sequence Introducer' - or it will be interpreted by the console and affect the layout.
+                    tcl::dict::set d $k CSI ;#don't emit the ansi 'Control Sequence Introducer' - or it will be interpreted by the console and affect the layout.
                 } else {
-                    dict set d $k [format %c $i]
+                    tcl::dict::set d $k [format %c $i]
                 }
             }
         }
@@ -427,22 +427,22 @@ namespace eval punk::char {
     }
 
     proc basedict_display {} {
-        set d [dict create]
+        set d [tcl::dict::create]
         set a128 [asciidict128]
         for {set i 0} {$i < 256} {incr i} {
             set k [format %02x $i]
             if {$i <=32} {
                 #no point emitting the lower control characters raw to screen - emit the short-names defined in the 'ascii' proc
-                dict set d $k [dict get $a128 $k]
+                tcl::dict::set d $k [tcl::dict::get $a128 $k]
             } else {
                 if {$i == 0x9b} {
-                    dict set d $k CSI ;#don't emit the ansi 'Control Sequence Introducer' - or it will be interpreted by the console and affect the layout.
+                    tcl::dict::set d $k CSI ;#don't emit the ansi 'Control Sequence Introducer' - or it will be interpreted by the console and affect the layout.
                 } elseif {$i == 0x9c} {
-                    dict set d $k OSC
+                    tcl::dict::set d $k OSC
                 } else {
-                    #dict set d $k [encoding convertfrom [encoding system] [format %c $i]]
+                    #tcl::dict::set d $k [encoding convertfrom [encoding system] [format %c $i]]
                     #don't use encoding convertfrom - we want the value independent of the current encoding system.
-                    dict set d $k [format %c $i]
+                    tcl::dict::set d $k [format %c $i]
                 }
             }
         }
@@ -450,20 +450,20 @@ namespace eval punk::char {
     }
     proc basedict_encoding_system {} {
         #result depends on 'encoding system' currently in effect
-        set d [dict create]
+        set d [tcl::dict::create]
         for {set i 0} {$i < 256} {incr i} {
             set k [format %02x $i]
-            dict set d $k [encoding convertfrom [encoding system] [format %c $i]]
+            tcl::dict::set d $k [encoding convertfrom [encoding system] [format %c $i]]
         }
         return $d
     }
     
     proc basedict {} {
         #this gives same result independent of current value of 'encoding system'
-        set d [dict create]
+        set d [tcl::dict::create]
         for {set i 0} {$i < 256} {incr i} {
             set k [format %02x $i]
-            dict set d $k [format %c $i]
+            tcl::dict::set d $k [format %c $i]
         }
         return $d
     }
@@ -474,22 +474,22 @@ namespace eval punk::char {
             -range {0 255}\
             -charset ""\
         ]
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         # -- --- --- --- --- --- --- --- --- ---
-        set range       [dict get $opts -range]
-        set charset     [dict get $opts -charset]
+        set range       [tcl::dict::get $opts -range]
+        set charset     [tcl::dict::get $opts -charset]
         # -- --- --- --- --- --- --- --- --- ---
         if {$charset ne ""} {
             if {$charset ni [charset_names]} {
                 error "unknown charset '$charset' - use 'charset_names' to get list"
             }
-            set setinfo [dict get $charsets $charset]
-            set ranges [dict get $setinfo ranges]
-            set charset_dict [dict create]
+            set setinfo [tcl::dict::get $charsets $charset]
+            set ranges [tcl::dict::get $setinfo ranges]
+            set charset_dict [tcl::dict::create]
             foreach r $ranges {
-                set start [dict get $r start]
-                set end   [dict get $r end]
-                #set charset_dict [dict merge $charset_dict [char_range_dict $start $end]]
+                set start [tcl::dict::get $r start]
+                set end   [tcl::dict::get $r end]
+                #set charset_dict [tcl::dict::merge $charset_dict [char_range_dict $start $end]]
                 break
             }
 
@@ -498,10 +498,10 @@ namespace eval punk::char {
             set end  [lindex $range 1]
         }
 
-        set d [dict create]
+        set d [tcl::dict::create]
         for {set i $start} {$i <= $end} {incr i} {
             set k [format %02x $i]
-            dict set d $k [encoding convertfrom $encname [format %c $i]]
+            tcl::dict::set d $k [encoding convertfrom $encname [format %c $i]]
         }
         return $d
     }
@@ -516,14 +516,14 @@ namespace eval punk::char {
 
     #review - use terminal to display actual supported DEC specials vs using dict at: punk::ansi::map_special_graphics which maps to known unicode equivalents
     proc asciidict2 {} {
-        set d [dict create]
-        dict for {k v} [basedict_display] {
-            if {[string length $v] == 1} {
+        set d [tcl::dict::create]
+        tcl::dict::for {k v} [basedict_display] {
+            if {[tcl::string::length $v] == 1} {
                 set num [expr {"0x$k"}]
-                #dict set d $k "\033(0[subst \\u00$k]\033(B"
-                dict set d $k "\033(0[format %c $num]\033(B"
+                #tcl::dict::set d $k "\033(0[subst \\u00$k]\033(B"
+                tcl::dict::set d $k "\033(0[format %c $num]\033(B"
             } else {
-                dict set d $k $v
+                tcl::dict::set d $k $v
             }
         }
         return $d
@@ -540,7 +540,7 @@ namespace eval punk::char {
             if {($encname eq "ascii")} {
                 #8.6 fails to round-trip convert 0x7f del character despite it being in the ascii range (review Why?? what else doesn't round-trip but should?)
                 #just strip it out of the string as we are only after a boolean answer and if s is only a single del char empty string will result in true
-                set s [string map [list [format %c 0x7f] ""] $s]
+                set s [tcl::string::map [list [format %c 0x7f] ""] $s]
             }
             string eq $s [encoding convertfrom $encname [encoding convertto $encname $s]]
         }
@@ -630,14 +630,14 @@ namespace eval punk::char {
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
     # Unicode character sets - some hardcoded - some loadable from data files
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    variable charinfo [dict create]
-    variable charsets [dict create]
+    variable charinfo [tcl::dict::create]
+    variable charsets [tcl::dict::create]
 
     
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
     # Aggregate character sets (ones that pick various ranges from underlying unicode ranges)
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    dict set charsets "WGL4" [list altname "Windows Glyph List 4" ranges [list\
+    tcl::dict::set charsets "WGL4" [list altname "Windows Glyph List 4" ranges [list\
         {start 0        end 127     name "basic latin"}\
         {start 128      end 255     name "latin-1 supplement"}\
         {start 256      end 383     name "Latin Extended-A"}\
@@ -668,202 +668,202 @@ namespace eval punk::char {
     #The base page 0-256 8bit range - values don't have specific characters or descriptions - as they are codepage dependent
     #we will fill this here for completeness - but with placeholders
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    dict set charsets "8bit" [list ranges [list {start 0 end 127 name ascii} {start 128 end 255 name 8bit-ascii}] description "8bit extended ascii range" settype "other"]
+    tcl::dict::set charsets "8bit" [list ranges [list {start 0 end 127 name ascii} {start 128 end 255 name 8bit-ascii}] description "8bit extended ascii range" settype "other"]
     for {set i 0} {$i < 256} {incr i} {
-        dict set charinfo $i [list desc "codepage-dependent" short "byte_[format %02x $i]"]
+        tcl::dict::set charinfo $i [list desc "codepage-dependent" short "byte_[format %02x $i]"]
     }
 
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
     # Unicode ranges 
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    dict set charsets "greek" [list ranges [list {start 880 end 1023} {start 7936 end 8191}] description "Greek and Coptic" settype "other"]
+    tcl::dict::set charsets "greek" [list ranges [list {start 880 end 1023} {start 7936 end 8191}] description "Greek and Coptic" settype "other"]
 
 
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    dict set charsets "Block Elements" [list ranges [list {start 9600 end 9631}] description "Block Elements" settype "other"]
-    dict set charinfo 9600 [list desc "Upper Half Block"                                    short "blocke_up_half"]
-    dict set charinfo 9601 [list desc "Lower One Eighth Block"                              short "blocke_lw_1_8th"]
-    dict set charinfo 9602 [list desc "Lower One Quarter Block"                             short "blocke_lw_1_qtr"]
+    tcl::dict::set charsets "Block Elements" [list ranges [list {start 9600 end 9631}] description "Block Elements" settype "other"]
+    tcl::dict::set charinfo 9600 [list desc "Upper Half Block"                                    short "blocke_up_half"]
+    tcl::dict::set charinfo 9601 [list desc "Lower One Eighth Block"                              short "blocke_lw_1_8th"]
+    tcl::dict::set charinfo 9602 [list desc "Lower One Quarter Block"                             short "blocke_lw_1_qtr"]
 
 
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    dict set charsets "Dingbats" [list ranges [list {start 9984 end 10175 }] description "Unicode Dingbats" settype "tcl_supplemented"]
-    dict set charinfo 9984 [list desc "Black Safety Scissors"                               short "dingbats_black_safety_scissors"]
+    tcl::dict::set charsets "Dingbats" [list ranges [list {start 9984 end 10175 }] description "Unicode Dingbats" settype "tcl_supplemented"]
+    tcl::dict::set charinfo 9984 [list desc "Black Safety Scissors"                               short "dingbats_black_safety_scissors"]
     #...
-    dict set charinfo 10175 [list desc "Double Curly Loop"                                  short "dingbats_double_curly_loop"]
+    tcl::dict::set charinfo 10175 [list desc "Double Curly Loop"                                  short "dingbats_double_curly_loop"]
 
 
 
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
     #variation selectors 0xFe01 - 0xFE0F
-    dict set charsets "Variation Selectors" [list ranges [list {start 65024 end 65039}] description "Variation Selectors" note "combining character with previous char - variant glyph display" settype "tcl_supplemented"]
-    dict set charinfo 65024 [list desc "Variation Selector-1"                                                short "VS1"]
-    dict set charinfo 65025 [list desc "Variation Selector-2"                                                short "VS2"]
-    dict set charinfo 65026 [list desc "Variation Selector-3"                                                short "VS3"]
-    dict set charinfo 65027 [list desc "Variation Selector-4"                                                short "VS4"]
-    dict set charinfo 65027 [list desc "Variation Selector-5"                                                short "VS5"]
-    dict set charinfo 65029 [list desc "Variation Selector-6"                                                short "VS6"]
-    dict set charinfo 65030 [list desc "Variation Selector-7"                                                short "VS7"]
-    dict set charinfo 65031 [list desc "Variation Selector-8"                                                short "VS8"]
-    dict set charinfo 65032 [list desc "Variation Selector-9"                                                short "VS9"]
-    dict set charinfo 65033 [list desc "Variation Selector-10"                                               short "VS10"]
-    dict set charinfo 65034 [list desc "Variation Selector-11"                                               short "VS11"]
-    dict set charinfo 65035 [list desc "Variation Selector-12"                                               short "VS12"]
-    dict set charinfo 65036 [list desc "Variation Selector-13"                                               short "VS13"]
-    dict set charinfo 65037 [list desc "Variation Selector-14"                                               short "VS14"]
-    dict set charinfo 65038 [list desc "Variation Selector-15 text variation"                                short "VS15"] ;#still an image - just more suitable for text-presentation e.g word-processing doc
-    dict set charinfo 65039 [list desc "Variation Selector-16 emoji variation"                               short "VS16"]
+    tcl::dict::set charsets "Variation Selectors" [list ranges [list {start 65024 end 65039}] description "Variation Selectors" note "combining character with previous char - variant glyph display" settype "tcl_supplemented"]
+    tcl::dict::set charinfo 65024 [list desc "Variation Selector-1"                                                short "VS1"]
+    tcl::dict::set charinfo 65025 [list desc "Variation Selector-2"                                                short "VS2"]
+    tcl::dict::set charinfo 65026 [list desc "Variation Selector-3"                                                short "VS3"]
+    tcl::dict::set charinfo 65027 [list desc "Variation Selector-4"                                                short "VS4"]
+    tcl::dict::set charinfo 65027 [list desc "Variation Selector-5"                                                short "VS5"]
+    tcl::dict::set charinfo 65029 [list desc "Variation Selector-6"                                                short "VS6"]
+    tcl::dict::set charinfo 65030 [list desc "Variation Selector-7"                                                short "VS7"]
+    tcl::dict::set charinfo 65031 [list desc "Variation Selector-8"                                                short "VS8"]
+    tcl::dict::set charinfo 65032 [list desc "Variation Selector-9"                                                short "VS9"]
+    tcl::dict::set charinfo 65033 [list desc "Variation Selector-10"                                               short "VS10"]
+    tcl::dict::set charinfo 65034 [list desc "Variation Selector-11"                                               short "VS11"]
+    tcl::dict::set charinfo 65035 [list desc "Variation Selector-12"                                               short "VS12"]
+    tcl::dict::set charinfo 65036 [list desc "Variation Selector-13"                                               short "VS13"]
+    tcl::dict::set charinfo 65037 [list desc "Variation Selector-14"                                               short "VS14"]
+    tcl::dict::set charinfo 65038 [list desc "Variation Selector-15 text variation"                                short "VS15"] ;#still an image - just more suitable for text-presentation e.g word-processing doc
+    tcl::dict::set charinfo 65039 [list desc "Variation Selector-16 emoji variation"                               short "VS16"]
 
 
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
     # emoticons https://www.unicode.org/charts/PDF/U1F600.pdf
-    dict set charsets "Emoticons" [list ranges [list {start 128512 end 128591}] description "Emoticons" settype "tcl_supplemented"]
-    dict set charinfo 128512 [list desc "Grinning Face"                                     short "emoticon_gface"]
-    dict set charinfo 128513 [list desc "Grinning Face with Smiling Eyes"                   short "emoticon_gface_smile_eyes"]
-    dict set charinfo 128514 [list desc "Face with Tears of Joy"                            short "emoticon_face_tears_joy"]
+    tcl::dict::set charsets "Emoticons" [list ranges [list {start 128512 end 128591}] description "Emoticons" settype "tcl_supplemented"]
+    tcl::dict::set charinfo 128512 [list desc "Grinning Face"                                     short "emoticon_gface"]
+    tcl::dict::set charinfo 128513 [list desc "Grinning Face with Smiling Eyes"                   short "emoticon_gface_smile_eyes"]
+    tcl::dict::set charinfo 128514 [list desc "Face with Tears of Joy"                            short "emoticon_face_tears_joy"]
 
     #todo
-    dict set charinfo 128590 [list desc "Person with Pouting Face"                          short "emoticon_person_pout"]
+    tcl::dict::set charinfo 128590 [list desc "Person with Pouting Face"                          short "emoticon_person_pout"]
 
     # -- -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    dict set charsets "Box Drawing" [list ranges [list {start 9472 end 9599}] description "Box Drawing" settype "tcl_supplemented"]
-    dict set charinfo 9472 [list desc "Box Drawings Light Horizontal"                       short "boxd_lhz"]
-    dict set charinfo 9473 [list desc "Box Drawings Heavy Horizontal"                       short "boxd_hhz"]
-    dict set charinfo 9474 [list desc "Box Drawings Light Vertical"                         short "boxd_lv"]
-    dict set charinfo 9475 [list desc "Box Drawings Heavy Vertical"                         short "boxd_hv"]
-    dict set charinfo 9476 [list desc "Box Drawings Light Triple Dash Horizontal"           short "boxd_ltdshhz"]
-    dict set charinfo 9477 [list desc "Box Drawings Heavy Triple Dash Horizontal"           short "boxd_htdshhz"]
-    dict set charinfo 9478 [list desc "Box Drawings Light Triple Dash Vertical"             short "boxd_ltdshv"]
-    dict set charinfo 9479 [list desc "Box Drawings Heavy Triple Dash Vertical"             short "boxd_htdshv"]
-    dict set charinfo 9480 [list desc "Box Drawings Light Quadruple Dash Horizontal"        short "boxd_lqdshhz"]
-    dict set charinfo 9481 [list desc "Box Drawings Heavy Quadruple Dash Horizontal"        short "boxd_hqdshhz"]
-    dict set charinfo 9482 [list desc "Box Drawings Light Quadruple Dash Vertical"          short "boxd_lqdshv"]
-    dict set charinfo 9483 [list desc "Box Drawings Heavy Quadruple Dash Vertical"          short "boxd_hqdshv"]
-    dict set charinfo 9484 [list desc "Box Drawings Light Down and Right"                   short "boxd_ldr"]
-    dict set charinfo 9485 [list desc "Box Drawings Down Light and Right Heavy"             short "boxd_dlrh"]
-    dict set charinfo 9486 [list desc "Box Drawings Down Heavy and Right Light"             short "boxd_dhrl"]
-    dict set charinfo 9487 [list desc "Box Drawings Heavy Down and Right"                   short "boxd_hdr"]
-    dict set charinfo 9488 [list desc "Box Drawings Light Down and Left"                    short "boxd_ldl"]
-    dict set charinfo 9489 [list desc "Box Drawings Down Light and Left Heavy"              short "boxd_dllh"]
-    dict set charinfo 9490 [list desc "Box Drawings Down Heavy and Left Light"              short "boxd_dhll"]
-    dict set charinfo 9491 [list desc "Box Drawings Heavy Down and Left"                    short "boxd_hdl"]
-    dict set charinfo 9492 [list desc "Box Drawings Light Up and Right"                     short "boxd_lur"]
-    dict set charinfo 9493 [list desc "Box Drawings Up Light and Right Heavy"               short "boxd_ulrh"]
-    dict set charinfo 9494 [list desc "Box Drawings Up Heavy and Right Light"               short "boxd_uhrl"]
-    dict set charinfo 9495 [list desc "Box Drawings Heavy Up and Right"                     short "boxd_hur"]
-    dict set charinfo 9496 [list desc "Box Drawings Light Up and Left"                      short "boxd_lul"]
-    dict set charinfo 9497 [list desc "Box Drawings Up Light and Left Heavy"                short "boxd_ullh"]
-    dict set charinfo 9498 [list desc "Box Drawings Up Heavy and Left Light"                short "boxd_uhll"]
-    dict set charinfo 9499 [list desc "Box Drawings Heavy Up and Left"                      short "boxd_hul"]
-    dict set charinfo 9500 [list desc "Box Drawings Light Vertical and Right"               short "boxd_lvr"]
-    dict set charinfo 9501 [list desc "Box Drawings Vertical Light and Right Heavy"         short "boxd_vlrh"]
-    dict set charinfo 9502 [list desc "Box Drawings Up Heavy and Right Down Light"          short "boxd_uhrdl"]
-    dict set charinfo 9503 [list desc "Box Drawings Down Heavy and Right Up Light"          short "boxd_dhrul"]
-    dict set charinfo 9504 [list desc "Box Drawings Vertical Heavy and Right Light"         short "boxd_vhrl"]
-    dict set charinfo 9505 [list desc "Box Drawings Down Light and Right Up Heavy"          short "boxd_dlruh"]
-    dict set charinfo 9506 [list desc "Box Drawings Up Light and Right Down Heavy"          short "boxd_ulrdh"]
-    dict set charinfo 9507 [list desc "Box Drawings Heavy Vertical and Right"               short "boxd_hvr"]
-    dict set charinfo 9508 [list desc "Box Drawings Light Vertical and Left"                short "boxd_lvl"]
-    dict set charinfo 9509 [list desc "Box Drawings Vertical Light and Left Heavy"          short "boxd_vllh"]
-    dict set charinfo 9510 [list desc "Box Drawings Up Heavy and Let Down Light"            short "boxd_uhldl"]
-    dict set charinfo 9511 [list desc "Box Drawings Down Heavy and Left Up Light"           short "boxd_dhlul"]
-    dict set charinfo 9512 [list desc "Box Drawings Vertical Heavy and Left Light"          short "boxd_vhll"]
-    dict set charinfo 9513 [list desc "Box Drawings Down Light and left Up Heavy"           short "boxd_dlluh"]
-    dict set charinfo 9514 [list desc "Box Drawings Up Light and Left Down Heavy"           short "boxd_ulldh"]
-    dict set charinfo 9515 [list desc "Box Drawings Heavy Vertical and Left"                short "boxd_hvl"]
-    dict set charinfo 9516 [list desc "Box Drawings Light Down and Horizontal"              short "boxd_ldhz"]
-    dict set charinfo 9517 [list desc "Box Drawings Left Heavy and Right Down Light"        short "boxd_lhrdl"]
-    dict set charinfo 9518 [list desc "Box Drawings Right Heavy and Left Down Light"        short "boxd_rhldl"]
-    dict set charinfo 9519 [list desc "Box Drawings Down Light and Horizontal Heavy"        short "boxd_dlhzh"]
-    dict set charinfo 9520 [list desc "Box Drawings Down Heavy and Horizontal Light"        short "boxd_dhhzl"]
-    dict set charinfo 9521 [list desc "Box Drawings Right Light and Left Down Heavy"        short "boxd_rlldh"]
-    dict set charinfo 9522 [list desc "Box Drawings Left Light and Right Down Heavy"        short "boxd_llrdh"]
-    dict set charinfo 9523 [list desc "Box Drawings Heavy Down and Horizontal"              short "boxd_hdhz"]
-    dict set charinfo 9524 [list desc "Box Drawings Light Up and Horizontal"                short "boxd_luhz"]
-    dict set charinfo 9525 [list desc "Box Drawings Left Heavy and Right Up Light"          short "boxd_lhrul"]
-    dict set charinfo 9526 [list desc "Box Drawings Right Heavy and Left Up Light"          short "boxd_rhlul"]
-    dict set charinfo 9527 [list desc "Box Drawings Up Light and Horizontal Heavy"          short "boxd_ulhzh"]
-    dict set charinfo 9528 [list desc "Box Drawings Up Heavy and Horizontal Light"          short "boxd_uhhzl"]
-    dict set charinfo 9529 [list desc "Box Drawings Right Light and Left Up Heavy"          short "boxd_rlluh"]
-    dict set charinfo 9530 [list desc "Box Drawings Left Light and Right Up Heavy"          short "boxd_llruh"]
-    dict set charinfo 9531 [list desc "Box Drawings Heavy Up and Horizontal"                short "boxd_huhz"]
-    dict set charinfo 9532 [list desc "Box Drawings Light Vertical and Horizontal"          short "boxd_lvhz"]
-    dict set charinfo 9533 [list desc "Box Drawings Left Heavy and Right Vertical Light"    short "boxd_lhrvl"]
-    dict set charinfo 9534 [list desc "Box Drawings Right Heavy and Left Vertical Light"    short "boxd_rhlvl"]
-    dict set charinfo 9535 [list desc "Box Drawings Vertical Light and Horizontal Heavy"    short "boxd_vlhzh"]
-    dict set charinfo 9536 [list desc "Box Drawings Up Heavy and Down Horizontal Light"     short "boxd_uhdhzl"]
-    dict set charinfo 9537 [list desc "Box Drawings Down Heavy and Up Horizontal Light"     short "boxd_dhuhzl"]
-    dict set charinfo 9538 [list desc "Box Drawings Vertical Heavy and Horizontal Light"    short "boxd_vhhzl"]
-    dict set charinfo 9539 [list desc "Box Drawings Left Up Heavy and Right Down Light"     short "boxd_luhrdl"]
-    dict set charinfo 9540 [list desc "Box Drawings Right Up Heavy and Left Down Light"     short "boxd_ruhldl"]
-    dict set charinfo 9541 [list desc "Box Drawings Left Down Heavy and Right Up Light"     short "boxd_ldhrul"]
-    dict set charinfo 9542 [list desc "Box Drawings Right Down Heavy and Left Up Light"     short "boxd_rdhlul"]
-    dict set charinfo 9543 [list desc "Box Drawings Down Light and Up Horizontal Heavy"     short "boxd_dluhzh"]
-    dict set charinfo 9544 [list desc "Box Drawings Up Light and Down Horizontal Heavy"     short "boxd_dldhzh"]
-    dict set charinfo 9545 [list desc "Box Drawings Right Light and Left Vertical Heavy"    short "boxd_rllvh"]
-    dict set charinfo 9546 [list desc "Box Drawings Left Light and Right Vertical Heavy"    short "boxd_llrvh"]
-    dict set charinfo 9547 [list desc "Box Drawings Heavy Vertical and Horizontal"          short "boxd_hvhz"]
-    dict set charinfo 9548 [list desc "Box Drawings Light Double Dash Horizontal"           short "boxd_lddshhz"]
-    dict set charinfo 9549 [list desc "Box Drawings Heavy Double Dash Horizontal"           short "boxd_hddshhz"]
-    dict set charinfo 9550 [list desc "Box Drawings Light Double Dash Vertical"             short "boxd_lddshv"]
-    dict set charinfo 9551 [list desc "Box Drawings Heavy Double Dash Vertical"             short "boxd_hddshv"]
-    dict set charinfo 9552 [list desc "Box Drawings Double Horizontal"                      short "boxd_dhz"]
-    dict set charinfo 9553 [list desc "Box Drawings Double Vertical"                        short "boxd_dv"]
-    dict set charinfo 9554 [list desc "Box Drawings Down Single and Right Double"           short "boxd_dsrd"]
-    dict set charinfo 9555 [list desc "Box Drawings Down Double and Right Single"           short "boxd_ddrs"]
-    dict set charinfo 9556 [list desc "Box Drawings Double Down and Right"                  short "boxd_ddr"]
-    dict set charinfo 9557 [list desc "Box Drawings Down Single and Left Double"            short "boxd_dsld"]
-    dict set charinfo 9558 [list desc "Box Drawings Down Double and Left Single"            short "boxd_ddls"]
-    dict set charinfo 9559 [list desc "Box Drawings Double Down and Left"                   short "boxd_ddl"]
-    dict set charinfo 9560 [list desc "Box Drawings Up Single and Right Double"             short "boxd_usrd"]
-    dict set charinfo 9561 [list desc "Box Drawings Up Double and Right Single"             short "boxd_udrs"]
-    dict set charinfo 9562 [list desc "Box Drawings Double Up and Right"                    short "boxd_dur"]
-    dict set charinfo 9563 [list desc "Box Drawings Up Single and Left Double"              short "boxd_usld"]
-    dict set charinfo 9564 [list desc "Box Drawings Up Double and Left Single"              short "boxd_udls"]
-    dict set charinfo 9565 [list desc "Box Drawings Double Up and Left"                     short "boxd_dul"]
-    dict set charinfo 9566 [list desc "Box Drawings Vertical Single and Right Double"       short "boxd_vsrd"]
-    dict set charinfo 9567 [list desc "Box Drawings Vertical Double and Right Single"       short "boxd_vdrs"]
-    dict set charinfo 9568 [list desc "Box Drawings Double Vertical and Right"              short "boxd_dvr"]
-    dict set charinfo 9569 [list desc "Box Drawings Vertical Single and Left Double"        short "boxd_vsld"]
-    dict set charinfo 9570 [list desc "Box Drawings Vertical Double and Left Single"        short "boxd_vdls"]
-    dict set charinfo 9571 [list desc "Box Drawings Double Vertical and Left"               short "boxd_dvl"]
-    dict set charinfo 9572 [list desc "Box Drawings Down Single and Horizontal Double"      short "boxd_dshzd"]
-    dict set charinfo 9573 [list desc "Box Drawings Down Double and Horizontal Single"      short "boxd_ddhzs"]
-    dict set charinfo 9574 [list desc "Box Drawings Double Down and Horizontal"             short "boxd_ddhz"]
-    dict set charinfo 9575 [list desc "Box Drawings Up Single and Horizontal Double"        short "boxd_ushzd"]
-    dict set charinfo 9576 [list desc "Box Drawings Up Double and Horizontal Single"        short "boxd_udhzs"]
-    dict set charinfo 9577 [list desc "Box Drawings Double Up and Horizontal"               short "boxd_duhz"]
-    dict set charinfo 9578 [list desc "Box Drawings Vertical Single and Horizontal Double"  short "boxd_vshzd"]
-    dict set charinfo 9579 [list desc "Box Drawings Vertical Double and Horizontal Single"  short "boxd_vdhzs"]
-    dict set charinfo 9580 [list desc "Box Drawings Double Vertical and Horizontal"         short "boxd_dvhz"]
-    dict set charinfo 9581 [list desc "Box Drawings Light Arc Down and Right"               short "boxd_ladr"]
-    dict set charinfo 9582 [list desc "Box Drawings Light Arc Down and Left"                short "boxd_ladl"]
-    dict set charinfo 9583 [list desc "Box Drawings Light Arc Up and Left"                  short "boxd_laul"]
-    dict set charinfo 9584 [list desc "Box Drawings Light Arc Up and Right"                 short "boxd_laur"]
-    dict set charinfo 9585 [list desc "Box Drawings Light Diagonal Upper Right To Lower Left"   short "boxd_ldgurll"]
-    dict set charinfo 9586 [list desc "Box Drawings Light Diagonal Upper Left To Lower Right"   short "boxd_ldgullr"]
-    dict set charinfo 9587 [list desc "Box Drawings Light Diagonal Cross"                   short "boxd_ldc"]
-    dict set charinfo 9588 [list desc "Box Drawings Light Left"                             short "boxd_ll"]
-    dict set charinfo 9589 [list desc "Box Drawings Light Up"                               short "boxd_lu"]
-    dict set charinfo 9590 [list desc "Box Drawings Light Right"                            short "boxd_lr"]
-    dict set charinfo 9591 [list desc "Box Drawings Light Down"                             short "boxd_ld"]
-    dict set charinfo 9592 [list desc "Box Drawings Heavy Left"                             short "boxd_hl"]
-    dict set charinfo 9593 [list desc "Box Drawings Heavy Up"                               short "boxd_hu"]
-    dict set charinfo 9594 [list desc "Box Drawings Heavy Right"                            short "boxd_hr"]
-    dict set charinfo 9595 [list desc "Box Drawings Heavy Down"                             short "boxd_hd"]
-    dict set charinfo 9596 [list desc "Box Drawings Light Left and Heavy Right"             short "boxd_llhr"]
-    dict set charinfo 9597 [list desc "Box Drawings Light Up and Heavy Down"                short "boxd_luhd"]
-    dict set charinfo 9598 [list desc "Box Drawings Heavy Left and Light Right"             short "boxd_hllr"]
-    dict set charinfo 9599 [list desc "Box Drawings Heavy Up and Light Down"                short "boxd_huld"]
-
-
-    dict set charsets "Halfwidth and Fullwidth Forms" [list ranges [list {start 65280 end 65519}] description "Halfwidth and Fullwidth Forms (variants)" settype "tcl_supplemental"]
-        dict set charsets "ascii_fullwidth" [list ranges [list {start 65281 end 65374}] description "Ascii 21 to 7E fullwidth" parentblock "halfwidth_and_fullwidth_forms" settype "other"]
-
-    dict set charsets "Specials" [list ranges [list {start 65520 end 65535}] description "Specials" settype "tcl_supplemental"]
-
-    dict set charsets "noncharacters" [list ranges [list\
+    tcl::dict::set charsets "Box Drawing" [list ranges [list {start 9472 end 9599}] description "Box Drawing" settype "tcl_supplemented"]
+    tcl::dict::set charinfo 9472 [list desc "Box Drawings Light Horizontal"                       short "boxd_lhz"]
+    tcl::dict::set charinfo 9473 [list desc "Box Drawings Heavy Horizontal"                       short "boxd_hhz"]
+    tcl::dict::set charinfo 9474 [list desc "Box Drawings Light Vertical"                         short "boxd_lv"]
+    tcl::dict::set charinfo 9475 [list desc "Box Drawings Heavy Vertical"                         short "boxd_hv"]
+    tcl::dict::set charinfo 9476 [list desc "Box Drawings Light Triple Dash Horizontal"           short "boxd_ltdshhz"]
+    tcl::dict::set charinfo 9477 [list desc "Box Drawings Heavy Triple Dash Horizontal"           short "boxd_htdshhz"]
+    tcl::dict::set charinfo 9478 [list desc "Box Drawings Light Triple Dash Vertical"             short "boxd_ltdshv"]
+    tcl::dict::set charinfo 9479 [list desc "Box Drawings Heavy Triple Dash Vertical"             short "boxd_htdshv"]
+    tcl::dict::set charinfo 9480 [list desc "Box Drawings Light Quadruple Dash Horizontal"        short "boxd_lqdshhz"]
+    tcl::dict::set charinfo 9481 [list desc "Box Drawings Heavy Quadruple Dash Horizontal"        short "boxd_hqdshhz"]
+    tcl::dict::set charinfo 9482 [list desc "Box Drawings Light Quadruple Dash Vertical"          short "boxd_lqdshv"]
+    tcl::dict::set charinfo 9483 [list desc "Box Drawings Heavy Quadruple Dash Vertical"          short "boxd_hqdshv"]
+    tcl::dict::set charinfo 9484 [list desc "Box Drawings Light Down and Right"                   short "boxd_ldr"]
+    tcl::dict::set charinfo 9485 [list desc "Box Drawings Down Light and Right Heavy"             short "boxd_dlrh"]
+    tcl::dict::set charinfo 9486 [list desc "Box Drawings Down Heavy and Right Light"             short "boxd_dhrl"]
+    tcl::dict::set charinfo 9487 [list desc "Box Drawings Heavy Down and Right"                   short "boxd_hdr"]
+    tcl::dict::set charinfo 9488 [list desc "Box Drawings Light Down and Left"                    short "boxd_ldl"]
+    tcl::dict::set charinfo 9489 [list desc "Box Drawings Down Light and Left Heavy"              short "boxd_dllh"]
+    tcl::dict::set charinfo 9490 [list desc "Box Drawings Down Heavy and Left Light"              short "boxd_dhll"]
+    tcl::dict::set charinfo 9491 [list desc "Box Drawings Heavy Down and Left"                    short "boxd_hdl"]
+    tcl::dict::set charinfo 9492 [list desc "Box Drawings Light Up and Right"                     short "boxd_lur"]
+    tcl::dict::set charinfo 9493 [list desc "Box Drawings Up Light and Right Heavy"               short "boxd_ulrh"]
+    tcl::dict::set charinfo 9494 [list desc "Box Drawings Up Heavy and Right Light"               short "boxd_uhrl"]
+    tcl::dict::set charinfo 9495 [list desc "Box Drawings Heavy Up and Right"                     short "boxd_hur"]
+    tcl::dict::set charinfo 9496 [list desc "Box Drawings Light Up and Left"                      short "boxd_lul"]
+    tcl::dict::set charinfo 9497 [list desc "Box Drawings Up Light and Left Heavy"                short "boxd_ullh"]
+    tcl::dict::set charinfo 9498 [list desc "Box Drawings Up Heavy and Left Light"                short "boxd_uhll"]
+    tcl::dict::set charinfo 9499 [list desc "Box Drawings Heavy Up and Left"                      short "boxd_hul"]
+    tcl::dict::set charinfo 9500 [list desc "Box Drawings Light Vertical and Right"               short "boxd_lvr"]
+    tcl::dict::set charinfo 9501 [list desc "Box Drawings Vertical Light and Right Heavy"         short "boxd_vlrh"]
+    tcl::dict::set charinfo 9502 [list desc "Box Drawings Up Heavy and Right Down Light"          short "boxd_uhrdl"]
+    tcl::dict::set charinfo 9503 [list desc "Box Drawings Down Heavy and Right Up Light"          short "boxd_dhrul"]
+    tcl::dict::set charinfo 9504 [list desc "Box Drawings Vertical Heavy and Right Light"         short "boxd_vhrl"]
+    tcl::dict::set charinfo 9505 [list desc "Box Drawings Down Light and Right Up Heavy"          short "boxd_dlruh"]
+    tcl::dict::set charinfo 9506 [list desc "Box Drawings Up Light and Right Down Heavy"          short "boxd_ulrdh"]
+    tcl::dict::set charinfo 9507 [list desc "Box Drawings Heavy Vertical and Right"               short "boxd_hvr"]
+    tcl::dict::set charinfo 9508 [list desc "Box Drawings Light Vertical and Left"                short "boxd_lvl"]
+    tcl::dict::set charinfo 9509 [list desc "Box Drawings Vertical Light and Left Heavy"          short "boxd_vllh"]
+    tcl::dict::set charinfo 9510 [list desc "Box Drawings Up Heavy and Let Down Light"            short "boxd_uhldl"]
+    tcl::dict::set charinfo 9511 [list desc "Box Drawings Down Heavy and Left Up Light"           short "boxd_dhlul"]
+    tcl::dict::set charinfo 9512 [list desc "Box Drawings Vertical Heavy and Left Light"          short "boxd_vhll"]
+    tcl::dict::set charinfo 9513 [list desc "Box Drawings Down Light and left Up Heavy"           short "boxd_dlluh"]
+    tcl::dict::set charinfo 9514 [list desc "Box Drawings Up Light and Left Down Heavy"           short "boxd_ulldh"]
+    tcl::dict::set charinfo 9515 [list desc "Box Drawings Heavy Vertical and Left"                short "boxd_hvl"]
+    tcl::dict::set charinfo 9516 [list desc "Box Drawings Light Down and Horizontal"              short "boxd_ldhz"]
+    tcl::dict::set charinfo 9517 [list desc "Box Drawings Left Heavy and Right Down Light"        short "boxd_lhrdl"]
+    tcl::dict::set charinfo 9518 [list desc "Box Drawings Right Heavy and Left Down Light"        short "boxd_rhldl"]
+    tcl::dict::set charinfo 9519 [list desc "Box Drawings Down Light and Horizontal Heavy"        short "boxd_dlhzh"]
+    tcl::dict::set charinfo 9520 [list desc "Box Drawings Down Heavy and Horizontal Light"        short "boxd_dhhzl"]
+    tcl::dict::set charinfo 9521 [list desc "Box Drawings Right Light and Left Down Heavy"        short "boxd_rlldh"]
+    tcl::dict::set charinfo 9522 [list desc "Box Drawings Left Light and Right Down Heavy"        short "boxd_llrdh"]
+    tcl::dict::set charinfo 9523 [list desc "Box Drawings Heavy Down and Horizontal"              short "boxd_hdhz"]
+    tcl::dict::set charinfo 9524 [list desc "Box Drawings Light Up and Horizontal"                short "boxd_luhz"]
+    tcl::dict::set charinfo 9525 [list desc "Box Drawings Left Heavy and Right Up Light"          short "boxd_lhrul"]
+    tcl::dict::set charinfo 9526 [list desc "Box Drawings Right Heavy and Left Up Light"          short "boxd_rhlul"]
+    tcl::dict::set charinfo 9527 [list desc "Box Drawings Up Light and Horizontal Heavy"          short "boxd_ulhzh"]
+    tcl::dict::set charinfo 9528 [list desc "Box Drawings Up Heavy and Horizontal Light"          short "boxd_uhhzl"]
+    tcl::dict::set charinfo 9529 [list desc "Box Drawings Right Light and Left Up Heavy"          short "boxd_rlluh"]
+    tcl::dict::set charinfo 9530 [list desc "Box Drawings Left Light and Right Up Heavy"          short "boxd_llruh"]
+    tcl::dict::set charinfo 9531 [list desc "Box Drawings Heavy Up and Horizontal"                short "boxd_huhz"]
+    tcl::dict::set charinfo 9532 [list desc "Box Drawings Light Vertical and Horizontal"          short "boxd_lvhz"]
+    tcl::dict::set charinfo 9533 [list desc "Box Drawings Left Heavy and Right Vertical Light"    short "boxd_lhrvl"]
+    tcl::dict::set charinfo 9534 [list desc "Box Drawings Right Heavy and Left Vertical Light"    short "boxd_rhlvl"]
+    tcl::dict::set charinfo 9535 [list desc "Box Drawings Vertical Light and Horizontal Heavy"    short "boxd_vlhzh"]
+    tcl::dict::set charinfo 9536 [list desc "Box Drawings Up Heavy and Down Horizontal Light"     short "boxd_uhdhzl"]
+    tcl::dict::set charinfo 9537 [list desc "Box Drawings Down Heavy and Up Horizontal Light"     short "boxd_dhuhzl"]
+    tcl::dict::set charinfo 9538 [list desc "Box Drawings Vertical Heavy and Horizontal Light"    short "boxd_vhhzl"]
+    tcl::dict::set charinfo 9539 [list desc "Box Drawings Left Up Heavy and Right Down Light"     short "boxd_luhrdl"]
+    tcl::dict::set charinfo 9540 [list desc "Box Drawings Right Up Heavy and Left Down Light"     short "boxd_ruhldl"]
+    tcl::dict::set charinfo 9541 [list desc "Box Drawings Left Down Heavy and Right Up Light"     short "boxd_ldhrul"]
+    tcl::dict::set charinfo 9542 [list desc "Box Drawings Right Down Heavy and Left Up Light"     short "boxd_rdhlul"]
+    tcl::dict::set charinfo 9543 [list desc "Box Drawings Down Light and Up Horizontal Heavy"     short "boxd_dluhzh"]
+    tcl::dict::set charinfo 9544 [list desc "Box Drawings Up Light and Down Horizontal Heavy"     short "boxd_dldhzh"]
+    tcl::dict::set charinfo 9545 [list desc "Box Drawings Right Light and Left Vertical Heavy"    short "boxd_rllvh"]
+    tcl::dict::set charinfo 9546 [list desc "Box Drawings Left Light and Right Vertical Heavy"    short "boxd_llrvh"]
+    tcl::dict::set charinfo 9547 [list desc "Box Drawings Heavy Vertical and Horizontal"          short "boxd_hvhz"]
+    tcl::dict::set charinfo 9548 [list desc "Box Drawings Light Double Dash Horizontal"           short "boxd_lddshhz"]
+    tcl::dict::set charinfo 9549 [list desc "Box Drawings Heavy Double Dash Horizontal"           short "boxd_hddshhz"]
+    tcl::dict::set charinfo 9550 [list desc "Box Drawings Light Double Dash Vertical"             short "boxd_lddshv"]
+    tcl::dict::set charinfo 9551 [list desc "Box Drawings Heavy Double Dash Vertical"             short "boxd_hddshv"]
+    tcl::dict::set charinfo 9552 [list desc "Box Drawings Double Horizontal"                      short "boxd_dhz"]
+    tcl::dict::set charinfo 9553 [list desc "Box Drawings Double Vertical"                        short "boxd_dv"]
+    tcl::dict::set charinfo 9554 [list desc "Box Drawings Down Single and Right Double"           short "boxd_dsrd"]
+    tcl::dict::set charinfo 9555 [list desc "Box Drawings Down Double and Right Single"           short "boxd_ddrs"]
+    tcl::dict::set charinfo 9556 [list desc "Box Drawings Double Down and Right"                  short "boxd_ddr"]
+    tcl::dict::set charinfo 9557 [list desc "Box Drawings Down Single and Left Double"            short "boxd_dsld"]
+    tcl::dict::set charinfo 9558 [list desc "Box Drawings Down Double and Left Single"            short "boxd_ddls"]
+    tcl::dict::set charinfo 9559 [list desc "Box Drawings Double Down and Left"                   short "boxd_ddl"]
+    tcl::dict::set charinfo 9560 [list desc "Box Drawings Up Single and Right Double"             short "boxd_usrd"]
+    tcl::dict::set charinfo 9561 [list desc "Box Drawings Up Double and Right Single"             short "boxd_udrs"]
+    tcl::dict::set charinfo 9562 [list desc "Box Drawings Double Up and Right"                    short "boxd_dur"]
+    tcl::dict::set charinfo 9563 [list desc "Box Drawings Up Single and Left Double"              short "boxd_usld"]
+    tcl::dict::set charinfo 9564 [list desc "Box Drawings Up Double and Left Single"              short "boxd_udls"]
+    tcl::dict::set charinfo 9565 [list desc "Box Drawings Double Up and Left"                     short "boxd_dul"]
+    tcl::dict::set charinfo 9566 [list desc "Box Drawings Vertical Single and Right Double"       short "boxd_vsrd"]
+    tcl::dict::set charinfo 9567 [list desc "Box Drawings Vertical Double and Right Single"       short "boxd_vdrs"]
+    tcl::dict::set charinfo 9568 [list desc "Box Drawings Double Vertical and Right"              short "boxd_dvr"]
+    tcl::dict::set charinfo 9569 [list desc "Box Drawings Vertical Single and Left Double"        short "boxd_vsld"]
+    tcl::dict::set charinfo 9570 [list desc "Box Drawings Vertical Double and Left Single"        short "boxd_vdls"]
+    tcl::dict::set charinfo 9571 [list desc "Box Drawings Double Vertical and Left"               short "boxd_dvl"]
+    tcl::dict::set charinfo 9572 [list desc "Box Drawings Down Single and Horizontal Double"      short "boxd_dshzd"]
+    tcl::dict::set charinfo 9573 [list desc "Box Drawings Down Double and Horizontal Single"      short "boxd_ddhzs"]
+    tcl::dict::set charinfo 9574 [list desc "Box Drawings Double Down and Horizontal"             short "boxd_ddhz"]
+    tcl::dict::set charinfo 9575 [list desc "Box Drawings Up Single and Horizontal Double"        short "boxd_ushzd"]
+    tcl::dict::set charinfo 9576 [list desc "Box Drawings Up Double and Horizontal Single"        short "boxd_udhzs"]
+    tcl::dict::set charinfo 9577 [list desc "Box Drawings Double Up and Horizontal"               short "boxd_duhz"]
+    tcl::dict::set charinfo 9578 [list desc "Box Drawings Vertical Single and Horizontal Double"  short "boxd_vshzd"]
+    tcl::dict::set charinfo 9579 [list desc "Box Drawings Vertical Double and Horizontal Single"  short "boxd_vdhzs"]
+    tcl::dict::set charinfo 9580 [list desc "Box Drawings Double Vertical and Horizontal"         short "boxd_dvhz"]
+    tcl::dict::set charinfo 9581 [list desc "Box Drawings Light Arc Down and Right"               short "boxd_ladr"]
+    tcl::dict::set charinfo 9582 [list desc "Box Drawings Light Arc Down and Left"                short "boxd_ladl"]
+    tcl::dict::set charinfo 9583 [list desc "Box Drawings Light Arc Up and Left"                  short "boxd_laul"]
+    tcl::dict::set charinfo 9584 [list desc "Box Drawings Light Arc Up and Right"                 short "boxd_laur"]
+    tcl::dict::set charinfo 9585 [list desc "Box Drawings Light Diagonal Upper Right To Lower Left"   short "boxd_ldgurll"]
+    tcl::dict::set charinfo 9586 [list desc "Box Drawings Light Diagonal Upper Left To Lower Right"   short "boxd_ldgullr"]
+    tcl::dict::set charinfo 9587 [list desc "Box Drawings Light Diagonal Cross"                   short "boxd_ldc"]
+    tcl::dict::set charinfo 9588 [list desc "Box Drawings Light Left"                             short "boxd_ll"]
+    tcl::dict::set charinfo 9589 [list desc "Box Drawings Light Up"                               short "boxd_lu"]
+    tcl::dict::set charinfo 9590 [list desc "Box Drawings Light Right"                            short "boxd_lr"]
+    tcl::dict::set charinfo 9591 [list desc "Box Drawings Light Down"                             short "boxd_ld"]
+    tcl::dict::set charinfo 9592 [list desc "Box Drawings Heavy Left"                             short "boxd_hl"]
+    tcl::dict::set charinfo 9593 [list desc "Box Drawings Heavy Up"                               short "boxd_hu"]
+    tcl::dict::set charinfo 9594 [list desc "Box Drawings Heavy Right"                            short "boxd_hr"]
+    tcl::dict::set charinfo 9595 [list desc "Box Drawings Heavy Down"                             short "boxd_hd"]
+    tcl::dict::set charinfo 9596 [list desc "Box Drawings Light Left and Heavy Right"             short "boxd_llhr"]
+    tcl::dict::set charinfo 9597 [list desc "Box Drawings Light Up and Heavy Down"                short "boxd_luhd"]
+    tcl::dict::set charinfo 9598 [list desc "Box Drawings Heavy Left and Light Right"             short "boxd_hllr"]
+    tcl::dict::set charinfo 9599 [list desc "Box Drawings Heavy Up and Light Down"                short "boxd_huld"]
+
+
+    tcl::dict::set charsets "Halfwidth and Fullwidth Forms" [list ranges [list {start 65280 end 65519}] description "Halfwidth and Fullwidth Forms (variants)" settype "tcl_supplemental"]
+        tcl::dict::set charsets "ascii_fullwidth" [list ranges [list {start 65281 end 65374}] description "Ascii 21 to 7E fullwidth" parentblock "halfwidth_and_fullwidth_forms" settype "other"]
+
+    tcl::dict::set charsets "Specials" [list ranges [list {start 65520 end 65535}] description "Specials" settype "tcl_supplemental"]
+
+    tcl::dict::set charsets "noncharacters" [list ranges [list\
         {start 64976 end 65007   note "BMP FDD0..FDEF"}\
         {start 65534 end 65535   note "BMP FFFE,FFFF"}\
         {start 131070 end 131071 note "plane1 1FFFE,1FFFF"}\
@@ -888,18 +888,18 @@ namespace eval punk::char {
     variable charshort
     proc _build_charshort {} {
         variable charshort
-        set charshort [dict create]
+        set charshort [tcl::dict::create]
         variable charinfo
-        dict for {k v} $charinfo {
-            if {[dict exists $v short]} {
-                set sh [dict get $v short]
-                if {[dict exists $charshort $sh]} {
+        tcl::dict::for {k v} $charinfo {
+            if {[tcl::dict::exists $v short]} {
+                set sh [tcl::dict::get $v short]
+                if {[tcl::dict::exists $charshort $sh]} {
                     puts stderr "_build_charshort WARNING character data load duplicate shortcode '$sh'"
                 }
-                dict set charshort $sh  [format %c $k]
+                tcl::dict::set charshort $sh  [format %c $k]
             }
         }
-        return [dict size $charshort]
+        return [tcl::dict::size $charshort]
     }
     _build_charshort
 
@@ -916,35 +916,35 @@ namespace eval punk::char {
         variable charset_extents_startpoints
         variable charset_extents_endpoints
         variable charset_extents_rangenames
-        set charset_extents_startpoints     [dict create]
-        set charset_extents_endpoints       [dict create]
-        set charset_extents_rangenames      [dict create]
-        dict for {setname setinfo} $charsets {
-            set ranges [dict get $setinfo ranges]
-            if {[dict get $setinfo settype] eq "block"} {
+        set charset_extents_startpoints     [tcl::dict::create]
+        set charset_extents_endpoints       [tcl::dict::create]
+        set charset_extents_rangenames      [tcl::dict::create]
+        tcl::dict::for {setname setinfo} $charsets {
+            set ranges [tcl::dict::get $setinfo ranges]
+            if {[tcl::dict::get $setinfo settype] eq "block"} {
                 #unicode block must have a single range
                 #we consider a char a member of the block even if unassigned/reserved (as per unicode documentation)
-                set start [dict get [lindex $ranges 0] start]
-                set end [dict get [lindex $ranges 0] end]
-                if {![dict exists $charset_extents_startpoints $start] || $end ni [dict get $charset_extents_startpoints $start]} {
+                set start [tcl::dict::get [lindex $ranges 0] start]
+                set end [tcl::dict::get [lindex $ranges 0] end]
+                if {![tcl::dict::exists $charset_extents_startpoints $start] || $end ni [tcl::dict::get $charset_extents_startpoints $start]} {
                     #assertion if end wasn't in startpoits list - then start won't be in endpoints list
-                    dict lappend charset_extents_startpoints  $start $end 
-                    dict lappend charset_extents_endpoints $end $start
+                    tcl::dict::lappend charset_extents_startpoints  $start $end 
+                    tcl::dict::lappend charset_extents_endpoints $end $start
                 }
-                dict lappend charset_extents_rangenames ${start},${end} [list $setname 1]
+                tcl::dict::lappend charset_extents_rangenames ${start},${end} [list $setname 1]
             } else {
                 #multirange sets/scripts. have holes. Char not a member if it's not explicitly in a defined range.
                 #They should be in order within a set - but we don't assume so
                 set r 1
                 foreach range $ranges {
-                    set start [dict get $range start]
-                    set end [dict get $range end]
-                    if {![dict exists $charset_extents_startpoints $start] || $end ni [dict get $charset_extents_startpoints $start]} {
+                    set start [tcl::dict::get $range start]
+                    set end [tcl::dict::get $range end]
+                    if {![tcl::dict::exists $charset_extents_startpoints $start] || $end ni [tcl::dict::get $charset_extents_startpoints $start]} {
                         #assertion if end wasn't in startpoits list - then start won't be in endpoints list
-                        dict lappend charset_extents_startpoints  $start $end
-                        dict lappend charset_extents_endpoints    $end   $start
+                        tcl::dict::lappend charset_extents_startpoints  $start $end
+                        tcl::dict::lappend charset_extents_endpoints    $end   $start
                     }
-                    dict lappend charset_extents_rangenames ${start},${end} [list $setname $r]
+                    tcl::dict::lappend charset_extents_rangenames ${start},${end} [list $setname $r]
                     incr r
                 }
             }
@@ -954,7 +954,7 @@ namespace eval punk::char {
         set charset_extents_startpoints [lsort -stride 2 -integer $charset_extents_startpoints]
         set charset_extents_endpoints   [lsort -stride 2 -integer $charset_extents_endpoints]
         #no need to sort charset_extents_rangenames - lookup only done using dict methods
-        return [dict size $charset_extents_startpoints]
+        return [tcl::dict::size $charset_extents_startpoints]
     }
     _build_charset_extents ;#rebuilds for all charsets 
 
@@ -982,11 +982,11 @@ namespace eval punk::char {
         if {[file exists $fname]} {
             #puts stderr "load_nerdfonts loading $fname"
             set data [fileutil::cat -translation binary $fname] 
-            set short_seen [dict create]
-            set current_set_range [dict create]
+            set short_seen [tcl::dict::create]
+            set current_set_range [tcl::dict::create]
             set filesets_loading [list]
             foreach ln [split $data \n] {
-                    set ln [string trim $ln]
+                    set ln [tcl::string::trim $ln]
                     if {$ln eq ""} {continue}
                     set desc [lassign $ln hex rawsetname]
                     set hexnum 0x$hex
@@ -994,36 +994,36 @@ namespace eval punk::char {
                     set setname "nf_$rawsetname"  ;#Ensure nerdfont set names are prefixed.
 
                     if {$setname ni $filesets_loading} {
-                        if {![dict exists $charsets $setname]} {
+                        if {![tcl::dict::exists $charsets $setname]} {
                             #set exists - but not in our filesets_loading list - therefore this set has been previously loaded, so clear old data first
                             dict unset charset $setname
                         }
                         set newrange [list start $dec end $dec]
-                        dict set current_set_range $setname $newrange 
-                        dict set charsets $setname [list ranges [list $newrange]  description "nerd fonts $rawsetname" settype "nerdfonts privateuse"]
+                        tcl::dict::set current_set_range $setname $newrange 
+                        tcl::dict::set charsets $setname [list ranges [list $newrange]  description "nerd fonts $rawsetname" settype "nerdfonts privateuse"]
 
                         lappend filesets_loading $setname
                     }
                     #expects ordered glyph list
-                    set existing_range [dict get $current_set_range $setname]
-                    set existing_end [dict get $existing_range end]
+                    set existing_range [tcl::dict::get $current_set_range $setname]
+                    set existing_end [tcl::dict::get $existing_range end]
                     if {$dec - $existing_end == 1} {
                         #part of current range
-                        dict set current_set_range $setname end $dec
+                        tcl::dict::set current_set_range $setname end $dec
                         #overwrite last ranges element
-                        set rangelist [lrange [dict get $charsets $setname ranges] 0 end-1]
-                        lappend rangelist [dict get $current_set_range $setname]
-                        dict set charsets $setname ranges $rangelist 
+                        set rangelist [lrange [tcl::dict::get $charsets $setname ranges] 0 end-1]
+                        lappend rangelist [tcl::dict::get $current_set_range $setname]
+                        tcl::dict::set charsets $setname ranges $rangelist 
                     } else {
                         #new range for set
-                        dict set current_set_range $setname start $dec
-                        dict set current_set_range $setname end $dec
-                        set rangelist [dict get $charsets $setname ranges]
-                        lappend rangelist [dict get $current_set_range $setname] 
-                        dict set charsets $setname ranges $rangelist
+                        tcl::dict::set current_set_range $setname start $dec
+                        tcl::dict::set current_set_range $setname end $dec
+                        set rangelist [tcl::dict::get $charsets $setname ranges]
+                        lappend rangelist [tcl::dict::get $current_set_range $setname] 
+                        tcl::dict::set charsets $setname ranges $rangelist
                     }
 
-                    if {![dict exists $charinfo $dec]} {
+                    if {![tcl::dict::exists $charinfo $dec]} {
                         # -- ---
                         #review
                         set map [list beaufort bf gibbous gb crescent cr thunderstorm tstorm thermometer thermom]
@@ -1042,16 +1042,16 @@ namespace eval punk::char {
                         }
                         set joined_desc [join $normdesc _]
                         #map after join so we can normalize some underscored elements e.g creativecommons & creative_commons
-                        set mapped_desc [string map $map $joined_desc]
+                        set mapped_desc [tcl::string::map $map $joined_desc]
                         set s nf_${rawsetname}_$mapped_desc
 
-                        if {![dict exists $short_seen $s]} {
-                            dict set short_seen $s {}
+                        if {![tcl::dict::exists $short_seen $s]} {
+                            tcl::dict::set short_seen $s {}
                         } else {
                             #duplicate in the data file (e.g 2023 weather night alt rain mix)
                             set s ${s}_$hex
                         }
-                        dict set charinfo $dec [list desc "$desc" short $s]
+                        tcl::dict::set charinfo $dec [list desc "$desc" short $s]
                     }
             }
            _build_charshort
@@ -1070,7 +1070,7 @@ namespace eval punk::char {
         set pkg_base  [file dirname $tmfile]
         return $pkg_base
     }
-    namespace eval internal {
+    tcl::namespace::eval internal {
         proc unicode_folder {} {
             set parent [file join [punk::char::package_base] char]
             set candidates [glob -nocomplain -type d -dir $parent -tail unicode*]
@@ -1086,8 +1086,8 @@ namespace eval punk::char {
                 error {wrong # args: should be "dict_getdef dictValue ?key ...? key default"}
             }
             set keys [lrange $args 0 end-1]
-            if {[dict exists $dictValue {*}$keys]} {
-                return [dict get $dictValue {*}$keys]
+            if {[tcl::dict::exists $dictValue {*}$keys]} {
+                return [tcl::dict::get $dictValue {*}$keys]
             } else {
                 return [lindex $args end] 
             }
@@ -1097,7 +1097,7 @@ namespace eval punk::char {
 
 
     #charsets structure
-    #dict set charsets "halfwidth_and_fullwidth_forms" [list ranges [list {start 65280 end 65519}] description "Halfwidth and Fullwidth Forms (variants) settype block"]
+    #tcl::dict::set charsets "halfwidth_and_fullwidth_forms" [list ranges [list {start 65280 end 65519}] description "Halfwidth and Fullwidth Forms (variants) settype block"]
 
     #unicode Blocks.txt
     #load the defined blocks into 'charsets' and mark as type 'block'. Unicode blocks have only one range - and don't overlap.
@@ -1119,20 +1119,20 @@ namespace eval punk::char {
         close $fd
         set block_count 0
         foreach ln [split $data \n] {
-            set ln [string trim $ln]
-            if {[string match #* $ln]} {
+            set ln [tcl::string::trim $ln]
+            if {[tcl::string::match #* $ln]} {
                 continue
             }
-            if {[set pcolon [string first ";" $ln]] > 0} {
-                set lhs [string trim [string range $ln 0 $pcolon-1]]
-                set name [string trim [string range $ln $pcolon+1 end]]
+            if {[set pcolon [tcl::string::first ";" $ln]] > 0} {
+                set lhs [tcl::string::trim [tcl::string::range $ln 0 $pcolon-1]]
+                set name [tcl::string::trim [tcl::string::range $ln $pcolon+1 end]]
                 set lhsparts [split $lhs .] 
                 set start [lindex $lhsparts 0]
                 set end   [lindex $lhsparts end]
                 #puts "$start -> $end  '$name'"
                 set  decimal_start [expr {"0x$start"}]
                 set  decimal_end   [expr {"0x$end"}]
-                dict set charsets $name [list ranges [list [list start $decimal_start end $decimal_end note "unicode block $lhs"]] description "" settype block]
+                tcl::dict::set charsets $name [list ranges [list [list start $decimal_start end $decimal_end note "unicode block $lhs"]] description "" settype block]
                 incr block_count
             }
         }
@@ -1169,7 +1169,7 @@ namespace eval punk::char {
 
     proc charshort {shortname} {
         variable charshort
-        return [dict get $charshort $shortname]
+        return [tcl::dict::get $charshort $shortname]
     }
 
     proc box_drawing {args} {
@@ -1180,8 +1180,8 @@ namespace eval punk::char {
     }
 
     proc char_info_hex {hex args} {
-        set hex [string map [list _ ""] $hex]
-        if {[string is xdigit -strict $hex]} {
+        set hex [tcl::string::map [list _ ""] $hex]
+        if {[tcl::string::is xdigit -strict $hex]} {
             #has no leading 0x
             set dec [expr {"0x$hex"}]
         } else {
@@ -1193,19 +1193,19 @@ namespace eval punk::char {
         #Note - on some versions of Tcl -e.g 8.6 use could supply something like \U1f600 (smiley icon) but we receive fffd (replacement special)
         #there is no way to detect what the user intended ie we can't distinguish if they actually typed \UFFFD
         #we can test if such mapping happens in general - and warn if codepoint is FFFD in the result dict
-        set returninfo [dict create]
-        if {[string equal \UFFFD $char] && [string equal \U1F600 \UFFFD]} {
-            dict set returninfo WARNING "this tcl maps multiple to FFFD"
+        set returninfo [tcl::dict::create]
+        if {[tcl::string::equal \UFFFD $char] && [tcl::string::equal \U1F600 \UFFFD]} {
+            tcl::dict::set returninfo WARNING "this tcl maps multiple to FFFD"
         }
         lassign [scan $char %c%s] dec_char remainder
-        if {[string length $remainder]} {
+        if {[tcl::string::length $remainder]} {
             error "char_info requires a single character"
         }
-        set result [dict merge $returninfo [char_info_dec $dec_char {*}$args]]
+        set result [tcl::dict::merge $returninfo [char_info_dec $dec_char {*}$args]]
     }
     proc char_info_dec {dec args} {
         set dec_char [expr {$dec}]
-        set opts [dict create\
+        set opts [tcl::dict::create\
             -fields {default}\
             -except {}\
         ]
@@ -1217,16 +1217,16 @@ namespace eval punk::char {
         foreach {k v} $args {
             switch -- $k {
                 -fields - -except {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "char_info unrecognised option '$k'. Known options:'[dict keys $opts]' known_fields: $known_fields usage: char_info <char> ?-fields {<fieldnames>}? ?-except {<fieldnames>}?"
+                    error "char_info unrecognised option '$k'. Known options:'[tcl::dict::keys $opts]' known_fields: $known_fields usage: char_info <char> ?-fields {<fieldnames>}? ?-except {<fieldnames>}?"
                 }
             }
         }
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_fields      [dict get $opts -fields]
-        set opt_except      [dict get $opts -except]
+        set opt_fields      [tcl::dict::get $opts -fields]
+        set opt_except      [tcl::dict::get $opts -except]
         # -- --- --- --- --- --- --- --- --- --- --- ---
         set initial_fields [list]
         if {"default" in $opt_fields} {
@@ -1270,51 +1270,51 @@ namespace eval punk::char {
         variable charinfo
         variable charsets
         set hex_char [format %04x $dec_char]
-        set returninfo [dict create]
+        set returninfo [tcl::dict::create]
         foreach f $fields {
             switch -- $f {
                 dec {
-                    dict set returninfo dec $dec_char
+                    tcl::dict::set returninfo dec $dec_char
                 }
                 hex {
-                    dict set returninfo hex $hex_char
+                    tcl::dict::set returninfo hex $hex_char
                 }
                 desc {
-                    if {[dict exists $charinfo $dec_char desc]} {
-                        dict set returninfo desc [dict get $charinfo $dec_char desc]
+                    if {[tcl::dict::exists $charinfo $dec_char desc]} {
+                        tcl::dict::set returninfo desc [tcl::dict::get $charinfo $dec_char desc]
                     } else {
-                        dict set returninfo desc ""
+                        tcl::dict::set returninfo desc ""
                     }
                 }
                 short {
-                    if {[dict exists $charinfo $dec_char short]} {
-                        dict set returninfo desc [dict get $charinfo $dec_char short]
+                    if {[tcl::dict::exists $charinfo $dec_char short]} {
+                        tcl::dict::set returninfo desc [tcl::dict::get $charinfo $dec_char short]
                     } else {
-                        dict set returninfo short ""
+                        tcl::dict::set returninfo short ""
                     }
                 }
                 testwidth {
                     #todo - expectedwidth - lookup the printing width it is *supposed* to have from unicode tables
                     #testwidth is one of the main ones likely to be worthwhile excluding as querying the console via ansi takes time
                     set existing_testwidth ""
-                    if {[dict exists $charinfo $dec_char testwidth]} {
-                    set existing_testwidth [dict get $charinfo $dec_char testwidth] 
+                    if {[tcl::dict::exists $charinfo $dec_char testwidth]} {
+                    set existing_testwidth [tcl::dict::get $charinfo $dec_char testwidth] 
                     }
                     if {$existing_testwidth eq ""} {
                         #no cached data - do expensive cursor-position test (Note this might not be 100% reliable - terminals lie e.g if ansi escape sequence has set to wide printing.)
                         set char [format %c $dec_char]
                         set chwidth [char_info_testwidth $char]
                         
-                        dict set returninfo testwidth $chwidth
+                        tcl::dict::set returninfo testwidth $chwidth
                         #cache it. todo - -verify flag to force recalc in case font/terminal changed in some way?
-                        dict set charinfo $dec_char testwidth $chwidth
+                        tcl::dict::set charinfo $dec_char testwidth $chwidth
                     } else {
-                        dict set returninfo testwidth $existing_testwidth
+                        tcl::dict::set returninfo testwidth $existing_testwidth
                     }
                 }
                 char {
                     set char [format %c $dec_char]
-                    dict set returninfo char $char
+                    tcl::dict::set returninfo char $char
                 }
                 memberof { 
                     #memberof takes in the order of a few hundred microseconds if a simple scan of all ranges is taken - possibly worthwhile caching/optimising
@@ -1323,17 +1323,17 @@ namespace eval punk::char {
                     #We could potentially populate it using a side-thread - but it seems reasonable to just cache result after first use here.
                     #some efficiency could also be gained by pre-calculating the extents for each charset which isn't a simple unicode block. (and perhaps sorting by max char)
                     set memberof [list]
-                    dict for {setname setinfo} $charsets {
-                        foreach r [dict get $setinfo ranges] {
-                            set s [dict get $r start]
-                            set e [dict get $r end]
+                    tcl::dict::for {setname setinfo} $charsets {
+                        foreach r [tcl::dict::get $setinfo ranges] {
+                            set s [tcl::dict::get $r start]
+                            set e [tcl::dict::get $r end]
                             if {$dec_char >= $s && $dec_char <= $e} {
                                 lappend memberof $setname
                                 break
                             }
                         }
                     }
-                    dict set returninfo memberof $memberof
+                    tcl::dict::set returninfo memberof $memberof
                 }
             }
         }
@@ -1344,10 +1344,10 @@ namespace eval punk::char {
     proc _char_info_dec_memberof_scan {dec} {
         variable charsets
         set memberof [list]
-        dict for {setname setinfo} $charsets {
-            foreach r [dict get $setinfo ranges] {
-                set s [dict get $r start]
-                set e [dict get $r end]
+        tcl::dict::for {setname setinfo} $charsets {
+            foreach r [tcl::dict::get $setinfo ranges] {
+                set s [tcl::dict::get $r start]
+                set e [tcl::dict::get $r end]
                 if {$dec >= $s && $dec <= $e} {
                     lappend memberof $setname
                     break
@@ -1359,15 +1359,15 @@ namespace eval punk::char {
     proc range_split_info {dec} {
         variable charset_extents_startpoints
         variable charset_extents_endpoints
-        set skeys [dict keys $charset_extents_startpoints]
-        set ekeys [dict keys $charset_extents_endpoints]
-        set splen [dict size $charset_extents_startpoints]
-        set eplen [dict size $charset_extents_endpoints]
+        set skeys [tcl::dict::keys $charset_extents_startpoints]
+        set ekeys [tcl::dict::keys $charset_extents_endpoints]
+        set splen [tcl::dict::size $charset_extents_startpoints]
+        set eplen [tcl::dict::size $charset_extents_endpoints]
         set s [lsearch -bisect -integer $skeys $dec]
         set s_at_or_below [lrange $skeys 0 $s] 
         set e_of_s [list]
         foreach sk $s_at_or_below {
-            lappend e_of_s {*}[dict get $charset_extents_startpoints $sk]
+            lappend e_of_s {*}[tcl::dict::get $charset_extents_startpoints $sk]
         }
         set e_of_s [lsort -integer $e_of_s]
         set splitposn [lsearch -bisect -integer $e_of_s $dec]
@@ -1376,7 +1376,7 @@ namespace eval punk::char {
         set reduced_endpoints [lrange $e_of_s $splitposn end]
         set sps [list]
         foreach ep $reduced_endpoints {
-            lappend sps {*}[dict get $charset_extents_endpoints $ep]
+            lappend sps {*}[tcl::dict::get $charset_extents_endpoints $ep]
         }
 
 
@@ -1386,14 +1386,14 @@ namespace eval punk::char {
             set e_at_or_above [lrange $ekeys $e end]
             set s_of_e [list]
             foreach  ek $e_at_or_above {
-                lappend s_of_e {*}[dict get $charset_extents_endpoints $ek]
+                lappend s_of_e {*}[tcl::dict::get $charset_extents_endpoints $ek]
             }
             set startpoints_of_above [llength $s_of_e]
             set splitposn [lsearch -bisect -integer $s_of_e $dec]
             set reduced_startpoints [lrange $s_of_e 0 $splitposn]
             set eps [list]
             foreach sp $reduced_startpoints {
-                lappend eps {*}[dict get $charset_extents_startpoints $sp]
+                lappend eps {*}[tcl::dict::get $charset_extents_startpoints $sp]
             }
         } else {
             set s_of_e [list]
@@ -1402,7 +1402,7 @@ namespace eval punk::char {
 
         }
         
-        return [dict create startpoints $splen endpoints $eplen midpoint [expr {floor($eplen/2)}] posn $e lhs_endpoints_to_check "[llength $reduced_endpoints]/[llength $e_of_s]=[llength $sps]ranges" rhs_startpoints_to_check "[llength $reduced_startpoints]/[llength $s_of_e]=[llength $eps]"]
+        return [tcl::dict::create startpoints $splen endpoints $eplen midpoint [expr {floor($eplen/2)}] posn $e lhs_endpoints_to_check "[llength $reduced_endpoints]/[llength $e_of_s]=[llength $sps]ranges" rhs_startpoints_to_check "[llength $reduced_startpoints]/[llength $s_of_e]=[llength $eps]"]
     }
     #for just a few extra sets such as wgl4 and unicode blocks loaded - this gives e.g 5x + better performance than the simple search above, and up to twice as slow for tcl 8.6
     #performance biased towards lower numbered characters (which is not too bad in the context of unicode)
@@ -1419,17 +1419,17 @@ namespace eval punk::char {
             #algorithm should theoretically be a little better with -stride
             set last_smaller_or_equal_startposn [lsearch -stride 2 -bisect -integer $charset_extents_startpoints $dec]
             set sets_starting_below [lrange $charset_extents_startpoints 0 $last_smaller_or_equal_startposn+1] ;#+1 to include 2nd element of stridden pair
-            set endpoints_of_starting_below [lsort -integer [concat {*}[dict values $sets_starting_below]]]
+            set endpoints_of_starting_below [lsort -integer [concat {*}[tcl::dict::values $sets_starting_below]]]
         } else {
             #no -stride available
-            set startkeys [dict keys $charset_extents_startpoints]
+            set startkeys [tcl::dict::keys $charset_extents_startpoints]
             set last_smaller_or_equal_startkeyposn [lsearch -bisect -integer $startkeys $dec] ;#assert will always return one of the keys if number >=0 supplied (last key if > all)
             #set startkey_found [lindex $startkeys $last_smaller_or_equal_startkeyposn]
             set start_below_keys [lrange $startkeys 0 $last_smaller_or_equal_startkeyposn] ;#These are the keys of sets which start at or below dec
             #puts "start_below_keys: '$start_below_keys'"
             set endpoints_of_starting_below [list]
             foreach belowkey $start_below_keys {
-                lappend endpoints_of_starting_below {*}[dict get $charset_extents_startpoints $belowkey]
+                lappend endpoints_of_starting_below {*}[tcl::dict::get $charset_extents_startpoints $belowkey]
             }
             set endpoints_of_starting_below [lsort -integer $endpoints_of_starting_below[unset endpoints_of_starting_below]]
         }
@@ -1446,9 +1446,9 @@ namespace eval punk::char {
         #we have reduced our set of endpoints sufficiently (to those at or above dec) to run through and test each startpoint
         set ranges [list]
         foreach ep $reduced_opposite_limit {
-            foreach s [dict get $charset_extents_endpoints $ep] {
+            foreach s [tcl::dict::get $charset_extents_endpoints $ep] {
                 if {$s <= $dec} {
-                    lappend ranges [dict get $charset_extents_rangenames $s,$ep]
+                    lappend ranges [tcl::dict::get $charset_extents_rangenames $s,$ep]
                 }
             }
         }
@@ -1459,7 +1459,7 @@ namespace eval punk::char {
 
     #with glob searching of description and short
     proc char_range_dict {start end args} {
-        if {![string is integer -strict $start] || ![string is integer -strict $end]} {
+        if {![tcl::string::is integer -strict $start] || ![tcl::string::is integer -strict $end]} {
             error "char_range_dict error start and end must be integers"
         }
         set and_globs [list]
@@ -1474,32 +1474,32 @@ namespace eval punk::char {
             }
         }
         variable charinfo
-        set cdict [dict create]
+        set cdict [tcl::dict::create]
         set start [expr {$start}] ;#force string rep to decimal - otherwise first use of i as string could be hex or other rep whilst other i values will be decimal string rep due to incr
         for {set i $start} {$i <= $end} {incr i} {
             set hx [format %04x $i]
             set ch [format %c $i]
-            if {[dict exists $charinfo $i desc]} {
-                set d [dict get $charinfo $i desc]
+            if {[tcl::dict::exists $charinfo $i desc]} {
+                set d [tcl::dict::get $charinfo $i desc]
             } else {
                 set d ""
             }
-            if {[dict exists $charinfo $i short]} {
-                set s [dict get $charinfo $i short]
+            if {[tcl::dict::exists $charinfo $i short]} {
+                set s [tcl::dict::get $charinfo $i short]
             } else {
                 set s ""
             }
             set matchcount 0
             foreach glob $and_globs {
-                if {[string match -nocase $glob $s] || [string match -nocase $glob $d]} {
+                if {[tcl::string::match -nocase $glob $s] || [tcl::string::match -nocase $glob $d]} {
                    incr matchcount 
                 }
             }
             if {$matchcount == [llength $and_globs]} {
-                if {[dict exists $charinfo $i]} {
-                    dict set cdict $hx [dict merge [dict create dec $i hex $hx char $ch] [dict get $charinfo $i]]
+                if {[tcl::dict::exists $charinfo $i]} {
+                    tcl::dict::set cdict $hx [tcl::dict::merge [tcl::dict::create dec $i hex $hx char $ch] [tcl::dict::get $charinfo $i]]
                 } else {
-                    dict set cdict $hx [list dec $i hex $hx char $ch desc $d short $s]
+                    tcl::dict::set cdict $hx [list dec $i hex $hx char $ch desc $d short $s]
                 }
             }
         }
@@ -1508,17 +1508,17 @@ 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]} {
+        if {![tcl::string::is integer -strict $start] || ![tcl::string::is integer -strict $end]} {
             error "char_range error start and end must be integers"
         }
         set charset_dict [char_range_dict $start $end {*}$args]
         set out ""
-        set col3 [string repeat " " 12]
-        dict for {k inf} $charset_dict {
+        set col3 [tcl::string::repeat " " 12]
+        tcl::dict::for {k inf} $charset_dict {
             set s [internal::dict_getdef $inf short ""]
             set d [internal::dict_getdef $inf desc ""]
             set s_col [overtype::left $col3 $s]
-            append out "$k [dict get $inf dec] [dict get $inf char] $s_col $d" \n
+            append out "$k [tcl::dict::get $inf dec] [tcl::dict::get $inf char] $s_col $d" \n
         }
         return $out
     }
@@ -1530,26 +1530,26 @@ namespace eval punk::char {
         #todo - more efficient datastructures?
         if {![regexp {[?*]} $name_or_glob]} {
             #no glob - just retrieve it 
-            if {[dict exists $charsets $name_or_glob]} {
-                if {[dict get $charsets $name_or_glob settype] eq "block"} {
-                    return [dict create $name_or_glob [dict get $charsets $name_or_glob]]
+            if {[tcl::dict::exists $charsets $name_or_glob]} {
+                if {[tcl::dict::get $charsets $name_or_glob settype] eq "block"} {
+                    return [tcl::dict::create $name_or_glob [tcl::dict::get $charsets $name_or_glob]]
                 }
             }
             #no exact match - try case insensitive..
-            set name [lsearch -inline -nocase [dict keys $charsets] $name_or_glob]
+            set name [lsearch -inline -nocase [tcl::dict::keys $charsets] $name_or_glob]
             if {$name ne ""} {
-                if {[dict get $charsets $name settype] eq "block"} {
-                    return [dict create $name [dict get $charsets $name]]
+                if {[tcl::dict::get $charsets $name settype] eq "block"} {
+                    return [tcl::dict::create $name [tcl::dict::get $charsets $name]]
                 }
             }
 
         } else {
             #build a subset
-            set charsets_block [dict create]
-            dict for {k v} $charsets {
-                if {[string match -nocase $name_or_glob $k]} {
-                    if {[dict get $v settype] eq "block"} {
-                        dict set charsets_block $k $v
+            set charsets_block [tcl::dict::create]
+            tcl::dict::for {k v} $charsets {
+                if {[tcl::string::match -nocase $name_or_glob $k]} {
+                    if {[tcl::dict::get $v settype] eq "block"} {
+                        tcl::dict::set charsets_block $k $v
                     }
                 }
             }
@@ -1560,20 +1560,20 @@ namespace eval punk::char {
         variable charsets
         if {![regexp {[?*]} $name_or_glob]} {
             #no glob - just retrieve it 
-            if {[dict exists $charsets $name_or_glob]} {
+            if {[tcl::dict::exists $charsets $name_or_glob]} {
                 return [list $name_or_glob]
             }
             #no exact match - try case insensitive..
-            set name [lsearch -inline -nocase [dict keys $charsets] $name_or_glob]
+            set name [lsearch -inline -nocase [tcl::dict::keys $charsets] $name_or_glob]
             if {$name ne ""} {
                 return [list $name]
             }
         } else {
             if {$name_or_glob eq "*"} {
-                return [lsort [dict keys $charsets]] 
+                return [lsort [tcl::dict::keys $charsets]] 
             }
-            #dict keys $dict <pattern> doesn't have option for case insensitive searches
-            return [lsort [lsearch -all -inline -nocase [dict keys $charsets] $name_or_glob]]
+            #tcl::dict::keys $dict <pattern> doesn't have option for case insensitive searches
+            return [lsort [lsearch -all -inline -nocase [tcl::dict::keys $charsets] $name_or_glob]]
         }
     }
 
@@ -1583,8 +1583,8 @@ namespace eval punk::char {
     proc charset_names2 {{namesearch *}} {
         variable charsets
         #dictionary sorting of the keys is slow! - we should obviously store it in sorted order instead of sorting entire list on retrieval - or just sort results
-        #set sortedkeys [lsort -increasing -dictionary [dict keys $charsets]] ;#NOTE must use -dictionary to use -sorted flag below
-        set sortedkeys [lsort -increasing [dict keys $charsets]] 
+        #set sortedkeys [lsort -increasing -dictionary [tcl::dict::keys $charsets]] ;#NOTE must use -dictionary to use -sorted flag below
+        set sortedkeys [lsort -increasing [tcl::dict::keys $charsets]] 
         if {$namesearch eq "*"} {
             return $sortedkeys
         }
@@ -1602,36 +1602,36 @@ namespace eval punk::char {
         set charset_names [charset_names $namesearch]
         set settype_list [list]
         foreach setname $charset_names {
-            lappend settype_list [dict get $charsets $setname settype]
+            lappend settype_list [tcl::dict::get $charsets $setname settype]
         }
 
         set charset_names [linsert $charset_names 0 "Set Name"]
         set settype_list  [linsert $settype_list 0 "Set Type"]
 
-        return [textblock::join [list_as_lines -- $charset_names] " " [list_as_lines $settype_list]]
+        return [textblock::join -- [list_as_lines -- $charset_names] " " [list_as_lines $settype_list]]
     }
     proc charset_defget {exactname} {
         variable charsets
-        return [dict get $charsets $exactname]
+        return [tcl::dict::get $charsets $exactname]
     }
     proc charset_defs {charsetname} {
         variable charsets
         set matches [charset_names $charsetname]
         set def_list [list]
         foreach setname $matches {
-            lappend def_list [dict create $setname [dict get $charsets $setname]]
+            lappend def_list [tcl::dict::create $setname [tcl::dict::get $charsets $setname]]
         }
         return [join $def_list \n]
     }
     proc charset_dictget {exactname} {
         variable charsets
-        set setinfo [dict get $charsets $exactname]
-        set ranges [dict get $setinfo ranges]
-        set charset_dict [dict create]
+        set setinfo [tcl::dict::get $charsets $exactname]
+        set ranges [tcl::dict::get $setinfo ranges]
+        set charset_dict [tcl::dict::create]
         foreach r $ranges {
-            set start [dict get $r start]
-            set end   [dict get $r end]
-            set charset_dict [dict merge $charset_dict [char_range_dict $start $end]]
+            set start [tcl::dict::get $r start]
+            set end   [tcl::dict::get $r end]
+            set charset_dict [tcl::dict::merge $charset_dict [char_range_dict $start $end]]
         }
         return $charset_dict
     }
@@ -1643,7 +1643,7 @@ namespace eval punk::char {
         }
         set dict_list [list]
         foreach m $matches {
-            lappend dict_list [dict create $m [charset_dictget $m]]
+            lappend dict_list [tcl::dict::create $m [charset_dictget $m]]
         }
         #return $dict_list
         return [join $dict_list \n]
@@ -1658,14 +1658,14 @@ namespace eval punk::char {
         if {![llength $matched_names]} {
             error "charset_page no charset matched pattern '$namesearch' - use 'charset_names' to get list"
         }
-        set defaults [dict create\
+        set defaults [tcl::dict::create\
             -ansi 0\
             -lined 1\
         ]
-        set opts [dict merge $defaults $args]
+        set opts [tcl::dict::merge $defaults $args]
         # -- --- --- ---
-        set opt_ansi        [dict get $opts -ansi]
-        set opt_lined       [dict get $opts -lined]
+        set opt_ansi        [tcl::dict::get $opts -ansi]
+        set opt_lined       [tcl::dict::get $opts -lined]
         # -- --- --- ---
         set re_diacritics {[\u0300-\u036f]+|[\u1ab0-\u1aff]+|[\u1dc0-\u1dff]+|[\u20d0-\u20ff]+|[\ufe20-\ufe2f]+} 
 
@@ -1681,18 +1681,18 @@ namespace eval punk::char {
         append out $prefix
         foreach charsetname $matched_names {
             if {[llength $search_this_and_that]} {
-                set setinfo [dict get $charsets $charsetname]
-                set ranges [dict get $setinfo ranges]
-                set charset_dict [dict create]
+                set setinfo [tcl::dict::get $charsets $charsetname]
+                set ranges [tcl::dict::get $setinfo ranges]
+                set charset_dict [tcl::dict::create]
                 foreach r $ranges {
-                    set start [dict get $r start]
-                    set end   [dict get $r end]
-                    set charset_dict [dict merge $charset_dict [char_range_dict $start $end {*}$search_this_and_that]]
+                    set start [tcl::dict::get $r start]
+                    set end   [tcl::dict::get $r end]
+                    set charset_dict [tcl::dict::merge $charset_dict [char_range_dict $start $end {*}$search_this_and_that]]
                 }
             } else {
                 set charset_dict [charset_dictget $charsetname]
             }
-            if {![dict size $charset_dict]} {
+            if {![tcl::dict::size $charset_dict]} {
                 continue
             }
             set i 1
@@ -1701,12 +1701,12 @@ namespace eval punk::char {
 
             set marker_line $prefix
             set line     $prefix
-            dict for {hex inf} $charset_dict {
-                set ch [dict get $inf char]
+            tcl::dict::for {hex inf} $charset_dict {
+                set ch [tcl::dict::get $inf char]
                 set twidth ""
                 set dec [expr {"0x$hex"}]
-                if {[dict exists $charinfo $dec testwidth]} {
-                    set twidth [dict get $charinfo $dec testwidth]
+                if {[tcl::dict::exists $charinfo $dec testwidth]} {
+                    set twidth [tcl::dict::get $charinfo $dec testwidth]
                 }
                 if {$twidth eq ""} {
                     #set width [ansifreestring_width $ch] ;#based on unicode props
@@ -1731,23 +1731,23 @@ namespace eval punk::char {
                     set marker "__ "
                     set displayv "${a1}$ch${a2} "
                 }
-                set hexlen [string length $hex]
-                append marker_line "[string repeat " " $hexlen] $marker"
+                set hexlen [tcl::string::length $hex]
+                append marker_line "[tcl::string::repeat " " $hexlen] $marker"
                 append line "$hex $displayv"
-                if {$i == [dict size $charset_dict] || $i % $cols == 0} {
+                if {$i == [tcl::dict::size $charset_dict] || $i % $cols == 0} {
                     if {$opt_lined} {
                         append out $marker_line \n
                     }
                     append out $line \n
                     set marker_line $prefix
                     set line $prefix
-                    #set out [string range $out 0 end-2]
+                    #set out [tcl::string::range $out 0 end-2]
                     #append out \n "        "
                 }
                 incr i
             }
         }
-        set out [string trimright $out " "]
+        set out [tcl::string::trimright $out " "]
         return $out
     }
 
@@ -1765,13 +1765,13 @@ namespace eval punk::char {
 
         foreach charsetname $matched_names {
             if {[llength $search_this_and_that]} {
-                set setinfo [dict get $charsets $charsetname]
-                set ranges [dict get $setinfo ranges]
-                set charset_dict [dict create]
+                set setinfo [tcl::dict::get $charsets $charsetname]
+                set ranges [tcl::dict::get $setinfo ranges]
+                set charset_dict [tcl::dict::create]
                 foreach r $ranges {
-                    set start [dict get $r start]
-                    set end   [dict get $r end]
-                    set charset_dict [dict merge $charset_dict [char_range_dict $start $end {*}$search_this_and_that]]
+                    set start [tcl::dict::get $r start]
+                    set end   [tcl::dict::get $r end]
+                    set charset_dict [tcl::dict::merge $charset_dict [char_range_dict $start $end {*}$search_this_and_that]]
                 }
             } else {
                 set charset_dict [charset_dictget $charsetname]
@@ -1779,22 +1779,22 @@ namespace eval punk::char {
             
             set col_items_short [list]
             set col_items_desc  [list]
-            dict for {k inf} $charset_dict {
+            tcl::dict::for {k inf} $charset_dict {
                 lappend col_items_desc  [internal::dict_getdef $inf desc ""]
                 lappend col_items_short [internal::dict_getdef $inf short ""]
             }
             if {[llength $col_items_desc]} {
-                set widest3 [tcl::mathfunc::max {*}[lmap v $col_items_short {string length $v}]]
+                set widest3 [tcl::mathfunc::max {*}[lmap v $col_items_short {tcl::string::length $v}]]
                 if {$widest3 == 0} {
                     set col3 " "
                 } else {
-                    set col3 [string repeat " " $widest3]
+                    set col3 [tcl::string::repeat " " $widest3]
                 }
-                dict for {k inf} $charset_dict {
+                tcl::dict::for {k inf} $charset_dict {
                     set s [internal::dict_getdef $inf short ""]
                     set d [internal::dict_getdef $inf desc ""]
                     set s_col [overtype::left $col3 $s]
-                    append out "$k [dict get $inf char] $s_col $d" \n
+                    append out "$k [tcl::dict::get $inf char] $s_col $d" \n
                 }
             }
         }
@@ -1812,44 +1812,44 @@ namespace eval punk::char {
         }
         set search_this_and_that $args
         set charcount 0
-        set width_results [dict create]
+        set width_results [tcl::dict::create]
         puts stdout "calibrating using terminal cursor movements.."
         foreach charsetname $matched_names {
             if {[llength $search_this_and_that]} {
-                set setinfo [dict get $charsets $charsetname]
-                set ranges [dict get $setinfo ranges]
-                set charset_dict [dict create]
+                set setinfo [tcl::dict::get $charsets $charsetname]
+                set ranges [tcl::dict::get $setinfo ranges]
+                set charset_dict [tcl::dict::create]
                 foreach r $ranges {
-                    set start [dict get $r start]
-                    set end   [dict get $r end]
-                    set charset_dict [dict merge $charset_dict [char_range_dict $start $end {*}$search_this_and_that]]
+                    set start [tcl::dict::get $r start]
+                    set end   [tcl::dict::get $r end]
+                    set charset_dict [tcl::dict::merge $charset_dict [char_range_dict $start $end {*}$search_this_and_that]]
                 }
             } else {
                 set charset_dict [charset_dictget $charsetname]
             }
-            if {![dict size $charset_dict]} {
+            if {![tcl::dict::size $charset_dict]} {
                 continue
             }
-            dict for {hex inf} $charset_dict {
+            tcl::dict::for {hex inf} $charset_dict {
                 set ch [format %c 0x$hex]
                 set twidth ""
                 set dec [expr {"0x$hex"}]
-                if {[dict exists $charinfo $dec testwidth]} {
-                    set twidth [dict get $charinfo $dec testwidth]
+                if {[tcl::dict::exists $charinfo $dec testwidth]} {
+                    set twidth [tcl::dict::get $charinfo $dec testwidth]
                 }
                 if {$twidth eq ""} {
                     #puts -nonewline stdout "." ;#this 
                     set width [char_info_testwidth $ch] ;#based on console test rather than unicode props
-                    dict set charinfo $dec testwidth $width
+                    tcl::dict::set charinfo $dec testwidth $width
                 } else {
                     set width $twidth
                 }
-                dict incr width_results $width
+                tcl::dict::incr width_results $width
                 incr charcount
             }
         }
         puts stdout "\ncalibration done - results cached in charinfo dictionary"
-        return [dict create charcount $charcount widths $width_results]
+        return [tcl::dict::create charcount $charcount widths $width_results]
     }
 
     #maint warning - also in overtype!
@@ -1861,19 +1861,19 @@ namespace eval punk::char {
     proc grapheme_width_cached {ch {key ""}} {
         variable grapheme_widths
         #if key eq "*" - we won't be able to clear that cache individually. Perhaps that's ok
-        if {[dict exists $grapheme_widths $key $ch]} {
-            return [dict get $grapheme_widths $key $ch]
+        if {[tcl::dict::exists $grapheme_widths $key $ch]} {
+            return [tcl::dict::get $grapheme_widths $key $ch]
         }
         set width [punk::char::ansifreestring_width $ch] ;#review - can we provide faster version if we know it's a single grapheme rather than a string? (grapheme is still a string as it may have combiners/diacritics)
-        dict set grapheme_widths $key $ch $width
+        tcl::dict::set grapheme_widths $key $ch $width
         return $width
     }
     proc grapheme_width_cache_clear {key} {
         variable grapheme_widths
         if {$key eq "*} {
-            set grapheme_widths [dict create]
+            set grapheme_widths [tcl::dict::create]
         } else {
-            dict unset grapheme_widths $key
+            tcl::dict::unset grapheme_widths $key
         }
         return
     }
@@ -1893,7 +1893,7 @@ namespace eval punk::char {
         if {[punk::ansi::ta::detect $text]} {
             puts stderr "string_width detected ANSI!"
         }
-        if {[string last \n $text] >= 0} {
+        if {[tcl::string::last \n $text] >= 0} {
             error "string_width accepts only a single line"
         }
         tailcall ansifreestring_width $text
@@ -1901,7 +1901,25 @@ namespace eval punk::char {
 
     #faster than textutil::wcswidth (at least for string up to a few K in length)
     proc wcswidth {string} {
-        set codes [scan $string [string repeat %c [string length $string]]]
+        set codes [scan $string [tcl::string::repeat %c [tcl::string::length $string]]]
+        set width 0
+        foreach c $codes {
+            if {$c <= 255} {
+                incr width 
+            } else {
+                set w [textutil::wcswidth_char $c]
+                if {$w < 0} {
+                    return -1
+                } else {
+                    incr width $w
+                }
+            }
+        }
+        return $width
+    }
+    #faster than textutil::wcswidth (at least for string up to a few K in length)
+    proc wcswidth1 {string} {
+        set codes [scan $string [tcl::string::repeat %c [tcl::string::length $string]]]
         set width 0
         foreach c $codes {
             set w [textutil::wcswidth_char $c]
@@ -1914,7 +1932,7 @@ namespace eval punk::char {
         return $width
     }
     proc wcswidth2 {string} {
-        set codes [scan $string [string repeat %c [string length $string]]]
+        set codes [scan $string [tcl::string::repeat %c [tcl::string::length $string]]]
         set widths [lmap c $codes {textutil::wcswidth_char $c}]
         if {-1 in $widths} {
             return -1
@@ -1931,7 +1949,7 @@ namespace eval punk::char {
         #we can c0 control characters after or while processing ansi escapes.
         #we need to map remaining control characters to zero-width (under assumption we're not using a font/codepage that displays them - review!) 
         #anyway - we must allow things like raw ESC,DEL, NUL etc to pass through without error
-        #if {[string first \033 $text] >= 0} {
+        #if {[tcl::string::first \033 $text] >= 0} {
         #    error "string_width doesn't accept ansi escape sequences. Use punk::ansi::stripansi first"
         #}
 
@@ -1972,7 +1990,10 @@ namespace eval punk::char {
         #\uFFEFBOM/ ZWNBSP and others that should be zero width
         #todo - work out proper way to mark/group zero width. 
 
-        set text [string map [list \u200b "" \u200c "" \u200d "" \uFFEF ""] $text]
+        #set text [tcl::string::map [list \u200b "" \u200c "" \u200d "" \uFFEF ""] $text]
+        set text [tcl::string::map [list \u200b "" \u200c "" \u200d ""] $text]
+        #\uFFEF tends to print as 1 length replacement char - REVIEW
+        #\uFFFF varies between terminals - some print replacement char (width 1) some print nothing (width 0)
         # -- --- --- --- --- --- ---
 
         #we should only map control sequences to nothing after processing ones with length effects, such as \b (\x07f) or DEL \x1f
@@ -1992,16 +2013,16 @@ namespace eval punk::char {
         #short-circuit basic cases
         #support tcl pre 2023-11 - see regexp bug below
         #if {![regexp {[\uFF-\U10FFFF]} $text]} {
-        #    return [string length $text]
+        #    return [tcl::string::length $text]
         #}
         if {![regexp "\[\uFF-\U10FFFF\]" $text]} {
-            return [string length $text]
+            return [tcl::string::length $text]
         }
 
         #split just to get the standalone character widths - and then scan for other combiners (?) - or scan for clusters first?
 
         #review
-        #set can_regex_high_unicode [string match [regexp -all -inline {[\U80-\U0010FFFF]} \U0001F525] \U0001F525]
+        #set can_regex_high_unicode [tcl::string::match [regexp -all -inline {[\U80-\U0010FFFF]} \U0001F525] \U0001F525]
         #tcl pre 2023-11 - braced high unicode regexes don't work
         #fixed in bug-4ed788c618 2023-11
         #set uc_chars [regexp -all -inline "\[\u0100-\U10FFFF\]" $text] ;#e.g return list of chars in range only 
@@ -2013,7 +2034,7 @@ namespace eval punk::char {
         foreach {uc ascii} $uc_sequences {
             #puts "-ascii $ascii"
             #puts "-uc $uc"
-            incr len [string length $ascii]
+            incr len [tcl::string::length $ascii]
             #textutil::wcswidth uses unicode data
             #fall back to textutil::wcswidth (which doesn't for example handle diactricts/combiners so we can't use until these and other things such as \u200b and diacritics are already stripped/accounted for)
             #todo - find something that understands grapheme clusters - needed also for grapheme_split
@@ -2035,7 +2056,7 @@ namespace eval punk::char {
         #we can c0 control characters after or while processing ansi escapes.
         #we need to map remaining control characters to zero-width (under assumption we're not using a font/codepage that displays them - review!) 
         #anyway - we must allow things like raw ESC,DEL, NUL etc to pass through without error
-        #if {[string first \033 $text] >= 0} {
+        #if {[tcl::string::first \033 $text] >= 0} {
         #    error "string_width doesn't accept ansi escape sequences. Use punk::ansi::stripansi first"
         #}
 
@@ -2078,10 +2099,10 @@ namespace eval punk::char {
         #short-circuit basic cases
         #support tcl pre 2023-11 - see regexp bug below
         #if {![regexp {[\uFF-\U10FFFF]} $text]} {
-        #    return [string length $text]
+        #    return [tcl::string::length $text]
         #}
         if {![regexp "\[\uFF-\U10FFFF\]" $text]} {
-            return [string length $text]
+            return [tcl::string::length $text]
         }
 
         #review - wcswidth should detect these
@@ -2091,7 +2112,7 @@ namespace eval punk::char {
         set zerowidth_char_count 0  
         #split just to get the standalone character widths - and then scan for other combiners (?)
         #review
-        #set can_regex_high_unicode [string match [regexp -all -inline {[\U80-\U0010FFFF]} \U0001F525] \U0001F525]
+        #set can_regex_high_unicode [tcl::string::match [regexp -all -inline {[\U80-\U0010FFFF]} \U0001F525] \U0001F525]
         #tcl pre 2023-11 - braced high unicode regexes don't work
         #fixed in bug-4ed788c618 2023-11
         #set uc_sequences [regexp -all -inline -indices {[\u0100-\U10FFFF]} $text]
@@ -2127,7 +2148,7 @@ namespace eval punk::char {
             }
         }
         #todo - work out what to do with anomalies like grave combiner which print at different lengths on different terminals (fonts?) and for which cursor-query escape sequence lies.
-        return [expr {[string length $text] + $doublewidth_char_count - $zerowidth_char_count}]
+        return [expr {[tcl::string::length $text] + $doublewidth_char_count - $zerowidth_char_count}]
     }
 
     #slow - textutil::wcswidth is slow with mixed ascii uc
@@ -2139,7 +2160,7 @@ namespace eval punk::char {
         #we can c0 control characters after or while processing ansi escapes.
         #we need to map remaining control characters to zero-width (under assumption we're not using a font/codepage that displays them - review!) 
         #anyway - we must allow things like raw ESC,DEL, NUL etc to pass through without error
-        #if {[string first \033 $text] >= 0} {
+        #if {[tcl::string::first \033 $text] >= 0} {
         #    error "string_width doesn't accept ansi escape sequences. Use punk::ansi::stripansi first"
         #}
 
@@ -2173,14 +2194,14 @@ namespace eval punk::char {
         #short-circuit basic cases
         #support tcl pre 2023-11 - see regexp bug below
         #if {![regexp {[\uFF-\U10FFFF]} $text]} {
-        #    return [string length $text]
+        #    return [tcl::string::length $text]
         #}
         if {![regexp "\[\uFF-\U10FFFF\]" $text]} {
-            return [string length $text]
+            return [tcl::string::length $text]
         }
 
         #slow when ascii mixed with unicode (but why?) 
-        return [punk::wcswidth $text]
+        return [punk::char::wcswidth $text]
     }
     #This shouldn't be called on text containing ansi codes!
     proc strip_nonprinting_ascii {str} {
@@ -2192,7 +2213,7 @@ namespace eval punk::char {
             \x07 ""\
             \x7f ""\
         ]
-        return [string map $map $str]
+        return [tcl::string::map $map $str]
     }
 
 
@@ -2203,25 +2224,25 @@ namespace eval punk::char {
         #
         #set re_diacritics {[\u0300-\u036f]+|[\u1ab0-\u1aff]+|[\u1dc0-\u1dff]+|[\u20d0-\u20ff]+|[\ufe20-\ufe2f]+} 
         set graphemes [list]
-        if {[string length $text] == 0} {
+        if {[tcl::string::length $text] == 0} {
             return {}
         }
         set list [list]
         set start 0
-        set strlen [string length $text]
+        set strlen [tcl::string::length $text]
         #make sure our regexes aren't non-greedy - or we may not have exit condition for loop 
         #review
         while {$start < $strlen && [regexp -start $start -indices -- {[\u0300-\u036f]+|[\u1ab0-\u1aff]+|[\u1dc0-\u1dff]+|[\u20d0-\u20ff]+|[\ufe20-\ufe2f]+} $text match]} {
             lassign $match      matchStart matchEnd
             #puts "->start $start ->match $matchStart $matchEnd"
-            lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
+            lappend list [tcl::string::range $text $start $matchStart-1] [tcl::string::range $text $matchStart $matchEnd] 
             set start [expr {$matchEnd+1}]
 
-            #if {$start >= [string length $text]} {
+            #if {$start >= [tcl::string::length $text]} {
             #    break
             #}
         }
-        lappend list [string range $text $start end]
+        lappend list [tcl::string::range $text $start end]
     }
 
     #ZWJ ZWNJ ?
@@ -2241,7 +2262,7 @@ namespace eval punk::char {
         foreach {pt combiners} [lrange $csplits 0 end-1] {
             set clist [split $pt ""]
             lappend graphemes {*}[lrange $clist 0 end-1]
-            lappend graphemes [string cat [lindex $clist end] $combiners]
+            lappend graphemes [tcl::string::cat [lindex $clist end] $combiners]
         } 
         #last csplit never has a combiner (_perlish_split style) - and may be empty - in which case we don't append it as a grapheme
         if {[lindex $csplits end] ne ""} {
@@ -2253,14 +2274,14 @@ namespace eval punk::char {
         set graphemes [list]
         set csplits [combiner_split $text]
         foreach {pt combiners} [lrange $csplits 0 end-1] {
-            set pt_decs [scan $pt [string repeat %c [string length $pt]]]
-            set combiner_decs [scan $combiners [string repeat %c [string length $combiners]]]
+            set pt_decs [scan $pt [tcl::string::repeat %c [tcl::string::length $pt]]]
+            set combiner_decs [scan $combiners [tcl::string::repeat %c [tcl::string::length $combiners]]]
             lset pt_decs end [concat [lindex $pt_decs end] $combiner_decs]
             lappend graphemes {*}$pt_decs
         } 
         #last csplit never has a combiner (_perlish_split style) - and may be empty - in which case we don't append it as a grapheme
         if {[lindex $csplits end] ne ""} {
-            lappend graphemes {*}[scan [lindex $csplits end] [string repeat %c [string length [lindex $csplits end]]]]
+            lappend graphemes {*}[scan [lindex $csplits end] [tcl::string::repeat %c [tcl::string::length [lindex $csplits end]]]]
         }
         return $graphemes
     }
@@ -2268,9 +2289,9 @@ namespace eval punk::char {
         set graphemes [list]
         set csplits [combiner_split $text]
         foreach {pt combiners} $csplits {
-            set pt_decs [scan $pt [string repeat %c [string length $pt]]]
+            set pt_decs [scan $pt [tcl::string::repeat %c [tcl::string::length $pt]]]
             if {$combiners ne ""} {
-                set combiner_decs [scan $combiners [string repeat %c [string length $combiners]]]
+                set combiner_decs [scan $combiners [tcl::string::repeat %c [tcl::string::length $combiners]]]
                 lset pt_decs end [concat [lindex $pt_decs end] $combiner_decs]
             }
             lappend graphemes {*}$pt_decs
@@ -2282,7 +2303,7 @@ namespace eval punk::char {
         set csplits [combiner_split $text]
         foreach {pt combiners} [lrange $csplits 0 end-1] {
             set clist [split $pt ""]
-            lappend graphemes {*}[lrange $clist 0 end-1] [string cat [lindex $clist end] $combiners]
+            lappend graphemes {*}[lrange $clist 0 end-1] [tcl::string::cat [lindex $clist end] $combiners]
         } 
         #last csplit never has a combiner (_perlish_split style) - and may be empty - in which case we don't append it as a grapheme
         if {[lindex $csplits end] ne ""} {
@@ -2303,12 +2324,12 @@ namespace eval punk::char {
         variable charinfo
         set dec [scan $char %c]
         set twidth ""
-        if {[dict exists $charinfo $dec testwidth]} {
-            set twidth [dict get $charinfo $dec testwidth]
+        if {[tcl::dict::exists $charinfo $dec testwidth]} {
+            set twidth [tcl::dict::get $charinfo $dec testwidth]
         }
         if {$twidth eq ""} {
             set width [char_info_testwidth $char]
-            dict set charinfo $dec testwidth $width
+            tcl::dict::set charinfo $dec testwidth $width
             return $width
         } else {
             return $twidth
@@ -2316,7 +2337,7 @@ namespace eval punk::char {
     }
     proc char_info_is_testwidth_cached {char} {
         variable charinfo
-        return [dict exists $charinfo [scan $char %c] testwidth]
+        return [tcl::dict::exists $charinfo [scan $char %c] testwidth]
     }
     # -- --- --- --- ---
 
@@ -2328,7 +2349,7 @@ namespace eval punk::char {
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide punk::char [namespace eval punk::char {
+package provide punk::char [tcl::namespace::eval punk::char {
     variable version
     set version 0.1.0 
 }]
diff --git a/src/bootsupport/modules/punk/console-0.1.1.tm b/src/bootsupport/modules/punk/console-0.1.1.tm
index 7697288..832232b 100644
--- a/src/bootsupport/modules/punk/console-0.1.1.tm
+++ b/src/bootsupport/modules/punk/console-0.1.1.tm
@@ -20,10 +20,10 @@
 package require punk::ansi
 
 
-if {"windows" eq $::tcl_platform(platform)} {
-    #package require zzzload
-    #zzzload::pkg_require twapi
-}
+#if {"windows" eq $::tcl_platform(platform)} {
+#    #package require zzzload
+#    #zzzload::pkg_require twapi
+#}
 
 #see https://learn.microsoft.com/en-us/windows/console/classic-vs-vt  
 #https://learn.microsoft.com/en-us/windows/console/creating-a-pseudoconsole-session
@@ -765,6 +765,7 @@ namespace eval punk::console {
     } ;#end namespace eval internal
 
     variable colour_disabled 0
+    #todo - move to punk::config
     # https://no-color.org
     if {[info exists ::env(NO_COLOR)]} {
         if {$::env(NO_COLOR) ne ""} {
@@ -779,7 +780,7 @@ namespace eval punk::console {
         #stdout
         variable ansi_wanted
         if {$ansi_wanted <= 0} {
-            puts -nonewline [punk::ansi::stripansi [::punk::ansi::a?]]
+            puts -nonewline [punk::ansi::stripansiraw [::punk::ansi::a?]]
         } else {
             tailcall ansi::a? {*}$args
         }
diff --git a/src/bootsupport/modules/punk/du-0.1.0.tm b/src/bootsupport/modules/punk/du-0.1.0.tm
index 121f1fb..538dc86 100644
--- a/src/bootsupport/modules/punk/du-0.1.0.tm
+++ b/src/bootsupport/modules/punk/du-0.1.0.tm
@@ -901,7 +901,7 @@ namespace eval punk::du {
 
                 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  [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}  * .*]
@@ -913,18 +913,20 @@ namespace eval punk::du {
                 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 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
+            #struct::set difference removes duplicates (but not always.. e.g if using tcl impl and 2nd element empty!)
+            #relying on struct::set to remove dupes is somewhat risky. It is not well documented - and behaviour of dupes in inputs is underspecified as it appears to be intended for mathematical 'sets'
             #remove links and . .. from directories, remove links from files
+            #struct::set will affect order: tcl vs critcl give different ordering!
             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 links [lsort -unique [concat $links $hlinks]]
 
 
             #----
@@ -1022,7 +1024,7 @@ namespace eval punk::du {
             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]
+            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]
         }
 
         #we can halve the number of round trips on unix-like systems, where 'hidden' always corresponds to dotted files
diff --git a/src/bootsupport/modules/punk/fileline-0.1.0.tm b/src/bootsupport/modules/punk/fileline-0.1.0.tm
index 54c693d..837b982 100644
--- a/src/bootsupport/modules/punk/fileline-0.1.0.tm
+++ b/src/bootsupport/modules/punk/fileline-0.1.0.tm
@@ -1555,10 +1555,10 @@ namespace eval punk::fileline::lib {
     }
 
     proc range_boundaries {start end chunksizes args} {
-        lassign [punk::get_leading_opts_and_values {\
-            -offset 0\
-        } $args] _opts opts _vals remainingargs
-
+        set argd [punk::args::get_dict {
+            -offset -default 0
+        } $args]
+        lassign [dict values $argd] opts remainingargs
 
     }
 
@@ -1650,16 +1650,19 @@ namespace eval punk::fileline::system {
     #gets very slow (comparitively) with large resultsets
     proc _range_spans_chunk_boundaries_tcl {start end chunksize args} {
         if {$chunksize < 1} {error "chunksize must be > 0"} ;#sanitycheck in case called directly
-        set defaults [dict create\
+        set opts [dict create\
             -offset 0\
         ]
-        set known_opts [dict keys $defaults]
         foreach {k v} $args {
-            if {$k ni $known_opts} {
-                error "unknown option '$k'. Known options: $known_opts"
+            switch -- $k {
+                -offset {
+                    dict set opts $k $v
+                }
+                default {
+                    error "unknown option '$k'. Known options: [dict keys $opts]"
+                }
             }
         }
-        set opts [dict merge $defaults $args]
         # -- --- --- ---
         set opt_offset [dict get $opts -offset]
         # -- --- --- ---
diff --git a/src/bootsupport/modules/punk/lib-0.1.1.tm b/src/bootsupport/modules/punk/lib-0.1.1.tm
index c257178..3d0332b 100644
--- a/src/bootsupport/modules/punk/lib-0.1.1.tm
+++ b/src/bootsupport/modules/punk/lib-0.1.1.tm
@@ -66,11 +66,11 @@ package require Tcl 8.6-
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # oo::class namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::lib::class {
+tcl::namespace::eval punk::lib::class {
     #*** !doctools
     #[subsection {Namespace punk::lib::class}]
     #[para] class definitions
-    if {[info commands [namespace current]::interface_sample1] eq ""} {
+    if {[info commands [tcl::namespace::current]::interface_sample1] eq ""} {
         #*** !doctools
         #[list_begin enumerated]
 
@@ -96,46 +96,46 @@ namespace eval punk::lib::class {
 }
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 
-namespace eval punk::lib::ensemble {
+tcl::namespace::eval punk::lib::ensemble {
     #wiki.tcl-lang.org/page/ensemble+extend
     # extend an ensemble-like routine with the routines in some namespace
     proc extend {routine extension} {
         if {![string match ::* $routine]} {
-            set resolved [uplevel 1 [list ::namespace which $routine]]
+            set resolved [uplevel 1 [list ::tcl::namespace::which $routine]]
             if {$resolved eq {}} {
                 error [list {no such routine} $routine]
             }
             set routine $resolved
         }
-        set routinens [namespace qualifiers $routine]
+        set routinens [tcl::namespace::qualifiers $routine]
         if {$routinens eq {::}} {
             set routinens {}
         }
-        set routinetail [namespace tail $routine]
+        set routinetail [tcl::namespace::tail $routine]
 
         if {![string match ::* $extension]} {
             set extension [uplevel 1 [
-                list [namespace which namespace] current]]::$extension
+                list [tcl::namespace::which namespace] current]]::$extension
         }
 
-        if {![namespace exists $extension]} {
+        if {![tcl::namespace::exists $extension]} {
             error [list {no such namespace} $extension]
         }
 
-        set extension [namespace eval $extension [
-            list [namespace which namespace] current]]
+        set extension [tcl::namespace::eval $extension [
+            list [tcl::namespace::which namespace] current]]
 
-        namespace eval $extension [
-            list [namespace which namespace] export *]
+        tcl::namespace::eval $extension [
+            list [tcl::namespace::which namespace] export *]
 
         while 1 {
             set renamed ${routinens}::${routinetail}_[info cmdcount]
-            if {[namespace which $renamed] eq {}} break
+            if {[tcl::namespace::which $renamed] eq {}} break
         }
 
         rename $routine $renamed
 
-        namespace eval $extension [
+        tcl::namespace::eval $extension [
             list namespace ensemble create -command $routine -unknown [
                 list apply {{renamed ensemble routine args} {
                     list $renamed $routine 
@@ -147,7 +147,7 @@ namespace eval punk::lib::ensemble {
     }
 }
 
-namespace eval punk::lib::compat {
+tcl::namespace::eval punk::lib::compat {
     #*** !doctools
     #[subsection {Namespace punk::lib::compat}]
     #[para] compatibility functions for features that may not be available in earlier Tcl versions
@@ -315,8 +315,8 @@ namespace eval punk::lib::compat {
         }
 
         # Bind [string insert] to [::tcl::string::insert].
-        namespace ensemble configure string -map [dict replace\
-            [namespace ensemble configure string -map]\
+        tcl::namespace::ensemble configure string -map [tcl::dict::replace\
+            [tcl::namespace::ensemble configure string -map]\
             insert ::tcl::string::insert]
     }
     #*** !doctools
@@ -327,7 +327,7 @@ namespace eval punk::lib::compat {
 # Base namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 namespace eval punk::lib {
-    namespace export *
+    tcl::namespace::export *
     #variable xyz
 
     #*** !doctools
@@ -335,15 +335,192 @@ namespace eval punk::lib {
     #[para] Core API functions for punk::lib 
     #[list_begin definitions]
 
-    proc range {from to args} {
-        if {[info commands lseq] ne ""} {
-            #tcl 8.7+ lseq significantly faster for larger ranges
-            return [lseq $from $to]
+    if {[info commands lseq] ne ""} {
+        #tcl 8.7+ lseq significantly faster, especially for larger ranges
+        #support minimal set from to
+        proc range {from to} {
+            lseq $from $to
+        }
+    } else {
+        #lseq accepts basic expressions e.g 4-2 for both arguments
+        #e.g we can do lseq 0 [llength $list]-1 
+        #if range is to be consistent with the lseq version above - it should support that, even though we don't support most lseq functionality in either wrapper.
+        proc range {from to} {
+            set to [offset_expr $to]
+            set from [offset_expr $from]
+            if {$to > $from} {
+                set count [expr {($to -$from) + 1}]
+                if {$from == 0} {
+                    return [lsearch -all [lrepeat $count 0] *]
+                } else {
+                    incr from -1
+                    return [lmap v [lrepeat $count 0] {incr from}]
+                }
+                #slower methods. 
+                #2)
+                #set i -1 
+                #set L [lrepeat $count 0]
+                #lmap v $L {lset L [incr i] [incr from];lindex {}}
+                #return $L
+                #3)
+                #set L {}
+                #for {set i 0} {$i < $count} {incr i} {
+                #    lappend L [incr from] 
+                #}
+                #return $L
+            } elseif {$from > $to} {
+                set count [expr {$from - $to} + 1]
+                #1)
+                if {$to == 0} {
+                    return [lreverse [lsearch -all [lrepeat $count 0] *]]
+                } else {
+                    incr from
+                    return [lmap v [lrepeat $count 0] {incr from -1}]
+                }
+
+                #2)
+                #set i -1 
+                #set L [lrepeat $count 0]
+                #lmap v $L {lset L [incr i] [incr from -1];lindex {}}
+                #return $L
+                #3)
+                #set L {}
+                #for {set i 0} {$i < $count} {incr i} {
+                #    lappend L [incr from -1] 
+                #}
+                #return $L
+            } else {
+                return [list $from]
+            }
         }
-        set count [expr {($to -$from) + 1}]
-        incr from -1
-        return [lmap v [lrepeat $count 0] {incr from}]
     }
+
+    proc pdict {args} {
+        set argd [punk::args::get_dict {
+            *proc -name pdict -help {Print dict keys,values to channel
+            (see also showdict)}
+            *opts -any 1
+            #default separator to provide similarity to tcl's parray function
+            -separator -default " = "
+            -channel -default stdout -help "existing channel - or 'none' to return as string"
+            *values -min 1 -max -1
+            dictvar -type string -help "name of dict variable"
+            patterns -type string -default * -multiple 1
+        } $args]
+        set opts [dict get $argd opts]
+        set dvar [dict get $argd values dictvar]
+        set patterns [dict get $argd values patterns]
+        set dvalue [uplevel 1 [list set $dvar]]
+        showdict {*}$opts $dvalue {*}$patterns
+    }
+    proc showdict {args} {   ;# analogous to parray (except that it takes the dict as a value)
+        set argd [punk::args::get_dict {
+            *id punk::lib::pdict
+            *proc -name punk::lib::pdict -help "display dictionary keys and values"
+            #todo - table tableobject
+            -return             -default "tailtohead" -choices {tailtohead sidebyside}
+            -channel            -default none 
+            -trimright          -default 1 -type boolean -help "Trim whitespace off rhs of each line.
+            This can help prevent a single long line that wraps in terminal from making every line wrap due to long rhs padding
+            "
+            -separator          -default " "  -help "Separator column between keys and values"
+            -ansibase_keys       -default ""
+            -ansibase_values     -default ""
+            -keysorttype        -default "none" -choices {none dictionary ascii integer real}
+            -keysortdirection   -default ascending -choices {ascending descending}
+            *values -min 1 -max -1
+            dictvalue                       -type dict -help "dict value"
+            patterns            -default *   -type string -multiple 1 -help "key or key glob pattern"
+        } $args]
+        set opt_sep                 [dict get $argd opts -separator]
+        set opt_keysorttype         [dict get $argd opts -keysorttype]
+        set opt_keysortdirection    [dict get $argd opts -keysortdirection]
+        set opt_trimright           [dict get $argd opts -trimright]
+        set opt_ansibase_key        [dict get $argd opts -ansibase_keys]
+        set opt_ansibase_value      [dict get $argd opts -ansibase_values]
+        set opt_return              [dict get $argd opts -return]
+
+        set dval [dict get $argd values dictvalue]
+        set patterns [dict get $argd values patterns]
+
+        set result ""
+
+        set filtered_keys [list]
+        foreach p $patterns {
+            lappend filtered_keys {*}[dict keys $dval $p]
+        }
+        if {$opt_keysorttype eq "none"} {
+            #we can only get duplicate keys if there are multiple patterns supplied
+            #ignore keysortdirection - doesn't apply
+            if {[llength $patterns] > 1} {
+                #order-maintaining  (order of keys as they appear in dict)
+                set filtered_keys [punk::lib::lunique $filtered_keys]
+            }
+        } else {
+            set filtered_keys [lsort -unique -$opt_keysorttype $opt_keysortdirection $filtered_keys]
+        }
+
+        if {[llength $filtered_keys]} {
+            #both keys and values could have newline characters.
+            #simple use of 'format' won't cut it for more complex dict keys/values
+            #use block::width or our columns won't align in some cases
+            set maxl [::tcl::mathfunc::max {*}[lmap v $filtered_keys {textblock::width $v}]]
+            set RST [a]
+            switch -- $opt_return {
+                "tailtohead" {
+                    #last line of key is side by side (possibly with separator) with first line of value
+                    #This is more intelligible when terminal wrapping occurs - and is closer to what happens with parray multiline keys and values
+                    #we still pad the key to max width so that the separator appears in the same column - which in the case of wide keys could cause that to wrap for all entries
+                    foreach key $filtered_keys  {
+                        lassign [textblock::size $key] _kw kwidth _kh kheight
+                        lassign [textblock::size [dict get $dval $key]] _vw vwidth _vh vheight
+                        set totalheight [expr {$kheight + $vheight -1}]
+                        set blanks_above [string repeat \n [expr {$kheight -1}]]
+                        set blanks_below [string repeat \n [expr {$vheight -1}]]
+                        set sepwidth  [textblock::width $opt_sep]
+                        #append result [textblock::pad $opt_ansibase_key$key$RST -width $maxl] $opt_sep $opt_ansibase_value[dict get $dval $key]$RST \n
+                        set kblock [textblock::pad $opt_ansibase_key$key$RST$blanks_below -width $maxl]
+                        set sblock [textblock::pad $blanks_above$opt_sep$blanks_below -width $sepwidth]
+                        set vblock $blanks_above$opt_ansibase_value[dict get $dval $key]$RST
+                        #only vblock is ragged - we can do a basic join because we don't care about rhs whitespace
+                        append result [textblock::join_basic $kblock $sblock $vblock] \n
+                    }
+                }
+                "sidebyside" {
+                    #This is nice for multiline keys and values of reasonable length, will produce unintuitive results when line-wrapping occurs.
+                    #use ansibase_key etc to make the output more comprehensible in that situation.
+                    #This is why it is not the default. (review - terminal width detection and wrapping?)
+                    foreach key $filtered_keys  {
+                        #append result [format "%-*s = %s" $maxl $key [dict get $dval $key]] \n
+                        #differing height blocks (ie ragged) so we need a full textblock::join rather than join_basic
+                        append result [textblock::join -- [textblock::pad $opt_ansibase_key$key$RST -width $maxl] $opt_sep "$opt_ansibase_value[dict get $dval $key]$RST"] \n
+                    }
+                }
+            }
+        }
+        if {$opt_trimright} {
+            set result [::join [lines_as_list -line trimright $result] \n]
+        }
+        if {[string last \n $result] == [string length $result]-1} {
+            set result [string range $result 0 end-1]
+        }
+        #stdout/stderr can exist but not be in 'chan names' (e.g when transforms in place)
+        set chan [dict get $argd opts -channel]
+        switch -- $chan {
+            stderr - stdout {
+                puts $chan $result
+            }
+            none {
+                return $result
+            }
+            default {
+                #review - check member of chan names?
+                #just try outputting to the supplied channel for now
+                puts $chan $result
+            }
+        }
+    }
+
     proc is_list_all_in_list {small large} {
         package require struct::list
         package require struct::set
@@ -356,7 +533,87 @@ namespace eval punk::lib {
         return [expr {[llength $i] == 0}]
     }
 
+    #somewhat like struct::set difference - but order preserving, and doesn't treat as a 'set' so preserves dupes in fromlist
+    #struct::set difference may happen to preserve ordering when items are integers, but order can't be relied on,
+    # especially as struct::set has 2 differing implementations (tcl vs critcl) which return results with different ordering to each other and different deduping behaviour in some cases (e.g empty 2nd arg)
+    proc ldiff {fromlist removeitems} {
+        if {[llength $removeitems] == 0} {return $fromlist}
+        set result {}
+        foreach item $fromlist {
+            if {$item ni $removeitems} {
+                lappend result $item
+            }
+        }
+        return $result
+    }
+    proc ldiff2 {fromlist removeitems} {
+        set doomed [list]
+        foreach item $removeitems {
+            lappend doomed {*}[lsearch -all -exact $fromlist $item]
+        }
+        lremove $fromlist {*}$doomed
+    }
 
+    #non-dupe preserving - for consistency in dedupe behaviour we don't shortcircuit empty B
+    #consistent dedupe and order-maintenance of remaining items in A differentiate this from struct::set difference
+    #also struct::set difference with critcl is faster
+    proc setdiff {A B} {
+        if {[llength $A] == 0} {return {}}
+        set d [dict create] 
+        foreach x $A    {dict set d $x {}}
+        foreach x $B    {dict unset d $x}
+        return [dict keys $d]
+    }
+    #bulk dict remove is slower than a foreach with dict unset
+    #proc setdiff2 {fromlist removeitems} {
+    #    #if {[llength $fromlist] == 0} {return {}}
+    #    set d [dict create] 
+    #    foreach x $fromlist {
+    #        dict set d $x {}
+    #    }
+    #    return [dict keys [dict remove $d {*}$removeitems]]
+    #}
+    #array is about 15% faster than dict - but unordered. (which is ok for sets - but we have struct::set for that)
+    proc setdiff_unordered {A B} {
+        if {[llength $A] == 0} {return {}}
+        array set tmp {}
+        foreach x $A {::set tmp($x) .}
+        foreach x $B {catch {unset tmp($x)}}
+        return [array names tmp]
+    }
+
+    package require struct::set
+    if {[struct::set equal [struct::set union {a a} {}] {a}]} {
+        proc lunique_unordered {list} {
+            struct::set union $list {}
+        }
+    } else {
+        puts stderr "WARNING: struct::set union <list> <emptylist> no longer dedupes!" 
+        #we could also test a sequence of: struct::set add 
+        proc lunique_unordered {list} {
+            tailcall lunique $list
+        }
+    }
+    #order-preserving
+    proc lunique {list} {
+        set new {}
+        foreach item $list {
+            if {$item ni $new} {
+            lappend new $item
+            }
+        }
+        return $new
+    }
+    proc lunique2 {list} {
+        set doomed [list]
+        #expr 'in' probably faster than using a dict - for lists approx < 20,000 items. (wiki wisdom - url?)
+        for {set i 0} {$i < [llength $list]} {} {
+            set item [lindex $list $i]
+            lappend doomed {*}[lrange [lsearch -all -exact -start $i $list $item] 1 end]
+            while {[incr i] in $doomed} {}
+        }
+        lremove $list {*}$doomed
+    }
     #The closure-like behaviour is *very* slow especially when called from a context such as the global namespace with lots of vars and large arrays such as ::env
     proc lmapflat_closure {varnames list script} {
         set result [list]
@@ -368,29 +625,29 @@ namespace eval punk::lib {
         #capture - use uplevel 1 or namespace eval depending on context
         set capture [uplevel 1 {
             apply { varnames  {
-                set capturevars [dict create]
-                set capturearrs [dict create]
+                set capturevars [tcl::dict::create]
+                set capturearrs [tcl::dict::create]
                 foreach fullv $varnames {
-                    set  v [namespace tail $fullv]
+                    set  v [tcl::namespace::tail $fullv]
                     upvar 1 $v var
                     if {[info exists var]} {
                         if {(![array exists var])} {
-                            dict set capturevars $v $var
+                            tcl::dict::set capturevars $v $var
                         } else {
-                            dict set capturearrs capturedarray_$v [array get var]
+                            tcl::dict::set capturearrs capturedarray_$v [array get var]
                         }
                     } else {
                         #A variable can show in the results for 'info vars' 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]
+                return [tcl::dict::create vars $capturevars arrs $capturearrs]
             } } [info vars]  
         } ]
         # -- --- ---
-        set cvars [dict get $capture vars]
-        set carrs [dict get $capture arrs]
+        set cvars [tcl::dict::get $capture vars]
+        set carrs [tcl::dict::get $capture arrs]
         set apply_script ""
-        foreach arrayalias [dict keys $carrs] {
+        foreach arrayalias [tcl::dict::keys $carrs] {
             set realname [string range $arrayalias [string first _ $arrayalias]+1 end]
             append apply_script [string map [list %realname% $realname %arrayalias% $arrayalias] {
                 array set %realname% [set %arrayalias%][unset %arrayalias%]
@@ -409,9 +666,9 @@ namespace eval punk::lib {
         foreach $varnames $list {
             lappend result {*}[apply\
                 [list\
-                    [concat $varnames [dict keys $cvars] [dict keys $carrs] ]\
+                    [concat $varnames [tcl::dict::keys $cvars] [tcl::dict::keys $carrs] ]\
                     $apply_script\
-                ]  {*}[subst $values] {*}[dict values $cvars] {*}[dict values $carrs]  ]
+                ]  {*}[subst $values] {*}[tcl::dict::values $cvars] {*}[tcl::dict::values $carrs]  ]
         }
         return $result
     }
@@ -447,8 +704,15 @@ namespace eval punk::lib {
         return $result
     }
 
-    proc lmapflat {varnames list script} {
-        concat {*}[uplevel 1 [list lmap $varnames $list $script]]
+    #proc lmapflat {varnames list script} {
+    #    concat {*}[uplevel 1 [list lmap $varnames $list $script]]
+    #}
+    #lmap can accept multiple var list pairs
+    proc lmapflat {args} {
+        concat {*}[uplevel 1 [list lmap {*}$args]]
+    }
+    proc lmapflat2 {args} {
+        concat {*}[uplevel 1 lmap {*}$args]
     }
 
     proc dict_getdef {dictValue args} {
@@ -456,8 +720,8 @@ namespace eval punk::lib {
             error {wrong # args: should be "dict_getdef dictValue ?key ...? key default"}
         }
         set keys [lrange $args -1 end-1]
-        if {[dict exists $dictValue {*}$keys]} {
-            return [dict get $dictValue {*}$keys]
+        if {[tcl::dict::exists $dictValue {*}$keys]} {
+            return [tcl::dict::get $dictValue {*}$keys]
         } else {
             return [lindex $args end] 
         }
@@ -475,6 +739,23 @@ namespace eval punk::lib {
     #    return "ok" 
     #}
 
+    #supports *safe* ultra basic offset expressions as used by lindex etc, but without the 'end' features
+    #safe in that we don't evaluate the expression as a string.
+    proc offset_expr {expression} {
+        set expression [tcl::string::map {_ {}} $expression]
+        if {[tcl::string::is integer -strict $expression]} {
+            return [expr {$expression}]
+        }
+        if {[regexp {(.*)([+-])(.*)} $expression _match a op b] && [tcl::string::is integer -strict $a] && [tcl::string::is integer -strict $b]} {
+            if {$op eq "-"} {
+                return [expr {$a - $b}]
+            } else {
+                return [expr {$a + $b}]
+            }
+        } else {
+            error "bad expression '$expression': must be integer?\[+-\]integer?"
+        }
+    }
     
     proc lindex_resolve {list index} {
         #*** !doctools
@@ -492,7 +773,7 @@ namespace eval punk::lib {
         if {![llength $list]} {
             return -1
         }
-        set index [string map [list _ ""] $index] ;#forward compatibility with integers such as 1_000
+        set index [tcl::string::map {_ {}} $index] ;#forward compatibility with integers such as 1_000
         if {[string is integer -strict $index]} {
             #can match +i -i 
             if {$index < 0} {
@@ -566,7 +847,7 @@ namespace eval punk::lib {
         } else {
             #we still don't know the actual integer index for an index such as end-x or int-int without parsing and evaluating ourself.
             #we can return the value - but only in a way that won't collide with our -1 out-of-range indicator
-            return  [dict create value [lindex $resultlist 0]]
+            return  [tcl::dict::create value [lindex $resultlist 0]]
         }
     }
 
@@ -661,17 +942,17 @@ namespace eval punk::lib {
         if {[llength $argopts]%2 !=0} {
             error "[namespace current]::hex2dec arguments prior to list_largeHex must be option/value pairs - received '$argopts'"
         }
-        set opts [dict create\
+        set opts [tcl::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 $opts]
+        set known_opts [tcl::dict::keys $opts]
         foreach {k v} $argopts {
-            dict set opts [tcl::prefix match -message "options for hex2dec. Unexpected option" $known_opts $k] $v
+            tcl::dict::set opts [tcl::prefix match -message "options for hex2dec. Unexpected option" $known_opts $k] $v
         }
         # -- --- --- --- 
-        set opt_validate [dict get $opts -validate]
-        set opt_empty [dict get $opts -empty_as_hex]
+        set opt_validate [tcl::dict::get $opts -validate]
+        set opt_empty [tcl::dict::get $opts -empty_as_hex]
         # -- --- --- --- 
 
         set list_largeHex [lmap h $list_largeHex[unset list_largeHex] {string map [list _ ""] [string trim $h]}]
@@ -710,21 +991,21 @@ namespace eval punk::lib {
         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\
+        set defaults [tcl::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]
+        set known_opts [tcl::dict::keys $defaults]
+        set fullopts [tcl::dict::create]
         foreach {k v} $argopts {
-            dict set fullopts [tcl::prefix match -message "options for [namespace current]::dec2hex. Unexpected option" $known_opts $k] $v
+            tcl::dict::set fullopts [tcl::prefix match -message "options for [tcl::namespace::current]::dec2hex. Unexpected option" $known_opts $k] $v
         }
-        set opts [dict merge $defaults $fullopts]
+        set opts [tcl::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 opt_width       [tcl::dict::get $opts -width]
+        set opt_case        [tcl::dict::get $opts -case]
+        set opt_empty       [tcl::dict::get $opts -empty_as_decimal]
         # -- --- --- ---
         
 
@@ -933,35 +1214,35 @@ namespace eval punk::lib {
     proc sieve n {
         set primes [list]
         if {$n < 2} {return $primes}
-        set nums [dict create]
+        set nums [tcl::dict::create]
         for {set i 2} {$i <= $n} {incr i} {
-            dict set nums $i ""
+            tcl::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}
+            for {set i $next} {$i <= $n} {incr i $next} {tcl::dict::unset nums $i}
             lappend primes $next
-            dict for {next -} $nums break
+            tcl::dict::for {next -} $nums break
         }
-        return [concat $primes [dict keys $nums]]
+        return [concat $primes [tcl::dict::keys $nums]]
     }
     proc sieve2 n {
         set primes [list]
         if {$n < 2} {return $primes}
-        set nums [dict create]
+        set nums [tcl::dict::create]
         for {set i 2} {$i <= $n} {incr i} {
-            dict set nums $i ""
+            tcl::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}
+            for {set i $next} {$i <= $n} {incr i $next} {tcl::dict::unset nums $i}
             lappend primes $next
             #dict for {next -} $nums break
             set next [lindex $nums 0]
         }
-        return [concat $primes [dict keys $nums]]
+        return [concat $primes [tcl::dict::keys $nums]]
     }
 
     proc hasglobs {str} {
@@ -1002,7 +1283,7 @@ namespace eval punk::lib {
         #[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] 
+        return [tcl::dict::merge [tcl::dict::merge $main $defaults] $main] 
     }
 
     proc askuser {question} {
@@ -1044,7 +1325,7 @@ namespace eval punk::lib {
                 set answer [gets stdin]
             }
         } finally {
-            fconfigure stdin -blocking [dict get $stdin_state -blocking]
+            fconfigure stdin -blocking [tcl::dict::get $stdin_state -blocking]
         }
         return $answer
     }
@@ -1162,13 +1443,13 @@ namespace eval punk::lib {
     }
     proc list_as_lines2 {args} {
         #eat or own dogfood version - shows the implementation is simpler - but  unfortunately not suitable for a simple function like this which should be as fast as possible?
-        lassign [dict values [punk::args::get_dict {
+        lassign [tcl::dict::values [punk::args::get_dict {
             -joinchar -default \n
             *values -min 1 -max 1
         } $args]] opts values
         puts "opts:$opts"
         puts "values:$values"
-        return [join [dict get $values 0] [dict get $opts -joinchar]]
+        return [join [tcl::dict::get $values 0] [tcl::dict::get $opts -joinchar]]
     }
 
     proc lines_as_list {args} {
@@ -1189,7 +1470,7 @@ namespace eval punk::lib {
         } else {
             set opts [lrange $args 0 end-1]
         }
-        #set opts [dict merge {-block {}}  $opts]
+        #set opts [tcl::dict::merge {-block {}}  $opts]
         set bposn [lsearch $opts -block]
         if {$bposn < 0} {
             lappend opts -block {}
@@ -1203,11 +1484,11 @@ namespace eval punk::lib {
         #-anyopts 1 avoids having to know what to say if odd numbers of options passed etc
         #we don't have to decide what is an opt vs a value
         #even if the caller provides the argument -block without a value the next function's validation will report a reasonable error because there is now nothing in $values (consumed by -block)
-        lassign [dict values [punk::args::get_dict {
+        lassign [tcl::dict::values [punk::args::get_dict {
             *opts -any 1
             -block -default {}
         } $args]] opts valuedict
-        tailcall linelist {*}$opts {*}[dict values $valuedict]
+        tailcall linelist {*}$opts {*}[tcl::dict::values $valuedict]
     }
     
     # important for pipeline & match_assign
@@ -1222,7 +1503,7 @@ namespace eval punk::lib {
         set text [string map [list \r\n \n] $text] ;#review - option?
 
         set arglist [lrange $args 0 end-1]
-        set opts [dict create\
+        set opts [tcl::dict::create\
             -block {trimhead1 trimtail1}\
             -line  {}\
             -commandprefix ""\
@@ -1232,7 +1513,7 @@ namespace eval punk::lib {
         foreach {o v} $arglist {
             switch -- $o {
                 -block - -line - -commandprefix - -ansiresets - -ansireplays {
-                    dict set opts $o $v
+                    tcl::dict::set opts $o $v
                 }
                 default {
                     error "linelist: Unrecognized option '$o' usage:$usage"
@@ -1240,7 +1521,7 @@ namespace eval punk::lib {
             }
         }
         # -- --- --- --- --- ---
-        set opt_block           [dict get $opts -block]
+        set opt_block           [tcl::dict::get $opts -block]
         if {[llength $opt_block]} {
             foreach bo $opt_block {
                 switch -- $bo {
@@ -1272,7 +1553,7 @@ namespace eval punk::lib {
         
 
         # -- --- --- --- --- ---
-        set opt_line            [dict get $opts -line]
+        set opt_line            [tcl::dict::get $opts -line]
         set tl_left 0
         set tl_right 0
         set tl_both 0
@@ -1299,11 +1580,11 @@ namespace eval punk::lib {
             set tl_both 1
         }
         # -- --- --- --- --- ---
-        set opt_commandprefix   [dict get $opts -commandprefix]
+        set opt_commandprefix   [tcl::dict::get $opts -commandprefix]
         # -- --- --- --- --- ---
-        set opt_ansiresets      [dict get $opts -ansiresets]
+        set opt_ansiresets      [tcl::dict::get $opts -ansiresets]
         # -- --- --- --- --- ---
-        set opt_ansireplays     [dict get $opts -ansireplays]
+        set opt_ansireplays     [tcl::dict::get $opts -ansireplays]
         if {$opt_ansireplays} {
             if {$opt_ansiresets eq "auto"} {
                 set opt_ansiresets 1
@@ -1414,7 +1695,11 @@ namespace eval punk::lib {
             set replaycodes $RST ;#todo - default?
             set transformed [list]
             #shortcircuit common case of no ansi
-            if {![punk::ansi::ta::detect $linelist]} {
+            #NOTE: running ta::detect on a list (or dict) as a whole can be problematic if items in the have backslash escapes due to Tcl list quoting and escaping behaviour.
+            #This commonly happens if there is an unbalanced brace  (which is a normal occurrence and needs to be handled)
+            #ta::detect on a list of ansi-containing string may appear to work for some simple inputs but is not reliable
+            #detect_in_list will check at first level. (not intended for detecting ansi in deeper structures)
+            if {![punk::ansi::ta::detect_in_list $linelist]} {
                 if {$opt_ansiresets} {
                     foreach ln $linelist {
                         lappend transformed $RST$ln$RST
@@ -1604,8 +1889,29 @@ namespace eval punk::lib {
     }
 
     #we are interested in seeing jumpTable line and following lines up until next line starting with "Command" or bracketed number e.g (164)
-    proc show_jump_tables {procname} {
-        set data [tcl::unsupported::disassemble proc $procname]
+    proc show_jump_tables {args} {
+        #avoiding use of 'info cmdtype' as unavaliable in safe interps as at 2024-06.
+        if {[llength $args] == 1} {
+            set data [tcl::unsupported::disassemble proc [lindex $args 0]]
+        } elseif {[llength $args] == 2} {
+            #review - this looks for direct methods on the supplied object/class, and then tries to disassemble method on the supplied class or class of supplied object if it isn't a class itself.
+            #not sure if this handles more complex hierarchies or mixins etc. 
+            lassign $args obj method
+            if {![info object isa object $obj]} {
+                error "show_jump_tables unable to examine '$args'. $obj is not an oo object"
+            }
+            #classes are objects too and can have direct methods
+            if {$method in [info object methods $obj]} {
+                set data [tcl::unsupported::disassemble objmethod $obj $method]
+            } else {
+                if {![info object isa class $obj]} {
+                    set obj [info object class $obj]
+                }
+                set data [tcl::unsupported::disassemble method $obj $method]
+            }
+        } else {
+            error "show_jump_tables expected a procname or a class/object and method" 
+        }
         set result ""
         set in_jt 0
         foreach ln [split $data \n] {
@@ -1626,6 +1932,12 @@ namespace eval punk::lib {
         return $result
     }
 
+    proc temperature_f_to_c {deg_fahrenheit} {
+        return [expr {($deg_fahrenheit -32) * (5/9.0)}]
+    }
+    proc temperature_c_to_f {deg_celsius} {
+        return [expr {($deg_celsius * (9/5.0)) + 32}]
+    }
     #*** !doctools
     #[list_end] [comment {--- end definitions namespace punk::lib ---}]
 }
@@ -1639,7 +1951,7 @@ namespace eval punk::lib {
 #todo - way to generate 'internal' docs separately?
 #*** !doctools
 #[section Internal]
-namespace eval punk::lib::system {
+tcl::namespace::eval punk::lib::system {
     #*** !doctools 
     #[subsection {Namespace punk::lib::system}]
     #[para] Internal functions that are not part of the API 
@@ -1664,6 +1976,51 @@ namespace eval punk::lib::system {
             return false
         }
     }
+    proc has_safeinterp_compile_bug {{show 0}} {
+        #ensemble calls within safe interp not compiled
+        namespace eval [namespace current]::testcompile {
+            proc ensembletest {} {string index a 0}
+        }
+
+        set has_bug 0
+
+        set bytecode_outer [tcl::unsupported::disassemble proc [namespace current]::testcompile::ensembletest]
+        if {$show} {
+            puts outer:
+            puts $bytecode_outer
+        }
+        if {![interp issafe]} {
+            #test of safe subinterp only needed if we aren't already in a safe interp
+            if {![catch {
+                interp create x -safe
+            } errMsg]} {
+                x eval {proc ensembletest {} {string index a 0}}
+                set bytecode_safe [x eval {tcl::unsupported::disassemble proc ::ensembletest}]
+                if {$show} {
+                    puts safe:
+                    puts $bytecode_safe
+                }
+                interp delete x
+                #mainly we expect the safe interp might contain invokeStk - indicating not byte compiled (or we would see strindex instead)
+                #It's possible the interp we're running in is also not compiling ensembles.
+                #we could then get a result of 2 - which still indicates a problem
+                if {[string last "invokeStk" $bytecode_safe] >= 1} {
+                    incr has_bug 
+                }
+            } else {
+                #our failure to create a safe interp here doesn't necessarily mean the Tcl version doesn't have the problem - but we could end up returning zero if somehow safe interp can't be created from unsafe interp? 
+                #unlikely - but we should warn 
+                puts stderr "Unable to create a safe sub-interp to test - result only indicates status of current interpreter"
+            }
+        }
+        
+        namespace delete [namespace current]::testcompile
+
+        if {[string last "invokeStk" $bytecode_outer] >= 1} {
+            incr has_bug
+        }
+        return $has_bug
+    }
 
     proc mostFactorsBelow {n} {
         ##*** !doctools
@@ -1888,7 +2245,7 @@ namespace eval punk::lib::system {
 }
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide punk::lib [namespace eval punk::lib {
+package provide punk::lib [tcl::namespace::eval punk::lib {
     variable pkg punk::lib
     variable version
     set version 0.1.1 
diff --git a/src/bootsupport/modules/punk/mix-0.2.tm b/src/bootsupport/modules/punk/mix-0.2.tm
index f24deb6..24ef156 100644
--- a/src/bootsupport/modules/punk/mix-0.2.tm
+++ b/src/bootsupport/modules/punk/mix-0.2.tm
@@ -1,25 +1,31 @@
 
 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
-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
+
+tcl::namespace::eval punk::mix {
+    proc init {} {
+        package require punk::cap::handlers::templates ;#handler for templates cap
+        punk::cap::register_capabilityname punk.templates ::punk::cap::handlers::templates ;#time taken should generally be sub 200us
+
+        package require punk::mix::templates ;#registers as provider pkg for 'punk.templates' capability with punk::cap
+        set t [time {
+        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
+        }
+        }]
+        puts stderr "->punk::mix::templates::provider register * t=$t"
+    }
+    init
+
 }
 
 package require punk::mix::base
 package require punk::mix::cli
 
-namespace eval punk::mix {
-    
-}
-
-package provide punk::mix [namespace eval punk::mix {
+package provide punk::mix [tcl::namespace::eval punk::mix {
     variable version
     set version 0.2
 
diff --git a/src/bootsupport/modules/punk/mix/base-0.1.tm b/src/bootsupport/modules/punk/mix/base-0.1.tm
index 0a13ad3..6eec4d8 100644
--- a/src/bootsupport/modules/punk/mix/base-0.1.tm
+++ b/src/bootsupport/modules/punk/mix/base-0.1.tm
@@ -394,7 +394,7 @@ namespace eval punk::mix::base {
         proc module_subpath {modulename} {
             set modulename [string trim $modulename :]
             set nsq [namespace qualifiers $modulename]
-            return [string map [list :: /] $nsq]
+            return [string map {:: /} $nsq]
         }
 
         proc get_build_workdir {path} {
@@ -420,8 +420,11 @@ namespace eval punk::mix::base {
         }
 
         #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
+        variable cksum_default_opts
+        set cksum_default_opts [dict create -cksum_content 1 -cksum_meta auto -cksum_acls 0 -cksum_usetar auto -cksum_algorithm sha1]
         proc cksum_default_opts {} {
-            return [dict create -cksum_content 1 -cksum_meta auto -cksum_acls 0 -cksum_usetar auto -cksum_algorithm sha1]
+            variable cksum_default_opts
+            return $cksum_default_opts
         }
 
         #crc::cksum is extremely slow in tcllib as at 2023 e.g 20x slower (no c implementation?)
diff --git a/src/bootsupport/modules/punk/mix/cli-0.3.tm b/src/bootsupport/modules/punk/mix/cli-0.3.tm
index 3e941e4..db21a25 100644
--- a/src/bootsupport/modules/punk/mix/cli-0.3.tm
+++ b/src/bootsupport/modules/punk/mix/cli-0.3.tm
@@ -123,8 +123,9 @@ namespace eval punk::mix::cli {
         }
 
         #review - why can't we be anywhere in the project? 
+        #also - if no make.tcl - can we use the running shell's make.tcl ? (after prompting user?)
         if {([file tail $sourcefolder] ne "src") || (![file exists $sourcefolder/make.tcl])} {
-            puts stderr "deck make must be run from src folder containing make.tcl - unable to proceed (cwd: [pwd])"
+            puts stderr "dev 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"
@@ -224,7 +225,7 @@ namespace eval punk::mix::cli {
             # -- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
             validate_name_not_empty_or_spaced $modulename -errorprefix $opt_errorprefix
-            set testname [string map [list :: ""] $modulename]
+            set testname [string map {:: {}} $modulename]
             if {[string first : $testname] >=0} {
                 error "$opt_errorprefix '$modulename' can only contain paired colons"
             }
@@ -366,13 +367,13 @@ namespace eval punk::mix::cli {
                     if {"project" in $repotypes} {
                         #punk project
                         if {![catch {package require textblock; package require patternpunk}]} {
-                           set result [textblock::join [>punk . logo] "  " $result] 
+                           set result [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]
+                    set timeline [string map {\r\n \n} $timeline]
                     append result $timeline 
                     if {$opt_v} {
                         set repostate [punk::repo::workingdir_state $repopath -repopaths $repopaths -repotypes fossil]
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 621aa00..401ddb7 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
@@ -31,7 +31,12 @@ namespace eval punk::mix::commandset::layout {
 
 
     #per layout functions
-    proc files {layout} {
+    proc files {{layout ""}} {
+        set argd [punk::args::get_dict {
+            *values -min 1 -max 1
+            layout -type string -minlen 1
+        } [list $layout]]
+
         set allfiles [lib::layout_all_files $layout]
         return [join $allfiles \n]
     }
@@ -77,6 +82,13 @@ namespace eval punk::mix::commandset::layout {
         }
 
         proc _default {args} {
+            punk::args::get_dict [subst {
+                *proc -name ::punk::mix::commandset::layout::collection::_default 
+                -startdir   -type string
+                -not        -type string -multiple 1
+                globsearches -default * -multiple 1
+            }] $args
+
             set tdict_low_to_high [as_dict {*}$args]
             #convert to screen order - with higher priority at the top
             set tdict [dict create]
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 39e9b09..f94bfed 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
@@ -26,33 +26,102 @@ package require punk::lib
 namespace eval punk::mix::commandset::loadedlib {
     namespace export *
     #search automatically wrapped in * * - can contain inner * ? globs
-    proc search {searchstring} {
+    proc search {args} {
+        set argspecs {
+            *proc -name "punk::mix::commandset::loadedlib search" -help "search all Tcl libraries available to your local interpreter"
+            -return  -type string -default table -choices {table tableobject list lines}
+            -present -type integer -default 2 -choices {0 1 2} -choicelabels {absent present both} -help "(unimplemented) Display only those that are 0:absent 1:present 2:both"
+            -highlight -type boolean -default 1 -help "Highlight which version is present with ansi underline and colour"
+            -refresh -default 0 -type boolean -help "Re-scan the tm and library folders"
+            searchstrings -default * -multiple 1 -help "Names to search for, may contain glob chars (* ?) e.g *lib*
+            If no glob chars are explicitly specified, the searchstring will be wrapped with star globs.
+            eg name -> *name* 
+            "
+        }
+        set argd [punk::args::get_dict $argspecs $args]
+        set searchstrings [dict get $argd values searchstrings]
+        set opts [dict get $argd opts]
+        set opt_return      [dict get $opts -return]
+        set opt_highlight   [dict get $opts -highlight]
+
         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 packages [package names]
+        set matches [list]
+        foreach search $searchstrings {
+            if {[regexp {[?*]} $search]} {
+                #caller has specified specific glob pattern - use it
+                #todo - respect supplied case only if uppers present? require another flag?
+                lappend matches {*}[lsearch -all -inline -nocase $packages $search]
+            } elseif {[string match =* $search]} {
+                lappend matches {*}[lsearch -all -inline -exact $packages [string range $search 1 end]]
+            } else {
+                #make it easy to search for anything
+                lappend matches {*}[lsearch -all -inline -nocase $packages "*$search*"]
+            }
         }
-
+        set matches [lsort -unique $matches][unset matches]
         set matchinfo [list]
+        set highlight_ansi [a+ web-limegreen underline]
+        set RST [a]
         foreach m $matches {
             set versions [package versions $m]
+            if {![llength $versions]} {
+                #e.g builtins such as zlib - shows no versions - but will show version when package present/provide used
+                set versions [package provide $m]
+                #if {![catch {package present $m} v]} {
+                #    set versions $v
+                #}
+            }
             if {$has_natsort} {
                 set versions [natsort::sort $versions]
             } else {
                 set versions [lsort $versions]
             }
+            if {$opt_highlight} {
+                set v [package provide $m]
+                if {$v ne ""} {
+                    set posn [lsearch $versions $v]
+                    if {$posn >= 0} {
+                        #FIXME! (probably in textblock::pad ?)
+                        #TODO - determine why underline is extended to padding even with double reset. (space or other char required to prevent)
+                        set highlighted "$highlight_ansi$v$RST $RST"
+                        set versions [lreplace $versions $posn $posn $highlighted]
+                    } else {
+                        #shouldn't be possible?
+                        puts stderr "failed to find version '$v' in versions:$versions for package $m"
+                    }
+                }
+            }
             lappend matchinfo [list $m $versions]
         }
-        return [join [lsort $matchinfo] \n]
+        switch -- $opt_return {
+            list {
+                return $matchinfo 
+            }
+            lines {
+                return [join $matchinfo \n]
+            }
+            table - tableobject {
+                set t [textblock::class::table new]
+                $t add_column -headers "Package"
+                $t add_column -headers "Version"
+                $t configure -show_hseps 0
+                foreach m $matchinfo {
+                    $t add_row [list [lindex $m 0] [join [lindex $m 1] " "]]
+                }
+                if {$opt_return eq "tableobject"} {
+                    return $t
+                }
+                set result [$t print]
+                $t destroy
+                return $result
+            }
+        }
     }
     proc loaded.search {searchstring} {
         set search_result [search $searchstring]
@@ -251,7 +320,7 @@ namespace eval punk::mix::commandset::loadedlib {
         }
 
         set loadinfo [package ifneeded $libfound $ver]
-        set loadinfo [string map [list \r\n \n] $loadinfo]
+        set loadinfo [string map {\r\n \n} $loadinfo]
         set loadinfo_lines [split $loadinfo \n]
         if {[catch {llength $loadinfo}]} {
             set loadinfo_is_listshaped 0
@@ -316,7 +385,7 @@ namespace eval punk::mix::commandset::loadedlib {
             #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 [string map {\r\n \n} $loadinfo]
             set loadinfo_lines [split $loadinfo \n]
             if {[catch {llength $loadinfo}]} {
                 set loadinfo_is_listshaped 0
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 794faf0..56aa815 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
@@ -111,7 +111,7 @@ namespace eval punk::mix::commandset::module {
         set tablewidth [expr {$widest(name) + 1 + $widest(pathtype) + 1 + $widest(name)}]
         set table ""
         append table [string repeat - $tablewidth] \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 "[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 {
@@ -122,6 +122,14 @@ namespace eval punk::mix::commandset::module {
     }
     #return all module templates with repeated ones suffixed with .2 .3 etc
     proc templates_dict {args} {
+        set argspec {
+            *proc -name templates_dict -help "Templates from module and project paths"
+            -startdir -default "" -help "Project folder used in addition to module paths"
+            -not -default "" -multiple 1
+            *values
+            globsearches -default * -multiple 1
+        }
+        set argd [punk::args::get_dict $argspec $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]
@@ -129,18 +137,26 @@ namespace eval punk::mix::commandset::module {
             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} {
+    proc new {args} {
         set year [clock format [clock seconds] -format %Y]
-        set defaults [list\
-            -project \uFFFF\
-            -version \uFFFF\
-            -license <unspecified>\
-            -template punk.module\
-            -type \uFFFF\
-            -force 0\
-            -quiet 0\
-            ]
-        set opts [dict merge $defaults $args]
+        set moduletypes [punk::mix::cli::lib::module_types]
+        # use \uFFFD because unicode replacement char should consistently render as 1 wide 
+        set argspecs [subst { 
+            -project    -default \uFFFD
+            -version    -default \uFFFD
+            -license    -default <unspecified>
+            -template   -default punk.module
+            -type       -default \uFFFD -choices {$moduletypes}
+            -force      -default 0      -type boolean
+            -quiet      -default 0     -type boolean
+            *values -min 1 -max 1
+            module      -type string
+        }]
+        set argd [punk::args::get_dict $argspecs $args]
+        lassign [dict values $argd] opts values
+        set module [dict get $values module]
+        
+        #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)
@@ -152,7 +168,7 @@ namespace eval punk::mix::commandset::module {
         # we need this value before looking at the named argument
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
         set opt_version_supplied                    [dict get $opts -version]
-        if {$opt_version_supplied eq "\uFFFF"} {
+        if {$opt_version_supplied eq "\uFFFD"} {
             set opt_version "0.1.0"
         } else {
             set opt_version $opt_version_supplied
@@ -178,7 +194,7 @@ namespace eval punk::mix::commandset::module {
             } else {
                 set vmsg "from -version option: $opt_version_supplied"
             }
-            if {$opt_version_supplied ne "\uFFFF"} {
+            if {$opt_version_supplied ne "\uFFFD"} {
                 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"
@@ -269,7 +285,7 @@ namespace eval punk::mix::commandset::module {
 
         # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
         set opt_type                                [dict get $opts -type]
-        if {$opt_type eq "\uFFFF"} {
+        if {$opt_type eq "\uFFFD"} {
             set opt_type [lindex [punk::mix::cli::lib::module_types] 0] ;#default to plain
         }
         if {$opt_type ni [punk::mix::cli::lib::module_types]} {
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 9ac7896..c61db42 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
@@ -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 [textblock::join [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 {
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 5521ad8..dab5312 100644
--- a/src/bootsupport/modules/punk/mix/templates-0.1.0.tm
+++ b/src/bootsupport/modules/punk/mix/templates-0.1.0.tm
@@ -59,7 +59,7 @@ namespace eval punk::mix::templates {
         oo::objdefine provider {
             method register {{capabilityname_glob *}} {
                 #puts  registering punk::mix::templates $capabilityname
-                next
+                next $capabilityname_glob
             }
             method capabilities {} {
                 next
diff --git a/src/bootsupport/modules/punk/mix/templates/layouts/project/src/make.tcl b/src/bootsupport/modules/punk/mix/templates/layouts/project/src/make.tcl
index f4eef65..c53315e 100644
--- a/src/bootsupport/modules/punk/mix/templates/layouts/project/src/make.tcl
+++ b/src/bootsupport/modules/punk/mix/templates/layouts/project/src/make.tcl
@@ -281,7 +281,7 @@ if {$::punkmake::command eq "bootsupport"} {
 
                 foreach {relpath module} $bootsupport_modules {
                     set module [string trim $module :]
-                    set module_subpath [string map [list :: /] [namespace qualifiers $module]]
+                    set module_subpath [string map {:: /} [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]-*]
@@ -617,7 +617,7 @@ if {[file exists $mapfile]} {
     fconfigure $fdmap -translation binary
     set mapdata [read $fdmap]
     close $fdmap
-    set mapdata [string map [list \r\n \n] $mapdata]
+    set mapdata [string map {\r\n \n} $mapdata]
     set missing [list]
     foreach ln [split $mapdata \n] {
         set ln [string trim $ln]
diff --git a/src/bootsupport/modules/punk/ns-0.1.0.tm b/src/bootsupport/modules/punk/ns-0.1.0.tm
index 5dbacbc..10a8d9a 100644
--- a/src/bootsupport/modules/punk/ns-0.1.0.tm
+++ b/src/bootsupport/modules/punk/ns-0.1.0.tm
@@ -20,12 +20,12 @@
 package require punk::lib
 package require punk::args
 
-namespace eval ::punk_dynamic::ns {
+tcl::namespace::eval ::punk_dynamic::ns {
 
 }
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::ns {
+tcl::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
@@ -58,7 +58,7 @@ namespace eval punk::ns {
             set has_globchars [regexp {[*?]} $ns_or_glob]
             if {$is_absolute} {
                 if {!$has_globchars} {
-                    if {![namespace exists $ns_or_glob]} {
+                    if {![tcl::namespace::exists $ns_or_glob]} {
                         error "cannot change to namespace $ns_or_glob"
                     }
                     set ns_current $ns_or_glob
@@ -71,7 +71,7 @@ namespace eval punk::ns {
             } else {
                 if {!$has_globchars} {
                     set nsnext [nsjoin $ns_current $ns_or_glob]
-                    if {![namespace exists $nsnext]} {
+                    if {![tcl::namespace::exists $nsnext]} {
                         error "cannot change to namespace $ns_or_glob"
                     }
                     set ns_current $nsnext
@@ -86,7 +86,7 @@ namespace eval punk::ns {
         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 {![catch [list tcl::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.
@@ -119,13 +119,13 @@ namespace eval punk::ns {
             set nspath [nsjoinall $ns_current {*}$args]
         }
 
-        set ns_exists [nseval [nsprefix $nspath] [list ::namespace exists [nstail $nspath] ]]
+        set ns_exists [nseval [nsprefix $nspath] [list ::tcl::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] {}]
+        #tcl::namespace::eval [nsprefix $nspath] [list tcl::namespace::eval [nstail $nspath] {}]
+        nseval [nsprefix $nspath] [list ::tcl::namespace::eval [nstail $nspath] {}]
         n/ $nspath
     }
 
@@ -157,7 +157,7 @@ namespace eval punk::ns {
     }
 
     #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
+    #approx 10x slower than normal tcl::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 ""} {
@@ -171,7 +171,7 @@ namespace eval punk::ns {
         set i 0
         set tails [lrepeat [llength $parts] ""]
         foreach ns $parts {
-            set cmdlist [list ::namespace eval $ns]
+            set cmdlist [list ::tcl::namespace::eval $ns]
             set t ""
             if {$i > 0} {
                 append body " <lb>"
@@ -194,7 +194,7 @@ namespace eval punk::ns {
         set scr {[::list ::eval [::uplevel <i>  {::set script}]]}
 
         set up [expr {$i - 1}]
-        set scr [string map [list <i> $up] $scr]
+        set scr [string map "<i> $up" $scr]
 
         set body [string map [list <script> $scr] $body]
         return $body
@@ -203,7 +203,7 @@ namespace eval punk::ns {
         if {![string match ::* $fqns]} {
             error "nseval only accepts a fully qualified namespace"
         }
-        set loc [string map [list :: "_sep_"] $fqns]
+        set loc [string map {:: _sep_} $fqns]
         #set cmd ::punk::pipecmds::nseval_$loc
         set cmd ::punk_dynamic::ns::eval-$loc
         if {$cmd ni [info commands $cmd]} {
@@ -221,7 +221,7 @@ namespace eval punk::ns {
         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]]
+        set nslist [tcl::namespace::eval $parent [list ::tcl::namespace::children $tail]]
         return [lsort $nslist]
     }
 
@@ -281,7 +281,7 @@ namespace eval punk::ns {
     # 
     proc nsprefix {{nspath ""}} {
         #normalize the common case of ::::
-        set nspath [string map [list :::: ::] $nspath]
+        set nspath [string map {:::: ::} $nspath]
         set rawprefix [string range $nspath 0 end-[string length [nstail $nspath]]]
         if {$rawprefix eq "::"} {
             return $rawprefix
@@ -299,8 +299,8 @@ namespace eval punk::ns {
     #review - consider making -strict raise an error for unexpected sequences such as ::::  or any situation with 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 nspath [string map {:::: ::} $nspath]
+        set mapped [string map {:: \u0FFF} $nspath] 
         set parts [split $mapped \u0FFF]
 
         set defaults [list -strict 0]
@@ -324,7 +324,7 @@ namespace eval punk::ns {
     #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'
+    #This is because Tcl's 'tcl::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. 
@@ -332,8 +332,8 @@ namespace eval punk::ns {
     #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 nspath [string map {:::: ::} $nspath]
+        set mapped [string map {:: \u0FFF} $nspath] 
         set parts [split $mapped \u0FFF]
         if {[lindex $parts end] eq ""} {
 
@@ -387,7 +387,8 @@ namespace eval punk::ns {
             } elseif {$seg eq "**"} {
                 lappend pats {.*}
             } else {
-                set seg [string map [list  . {[.]}] $seg]
+                #set seg [string map [list  . {[.]}] $seg]
+                set seg [string map {. [.]} $seg]
                 if {[regexp {[*?]} $seg]} {
                     set pat [string map [list ** {.*} * {[^:]*} ? {[^:]}] $seg]
                     lappend pats "$pat"
@@ -469,14 +470,14 @@ namespace eval punk::ns {
            set base $location 
            set tailparts $subnslist
         }
-        if {![namespace exists $base]} {
+        if {![tcl::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]]]
+        set allchildren [lsort [tcl::namespace::eval $base [list ::namespace children]]]
 
         #puts "->base:$base tailparts:$tailparts allchildren: $allchildren"
         #puts "->base:$base tailparts:$tailparts childcount: [llength $allchildren]"
@@ -994,7 +995,19 @@ namespace eval punk::ns {
     }
 
     #info cmdtype available in 8.7+ 
+    #safe interps also seem to have it disabled for some reason
     proc cmdtype {cmd} {
+        if {[interp issafe]} {
+            if {[catch {::tcl::info::cmdtype $cmd} result]} {
+                if {[info commands ::cmdtype] ne ""} {
+                    #hack - look for an alias that may have been specifically enabled to bring this back
+                    tailcall ::cmdtype $cmd
+                }
+                return na
+            } else {
+                return $result
+            }
+        }
         if {[info commands ::tcl::info::cmdtype] ne ""} {
             tailcall info cmdtype $cmd
         }
@@ -1072,8 +1085,8 @@ namespace eval punk::ns {
             
 #JMN
             set location $ch 
-            set exportpatterns [namespace eval $location {::namespace export}]
-            set nspathlist     [namespace eval $location {::namespace path}]
+            set exportpatterns [tcl::namespace::eval $location {::namespace export}]
+            set nspathlist     [tcl::namespace::eval $location {::namespace path}]
             set nspathdict [dict create]
             if {$nspathcommands} {
                 foreach pathns $nspathlist {
@@ -1092,7 +1105,7 @@ namespace eval punk::ns {
             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]]]
+                    lappend matched {*}[tcl::namespace::eval $location [list ::info commands [nsjoin ${location} $p]]]
                     foreach m $matched {
                         lappend allexported [nstail $m]
                     }
@@ -1101,8 +1114,8 @@ namespace eval punk::ns {
                 }
             }
             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}] 
+            #NOTE: info procs within tcl::namespace::eval is different to 'info commands' within tcl::namespace::eval (info procs doesn't look outside of namespace)
+            set allprocs [tcl::namespace::eval $location {::info procs}] 
             #set allprocs    [nseval $location {::info procs}]
             set childtails [lmap v $allchildren {nstail $v}]
             set allaliases [list]
@@ -1120,7 +1133,7 @@ namespace eval punk::ns {
             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 [tcl::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 {
@@ -1363,8 +1376,8 @@ namespace eval punk::ns {
                 }
 
                 ::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]} {
+                #important not to call tcl::namespace::eval (or punk::ns::nseval) on non-existant base - or it will be created
+                ::if {![::tcl::namespace::exists $base]} {
                    ::continue 
                 }
 
@@ -1374,7 +1387,7 @@ namespace eval punk::ns {
                     #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]}
+                            caseresult.= ::list $base $what |,basens/0,g/1>  {tcl::namespace::eval $basens [::list ::info commands $g]}
                     }]
                     #lappend commandlist {*}[@@ok/result= $matchedcommands]
                     #need to pull result from matchedcommands dict
@@ -1450,8 +1463,8 @@ namespace eval punk::ns {
                 }
 
                 ::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]} {
+                #important not to call tcl::namespace::eval (or punk::ns::nseval) on non-existant base - or it will be created
+                ::if {![::tcl::namespace::exists $base]} {
                    ::continue 
                 }
                 ::set all_ns_tails [::lmap v $all_ns_commands {::punk::ns::nstail $v}]
@@ -1615,7 +1628,7 @@ namespace eval punk::ns {
     }
 
 
-    namespace eval internal {
+    tcl::namespace::eval internal {
 
 
         #maintenance: similar in punk::winrun
@@ -1701,7 +1714,7 @@ namespace eval punk::ns {
             }
             default {
                 if {[string match ::* $pkg_or_existing_ns]} {
-                    if {![namespace exists $pkg_or_existing_ns]} {
+                    if {![tcl::namespace::exists $pkg_or_existing_ns]} {
                         set ver [package require [string range $pkg_or_existing_ns 2 end]]
                     } else {
                         set ver ""
@@ -1713,7 +1726,7 @@ namespace eval punk::ns {
                 }
             }
         }
-        if {[namespace exists $ns]} {
+        if {[tcl::namespace::exists $ns]} {
             if {[llength $cmdargs]} {
                 set binding {}
                 #if {[info level] == 1} {
@@ -1724,10 +1737,10 @@ namespace eval punk::ns {
                 #}
                 #set vars [uplevel 1 {*}$get_vars]
 
-                #set vars [namespace eval $ns {info vars}]
+                #set vars [tcl::namespace::eval $ns {info vars}]
 
                 #review - upvar in apply within ns eval vs direct access of ${ns}::varname
-                set capture [namespace eval $ns {
+                set capture [tcl::namespace::eval $ns {
                     apply { varnames  {
                         while {"prev_args[incr n]" in $varnames} {}
                         set capturevars [dict create]
@@ -1799,8 +1812,8 @@ namespace eval punk::ns {
         lassign [dict values [punk::args::get_dict $argspecs $args]]  opts values
         set sourcepattern [dict get $values sourcepattern]
 
-        set source_ns [namespace qualifiers $sourcepattern]
-        if {![namespace exists $source_ns]} {
+        set source_ns [tcl::namespace::qualifiers $sourcepattern]
+        if {![tcl::namespace::exists $source_ns]} {
             error "nsimport_noclobber error namespace $source_ns not found"
         }
         set target_ns [dict get $opts -targetnamespace]
@@ -1811,9 +1824,9 @@ namespace eval punk::ns {
             set target_ns [punk::nsjoin $nscaller $target_ns]
         }
 
-        set a_export_patterns [namespace eval $source_ns {namespace export}] 
+        set a_export_patterns [tcl::namespace::eval $source_ns {namespace export}] 
         set a_commands [info commands $sourcepattern]
-        set a_tails [lmap v $a_commands {namespace tail $v}]
+        set a_tails [lmap v $a_commands {tcl::namespace::tail $v}]
         set a_exported_tails [list]
         foreach epattern $a_export_patterns {
             set matches [lsearch -all -inline $a_tails $epattern]
@@ -1825,7 +1838,7 @@ namespace eval punk::ns {
         }
         set imported_commands [list]
         foreach e $a_exported_tails {
-            set imported [namespace eval $target_ns [string map [list <func> $e <a> $source_ns] {
+            set imported [tcl::namespace::eval $target_ns [string map [list <func> $e <a> $source_ns] {
                 set cmd ""
                 if {![catch {namespace import <a>::<func>}]} {
                     set cmd <func>
@@ -1890,7 +1903,7 @@ namespace eval punk::ns {
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide punk::ns [namespace eval punk::ns {
+package provide punk::ns [tcl::namespace::eval punk::ns {
     variable version
     set version 0.1.0 
 }]
diff --git a/src/bootsupport/modules/punk/overlay-0.1.tm b/src/bootsupport/modules/punk/overlay-0.1.tm
index eebf0e1..5534dad 100644
--- a/src/bootsupport/modules/punk/overlay-0.1.tm
+++ b/src/bootsupport/modules/punk/overlay-0.1.tm
@@ -2,37 +2,37 @@
 
 package require punk::mix::util
 
-namespace eval ::punk::overlay {
+tcl::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 {![tcl::string::match ::* $routine]} {
+            set resolved [uplevel 1 [list ::tcl::namespace::which $routine]]
             if {$resolved eq {}} {
                 error [list {no such routine} $routine]
             }
             set routine $resolved
         }
-        set routinens [namespace qualifiers $routine]
+        set routinens [tcl::namespace::qualifiers $routine]
         if {$routinens eq {::}} {
             set routinens {}
         }
-        set routinetail [namespace tail $routine]
+        set routinetail [tcl::namespace::tail $routine]
 
-        if {![string match ::* $base]} {
+        if {![tcl::string::match ::* $base]} {
             set base [uplevel 1 [
-                list [namespace which namespace] current]]::$base
+                list [tcl::namespace::which namespace] current]]::$base
         }
 
-        if {![namespace exists $base]} {
+        if {![tcl::namespace::exists $base]} {
             error [list {no such namespace} $base]
         }
 
-        set base [namespace eval $base [
-            list [namespace which namespace] current]]
+        set base [tcl::namespace::eval $base [
+            list [tcl::namespace::which namespace] current]]
 
 
         #while 1 {
@@ -40,42 +40,42 @@ namespace eval ::punk::overlay {
         #    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 
+        tcl::namespace::eval $routine [
+            ::list tcl::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::*
+            #::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 import <base>::lib::*
         #}]
 
-        namespace eval ${routine}::lib [string map [list <base> $base <routine> $routine] {
-            if {[namespace exists <base>::lib]} {
-                set current_paths [namespace path]
+        tcl::namespace::eval ${routine}::lib [tcl::string::map [list <base> $base <routine> $routine] {
+            if {[tcl::namespace::exists <base>::lib]} {
+                ::set current_paths [tcl::namespace::path]
                 if {"<routine>" ni $current_paths} {
-                    lappend current_paths <routine>
+                    ::lappend current_paths <routine>
                 }
-                namespace path $current_paths
+                tcl::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
+        tcl::namespace::eval $routine {
+            ::set exportlist [::list]
+            ::foreach cmd [tcl::info::commands [tcl::namespace::current]::*] {
+                ::set c [tcl::namespace::tail $cmd]
+                if {![tcl::string::match _* $c]} {
+                    ::lappend exportlist $c
                 }
             }
-            namespace export {*}$exportlist
+            tcl::namespace::export {*}$exportlist
         }
 
         return $routine
@@ -96,20 +96,20 @@ namespace eval ::punk::overlay {
         }
         #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]
+        if {[tcl::string::range $cmdnamespace 0 1] eq "::"} {
+            set cmdpackage [tcl::string::range $cmdnamespace 2 end]
         } else {
             set cmdpackage $cmdnamespace
             set cmdnamespace ::$cmdnamespace
         }
 
-        if {![namespace exists $cmdnamespace]} {
+        if {![tcl::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]} {
+            if {![tcl::namespace::exists $cmdnamespace]} {
                 set prov [package provide $cmdpackage]
-                if {[string length $prov]} {
+                if {[tcl::string::length $prov]} {
                     set provinfo "(package $cmdpackage is present with version $prov)"
                 } else {
                     set provinfo "(package $cmdpackage not present)"
@@ -121,21 +121,21 @@ namespace eval ::punk::overlay {
         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]
+        tcl::namespace::eval ${cmdnamespace}::lib [tcl::string::map [list <cmdns> $cmdnamespace] {
+            ::set nspaths [tcl::namespace::path]
             if {"<cmdns>" ni $nspaths} {
-                lappend nspaths <cmdns>
+                ::lappend nspaths <cmdns>
             }
-            namespace path $nspaths
+            tcl::namespace::path $nspaths
         }]
 
         set imported_commands [list]
-        set nscaller [uplevel 1 [list namespace current]]
+        set nscaller [uplevel 1 [list tcl::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]
+            tcl::namespace::eval ${nscaller}::temp_import [list tcl::namespace::import ${cmdnamespace}::*]
+            foreach cmd [tcl::info::commands ${nscaller}::temp_import::*] {
+                set cmdtail [tcl::namespace::tail $cmd]
                 if {$cmdtail eq "_default"} {
                     set import_as ${nscaller}::${prefix}
                 } else {
@@ -153,7 +153,7 @@ namespace eval ::punk::overlay {
 }
 
 
-package provide punk::overlay [namespace eval punk::overlay {
+package provide punk::overlay [tcl::namespace::eval punk::overlay {
     variable version
     set version 0.1 
 }]
diff --git a/src/bootsupport/modules/punk/path-0.1.0.tm b/src/bootsupport/modules/punk/path-0.1.0.tm
index 9868219..4abba69 100644
--- a/src/bootsupport/modules/punk/path-0.1.0.tm
+++ b/src/bootsupport/modules/punk/path-0.1.0.tm
@@ -131,7 +131,8 @@ namespace eval punk::path {
                 **  {lappend pats {.*}} 
                 default {
                     set seg [string map [list {^ {\^} $ {\$} [} {\[} ( {\(} \{ \\\{ \\ {\\}] $seg] ;#treat regex characters in the input as literals 
-                    set seg [string map [list  . {[.]}] $seg]
+                    #set seg [string map [list  . {[.]}] $seg]
+                    set seg [string map {. [.]} $seg]
                     if {[regexp {[*?]} $seg]} {
                         set pat [string map [list ** {.*} * {[^/]*} ? {[^/]}] $seg]
                         lappend pats "$pat"
@@ -212,12 +213,14 @@ namespace eval punk::path {
         #[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 argd [punk::args::get_dict {
+            -directory              -default "\uFFFF"
+            -call-depth-internal    -default 0 -type integer
+            -antiglob_paths         -default {}
+            *values -min 0 -max -1 -type string 
+        } $args]
+        lassign [dict values $argd] opts values 
+        set tailglobs [dict values $values]
         # -- --- --- --- --- --- ---
         set opt_antiglob_paths [dict get $opts -antiglob_paths]
         set CALLDEPTH [dict get $opts -call-depth-internal]
diff --git a/src/bootsupport/modules/punk/repo-0.1.1.tm b/src/bootsupport/modules/punk/repo-0.1.1.tm
index 9a3a7f4..4b1e2f4 100644
--- a/src/bootsupport/modules/punk/repo-0.1.1.tm
+++ b/src/bootsupport/modules/punk/repo-0.1.1.tm
@@ -1303,7 +1303,7 @@ namespace eval punk::repo {
                 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 repolines [string map {\r\n \n} $repolines]
                     set repolist [split $repolines \n]
                     set dbcmd "fossil_get_configdb_tempdb"
                     foreach repodb $repolist {
@@ -1383,12 +1383,12 @@ namespace eval punk::repo {
         return [lindex [split $content \x1A] 0]
     }
     proc grep {pattern data} {
-        set data [string map [list \r\n \n] $data]
+        set data [string map {\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]
+        set data [string map {\r\n \n} $data]
         return [lsearch -all -inline -regexp [split $data \n] $pattern]
     }
 
diff --git a/src/bootsupport/modules/punk/winpath-0.1.0.tm b/src/bootsupport/modules/punk/winpath-0.1.0.tm
index a21e91e..b30133b 100644
--- a/src/bootsupport/modules/punk/winpath-0.1.0.tm
+++ b/src/bootsupport/modules/punk/winpath-0.1.0.tm
@@ -31,10 +31,10 @@ namespace eval punk::winpath {
     #\\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)
+        set strcopy_path [string map {\\ /} $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 "//?/" "//./"]} {
+            if {[string range $strcopy_path 0 3] in {//?/ //./}} {
                 #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
@@ -78,8 +78,8 @@ namespace eval punk::winpath {
     #(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 "//?/" "//./"]} {
+        set strcopy_path [string map {\\ /} $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 {//?/ //./}} {
             return 1
         } else {
             return 0
diff --git a/src/bootsupport/modules/punkcheck-0.1.0.tm b/src/bootsupport/modules/punkcheck-0.1.0.tm
index 8175ac0..56d42b2 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 'deck make' or src/make.tcl to update from <pkg>-buildversion.txt
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'dev 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.
@@ -116,16 +116,21 @@ namespace eval punkcheck {
                 }
 
                 method as_record {} {
-
-                    set fields [list\
+                    #set fields [list\
+                    #    -targets $o_targets\
+                    #    -keep_installrecords $o_keep_installrecords\
+                    #    -keep_skipped $o_keep_skipped\
+                    #    -keep_inprogress $o_keep_inprogress\
+                    #    body $o_records\
+                    #]
+
+                    dict create \
+                        tag FILEINFO\
                         -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]
+                        body $o_records
                 }
                 
                 #retrieve last completed record for the fileset ie exclude SKIPPED,INSTALL-INPROGRESS,DELETE-INPROGRESS,MODIFY-INPROGRESS
@@ -199,7 +204,21 @@ namespace eval punkcheck {
                     } else {
                         set tsiso_end ""
                     }
-                    set fields [list\
+                    #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]
+
+                    dict create \
+                        tag EVENT\
                         -tsiso_begin $tsiso_begin\
                         -ts_begin    $o_ts_begin\
                         -tsiso_end   $tsiso_end\
@@ -208,10 +227,8 @@ namespace eval punkcheck {
                         -source      $o_rel_sourceroot\
                         -targets     $o_rel_targetroot\
                         -types       $o_types\
-                        -config      $o_configdict\
-                    ]
+                        -config      $o_configdict
 
-                    set record [dict create tag EVENT {*}$fields]
                 }
                 method get_id {} {
                     return $o_id
@@ -1294,7 +1311,7 @@ namespace eval punkcheck {
                     dict unset config -call-depth-internal
                     dict unset config -max_depth
                     dict unset config -subdirlist
-                    dict for {k v} $config {
+                    tcl::dict::for {k v} $config {
                         if {$v eq "\uFFFF"} {
                             dict unset config $k
                         }
diff --git a/src/bootsupport/modules/textblock-0.1.1.tm b/src/bootsupport/modules/textblock-0.1.1.tm
index c597e96..055fdfc 100644
--- a/src/bootsupport/modules/textblock-0.1.1.tm
+++ b/src/bootsupport/modules/textblock-0.1.1.tm
@@ -26,13 +26,13 @@ package require overtype
 package require term::ansi::code::macros ;#required for frame if old ansi g0 used - review - make package optional?
 package require textutil
 
-namespace eval textblock {
+tcl::namespace::eval textblock {
     #review - what about ansi off in punk::console?
-    namespace import ::punk::ansi::a ::punk::ansi::a+
+    tcl::namespace::import ::punk::ansi::a ::punk::ansi::a+
 
-    namespace eval class {
+    tcl::namespace::eval class {
         variable opts_table_defaults
-        set opts_table_defaults [dict create\
+        set opts_table_defaults [tcl::dict::create\
             -title ""\
             -titlealign "left"\
             -titletransparent 0\
@@ -70,7 +70,7 @@ namespace eval textblock {
             -maxwidth ""\
         ]
         variable opts_column_defaults
-        set opts_column_defaults [dict create\
+        set opts_column_defaults [tcl::dict::create\
             -headers [list]\
             -header_colspans [list]\
             -footers [list]\
@@ -105,7 +105,7 @@ namespace eval textblock {
         set rights  [list trc brc vlr]
 
         variable table_edge_parts
-        set table_edge_parts [dict create\
+        set table_edge_parts [tcl::dict::create\
             topleft     [struct::set intersect $C [concat $tops $lefts]]\
             topinner    [struct::set intersect $C [concat $tops]]\
             topright    [struct::set intersect $O [concat $tops $rights]]\
@@ -127,7 +127,7 @@ namespace eval textblock {
         #for header rows - we don't consider the bottom border as part of the edge - even if table body has no rows
         #The usual-case of a single header line is the 'onlyleft,onlyinner,onlyright,onlysolo' set.
         variable header_edge_parts
-        set header_edge_parts [dict create\
+        set header_edge_parts [tcl::dict::create\
             topleft     [struct::set intersect $C [concat $tops $lefts]]\
             topinner    [struct::set intersect $C [concat $tops]]\
             topright    [struct::set intersect $O [concat $tops $rights]]\
@@ -146,7 +146,7 @@ namespace eval textblock {
             onlysolo    [struct::set intersect $O [concat $tops $lefts $rights]]\
         ]
         variable table_hseps
-        set table_hseps [dict create\
+        set table_hseps [tcl::dict::create\
             topleft     [list blc hlb]\
             topinner    [list blc hlb]\
             topright    [list blc hlb brc]\
@@ -165,7 +165,7 @@ namespace eval textblock {
             onlysolo    [list]\
         ]
         variable table_vseps
-        set table_vseps [dict create\
+        set table_vseps [tcl::dict::create\
             topleft     [list]\
             topinner    [list vll tlc blc]\
             topright    [list vll tlc blc]\
@@ -184,46 +184,50 @@ namespace eval textblock {
             onlysolo    [list]\
         ]
 
-
+        #ensembles seem to be not compiled in safe interp
+        #https://core.tcl-lang.org/tcl/tktview/1095bf7f75
+        #as we want textblock to be usable in safe interps - use tcl::dict::for as a partial workaround
+        #This at least means the script argument, especially switch statements can get compiled.
+        #It does however affect all ensemble commands - so even 'dict get/set' etc won't be as efficient in a safe interp.
 
         #e.g $t configure -framemap_body [table_edge_map " "]
         proc table_edge_map {char} {
             variable table_edge_parts
             set map [list]
-            dict for {celltype parts} $table_edge_parts {
+            tcl::dict::for {celltype parts} $table_edge_parts {
                 set tmap [list]
                 foreach p $parts {
-                    dict set tmap $p $char
+                    tcl::dict::set tmap $p $char
                 }
-                dict set map $celltype $tmap
+                tcl::dict::set map $celltype $tmap
             }
             return $map
         }
         proc table_sep_map {char} {
             variable table_hseps
             set map [list]
-            dict for {celltype parts} $table_hseps {
+            tcl::dict::for {celltype parts} $table_hseps {
                 set tmap [list]
                 foreach p $parts {
-                    dict set tmap $p $char
+                    tcl::dict::set tmap $p $char
                 }
-                dict set map $celltype $tmap
+                tcl::dict::set map $celltype $tmap
             }
             return $map
         }
         proc header_edge_map {char} {
             variable header_edge_parts
             set map [list]
-            dict for {celltype parts} $header_edge_parts {
+            tcl::dict::for {celltype parts} $header_edge_parts {
                 set tmap [list]
                 foreach p $parts {
-                    dict set tmap $p $char
+                    tcl::dict::set tmap $p $char
                 }
-                dict set map $celltype $tmap
+                tcl::dict::set map $celltype $tmap
             }
             return $map
         }
-        if {[info commands [namespace current]::table] eq ""} {
+        if {[tcl::info::commands [tcl::namespace::current]::table] eq ""} {
             #*** !doctools
             #[subsection {Namespace textblock::class}]
             #[para] class definitions
@@ -234,15 +238,15 @@ namespace eval textblock {
 
             #this makes new table objects a little faster when multiple opts specified as well as to configure
             #as tables are a heavyweight thing, but handy to nest sometimes - we'll take what we can get
-            set topt_keys [dict keys $::textblock::class::opts_table_defaults]
+            set topt_keys [tcl::dict::keys $::textblock::class::opts_table_defaults]
             set switch_keys_valid_topts [punk::lib::lmapflat v $topt_keys {list $v -}]
             set switch_keys_valid_topts [lrange $switch_keys_valid_topts 0 end-1] ;#remove last dash
 
-            set copt_keys [dict keys $::textblock::class::opts_column_defaults]
+            set copt_keys [tcl::dict::keys $::textblock::class::opts_column_defaults]
             set switch_keys_valid_copts [punk::lib::lmapflat v $copt_keys {list $v -}]
             set switch_keys_valid_copts [lrange $switch_keys_valid_copts 0 end-1]
 
-            oo::class create [namespace current]::table [string map [list %topt_keys% $topt_keys %topt_switchkeys% $switch_keys_valid_topts %copt_keys% $copt_keys %copt_switchkeys% $switch_keys_valid_copts] {
+            oo::class create [tcl::namespace::current]::table [tcl::string::map [list %topt_keys% $topt_keys %topt_switchkeys% $switch_keys_valid_topts %copt_keys% $copt_keys %copt_switchkeys% $switch_keys_valid_copts] {
                 #*** !doctools
                 #[enum] CLASS [class interface_caphandler.registry]
                 #[list_begin definitions]
@@ -278,7 +282,7 @@ namespace eval textblock {
                         set args [list -title [lindex $args 0]]
                     }
                     if {[llength $args] %2 !=0} {
-                        error "[namespace current]::table constructor - unexpected argument count. Require single value being title, or name value pairs"
+                        error "[tcl::namespace::current]::table constructor - unexpected argument count. Require single value being title, or name value pairs"
                     }
 
                     set o_opts_table            $o_opts_table_defaults
@@ -288,35 +292,35 @@ namespace eval textblock {
                     foreach {k v} $args {
                         switch -- $k {
                             %topt_switchkeys% {
-                                dict set o_opts_table $k $v
+                                tcl::dict::set o_opts_table $k $v
                             }
                             default {
-                                error "[namespace current]::table unrecognised option '$k'. Known values [dict keys $o_opts_table_defaults]"
+                                error "[tcl::namespace::current]::table unrecognised option '$k'. Known values [tcl::dict::keys $o_opts_table_defaults]"
                             }
                         }
                     }
                     my configure {*}$o_opts_table
 
                     #foreach {k v} $args {
-                    #    #todo - convert to literal switch using string map so we don't have to define o_opts_table_defaults here.
-                    #    if {$k ni [dict keys $o_opts_table_defaults]} {
-                    #        error "[namespace current]::table unrecognised option '$k'. Known values [dict keys $o_opts_table_defaults]"
+                    #    #todo - convert to literal switch using tcl::string::map so we don't have to define o_opts_table_defaults here.
+                    #    if {$k ni [tcl::dict::keys $o_opts_table_defaults]} {
+                    #        error "[tcl::namespace::current]::table unrecognised option '$k'. Known values [tcl::dict::keys $o_opts_table_defaults]"
                     #    }
                     #}
-                    #set o_opts_table [dict merge $o_opts_table_defaults $args]
-                    #my configure {*}[dict merge $o_opts_table_defaults $args]
+                    #set o_opts_table [tcl::dict::merge $o_opts_table_defaults $args]
+                    #my configure {*}[tcl::dict::merge $o_opts_table_defaults $args]
 
-                    set o_columndefs [dict create]
-                    set o_columndata [dict create] ;#we store data by column even though it is often added row by row
-                    set o_columnstates [dict create] ;#store the maxwidthbodyseen etc as we add rows and maxwidthheaderseen etc as we add headers - it is needed often and expensive to calculate repeatedly
-                    set o_headerstates [dict create]
-                    set o_rowdefs [dict create] ;#user requested row data e.g -minheight -maxheight
-                    set o_rowstates [dict create] ;#actual row data such as -minheight and -maxheight detected from supplied row data
+                    set o_columndefs    [tcl::dict::create]
+                    set o_columndata    [tcl::dict::create] ;#we store data by column even though it is often added row by row
+                    set o_columnstates  [tcl::dict::create] ;#store the maxwidthbodyseen etc as we add rows and maxwidthheaderseen etc as we add headers - it is needed often and expensive to calculate repeatedly
+                    set o_headerstates  [tcl::dict::create]
+                    set o_rowdefs       [tcl::dict::create] ;#user requested row data e.g -minheight -maxheight
+                    set o_rowstates     [tcl::dict::create] ;#actual row data such as -minheight and -maxheight detected from supplied row data
 
                     set TSUB \uF111 ;#should be BMP PUA code to show as either replacement char or nerdfont glyph. See FSUB for comments regarding choices.
                     set o_calculated_column_widths [list]
                     set o_column_width_algorithm "span"
-                    set header_defaults [dict create\
+                    set header_defaults [tcl::dict::create\
                         -colspans {}\
                         -values {}\
                         -ansibase {}\
@@ -335,9 +339,9 @@ namespace eval textblock {
                     set o_column_width_algorithm $alg
                 }
                 method Get_seps {} {
-                    set requested_seps      [dict get $o_opts_table -show_seps]
-                    set requested_seps_h    [dict get $o_opts_table -show_hseps]
-                    set requested_seps_v   [dict get $o_opts_table -show_vseps]
+                    set requested_seps      [tcl::dict::get $o_opts_table -show_seps]
+                    set requested_seps_h    [tcl::dict::get $o_opts_table -show_hseps]
+                    set requested_seps_v   [tcl::dict::get $o_opts_table -show_vseps]
                     set seps    $requested_seps
                     set seps_h  $requested_seps_h 
                     set seps_v  $requested_seps_v 
@@ -356,12 +360,12 @@ namespace eval textblock {
                             set seps_v $seps 
                         }
                     }
-                    return [dict create horizontal $seps_h vertical $seps_v]
+                    return [tcl::dict::create horizontal $seps_h vertical $seps_v]
                 }
                 method Get_frametypes {} {
-                    set requested_ft [dict get $o_opts_table -frametype]
-                    set requested_ft_header [dict get $o_opts_table -frametype_header]
-                    set requested_ft_body   [dict get $o_opts_table -frametype_body]
+                    set requested_ft        [tcl::dict::get $o_opts_table -frametype]
+                    set requested_ft_header [tcl::dict::get $o_opts_table -frametype_header]
+                    set requested_ft_body   [tcl::dict::get $o_opts_table -frametype_body]
                     set ft $requested_ft
                     set ft_header $requested_ft_header 
                     set ft_body $requested_ft_body 
@@ -383,17 +387,17 @@ namespace eval textblock {
                             }
                         }
                     }
-                    return [dict create header $ft_header body $ft_body]
+                    return [tcl::dict::create header $ft_header body $ft_body]
                 }
                 method Set_effective_framelimits {} {
                     upvar ::textblock::class::opts_table_defaults tdefaults
-                    set default_blims [dict get $tdefaults -framelimits_body]
-                    set default_hlims [dict get $tdefaults -framelimits_header]
-                    set eff_blims [dict get $o_opts_table_effective -framelimits_body]
-                    set eff_hlims [dict get $o_opts_table_effective -framelimits_header]
+                    set default_blims [tcl::dict::get $tdefaults -framelimits_body]
+                    set default_hlims [tcl::dict::get $tdefaults -framelimits_header]
+                    set eff_blims [tcl::dict::get $o_opts_table_effective -framelimits_body]
+                    set eff_hlims [tcl::dict::get $o_opts_table_effective -framelimits_header]
 
-                    set requested_blims [dict get $o_opts_table -framelimits_body]
-                    set requested_hlims [dict get $o_opts_table -framelimits_header]
+                    set requested_blims [tcl::dict::get $o_opts_table -framelimits_body]
+                    set requested_hlims [tcl::dict::get $o_opts_table -framelimits_header]
                     set blims $eff_blims
                     set hlims $eff_hlims
                     switch -- $requested_blims {
@@ -419,7 +423,7 @@ namespace eval textblock {
                             set blims [lsort -unique $blims]
                         }
                     }
-                    dict set o_opts_table_effective -framelimits_body $blims
+                    tcl::dict::set o_opts_table_effective -framelimits_body $blims
                     switch -- $requested_hlims {
                         "default" {
                             set hlims $default_hlims
@@ -443,8 +447,8 @@ namespace eval textblock {
                             set hlims [lsort -unique $hlims]
                         }
                     }
-                    dict set o_opts_table_effective -framelimits_header $hlims
-                    return [dict create body $blims header $hlims]
+                    tcl::dict::set o_opts_table_effective -framelimits_header $hlims
+                    return [tcl::dict::create body $blims header $hlims]
                 }
                 method configure args {
                     if {![llength $args]} {
@@ -454,36 +458,36 @@ namespace eval textblock {
                         if {[lindex $args 0] in [list %topt_keys%]} {
                             #query single option
                             set k [lindex $args 0]
-                            set val [dict get $o_opts_table $k]
-                            set returndict [dict create option $k value $val ansireset "\x1b\[m"]
-                            set infodict [dict create]
+                            set val [tcl::dict::get $o_opts_table $k]
+                            set returndict [tcl::dict::create option $k value $val ansireset "\x1b\[m"]
+                            set infodict [tcl::dict::create]
                             switch -- $k {
                                 -ansibase_header - -ansibase_body - -ansiborder_header - -ansiborder_body - -ansiborder_footer  {
-                                    dict set infodict debug [ansistring VIEW $val]
+                                    tcl::dict::set infodict debug [ansistring VIEW $val]
                                 }
                                 -framemap_body - -framemap_header - -framelimits_body - -framelimits_header {
-                                    dict set returndict effective [dict get $o_opts_table_effective $k] 
+                                    tcl::dict::set returndict effective [tcl::dict::get $o_opts_table_effective $k] 
                                 }
                             }
-                            dict set returndict info $infodict
+                            tcl::dict::set returndict info $infodict
                             return $returndict
-                            #return [dict create option $k value $val ansireset "\x1b\[m" info $infodict]
+                            #return [tcl::dict::create option $k value $val ansireset "\x1b\[m" info $infodict]
                         } else {
-                            error "textblock::table configure - unrecognised option '[lindex $args 0]'. Known values [dict keys $o_opts_table_defaults]"
+                            error "textblock::table configure - unrecognised option '[lindex $args 0]'. Known values [tcl::dict::keys $o_opts_table_defaults]"
                         }
                     }
                     if {[llength $args] %2 != 0} {
-                        error "[namespace current]::table configure - unexpected argument count. Require name value pairs"
+                        error "[tcl::namespace::current]::table configure - unexpected argument count. Require name value pairs"
                     }
                     foreach {k v} $args {
                         switch -- $k {
                             %topt_switchkeys% {}
                             default {
-                                error "[namespace current]::table configure - unrecognised option '$k'. Known values [dict keys $o_opts_table_defaults]"
+                                error "[tcl::namespace::current]::table configure - unrecognised option '$k'. Known values [tcl::dict::keys $o_opts_table_defaults]"
                             }
                         }
-                        #if {$k ni [dict keys $o_opts_table_defaults]} {
-                        #    error "[namespace current]::table configure - unrecognised option '$k'. Known values [dict keys $o_opts_table_defaults]"
+                        #if {$k ni [tcl::dict::keys $o_opts_table_defaults]} {
+                        #    error "[tcl::namespace::current]::table configure - unrecognised option '$k'. Known values [tcl::dict::keys $o_opts_table_defaults]"
                         #}
                     }
                     set checked_opts [list]
@@ -511,25 +515,29 @@ namespace eval textblock {
                             }
                             -framemap_body - -framemap_header {
                                 #upvar ::textblock::class::opts_table_defaults tdefaults
-                                #set default_bmap [dict get $tdefaults -framemap_body]
+                                #set default_bmap [tcl::dict::get $tdefaults -framemap_body]
                                 #todo - check keys and map 
                                 if {[llength $v] == 1} {
                                     if {$v eq "default"} {
                                         upvar ::textblock::class::opts_table_defaults tdefaults
-                                        set default_map [dict get $tdefaults $k]
+                                        set default_map [tcl::dict::get $tdefaults $k]
                                         lappend checked_opts $k $default_map
                                     } else {
                                         error "textblock::table::configure invalid $k value $v. Expected the value 'default' or a dict e.g topleft {hl *}"
                                     }
                                 } else {
-                                    dict for {subk subv} $v {
+                                    #safe jumptable test
+                                    #dict for {subk subv} $v {}
+                                    foreach {subk subv} $v {
                                         switch -- $subk {
                                             topleft - topinner - topright - topsolo - middleleft - middleinner - middleright - middlesolo - bottomleft - bottominner - bottomright - bottomsolo - onlyleft - onlyinner - onlyright - onlysolo {}
                                             default {
                                                 error "textblock::table::configure invalid $subk. Known values {topleft topinner topright topsolo middleleft middleinner middleright middlesolo bottomleft bottominner bottomright bottomsolo onlyleft onlyinner onlyright onlysolo}" 
                                             }
                                         }
-                                        dict for {seg subst} $subv {
+                                        #safe jumptable test
+                                        #dict for {seg subst} $subv {}
+                                        foreach {seg subst} $subv {
                                             switch -- $seg {
                                                 hl - hlt - hlb - vl - vll - vlr - trc - tlc - blc - brc {}
                                                 default {
@@ -575,14 +583,14 @@ namespace eval textblock {
                                 }
                             }
                             -show_hseps {
-                                if {![string is boolean $v]} {
+                                if {![tcl::string::is boolean $v]} {
                                     error "textblock::table::configure invalid $k '$v'. Must be a boolean or empty string" 
                                 }
                                 lappend checked_opts $k $v
                                 #these don't affect column width calculations
                             }
                             -show_edge {
-                                if {![string is boolean $v]} {
+                                if {![tcl::string::is boolean $v]} {
                                     error "textblock::table::configure invalid $k '$v'. Must be a boolean or empty string" 
                                 }
                                 lappend checked_opts $k $v
@@ -591,7 +599,7 @@ namespace eval textblock {
                             }
                             -show_vseps {
                                 #we allow empty string - so don't use -strict boolean check
-                                if {![string is boolean $v]} {
+                                if {![tcl::string::is boolean $v]} {
                                     error "textblock::table::configure invalid $k '$v'. Must be a boolean or empty string" 
                                 }
                                 #affects width calculations
@@ -609,7 +617,7 @@ namespace eval textblock {
                     }
                     #all options checked - ok to update o_opts_table and o_opts_table_effective
 
-                    #set o_opts_table [dict merge $o_opts_table $checked_opts]
+                    #set o_opts_table [tcl::dict::merge $o_opts_table $checked_opts]
                     foreach {k v} $args {
                         switch -- $k {
                             -framemap_header - -framemap_body {
@@ -617,43 +625,46 @@ namespace eval textblock {
                                 #e.g configure -framemaps {topleft <map>}
                                 #needs to merge with existing unspecified keys such as topright middleleft etc.
                                 if {$v eq "default"} {
-                                    dict set o_opts_table $k default
+                                    tcl::dict::set o_opts_table $k default
                                 } else {
-                                    if {[dict get $o_opts_table $k] eq "default"} {
-                                        dict set o_opts_table $k $v
+                                    if {[tcl::dict::get $o_opts_table $k] eq "default"} {
+                                        tcl::dict::set o_opts_table $k $v
                                     } else {
-                                        dict set o_opts_table $k [dict merge [dict get $o_opts_table $k] $v]
+                                        tcl::dict::set o_opts_table $k [tcl::dict::merge [tcl::dict::get $o_opts_table $k] $v]
                                     }
                                 }
                             }
                             default {
-                                dict set o_opts_table $k $v
+                                tcl::dict::set o_opts_table $k $v
                             }
                         }
                     }
                     #use values from checked_opts for the effective opts
-                    dict for {k v} $checked_opts {
+                    #safe jumptable test
+                    #dict for {k v} $checked_opts {}
+                    #foreach {k v} $checked_opts {}
+                    tcl::dict::for {k v} $checked_opts {
                         switch -- $k {
                             -framemap_body - -framemap_header {
-                                set existing [dict get $o_opts_table_effective $k]
+                                set existing [tcl::dict::get $o_opts_table_effective $k]
                                 #set updated $existing
                                 #dict for {subk subv} $v {
-                                #    dict set updated $subk $subv
+                                #    tcl::dict::set updated $subk $subv
                                 #}
-                                #dict set o_opts_table_effective $k $updated
-                                dict set o_opts_table_effective $k [dict merge $existing $v]
+                                #tcl::dict::set o_opts_table_effective $k $updated
+                                tcl::dict::set o_opts_table_effective $k [tcl::dict::merge $existing $v]
                             }
                             -framelimits_body - -framelimits_header {
                                 #my Set_effective_framelimits
-                                dict set o_opts_table_effective $k $v
+                                tcl::dict::set o_opts_table_effective $k $v
                             }
                             default {
-                                dict set o_opts_table_effective $k $v
+                                tcl::dict::set o_opts_table_effective $k $v
                             }
                         }
                     }
                     #ansireset exception
-                    dict set o_opts_table -ansireset [dict get $o_opts_table_effective -ansireset] 
+                    tcl::dict::set o_opts_table -ansireset [tcl::dict::get $o_opts_table_effective -ansireset] 
                     return $o_opts_table
                 }
 
@@ -685,9 +696,9 @@ namespace eval textblock {
                     }  else {
                         set m [struct::matrix $cmd]
                     }
-                    $m add columns [dict size $o_columndata]
-                    $m add rows [dict size $o_rowdefs]
-                    dict for {k v} $o_columndata { 
+                    $m add columns [tcl::dict::size $o_columndata]
+                    $m add rows [tcl::dict::size $o_rowdefs]
+                    tcl::dict::for {k v} $o_columndata { 
                         $m set column $k $v 
                     }
                     return $m
@@ -698,36 +709,36 @@ namespace eval textblock {
 
 
                     if {[llength $args] %2 != 0} {
-                        error "[namespace current]::table::add_column unexpected argument count. Require name value pairs. Known options: %copt_keys%"
+                        error "[tcl::namespace::current]::table::add_column unexpected argument count. Require name value pairs. Known options: %copt_keys%"
                     }
                     set opts $o_opts_column_defaults
                     foreach {k v} $args {
                         switch -- $k {
                             %copt_switchkeys% {
-                                dict set opts $k $v
+                                tcl::dict::set opts $k $v
                             }
                             default {
-                                error "[namespace current]::table::add_column unknown option '$k'. Known options: %copt_keys%"
+                                error "[tcl::namespace::current]::table::add_column unknown option '$k'. Known options: %copt_keys%"
                             }
                         }
                     }
-                    set colcount [dict size $o_columndefs] 
+                    set colcount [tcl::dict::size $o_columndefs] 
 
 
-                    dict set o_columndata $colcount [list]
-                    #dict set o_columndefs $colcount $defaults ;#ensure record exists 
-                    dict set o_columndefs $colcount $o_opts_column_defaults ;#ensure record exists 
+                    tcl::dict::set o_columndata $colcount [list]
+                    #tcl::dict::set o_columndefs $colcount $defaults ;#ensure record exists 
+                    tcl::dict::set o_columndefs $colcount $o_opts_column_defaults ;#ensure record exists 
 
 
-                    dict set o_columnstates $colcount [dict create minwidthbodyseen 0 maxwidthbodyseen 0 maxwidthheaderseen 0]
+                    tcl::dict::set o_columnstates $colcount [tcl::dict::create minwidthbodyseen 0 maxwidthbodyseen 0 maxwidthheaderseen 0]
                     set prev_calculated_column_widths $o_calculated_column_widths
                     if {[catch { 
                         my configure_column $colcount {*}$opts
                     } errMsg]} {
                         #configure failed - ensure o_columndata and o_columndefs entries are removed
-                        dict unset o_columndata $colcount
-                        dict unset o_columndefs $colcount
-                        dict unset o_columnstates $colcount
+                        tcl::dict::unset o_columndata $colcount
+                        tcl::dict::unset o_columndefs $colcount
+                        tcl::dict::unset o_columnstates $colcount
                         #undo cache invalidation
                         set o_calculated_column_widths $prev_calculated_column_widths
                         error "add_column failed to configure with supplied options $opts. Err:\n$errMsg" 
@@ -738,38 +749,38 @@ namespace eval textblock {
                     if {$numrows > 0} {
                         #fill column with default values
                         #puts ">>> adding default values for column $colcount"
-                        set dval [dict get $opts -defaultvalue]
+                        set dval [tcl::dict::get $opts -defaultvalue]
                         set width [textblock::width $dval]
-                        dict set o_columndata $colcount [lrepeat $numrows $dval]
-                        dict set o_columnstates $colcount maxwidthbodyseen $width
-                        dict set o_columnstates $colcount minwidthbodyseen $width
+                        tcl::dict::set o_columndata $colcount [lrepeat $numrows $dval]
+                        tcl::dict::set o_columnstates $colcount maxwidthbodyseen $width
+                        tcl::dict::set o_columnstates $colcount minwidthbodyseen $width
                     }
                     return $colcount
                 }
                 method column_count {} {
-                    return [dict size $o_columndefs]
+                    return [tcl::dict::size $o_columndefs]
                 }
                 method configure_column {index_expression args} {
-                    set cidx [lindex [dict keys $o_columndefs] $index_expression]
+                    set cidx [lindex [tcl::dict::keys $o_columndefs] $index_expression]
                     if {$cidx eq ""} {
                         error "textblock::table::configure_column - no column defined at index '$cidx'.Use add_column to define columns"
                     } 
                     if {![llength $args]} {
-                        return [dict get $o_columndefs $cidx]
+                        return [tcl::dict::get $o_columndefs $cidx]
                     } else {
                         if {[llength $args] == 1} {
                             if {[lindex $args 0] in [list %copt_keys%]} {
                                 #query single option
                                 set k [lindex $args 0]
-                                set val [dict get $o_columndefs $cidx $k]
-                                set returndict [dict create option $k value $val ansireset "\x1b\[m"]
-                                set infodict [dict create]
+                                set val [tcl::dict::get $o_columndefs $cidx $k]
+                                set returndict [tcl::dict::create option $k value $val ansireset "\x1b\[m"]
+                                set infodict [tcl::dict::create]
                                 switch -- $k {
                                     -ansibase {
-                                        dict set infodict debug [ansistring VIEW $val]
+                                        tcl::dict::set infodict debug [ansistring VIEW $val]
                                     }
                                 }
-                                dict set returndict info $infodict
+                                tcl::dict::set returndict info $infodict
                                 return $returndict
                             } else {
                                 error "textblock::table configure_column - unrecognised option '[lindex $args 0]'. Known values %copt_keys%"
@@ -782,14 +793,14 @@ namespace eval textblock {
                             switch -- $k {
                                 %copt_switchkeys% {}
                                 default {
-                                    error "[namespace current]::table configure_column unknown option '$k'. Known options: %copt_keys%"
+                                    error "[tcl::namespace::current]::table configure_column unknown option '$k'. Known options: %copt_keys%"
                                 }
                             }
                         }
-                        set checked_opts [dict get $o_columndefs $cidx] ;#copy of current state
+                        set checked_opts [tcl::dict::get $o_columndefs $cidx] ;#copy of current state
 
                         set hstates $o_headerstates ;#operate on a copy 
-                        set colstate [dict get $o_columnstates $cidx]
+                        set colstate [tcl::dict::get $o_columnstates $cidx]
                         set args_got_headers 0
                         set args_got_header_colspans 0
                         foreach {k v} $args {
@@ -804,22 +815,22 @@ namespace eval textblock {
                                         lassign [textblock::size $hdr] _w this_header_width _h this_header_height
 
                                         if {$this_header_height >= $currentmax} {
-                                            dict set hstates $i maxheightseen $this_header_height
+                                            tcl::dict::set hstates $i maxheightseen $this_header_height
                                         } else {
-                                            dict set hstates $i maxheightseen $currentmax
+                                            tcl::dict::set hstates $i maxheightseen $currentmax
                                         }
                                         if {$this_header_width >= $maxseen} {
                                             set maxseen $this_header_width
                                         }
-                                        #if {$this_header_width > [dict get $colstate maxwidthheaderseen]} {
-                                        #    dict set colstate maxwidthheaderseen $this_header_width
+                                        #if {$this_header_width > [tcl::dict::get $colstate maxwidthheaderseen]} {
+                                        #    tcl::dict::set colstate maxwidthheaderseen $this_header_width
                                         #}
                                         incr i
                                     }
-                                    dict set colstate maxwidthheaderseen $maxseen
+                                    tcl::dict::set colstate maxwidthheaderseen $maxseen
                                     #review - we could avoid some recalcs if we check current width range compared to previous
                                     set o_calculated_column_widths [list] ;#invalidate cached column widths - a recalc will be forced when needed
-                                    dict set checked_opts $k $v
+                                    tcl::dict::set checked_opts $k $v
                                 }
                                 -header_colspans {
                                     set args_got_header_colspans 1
@@ -828,12 +839,12 @@ namespace eval textblock {
                                     #note that 'all' represents span all up to the next non-zero defined colspan.
                                     set cspans [my header_colspans]
                                     set h 0
-                                    if {[llength $v] > [dict size $cspans]} {
-                                        error "configure_column $cidx -header_colspans. Only [dict size $cspans] headers exist. Too many values supplied"
+                                    if {[llength $v] > [tcl::dict::size $cspans]} {
+                                        error "configure_column $cidx -header_colspans. Only [tcl::dict::size $cspans] headers exist. Too many values supplied"
                                     }
                                     foreach s $v {
                                         if {$cidx == 0} {
-                                            if {[string is integer -strict $s]} {
+                                            if {[tcl::string::is integer -strict $s]} {
                                                 if {$s < 1} {
                                                     error "configure_column $cidx -header_colspans bad first value '$s' for header '$h' . First column cannot have span less than 1. use 'all' or a positive integer"
                                                 }
@@ -843,12 +854,12 @@ namespace eval textblock {
                                                 }
                                             }
                                         } else {
-                                            #if {![string is integer -strict $s]} {
+                                            #if {![tcl::string::is integer -strict $s]} {
                                             #    if {$s ne "all" && $s ne ""} {
                                             #        error "configure_column $cidx -header_colspans unrecognised value '$s' for header '$h' - must be a positive integer or the keyword 'all'"
                                             #    }
                                             #} else {
-                                                set header_spans [dict get $cspans $h]
+                                                set header_spans [tcl::dict::get $cspans $h]
                                                 set remaining [lindex $header_spans 0] 
                                                 if {$remaining ne "all"} {
                                                     incr remaining -1
@@ -894,15 +905,15 @@ namespace eval textblock {
                                     }
                                     #todo - avoid recalc if no change
                                     set o_calculated_column_widths [list] ;#invalidate cached column widths - a recalc will be forced when needed
-                                    dict set checked_opts $k $v
+                                    tcl::dict::set checked_opts $k $v
                                 }
                                 -minwidth {
                                     set o_calculated_column_widths [list] ;#invalidate cached column widths - a recalc will be forced when needed
-                                    dict set checked_opts $k $v
+                                    tcl::dict::set checked_opts $k $v
                                 }
                                 -maxwidth {
                                     set o_calculated_column_widths [list] ;#invalidate cached column widths - a recalc will be forced when needed
-                                    dict set checked_opts $k $v
+                                    tcl::dict::set checked_opts $k $v
                                 }
                                 -ansibase {
                                     set parts [punk::ansi::ta::split_codes_single $v] ;#caller may have supplied separated codes eg "[a+ Yellow][a+ red]"
@@ -917,11 +928,11 @@ namespace eval textblock {
                                         }
                                     }
                                     set col_ansibase [punk::ansi::codetype::sgr_merge_singles $col_ansibase_items]
-                                    dict set checked_opts $k $col_ansibase
+                                    tcl::dict::set checked_opts $k $col_ansibase
                                 }
                                 -ansireset {
                                     if {$v eq "\uFFEF"} {
-                                        dict set checked_opts $k "\x1b\[m" ;# [a]
+                                        tcl::dict::set checked_opts $k "\x1b\[m" ;# [a]
                                     } else {
                                         error "textblock::table::configure_column -ansireset is read-only. It is present only to prevent unwanted colourised output in configure commands"
                                     }
@@ -929,35 +940,35 @@ namespace eval textblock {
                                 -blockalign - -textalign {
                                     switch -- $v {
                                         left - right {
-                                            dict set checked_opts $k $v
+                                            tcl::dict::set checked_opts $k $v
                                         }
                                         centre - centre {
-                                            dict set checked_opts $k centre
+                                            tcl::dict::set checked_opts $k centre
                                         }
                                     }
                                 }
                                 default {
-                                    dict set checked_opts $k $v
+                                    tcl::dict::set checked_opts $k $v
                                 }
                             }
                         }
                         #args checked - ok to update headerstates  and columndefs and columnstates
-                        dict set o_columndefs $cidx $checked_opts
+                        tcl::dict::set o_columndefs $cidx $checked_opts
 
                         set o_headerstates $hstates 
-                        dict set o_columnstates $cidx $colstate
+                        tcl::dict::set o_columnstates $cidx $colstate
 
                         if {$args_got_headers} {
                             #if the headerlist length for this column has shrunk,and it was the longest - we may now have excess entries in o_headerstates
                             set zero_heights [list]
-                            dict for {hidx _v} $o_headerstates {
+                            tcl::dict::for {hidx _v} $o_headerstates {
                                 #pass empty string for exclude_column so we don't exclude our own column
                                 if {[my header_height_calc $hidx ""] == 0} {
                                     lappend zero_heights $hidx
                                 }
                             }
                             foreach zidx $zero_heights {
-                                dict unset o_headerstates $zidx
+                                tcl::dict::unset o_headerstates $zidx
                             }
                         }
                         if {$args_got_headers || $args_got_header_colspans} {
@@ -965,24 +976,24 @@ namespace eval textblock {
 
                         }
 
-                        return [dict get $o_columndefs $cidx]
+                        return [tcl::dict::get $o_columndefs $cidx]
                     }
                 }
 
                 method header_count {} {
-                    return [dict size $o_headerstates]
+                    return [tcl::dict::size $o_headerstates]
                 }
                 method header_count_calc {} {
                     set max_headers 0
-                    dict for {k cdef} $o_columndefs {
-                        set num_headers [llength [dict get $cdef -headers]]
+                    tcl::dict::for {k cdef} $o_columndefs {
+                        set num_headers [llength [tcl::dict::get $cdef -headers]]
                         set max_headers [expr {max($max_headers,$num_headers)}]
                     }
                     return $max_headers
                 }
                 method header_height {header_index} {
-                    set idx [lindex [dict keys $o_headerstates $header_index]]
-                    return [dict get $o_headerstates $idx maxheightseen]
+                    set idx [lindex [tcl::dict::keys $o_headerstates $header_index]]
+                    return [tcl::dict::get $o_headerstates $idx maxheightseen]
                 }
 
                 #review - use maxwidth (considering colspans) of each column to determine height after wrapping
@@ -992,13 +1003,13 @@ namespace eval textblock {
                     if {$exclude_column eq ""} {
                         set exclude_colidx ""
                     } else {
-                        set exclude_colidx [lindex [dict keys $o_columndefs] $exclude_column]
+                        set exclude_colidx [lindex [tcl::dict::keys $o_columndefs] $exclude_column]
                     }
-                    dict for {cidx cdef} $o_columndefs {
+                    tcl::dict::for {cidx cdef} $o_columndefs {
                         if {$exclude_colidx == $cidx} {
                             continue
                         }
-                        set headerlist [dict get $cdef -headers]
+                        set headerlist [tcl::dict::get $cdef -headers]
                         if {$header_index < [llength $headerlist]} {
                             set this_height [textblock::height [lindex $headerlist $header_index]]
                             set dataheight [expr {max($dataheight,$this_height)}]
@@ -1013,10 +1024,10 @@ namespace eval textblock {
                 #
                 method header_colspans {} {
                     set num_headers [my header_count_calc]
-                    set colspans_by_header [dict create]
-                    dict for {cidx cdef} $o_columndefs {
-                        set headerlist [dict get $cdef -headers]
-                        set colspans_for_column   [dict get $cdef -header_colspans]
+                    set colspans_by_header [tcl::dict::create]
+                    tcl::dict::for {cidx cdef} $o_columndefs {
+                        set headerlist [tcl::dict::get $cdef -headers]
+                        set colspans_for_column   [tcl::dict::get $cdef -header_colspans]
                         for {set h 0} {$h < $num_headers} {incr h} {
                             set headerspans [punk::lib::dict_getdef $colspans_by_header $h [list]]
                             set defined_span [lindex $colspans_for_column $h] 
@@ -1050,7 +1061,7 @@ namespace eval textblock {
                             } else {
                                 lappend headerspans $defined_span
                             }
-                            dict set colspans_by_header $h $headerspans 
+                            tcl::dict::set colspans_by_header $h $headerspans 
                         }
                     }
                     return $colspans_by_header
@@ -1062,7 +1073,7 @@ namespace eval textblock {
                     #It can also be set column by column - but it is much easier (especially for colspans) to configure them on a header-row basis
                     #e.g o_headerstates: 0 {maxheightseen 1} 1 {maxheightseen 2}
                     set num_headers [my header_count_calc]
-                    set hidx [lindex [dict keys $o_headerstates] $index_expression]
+                    set hidx [lindex [tcl::dict::keys $o_headerstates] $index_expression]
                     if {$hidx eq ""} {
                         error "textblock::table::configure_header - no row defined at index '$hidx'."
                     }
@@ -1073,68 +1084,70 @@ namespace eval textblock {
 
                     if {![llength $args]} {
                         set colspans_by_header [my header_colspans] 
-                        set result [dict create]
-                        dict set result -colspans [dict get $colspans_by_header $hidx]
+                        set result [tcl::dict::create]
+                        tcl::dict::set result -colspans [tcl::dict::get $colspans_by_header $hidx]
                         set header_row_items [list]
-                        dict for {cidx cdef} $o_columndefs {
-                            set colheaders [dict get $cdef -headers]
+                        tcl::dict::for {cidx cdef} $o_columndefs {
+                            set colheaders [tcl::dict::get $cdef -headers]
                             set relevant_header [lindex $colheaders $hidx]
                             #The -headers element of the column def is allowed to have less elements than the total, even be empty. Number of headers is defined by the longest -header list in the set of columns
                             lappend header_row_items $relevant_header ;#may be empty string because column had nothing at that index, or may be empty string stored in that column. We don't differentiate. 
                         }
-                        dict set result -values $header_row_items 
+                        tcl::dict::set result -values $header_row_items 
                         return $result
                     }
                     if {[llength $args] == 1} {
-                        if {[lindex $args 0] in [dict keys $o_opts_header_defaults]} {
+                        if {[lindex $args 0] in [tcl::dict::keys $o_opts_header_defaults]} {
                             #query single option
                             set k [lindex $args 0]
-                            #set val [dict get $o_rowdefs $ridx $k]
+                            #set val [tcl::dict::get $o_rowdefs $ridx $k]
 
-                            set infodict [dict create]
+                            set infodict [tcl::dict::create]
                             switch -- $k {
                                 -values {
                                     set header_row_items [list]
-                                    dict for {cidx cdef} $o_columndefs {
-                                        set colheaders [dict get $cdef -headers]
+                                    tcl::dict::for {cidx cdef} $o_columndefs {
+                                        set colheaders [tcl::dict::get $cdef -headers]
                                         set relevant_header [lindex $colheaders $hidx]
                                         #The -headers element of the column def is allowed to have less elements than the total, even be empty. Number of headers is defined by the longest -header list in the set of columns
                                         lappend header_row_items $relevant_header ;#may be empty string because column had nothing at that index, or may be empty string stored in that column. We don't differentiate. 
 
                                     }
                                     set val $header_row_items 
-                                    set returndict [dict create option $k value $val ansireset "\x1b\[m"]
+                                    set returndict [tcl::dict::create option $k value $val ansireset "\x1b\[m"]
                                 }
                                 -colspans {
                                     set colspans_by_header [my header_colspans] 
-                                    set result [dict create]
-                                    set val [dict get $colspans_by_header $hidx]
-                                    set returndict [dict create option $k value $val ansireset "\x1b\[m"]
+                                    set result [tcl::dict::create]
+                                    set val [tcl::dict::get $colspans_by_header $hidx]
+                                    set returndict [tcl::dict::create option $k value $val ansireset "\x1b\[m"]
                                 }
                                 -ansibase {
                                     set val ???
-                                    set returndict [dict create option $k value $val ansireset "\x1b\[m"]
-                                    dict set infodict debug [ansistring VIEW $val]
+                                    set returndict [tcl::dict::create option $k value $val ansireset "\x1b\[m"]
+                                    tcl::dict::set infodict debug [ansistring VIEW $val]
                                 }
                             }
-                            dict set returndict info $infodict
+                            tcl::dict::set returndict info $infodict
                             return $returndict
-                            #return [dict create option $k value $val ansireset "\x1b\[m" info $infodict]
+                            #return [tcl::dict::create option $k value $val ansireset "\x1b\[m" info $infodict]
                         } else {
-                            error "textblock::table configure_header - unrecognised option '[lindex $args 0]'. Known values [dict keys $o_opts_header_defaults]"
+                            error "textblock::table configure_header - unrecognised option '[lindex $args 0]'. Known values [tcl::dict::keys $o_opts_header_defaults]"
                         }
                     }
                     if {[llength $args] %2 != 0} {
-                        error "textblock::table configure_header incorrect number of options following index_expression. Require name value pairs. Known options: [dict keys $o_opts_header_defaults]"
+                        error "textblock::table configure_header incorrect number of options following index_expression. Require name value pairs. Known options: [tcl::dict::keys $o_opts_header_defaults]"
                     }
-                    dict for {k v} $args {
-                        if {$k ni [dict keys $o_opts_header_defaults]} {
-                            error "[namespace current]::table configure_row unknown option '$k'. Known options: [dict keys $o_opts_header_defaults]"
+                    foreach {k v} $args {
+                        if {$k ni [tcl::dict::keys $o_opts_header_defaults]} {
+                            error "[tcl::namespace::current]::table configure_row unknown option '$k'. Known options: [tcl::dict::keys $o_opts_header_defaults]"
                         }
                     }
 
                     set checked_opts [list]
-                    dict for {k v} $args {
+                    #safe jumptable test
+                    #dict for {k v} $args {}
+                    foreach {k v} $args {
                         switch -- $k {
                             -ansibase {
                                 set parts [punk::ansi::ta::split_codes_single $v] ;#caller may have supplied separated codes eg "[a+ Yellow][a+ red]"
@@ -1160,18 +1173,18 @@ namespace eval textblock {
                                 }
                             }
                             -values {
-                                if {[llength $v] > [dict size $o_columndefs]} {
-                                    error "textblock::table::configure_header -values length ([llength $v]) is longer than number of columns ([dict size $o_columndefs])"
+                                if {[llength $v] > [tcl::dict::size $o_columndefs]} {
+                                    error "textblock::table::configure_header -values length ([llength $v]) is longer than number of columns ([tcl::dict::size $o_columndefs])"
                                 }
                                 lappend checked_opts $k $v
                             }
                             -colspans {
-                                set numcols [dict size $o_columndefs]
+                                set numcols [tcl::dict::size $o_columndefs]
                                 if {[llength $v] > $numcols} {
-                                    error "textblock::table::configure_header -colspans length ([llength $v]) is longer than number of columns ([dict size $o_columndefs])"
+                                    error "textblock::table::configure_header -colspans length ([llength $v]) is longer than number of columns ([tcl::dict::size $o_columndefs])"
                                 }
                                 if {[llength $v] < $numcols} { 
-                                    puts stderr "textblock::table::configure_header warning - only [llength $v] spans specified for [dict size $o_columndefs] columns."
+                                    puts stderr "textblock::table::configure_header warning - only [llength $v] spans specified for [tcl::dict::size $o_columndefs] columns."
                                     puts stderr "It is recommended to set all spans explicitly. (auto-calc not implemented)"
                                 }
                                 if {[llength $v]} {
@@ -1179,7 +1192,7 @@ namespace eval textblock {
                                     set first_is_ok 0
                                     if {$firstspan eq "all"} {
                                         set first_is_ok 1
-                                    } elseif {[string is integer -strict $firstspan] && $firstspan > 0 && $firstspan <= $numcols} {
+                                    } elseif {[tcl::string::is integer -strict $firstspan] && $firstspan > 0 && $firstspan <= $numcols} {
                                         set first_is_ok 1
                                     }
                                     if {!$first_is_ok} {
@@ -1248,40 +1261,43 @@ namespace eval textblock {
                     }
 
                     #configured opts all good
-
-                    dict for {k v} $checked_opts {
+                    #safe jumptable test
+                    #dict for {k v} $checked_opts {}
+                    #foreach {k v} $checked_opts {}
+                    tcl::dict::for {k v} $checked_opts {
                         switch -- $k {
                             -values {
                                 set c 0
                                 foreach hval $v {
                                     #retrieve -headers from relevant col, insert at header index, and write back.
-                                    set colheaders [dict get $o_columndefs $c -headers]
-                                    set missing [expr {($hidx +1) - [llength $colheaders]}]
+                                    set thiscol_headers_vertical [tcl::dict::get $o_columndefs $c -headers]
+                                    set missing [expr {($hidx +1) - [llength $thiscol_headers_vertical]}]
                                     if {$missing > 0} {
-                                        lappend colheaders {*}[lrepeat $missing ""]
+                                        lappend thiscol_headers_vertical {*}[lrepeat $missing ""]
                                     }
-                                    lset colheaders $hidx $hval
-                                    dict set o_columndefs $c -headers $colheaders 
+                                    lset thiscol_headers_vertical $hidx $hval
+                                    tcl::dict::set o_columndefs $c -headers $thiscol_headers_vertical
                                     #invalidate column width cache
                                     set o_calculated_column_widths [list]
                                     # -- -- -- -- -- --
                                     #also update maxwidthseen & maxheightseen
                                     set i 0
                                     set maxwidthseen 0 
-                                    set maxheightseen 0
-                                    foreach hdr $colheaders {
+                                    #set maxheightseen 0
+                                    foreach hdr $thiscol_headers_vertical {
                                         lassign [textblock::size $hdr] _w this_header_width _h this_header_height
+                                        set maxheightseen [punk::lib::dict_getdef $o_headerstates $i maxheightseen 0]
                                         if {$this_header_height >= $maxheightseen} {
-                                            dict set o_headerstates $i maxheightseen $this_header_height
+                                            tcl::dict::set o_headerstates $i maxheightseen $this_header_height
                                         } else {
-                                            dict set o_headerstates $i maxheightseen $maxheightseen
+                                            tcl::dict::set o_headerstates $i maxheightseen $maxheightseen
                                         }
                                         if {$this_header_width >= $maxwidthseen} {
                                             set maxwidthseen $this_header_width
                                         }
                                         incr i
                                     }
-                                    dict set o_columnstates $c maxwidthheaderseen $maxwidthseen
+                                    tcl::dict::set o_columnstates $c maxwidthheaderseen $maxwidthseen
                                     # -- -- -- -- -- --
                                     incr c
                                 }
@@ -1290,7 +1306,7 @@ namespace eval textblock {
                                 #sequence has been verified above - we need to split it and store across columns 
                                 set c 0 ;#column index
                                 foreach span $v {
-                                    set colspans [dict get $o_columndefs $c -header_colspans]
+                                    set colspans [tcl::dict::get $o_columndefs $c -header_colspans]
                                     if {$hidx > [llength $colspans]-1} {
                                         set colspans_by_header [my header_colspans]
                                         #puts ">>>>>?$colspans_by_header"
@@ -1300,17 +1316,17 @@ namespace eval textblock {
                                         #use the header_colspans calculation to update only those entries necessary
                                         set spanlist [list]
                                         for {set h 0} {$h < $hidx} {incr h} {
-                                            set cspans [dict get $colspans_by_header $h]
+                                            set cspans [tcl::dict::get $colspans_by_header $h]
                                             set requiredval [lindex $cspans $c]
                                             lappend spanlist $requiredval
                                         }
-                                        dict set o_columndefs $c -header_colspans $spanlist
+                                        tcl::dict::set o_columndefs $c -header_colspans $spanlist
 
-                                        set colspans [dict get $o_columndefs $c -header_colspans]
+                                        set colspans [tcl::dict::get $o_columndefs $c -header_colspans]
                                     }
 
                                     lset colspans $hidx $span
-                                    dict set o_columndefs $c -header_colspans $colspans
+                                    tcl::dict::set o_columndefs $c -header_colspans $colspans
                                     incr c
                                 }
                             }
@@ -1321,17 +1337,17 @@ namespace eval textblock {
                 method add_row {valuelist args} {
                     #*** !doctools
                     #[call class::table [method add_row] [arg args]]
-                    if {[dict size $o_columndefs] > 0 && ([llength $valuelist] && [llength $valuelist] != [dict size $o_columndefs])} {
+                    if {[tcl::dict::size $o_columndefs] > 0 && ([llength $valuelist] && [llength $valuelist] != [tcl::dict::size $o_columndefs])} {
                         set msg ""
-                        append msg "add_row - invalid number ([llength $valuelist]) of values in row - Must match existing column count: [dict size $o_columndefs]" \n
+                        append msg "add_row - invalid number ([llength $valuelist]) of values in row - Must match existing column count: [tcl::dict::size $o_columndefs]" \n
                         append msg "rowdata: $valuelist"
                         error $msg
                     }
-                    if {[dict size $o_columndefs] == 0 && ![llength $valuelist]} {
+                    if {[tcl::dict::size $o_columndefs] == 0 && ![llength $valuelist]} {
                         error "add_row - no values supplied, and no columns defined, so cannot use default column values"
                     }
                     
-                    set defaults [dict create\
+                    set defaults [tcl::dict::create\
                         -minheight 1\
                         -maxheight ""\
                         -ansibase ""\
@@ -1340,20 +1356,22 @@ namespace eval textblock {
                     set o_opts_row_defaults $defaults 
 
                     if {[llength $args] %2 !=0} {
-                        error "[namespace current]::table::add_row unexpected argument count. Require name value pairs. Known options: [dict keys $defaults]"
+                        error "[tcl::namespace::current]::table::add_row unexpected argument count. Require name value pairs. Known options: [tcl::dict::keys $defaults]"
                     }
-                    dict for {k v} $args {
+                    #safe jumptable test
+                    #dict for {k v} $args {}
+                    foreach {k v} $args {
                         switch -- $k {
                             -minheight - -maxheight - -ansibase - -ansireset {}
                             default {
-                                error "Invalid option '$k' Known options: [dict keys $defaults] (-ansireset is read-only)"
+                                error "Invalid option '$k' Known options: [tcl::dict::keys $defaults] (-ansireset is read-only)"
                             }
                         }
                     }
-                    set opts [dict merge $defaults $args]
+                    set opts [tcl::dict::merge $defaults $args]
 
                     set auto_columns 0
-                    if {[dict size $o_columndefs] == 0} {
+                    if {[tcl::dict::size $o_columndefs] == 0} {
                         set auto_columns 1
                         #no columns defined - auto define with defaults for each column in first supplied row
                         #auto define columns only valid if no existing columns
@@ -1363,24 +1381,24 @@ namespace eval textblock {
                         }
                     } else {
                         if {![llength $valuelist]} {
-                            dict for {k coldef} $o_columndefs {
-                                lappend valuelist [dict get $coldef -defaultvalue]
+                            tcl::dict::for {k coldef} $o_columndefs {
+                                lappend valuelist [tcl::dict::get $coldef -defaultvalue]
                             }
                         }
                     }
-                    set rowcount [dict size $o_rowdefs]
-                    dict set o_rowdefs $rowcount $defaults ;# ensure record exists before configure 
+                    set rowcount [tcl::dict::size $o_rowdefs]
+                    tcl::dict::set o_rowdefs $rowcount $defaults ;# ensure record exists before configure 
 
                     if {[catch {
                         my configure_row $rowcount {*}$opts
                     } errMsg]} {
                         #undo anything we saved before configure_row
-                        dict unset o_rowdefs $rowcount
+                        tcl::dict::unset o_rowdefs $rowcount
                         #remove auto_columns  
                         if {$auto_columns} {
-                            set o_columndata [dict create]
-                            set o_columndefs [dict create]
-                            set o_columnstate [dict create]
+                            set o_columndata    [tcl::dict::create]
+                            set o_columndefs    [tcl::dict::create]
+                            set o_columnstate   [tcl::dict::create]
                         }
                         error "add_row failed to configure with supplied options $opts. Err:\n$errMsg" 
                     }
@@ -1389,75 +1407,75 @@ namespace eval textblock {
                     set c 0
                     set max_height_seen 1
                     foreach v $valuelist {
-                        set prev_maxwidth [dict get $o_columnstates $c maxwidthbodyseen]
-                        set prev_minwidth [dict get $o_columnstates $c minwidthbodyseen]
+                        set prev_maxwidth [tcl::dict::get $o_columnstates $c maxwidthbodyseen]
+                        set prev_minwidth [tcl::dict::get $o_columnstates $c minwidthbodyseen]
 
-                        dict lappend o_columndata $c $v
+                        tcl::dict::lappend o_columndata $c $v
                         set valheight [textblock::height $v] 
                         if {$valheight > $max_height_seen} {
                             set max_height_seen $valheight
                         }
                         set width [textblock::width $v]
-                        if {$width > [dict get $o_columnstates $c maxwidthbodyseen]} {
-                            dict set o_columnstates $c maxwidthbodyseen $width
+                        if {$width > [tcl::dict::get $o_columnstates $c maxwidthbodyseen]} {
+                            tcl::dict::set o_columnstates $c maxwidthbodyseen $width
                         }
-                        if {$width < [dict get $o_columnstates $c minwidthbodyseen]} {
-                            dict set o_columnstates $c minwidthbodyseen $width
+                        if {$width < [tcl::dict::get $o_columnstates $c minwidthbodyseen]} {
+                            tcl::dict::set o_columnstates $c minwidthbodyseen $width
                         }
 
-                        if {[dict get $o_columnstates $c maxwidthbodyseen] > $prev_maxwidth || [dict get $o_columnstates $c minwidthbodyseen] < $prev_minwidth} {
+                        if {[tcl::dict::get $o_columnstates $c maxwidthbodyseen] > $prev_maxwidth || [tcl::dict::get $o_columnstates $c minwidthbodyseen] < $prev_minwidth} {
                             #invalidate calculated column width cache if any new value was outside the previous range of widths
                             set o_calculated_column_widths [list]
                         }
                         incr c
                     }
 
-                    set opt_maxh [dict get $o_rowdefs $rowcount -maxheight]
+                    set opt_maxh [tcl::dict::get $o_rowdefs $rowcount -maxheight]
                     if {$opt_maxh ne ""} {
-                        dict set o_rowstates $rowcount -maxheight [expr {min($opt_maxh,$max_height_seen)}]
+                        tcl::dict::set o_rowstates $rowcount -maxheight [expr {min($opt_maxh,$max_height_seen)}]
                     } else {
-                        dict set o_rowstates $rowcount -maxheight $max_height_seen
+                        tcl::dict::set o_rowstates $rowcount -maxheight $max_height_seen
                     }
 
                     return $rowcount
                 }
                 method configure_row {index_expression args} {
-                    set ridx [lindex [dict keys $o_rowdefs] $index_expression]
+                    set ridx [lindex [tcl::dict::keys $o_rowdefs] $index_expression]
                     if {$ridx eq ""} {
                         error "textblock::table::configure_row - no row defined at index '$ridx'.Use add_row to define rows"
                     }
                     if {![llength $args]} {
-                        return [dict get $o_rowdefs $ridx]
+                        return [tcl::dict::get $o_rowdefs $ridx]
                     }
                     if {[llength $args] == 1} {
-                        if {[lindex $args 0] in [dict keys $o_opts_row_defaults]} {
+                        if {[lindex $args 0] in [tcl::dict::keys $o_opts_row_defaults]} {
                             #query single option
                             set k [lindex $args 0]
-                            set val [dict get $o_rowdefs $ridx $k]
-                            set returndict [dict create option $k value $val ansireset "\x1b\[m"]
-                            set infodict [dict create]
+                            set val [tcl::dict::get $o_rowdefs $ridx $k]
+                            set returndict [tcl::dict::create option $k value $val ansireset "\x1b\[m"]
+                            set infodict [tcl::dict::create]
                             switch -- $k {
                                 -ansibase {
-                                    dict set infodict debug [ansistring VIEW $val]
+                                    tcl::dict::set infodict debug [ansistring VIEW $val]
                                 }
                             }
-                            dict set returndict info $infodict
+                            tcl::dict::set returndict info $infodict
                             return $returndict
-                            #return [dict create option $k value $val ansireset "\x1b\[m" info $infodict]
+                            #return [tcl::dict::create option $k value $val ansireset "\x1b\[m" info $infodict]
                         } else {
-                            error "textblock::table configure_row - unrecognised option '[lindex $args 0]'. Known values [dict keys $o_opts_row_defaults]"
+                            error "textblock::table configure_row - unrecognised option '[lindex $args 0]'. Known values [tcl::dict::keys $o_opts_row_defaults]"
                         }
                     }
                     if {[llength $args] %2 != 0} {
-                        error "textblock::table configure_row incorrect number of options following index_expression. Require name value pairs. Known options: [dict keys $o_opts_row_defaults]"
+                        error "textblock::table configure_row incorrect number of options following index_expression. Require name value pairs. Known options: [tcl::dict::keys $o_opts_row_defaults]"
                     }
-                    dict for {k v} $args {
-                        if {$k ni [dict keys $o_opts_row_defaults]} {
-                            error "[namespace current]::table configure_row unknown option '$k'. Known options: [dict keys $o_opts_row_defaults]"
+                    foreach {k v} $args {
+                        if {$k ni [tcl::dict::keys $o_opts_row_defaults]} {
+                            error "[tcl::namespace::current]::table configure_row unknown option '$k'. Known options: [tcl::dict::keys $o_opts_row_defaults]"
                         }
                     }
                     set checked_opts [list]
-                    dict for {k v} $args {
+                    foreach {k v} $args {
                         switch -- $k {
                             -ansibase {
                                 set parts [punk::ansi::ta::split_codes_single $v] ;#caller may have supplied separated codes eg "[a+ Yellow][a+ red]"
@@ -1487,46 +1505,48 @@ namespace eval textblock {
                         }
                     }
 
-                    set current_opts [dict get $o_rowdefs $ridx]
-                    set opts [dict merge $current_opts $checked_opts]
+                    set current_opts [tcl::dict::get $o_rowdefs $ridx]
+                    set opts [tcl::dict::merge $current_opts $checked_opts]
 
                     #check minheight and maxheight together
-                    set opt_minh [dict get $opts -minheight]
-                    set opt_maxh [dict get $opts -maxheight]
-                    if {![string is integer $opt_minh] || ($opt_maxh ne "" && ![string is integer -strict $opt_maxh])} {
-                        error "[namespace current]::table::add_row error -minheight '$opt_minh' and -maxheight '$opt_maxh' must be integers greater than or equal to 1"
+                    set opt_minh [tcl::dict::get $opts -minheight]
+                    set opt_maxh [tcl::dict::get $opts -maxheight]
+
+                    #todo - allow zero values to hide/collapse rows as is possible with columns
+                    if {![tcl::string::is integer $opt_minh] || ($opt_maxh ne "" && ![tcl::string::is integer -strict $opt_maxh])} {
+                        error "[tcl::namespace::current]::table::configure_row error -minheight '$opt_minh' and -maxheight '$opt_maxh' must be integers greater than or equal to 1 (for now)"
                     }
                     if {$opt_minh < 1 || ($opt_maxh ne "" && $opt_maxh < 1)} {
-                        error "[namespace current]::table::add_row error -minheight '$opt_minh' and -maxheight '$opt_maxh' must both be 1 or greater"
+                        error "[tcl::namespace::current]::table::configure_row error -minheight '$opt_minh' and -maxheight '$opt_maxh' must both be 1 or greater (for now)"
                     }
                     if {$opt_maxh ne "" && $opt_maxh < $opt_minh} {
-                        error "[namespace current]::table::add_row error -maxheight '$opt_maxh' must greater than -minheight '$opt_minh'"
+                        error "[tcl::namespace::current]::table::configure_row error -maxheight '$opt_maxh' must greater than -minheight '$opt_minh'"
                     }
-                    dict set o_rowstates $ridx -minheight $opt_minh
+                    tcl::dict::set o_rowstates $ridx -minheight $opt_minh
 
 
-                    dict set o_rowdefs $ridx $opts
+                    tcl::dict::set o_rowdefs $ridx $opts
                 }
                 method row_count {} {
-                    return [dict size $o_rowdefs]
+                    return [tcl::dict::size $o_rowdefs]
                 }
                 method row_clear {} {
-                    set o_rowdefs   [dict create]
-                    set o_rowstates [dict create]
+                    set o_rowdefs   [tcl::dict::create]
+                    set o_rowstates [tcl::dict::create]
                     #The data values are stored by column regardless of whether added row by row
-                    dict for {cidx records} $o_columndata {
-                        dict set o_columndata $cidx [list]
+                    tcl::dict::for {cidx records} $o_columndata {
+                        tcl::dict::set o_columndata $cidx [list]
                         #reset only the body fields in o_columnstates
-                        dict set o_columnstates $cidx minwidthbodyseen 0
-                        dict set o_columnstates $cidx maxwidthbodyseen 0
+                        tcl::dict::set o_columnstates $cidx minwidthbodyseen 0
+                        tcl::dict::set o_columnstates $cidx maxwidthbodyseen 0
                     }
                     set o_calculated_column_widths [list]
                 }
                 method clear {} {
                     my row_clear
-                    set o_columndefs    [dict create]
-                    set o_columndata    [dict create]
-                    set o_columnstates  [dict create]
+                    set o_columndefs    [tcl::dict::create]
+                    set o_columndata    [tcl::dict::create]
+                    set o_columnstates  [tcl::dict::create]
                 }
 
 
@@ -1537,99 +1557,139 @@ namespace eval textblock {
                 #specify range with x..y
                 method Get_columns_by_indices {index_list} {
                     foreach spec $index_list {
-                        if {[string is integer -strict $c]} {
+                        if {[tcl::string::is integer -strict $c]} {
                             set colidx $c
                         } else {
-                            dict for {colidx coldef} $o_columndefs {
-                                #if {[string match x x]} {}
+                            tcl::dict::for {colidx coldef} $o_columndefs {
+                                #if {[tcl::string::match x x]} {}
                             }
                         }
                     }
                 }
                 method Get_boxlimits_and_joins {position fname_body} {
+                    #fname_body will be "custom" or one of the predefined types  light,heavy etc
+                    switch -- $position {
+                        left {
+                            return [tcl::dict::create \
+                                boxlimits       [list hlb blc vll]\
+                                boxlimits_top   [list hlb blc vll hlt tlc]\
+                                joins           [list down]\
+                                bodyjoins       [list down-$fname_body]\
+                            ]
+                        }
+                        inner {
+                            return [tcl::dict::create \
+                                boxlimits           [list hlb blc vll]\
+                                boxlimits_top       [list hlb blc vll hlt tlc]\
+                                joins               [list down left]\
+                                bodyjoins           [list left down-$fname_body]
+                            ]
+                        }
+                        right {
+                            return [tcl::dict::create \
+                                boxlimits           [list hlb blc vll vlr brc]\
+                                boxlimits_top       [list hlb blc vll vlr brc hlt tlc trc]\
+                                joins               [list down left]\
+                                bodyjoins           [list left down-$fname_body]\
+                            ]
+                        }
+                        solo {
+                            return [tcl::dict::create \
+                                boxlimits           [list hlb blc vll vlr brc]\
+                                boxlimits_top       [list hlb blc vll vlr brc hlt tlc trc]\
+                                joins               [list down]\
+                                bodyjoins           [list down-$fname_body]\
+                            ]
+                        }
+                        default {
+                            error "Get_boxlimits_and_joins unrecognised position '$position' expected: left inner right solo"
+                        }
+                    }
+                }
+                method Get_boxlimits_and_joins1 {position fname_body} {
                     #fname_body will be "custom" or one of the predefined types  light,heavy etc
                     switch -- $position {
                         left {
                             #set header_boxlimits {hlb hlt tlc blc vll}
-                            set header_body_joins [list down-$fname_body]
-                            set boxlimits_position {hlb blc vll}
-                            set boxlimits_toprow [concat $boxlimits_position {hlt tlc}]
-                            set joins {down}
+                            set header_body_joins   [list down-$fname_body]
+                            set boxlimits_position  [list hlb blc vll]
+                            #set boxlimits_toprow [concat $boxlimits_position {hlt tlc}]
+                            set boxlimits_toprow    [list hlb blc vll hlt tlc]
+                            set joins               [list down]
                         }
                         inner {
                             #set header_boxlimits {hlb hlt tlc blc vll}
-                            set header_body_joins [list left down-$fname_body]
-                            set boxlimits_position {hlb blc vll}
-                            set boxlimits_toprow [concat $boxlimits_position {hlt tlc}]
-                            set joins {down left}
+                            set header_body_joins   [list left down-$fname_body]
+                            set boxlimits_position  [list hlb blc vll]
+                            #set boxlimits_toprow [concat $boxlimits_position {hlt tlc}]
+                            set boxlimits_toprow    [list hlb blc vll hlt tlc]
+                            set joins               [list down left]
                         }
                         right {
                             #set header_boxlimits {hlb hlt tlc blc vll vlr trc brc}
-                            set header_body_joins [list left down-$fname_body]
-                            set boxlimits_position {hlb blc vll vlr brc}
-                            set boxlimits_toprow [concat $boxlimits_position {hlt tlc trc}]
-                            set joins {down left}
+                            set header_body_joins   [list left down-$fname_body]
+                            set boxlimits_position  [list hlb blc vll vlr brc]
+                            #set boxlimits_toprow [concat $boxlimits_position {hlt tlc trc}]
+                            set boxlimits_toprow    [list hlb blc vll vlr brc hlt tlc trc]
+                            set joins               [list down left]
                         }
                         solo {
                             #set header_boxlimits {hlb hlt tlc blc vll vlr trc brc}
-                            set header_body_joins [list down-$fname_body]
-                            set boxlimits_position   {hlb blc vll vlr brc}
-                            set boxlimits_toprow [concat $boxlimits_position {hlt tlc trc}]
-                            set joins {down}
+                            set header_body_joins   [list down-$fname_body]
+                            set boxlimits_position  [list hlb blc vll vlr brc]
+                            #set boxlimits_toprow    [concat $boxlimits_position {hlt tlc trc}]
+                            set boxlimits_toprow    [list hlb blc vll vlr brc hlt tlc trc]
+                            set joins               [list down]
                         }
                     }
-                    return [dict create boxlimits $boxlimits_position boxlimits_top $boxlimits_toprow joins $joins bodyjoins $header_body_joins ]
+                    return [tcl::dict::create boxlimits $boxlimits_position boxlimits_top $boxlimits_toprow joins $joins bodyjoins $header_body_joins ]
                 }
                 method get_column_by_index {index_expression args} {
-                    #puts "+++> get_column_by_index $index_expression $args [namespace current]"
+                    #puts "+++> get_column_by_index $index_expression $args [tcl::namespace::current]"
                     #index_expression may be something like end-1 or 2+2  - we can't directly use it as a lookup for dicts. 
-                    set opts [dict create\
+                    set opts [tcl::dict::create\
                         -position "inner"\
                         -return   "string"\
                     ]
-                    dict for {k v} $args {
+                    foreach {k v} $args {
                         switch -- $k {
                             -position - -return {
-                                dict set opts $k $v
+                                tcl::dict::set opts $k $v
                             }
                             default {
-                                error "[namespace current]::table::get_column_by_index error invalid option '$k'. Known options [dict keys $opts]"
+                                error "[tcl::namespace::current]::table::get_column_by_index error invalid option '$k'. Known options [tcl::dict::keys $opts]"
                             }
                         }
                     }
-                    set opt_posn    [dict get $opts -position]
-                    set opt_return  [dict get $opts -return]
+                    set opt_posn    [tcl::dict::get $opts -position]
+                    set opt_return  [tcl::dict::get $opts -return]
 
-                    set valid_positions [list left inner right solo]
                     switch -- $opt_posn {
                         left - inner - right - solo {}
                         default {
-                            error "[namespace current]::table::get_column_by_index error invalid value '$opt_posn' for -position. Valid values: $valid_positions"
+                            error "[tcl::namespace::current]::table::get_column_by_index error invalid value '$opt_posn' for -position. Valid values: [list left inner right solo]"
                         }
                     }
                     switch -- $opt_return {
                         string - dict {}
                         default {
-                            error "[namespace current]::table::get_column_by_index error invalid value '$opt_return' for -return. Valid values: string dict"
+                            error "[tcl::namespace::current]::table::get_column_by_index error invalid value '$opt_return' for -return. Valid values: string dict"
                         }
                     }
 
                     set columninfo [my get_column_cells_by_index $index_expression]
-                    set header_list [dict get $columninfo headers]
+                    set header_list [tcl::dict::get $columninfo headers]
                     #puts "===== header_list: $header_list"
-                    set cells [dict get $columninfo cells]
+                    set cells [tcl::dict::get $columninfo cells]
 
-                    set topt_show_header [dict get $o_opts_table -show_header]
+                    set topt_show_header [tcl::dict::get $o_opts_table -show_header]
                     if {$topt_show_header eq ""} {
-                        set allheaders ""
-                        set all_cols [dict keys $o_columndefs]
+                        set allheaders 0 
+                        set all_cols [tcl::dict::keys $o_columndefs]
                         foreach c $all_cols {
-                            set headerset [dict get $o_columndefs $c -headers]
-                            foreach hdr $headerset {
-                                append allheaders $hdr 
-                            }
+                            incr allheaders [llength [tcl::dict::get $o_columndefs $c -headers]]
                         }
-                        if {$allheaders eq ""} {
+                        if {$allheaders == 0} {
                             set do_show_header 0
                         } else {
                             set do_show_header 1
@@ -1637,7 +1697,7 @@ namespace eval textblock {
                     } else {
                         set do_show_header $topt_show_header
                     }
-                    set topt_show_footer [dict get $o_opts_table -show_footer]
+                    set topt_show_footer [tcl::dict::get $o_opts_table -show_footer]
 
 
                     set output ""
@@ -1652,107 +1712,77 @@ namespace eval textblock {
 
 
                     set ftypes [my Get_frametypes]
-                    set ftype_body [dict get $ftypes body]
+                    set ftype_body [tcl::dict::get $ftypes body]
                     if {[llength $ftype_body] >= 2} {
                         set fname_body "custom"
                     } else {
                         set fname_body $ftype_body
                     }
-                    set ftype_header [dict get $ftypes header]
+                    set ftype_header [tcl::dict::get $ftypes header]
                     if {[llength $ftype_header] >= 2} {
                         set fname_header "custom"
                     } else {
                         set fname_header $ftype_header
                     }
 
-                    switch -- $opt_posn {
-                        left {
-                            #set header_boxlimits {hlb hlt tlc blc vll}
-                            set header_body_joins [list down-$fname_body]
-                            set boxlimits_position {hlb blc vll}
-                            set boxlimits_toprow [concat $boxlimits_position {hlt tlc}]
-                            set joins {down}
-                        }
-                        inner {
-                            #set header_boxlimits {hlb hlt tlc blc vll}
-                            set header_body_joins [list left down-$fname_body]
-                            set boxlimits_position {hlb blc vll}
-                            set boxlimits_toprow [concat $boxlimits_position {hlt tlc}]
-                            set joins {down left}
-                        }
-                        right {
-                            #set header_boxlimits {hlb hlt tlc blc vll vlr trc brc}
-                            set header_body_joins [list left down-$fname_body]
-                            set boxlimits_position {hlb blc vll vlr brc}
-                            set boxlimits_toprow [concat $boxlimits_position {hlt tlc trc}]
-                            set joins {down left}
-                        }
-                        solo {
-                            #set header_boxlimits {hlb hlt tlc blc vll vlr trc brc}
-                            set header_body_joins [list down-$fname_body]
-                            set boxlimits_position   {hlb blc vll vlr brc}
-                            set boxlimits_toprow [concat $boxlimits_position {hlt tlc trc}]
-                            set joins {down}
-                        }
-                    }
                     set limj [my Get_boxlimits_and_joins $opt_posn $fname_body]
-                    set header_body_joins   [dict get $limj bodyjoins]
-                    set joins               [dict get $limj joins] 
-                    set boxlimits_position  [dict get $limj boxlimits] 
-                    set boxlimits_toprow    [dict get $limj boxlimits_top] 
+                    set header_body_joins   [tcl::dict::get $limj bodyjoins]
+                    set joins               [tcl::dict::get $limj joins] 
+                    set boxlimits_position  [tcl::dict::get $limj boxlimits] 
+                    set boxlimits_toprow    [tcl::dict::get $limj boxlimits_top] 
                     #use struct::set instead of simple for loop - will be faster at least when critcl available
-                    set boxlimits               [struct::set intersect [dict get $o_opts_table_effective -framelimits_body] $boxlimits_position]
-                    set boxlimits_headerless    [struct::set intersect [dict get $o_opts_table_effective -framelimits_body] $boxlimits_toprow]
-                    set header_boxlimits        [struct::set intersect [dict get $o_opts_table_effective -framelimits_header] $boxlimits_position]
-                    set header_boxlimits_toprow [struct::set intersect [dict get $o_opts_table_effective -framelimits_header] $boxlimits_toprow]
+                    set boxlimits               [struct::set intersect [tcl::dict::get $o_opts_table_effective -framelimits_body] $boxlimits_position]
+                    set boxlimits_headerless    [struct::set intersect [tcl::dict::get $o_opts_table_effective -framelimits_body] $boxlimits_toprow]
+                    set header_boxlimits        [struct::set intersect [tcl::dict::get $o_opts_table_effective -framelimits_header] $boxlimits_position]
+                    set header_boxlimits_toprow [struct::set intersect [tcl::dict::get $o_opts_table_effective -framelimits_header] $boxlimits_toprow]
 
-                    set fmap [dict get $o_opts_table_effective -framemap_body]
-                    set hmap [dict get $o_opts_table_effective -framemap_header]
+                    set fmap [tcl::dict::get $o_opts_table_effective -framemap_body]
+                    set hmap [tcl::dict::get $o_opts_table_effective -framemap_header]
 
-                    #if {![dict get $o_opts_table -show_edge]} {
+                    #if {![tcl::dict::get $o_opts_table -show_edge]} {
                     #    set body_edgemap [textblock::class::table_edge_map ""]
                     #    dict for {k v} $fmap {
-                    #        #dict set fmap $k [dict merge $v [dict get $body_edgemap $k]]
+                    #        #tcl::dict::set fmap $k [tcl::dict::merge $v [tcl::dict::get $body_edgemap $k]]
                     #    }
                     #    set header_edgemap [textblock::class::header_edge_map ""]
                     #    dict for {k v} $hmap {
-                    #        #dict set hmap $k [dict merge $v [dict get $header_edgemap $k]]
+                    #        #tcl::dict::set hmap $k [tcl::dict::merge $v [tcl::dict::get $header_edgemap $k]]
                     #    }
                     #}
                     set sep_elements_horizontal $::textblock::class::table_hseps
                     set sep_elements_vertical   $::textblock::class::table_vseps
 
-                    set topmap      [dict get $fmap top$opt_posn] 
-                    set botmap      [dict get $fmap bottom$opt_posn] 
-                    set midmap      [dict get $fmap middle$opt_posn] 
-                    set onlymap     [dict get $fmap only$opt_posn]
+                    set topmap      [tcl::dict::get $fmap top$opt_posn] 
+                    set botmap      [tcl::dict::get $fmap bottom$opt_posn] 
+                    set midmap      [tcl::dict::get $fmap middle$opt_posn] 
+                    set onlymap     [tcl::dict::get $fmap only$opt_posn]
 
-                    set hdrmap      [dict get $hmap only${opt_posn}]
+                    set hdrmap      [tcl::dict::get $hmap only${opt_posn}]
 
-                    set topseps_h   [dict get $sep_elements_horizontal top$opt_posn]
-                    set topseps_v   [dict get $sep_elements_vertical top$opt_posn]
-                    set midseps_h   [dict get $sep_elements_horizontal middle$opt_posn]
-                    set midseps_v   [dict get $sep_elements_vertical middle$opt_posn]
-                    set botseps_v   [dict get $sep_elements_vertical bottom$opt_posn]
-                    set onlyseps_v  [dict get $sep_elements_vertical only$opt_posn]
+                    set topseps_h   [tcl::dict::get $sep_elements_horizontal top$opt_posn]
+                    set topseps_v   [tcl::dict::get $sep_elements_vertical top$opt_posn]
+                    set midseps_h   [tcl::dict::get $sep_elements_horizontal middle$opt_posn]
+                    set midseps_v   [tcl::dict::get $sep_elements_vertical middle$opt_posn]
+                    set botseps_v   [tcl::dict::get $sep_elements_vertical bottom$opt_posn]
+                    set onlyseps_v  [tcl::dict::get $sep_elements_vertical only$opt_posn]
 
                     #top should work for all header rows regarding vseps - as we only use it to reduce the box elements, and lower headers have same except for tlc which isn't present anyway 
-                    set headerseps_v     [dict get $sep_elements_vertical top$opt_posn]
+                    set headerseps_v     [tcl::dict::get $sep_elements_vertical top$opt_posn]
 
                     lassign [my Get_seps] _h show_seps_h _v show_seps_v
                     set return_headerheight 0
                     set return_headerwidth 0
-                    set cidx [lindex [dict keys $o_columndefs] $index_expression]
+                    set cidx [lindex [tcl::dict::keys $o_columndefs] $index_expression]
 
                     set colwidth [my column_width $cidx]
 
-                    set col_blockalign [dict get $o_columndefs $cidx -blockalign]
+                    set col_blockalign [tcl::dict::get $o_columndefs $cidx -blockalign]
 
                     if {$do_show_header} {
                         #puts "boxlimitsinfo header $opt_posn: -- boxlimits $header_boxlimits -- boxmap $hdrmap"
-                        set ansibase_header [dict get $o_opts_table -ansibase_header] ;#merged to single during configure
-                        set ansiborder_header [dict get $o_opts_table -ansiborder_header]
-                        if {[dict get $o_opts_table -frametype_header] eq "block"} {
+                        set ansibase_header [tcl::dict::get $o_opts_table -ansibase_header] ;#merged to single during configure
+                        set ansiborder_header [tcl::dict::get $o_opts_table -ansiborder_header]
+                        if {[tcl::dict::get $o_opts_table -frametype_header] eq "block"} {
                             set extrabg  [punk::ansi::codetype::sgr_merge_singles [list $ansibase_header] -filter_fg 1] 
                             set ansiborder_final $ansibase_header$ansiborder_header$extrabg
                         } else {
@@ -1763,16 +1793,16 @@ namespace eval textblock {
 
                         set hcolwidth $colwidth 
                         #set hcolwidth [my column_width_configured $cidx]
-                        set hcell_line_blank [string repeat " " $hcolwidth]
+                        set hcell_line_blank [tcl::string::repeat " " $hcolwidth]
 
                         set all_colspans [my header_colspans]
 
                         #default span_extend_map - used as base to customise with specific joins
                         set fdef_header [textblock::framedef $ftype_header]
-                        set span_extend_map [dict create \
+                        set span_extend_map [tcl::dict::create \
                                 vll " "\
-                                tlc [dict get $fdef_header hlt]\
-                                blc [dict get $fdef_header hlb]\
+                                tlc [tcl::dict::get $fdef_header hlt]\
+                                blc [tcl::dict::get $fdef_header hlb]\
                             ]
                         set framedef_leftbox [textblock::framedef $ftype_header -joins left]
 
@@ -1783,7 +1813,7 @@ namespace eval textblock {
                         set hrow 0
                         set hmax [expr {[llength $header_list] -1}]
                         foreach header $header_list {
-                            set headerspans [dict get $all_colspans $hrow]
+                            set headerspans [tcl::dict::get $all_colspans $hrow]
                             set this_span [lindex $headerspans $cidx]
                             set hval $ansibase_header$header ;#no reset
                             set rowh [my header_height $hrow]
@@ -1816,21 +1846,21 @@ namespace eval textblock {
                             } else {
                                 set header_joins $joins 
                             }
-                            if {![dict get $o_opts_table -show_edge]} {
-                                set hlims [struct::set difference $hlims [dict get $::textblock::class::header_edge_parts $rowpos$opt_posn] ]
+                            if {![tcl::dict::get $o_opts_table -show_edge]} {
+                                set hlims [struct::set difference $hlims [tcl::dict::get $::textblock::class::header_edge_parts $rowpos$opt_posn] ]
                             }
                             #puts ">>> headerspans: $headerspans cidx: $cidx"
 
                             if {$this_span eq "all" || $this_span > 0} {
-                                set startmap      [dict get $hmap $rowpos${opt_posn}]
+                                set startmap      [tcl::dict::get $hmap $rowpos${opt_posn}]
                                 #look at spans in header below to determine joins required at blc
                                 if {$show_seps_v} {
-                                    if {[dict exists $all_colspans [expr {$hrow+1}]]} {
-                                        set next_spanlist [dict get $all_colspans [expr {$hrow+1}]]
+                                    if {[tcl::dict::exists $all_colspans [expr {$hrow+1}]]} {
+                                        set next_spanlist [tcl::dict::get $all_colspans [expr {$hrow+1}]]
                                         set spanbelow [lindex $next_spanlist $cidx]
                                         if {$spanbelow == 0} {
                                             #we don't want a down-join for blc - use a framedef with only left joins 
-                                            dict set startmap blc [dict get $framedef_leftbox blc]
+                                            tcl::dict::set startmap blc [tcl::dict::get $framedef_leftbox blc]
                                         }
                                     } else {
                                         set next_spanlist [list]
@@ -1847,7 +1877,7 @@ namespace eval textblock {
                                 #This ellipsis 0 makes a difference (unwanted ellipsis at rhs of header column that starts span)
 
                                 # -width is always +2 - as the boxlimits take into account show_vseps and show_edge
-                                #set header_cell_startspan [textblock::frame -ellipsis 0 -usecache 1 -width [expr {$hcolwidth+2}] -type [dict get $ftypes header]\
+                                #set header_cell_startspan [textblock::frame -ellipsis 0 -usecache 1 -width [expr {$hcolwidth+2}] -type [tcl::dict::get $ftypes header]\
                                 #    -ansibase $ansibase_header -ansiborder $ansiborder_final\
                                 #    -boxlimits $hlims -boxmap $startmap -joins $header_joins $hval\
                                 #    ]
@@ -1857,9 +1887,9 @@ namespace eval textblock {
                                     set cellcontents $hval
                                 } else {
                                     #just write an empty vertical placeholder. The spanned value will be overtyped below
-                                    set cellcontents [join [lrepeat [llength [split $hval \n]] ""] \n]
+                                    set cellcontents [::join [lrepeat [llength [split $hval \n]] ""] \n]
                                 }
-                                set header_cell_startspan [textblock::frame -blockalign $col_blockalign -ellipsis 0 -usecache 1 -width [expr {$hcolwidth+2}] -type [dict get $ftypes header]\
+                                set header_cell_startspan [textblock::frame -blockalign $col_blockalign -ellipsis 0 -usecache 1 -width [expr {$hcolwidth+2}] -type [tcl::dict::get $ftypes header]\
                                     -ansibase $ansibase_header -ansiborder $ansiborder_final\
                                     -boxlimits $hlims -boxmap $startmap -joins $header_joins $cellcontents\
                                     ]
@@ -1869,7 +1899,7 @@ namespace eval textblock {
                                     set spanned_parts [list $header_cell_startspan]
                                     #assert this_span == "all" or >1 ie a header that spans other columns
                                     #therefore more parts to append
-                                    #set remaining_cols [lrange [dict keys $o_columndefs] $cidx end]
+                                    #set remaining_cols [lrange [tcl::dict::keys $o_columndefs] $cidx end]
                                     set remaining_spans [lrange $headerspans $cidx+1 end]
                                     #puts ">> remaining_spans: $remaining_spans"
                                     set spancol [expr {$cidx + 1}]
@@ -1889,18 +1919,18 @@ namespace eval textblock {
                                                 set next_posn inner
                                             }
 
-                                            set next_headerseps_v   [dict get $sep_elements_vertical top$next_posn] ;#static top ok
+                                            set next_headerseps_v   [tcl::dict::get $sep_elements_vertical top$next_posn] ;#static top ok
 
                                             set limj [my Get_boxlimits_and_joins $next_posn $fname_body]
-                                            set span_joins_body     [dict get $limj bodyjoins]
-                                            set span_joins          [dict get $limj joins] 
-                                            set span_boxlimits      [dict get $limj boxlimits] 
-                                            set span_boxlimits_top  [dict get $limj boxlimits_top] 
+                                            set span_joins_body     [tcl::dict::get $limj bodyjoins]
+                                            set span_joins          [tcl::dict::get $limj joins] 
+                                            set span_boxlimits      [tcl::dict::get $limj boxlimits] 
+                                            set span_boxlimits_top  [tcl::dict::get $limj boxlimits_top] 
                                             #use struct::set instead of simple for loop - will be faster at least when critcl available
-                                            #set span_boxlimits               [struct::set intersect [dict get $o_opts_table_effective -framelimits_body] $span_boxlimits]
-                                            #set span_boxlimits_top    [struct::set intersect [dict get $o_opts_table_effective -framelimits_body] $span_boxlimits_top]
-                                            set header_span_boxlimits       [struct::set intersect [dict get $o_opts_table_effective -framelimits_header] $span_boxlimits]
-                                            set header_span_boxlimits_top   [struct::set intersect [dict get $o_opts_table_effective -framelimits_header] $span_boxlimits_top]
+                                            #set span_boxlimits               [struct::set intersect [tcl::dict::get $o_opts_table_effective -framelimits_body] $span_boxlimits]
+                                            #set span_boxlimits_top    [struct::set intersect [tcl::dict::get $o_opts_table_effective -framelimits_body] $span_boxlimits_top]
+                                            set header_span_boxlimits       [struct::set intersect [tcl::dict::get $o_opts_table_effective -framelimits_header] $span_boxlimits]
+                                            set header_span_boxlimits_top   [struct::set intersect [tcl::dict::get $o_opts_table_effective -framelimits_header] $span_boxlimits_top]
                                             if {$hrow == 0} {
                                                 set hlims $header_span_boxlimits_top
                                             } else {
@@ -1915,12 +1945,12 @@ namespace eval textblock {
                                                     set spanbelow [lindex $next_spanlist $spancol]
                                                     if {$spanbelow != 0} {
                                                         set downbox [textblock::framedef $ftype_header -joins {down}]
-                                                        dict set this_span_map blc [dict get $downbox hlbj] ;#horizontal line bottom with down join - to same frametype
+                                                        tcl::dict::set this_span_map blc [tcl::dict::get $downbox hlbj] ;#horizontal line bottom with down join - to same frametype
                                                     }
                                                 } else {
                                                     #join to body
                                                     set downbox [textblock::framedef $ftype_header -joins [list down-$fname_body]]
-                                                    dict set this_span_map blc [dict get $downbox hlbj] ;#horizontal line bottom with down join - from header frametype to body frametype 
+                                                    tcl::dict::set this_span_map blc [tcl::dict::get $downbox hlbj] ;#horizontal line bottom with down join - from header frametype to body frametype 
                                                 }
                                             }
 
@@ -1929,12 +1959,12 @@ namespace eval textblock {
                                             } else {
                                                 set header_joins $span_joins 
                                             }
-                                            if {![dict get $o_opts_table -show_edge]} {
-                                                set hlims [struct::set difference $hlims [dict get $::textblock::class::header_edge_parts $rowpos$next_posn] ]
+                                            if {![tcl::dict::get $o_opts_table -show_edge]} {
+                                                set hlims [struct::set difference $hlims [tcl::dict::get $::textblock::class::header_edge_parts $rowpos$next_posn] ]
                                             }
 
                                             set contentwidth [my column_width $spancol]
-                                            set header_cell [textblock::frame -ellipsis 0 -width [expr {$contentwidth + 2}] -type [dict get $ftypes header]\
+                                            set header_cell [textblock::frame -ellipsis 0 -width [expr {$contentwidth + 2}] -type [tcl::dict::get $ftypes header]\
                                                 -ansibase $ansibase_header -ansiborder $ansiborder_final\
                                                 -boxlimits $hlims -boxmap $this_span_map -joins $header_joins $hcell_blank\
                                                 ]
@@ -1946,7 +1976,9 @@ namespace eval textblock {
                                         incr i
                                     }
 
-                                    set spanned_frame [textblock::join {*}$spanned_parts]
+                                    #JMN
+                                    #spanned_parts are all built with textblock::frame - therefore uniform-width lines - can use join_basic
+                                    set spanned_frame [textblock::join_basic -- {*}$spanned_parts]
 
                                     if {$hrow == 0} {
                                         set hlims $header_boxlimits_toprow
@@ -1956,9 +1988,9 @@ namespace eval textblock {
                                     if {!$show_seps_v} {
                                         set hlims [struct::set difference $hlims $headerseps_v]
                                     }
-                                    if {![dict get $o_opts_table -show_edge]} {
+                                    if {![tcl::dict::get $o_opts_table -show_edge]} {
                                         #use the edge_parts corresponding to the column being written to ie use opt_posn
-                                        set hlims [struct::set difference $hlims [dict get $::textblock::class::header_edge_parts $rowpos$opt_posn] ]
+                                        set hlims [struct::set difference $hlims [tcl::dict::get $::textblock::class::header_edge_parts $rowpos$opt_posn] ]
                                     }
 
                                     set spacemap [list hl " " vl " " tlc " " blc " " trc " " brc " "] ;#transparent overlay elements
@@ -1966,7 +1998,7 @@ namespace eval textblock {
                                     #-usecache 1 ok
                                     #hval is not raw headerval - it has been padded to required width and has ansi applied
                                     set hblock [textblock::frame -ellipsis 0 -type $spacemap -boxlimits $hlims -ansibase $ansibase_header $hval] ;#review -ansibase
-                                    #puts "==>boxlimits:'$hlims' hval_width:[string length $hval] blockwidth:[textblock::width $hblock]"
+                                    #puts "==>boxlimits:'$hlims' hval_width:[tcl::string::length $hval] blockwidth:[textblock::width $hblock]"
                                     #puts $hblock
                                     #puts "==>hval:'$hval'[a]"
                                     #puts "==>hval:'[ansistring VIEW $hval]'"
@@ -1977,7 +2009,7 @@ namespace eval textblock {
 
                                 } else {
                                     #this_span == 1
-                                    set spanned_frame [textblock::join $header_cell_startspan]
+                                    set spanned_frame [textblock::join_basic -- $header_cell_startspan]
                                 }
 
 
@@ -2000,17 +2032,17 @@ namespace eval textblock {
                                 #avoiding frame here is faster.. but not by much (<10%? on textblock::spantest2 )
                                 if 0 {
                                     #breaks -show_edge 0
-                                    if {$rowpos eq "top" && [dict get $o_opts_table -show_edge]} {
+                                    if {$rowpos eq "top" && [tcl::dict::get $o_opts_table -show_edge]} {
                                         set padheight [expr {$rowh + 2}]
                                     } else {
                                         set padheight [expr {$rowh + 1}]
                                     }
-                                    set bline [string repeat $TSUB [expr {$padwidth +1}]]
+                                    set bline [tcl::string::repeat $TSUB [expr {$padwidth +1}]]
                                     set h_lines [lrepeat $padheight $bline]
                                     set hcell_blank [::join $h_lines \n]
                                     set header_frame $hcell_blank
                                 } else { 
-                                    set bline [string repeat $TSUB $padwidth]
+                                    set bline [tcl::string::repeat $TSUB $padwidth]
                                     set h_lines [lrepeat $rowh $bline]
                                     set hcell_blank [::join $h_lines \n]
                                     # -usecache 1 ok
@@ -2033,30 +2065,30 @@ namespace eval textblock {
                             if {!$show_seps_v} {
                                 set hlims [struct::set difference $hlims $headerseps_v]
                             }
-                            if {![dict get $o_opts_table -show_edge]} {
-                                set hlims [struct::set difference $hlims [dict get $::textblock::class::header_edge_parts only$opt_posn] ]
+                            if {![tcl::dict::get $o_opts_table -show_edge]} {
+                                set hlims [struct::set difference $hlims [tcl::dict::get $::textblock::class::header_edge_parts only$opt_posn] ]
                             }
                             set header_joins $header_body_joins
-                            set header_frame [textblock::frame -width [expr {$hcolwidth+2}] -type [dict get $ftypes header]\
+                            set header_frame [textblock::frame -width [expr {$hcolwidth+2}] -type [tcl::dict::get $ftypes header]\
                                 -ansibase $ansibase_header -ansiborder $ansiborder_final\
                                 -boxlimits $hlims -boxmap $hdrmap -joins $header_joins\
                                 ]
                             append part_header $header_frame\n
                         }
-                        set part_header [string trimright $part_header \n]
+                        set part_header [tcl::string::trimright $part_header \n]
                         lassign [textblock::size $part_header] _w return_headerwidth _h return_headerheight 
 
-                        set padline [string repeat $TSUB $return_headerwidth]
+                        set padline [tcl::string::repeat $TSUB $return_headerwidth]
                         set adjusted_lines [list] 
                         foreach ln [split $part_header \n] {
-                            if {[string first $TSUB $ln] >=0} {
+                            if {[tcl::string::first $TSUB $ln] >=0} {
                                 lappend adjusted_lines $padline 
                             } else {
                                 lappend adjusted_lines $ln
                             }
                         }
-                        set part_header [join $adjusted_lines \n]
-                        append output $part_header \n
+                        set part_header [::join $adjusted_lines \n]
+                        #append output $part_header \n
                     }
 
                     set r 0
@@ -2083,15 +2115,15 @@ namespace eval textblock {
                         set blims_only_headerless [struct::set difference $blims_only_headerless $onlyseps_v]
                     }
 
-                    set colidx [lindex [dict keys $o_columndefs] $index_expression] ;#convert possible end-1,2+2 etc expression to >= 0 integer in dict range
+                    set colidx [lindex [tcl::dict::keys $o_columndefs] $index_expression] ;#convert possible end-1,2+2 etc expression to >= 0 integer in dict range
 
-                    set opt_col_ansibase [dict get $o_columndefs $colidx -ansibase] ;#ordinary merge of codes already done in configure_column
+                    set opt_col_ansibase [tcl::dict::get $o_columndefs $colidx -ansibase] ;#ordinary merge of codes already done in configure_column
                     #set colwidth [my column_width $colidx]
 
-                    set body_ansibase [dict get $o_opts_table -ansibase_body]
+                    set body_ansibase [tcl::dict::get $o_opts_table -ansibase_body]
                     #set ansibase [punk::ansi::codetype::sgr_merge_singles [list $body_ansibase $opt_col_ansibase]] ;#allow col to override body
-                    set body_ansiborder [dict get $o_opts_table -ansiborder_body]
-                    if {[dict get $o_opts_table -frametype] eq "block"} {
+                    set body_ansiborder [tcl::dict::get $o_opts_table -ansiborder_body]
+                    if {[tcl::dict::get $o_opts_table -frametype] eq "block"} {
                         #block is the only style where bg colour can fill the frame content area exactly if the L-shaped border elements are styled
                         #we need to only accept background ansi codes from the columndef  ansibase for this
                         set col_bg [punk::ansi::codetype::sgr_merge_singles [list $opt_col_ansibase] -filter_fg 1]  ;#special merge for block borders - don't override fg colours
@@ -2099,19 +2131,22 @@ namespace eval textblock {
                     } else {
                         set border_ansi $body_ansibase$body_ansiborder
                     }
+
+
                     set r 0
-                    set ftblock [expr {[dict get $o_opts_table -frametype] eq "block"}]
+                    set ftblock [expr {[tcl::dict::get $o_opts_table -frametype] eq "block"}]
                     foreach c $cells {
-                        set ansibase $body_ansibase$opt_col_ansibase
-                        set row_ansibase [dict get $o_rowdefs $r -ansibase]
-                        #todo - joinleft,joinright,joindown based on opts in args
-                        #append output [textblock::frame -boxlimits {vll blc hlb} $c]\n
-                        set cell_ansibase ""
-
+                        #cells in column - each new c is in a different row
+                        set row_ansibase [tcl::dict::get $o_rowdefs $r -ansibase]
                         set row_bg ""
                         if {$row_ansibase ne ""} {
                             set row_bg [punk::ansi::codetype::sgr_merge_singles [list $row_ansibase] -filter_fg 1]
                         }
+
+                        set ansibase $body_ansibase$opt_col_ansibase
+                        #todo - joinleft,joinright,joindown based on opts in args
+                        set cell_ansibase ""
+
                         set ansiborder_body_col_row $border_ansi$row_bg
                         set ansiborder_final $ansiborder_body_col_row 
                         #$c will always have ansi resets due to overtype behaviour ?
@@ -2155,7 +2190,6 @@ namespace eval textblock {
                             }
                         }
 
-
                         set ansibase_final $ansibase$row_ansibase$cell_ansibase
 
                         if {$r == 0} {
@@ -2167,8 +2201,8 @@ namespace eval textblock {
                                 } else {
                                     set blims $blims_only_headerless
                                 }
-                                if {![dict get $o_opts_table -show_edge]} {
-                                    set blims [struct::set difference $blims [dict get $::textblock::class::table_edge_parts only$opt_posn] ]
+                                if {![tcl::dict::get $o_opts_table -show_edge]} {
+                                    set blims [struct::set difference $blims [tcl::dict::get $::textblock::class::table_edge_parts only$opt_posn] ]
                                 }
                             } else {
                                 set bmap $topmap
@@ -2177,29 +2211,29 @@ namespace eval textblock {
                                 } else {
                                     set blims $blims_top_headerless
                                 }
-                                if {![dict get $o_opts_table -show_edge]} {
-                                    set blims [struct::set difference $blims [dict get $::textblock::class::table_edge_parts top$opt_posn] ]
+                                if {![tcl::dict::get $o_opts_table -show_edge]} {
+                                    set blims [struct::set difference $blims [tcl::dict::get $::textblock::class::table_edge_parts top$opt_posn] ]
                                 }
                             }
-                            set rowframe [textblock::frame -type [dict get $ftypes body] -width [expr {$colwidth+2}] -blockalign $col_blockalign -ansibase $ansibase_final -ansiborder $ansiborder_final -boxlimits $blims -boxmap $bmap -joins $joins $c]
-                            set return_bodywidth [textblock::width $rowframe]
+                            set rowframe [textblock::frame -type [tcl::dict::get $ftypes body] -width [expr {$colwidth+2}] -blockalign $col_blockalign -ansibase $ansibase_final -ansiborder $ansiborder_final -boxlimits $blims -boxmap $bmap -joins $joins $c]
+                            set return_bodywidth [textblock::widthtopline $rowframe] ;#frame lines always same width - just look at top line
                             append part_body $rowframe \n
                         } else {
                             if {$r == $rmax} {
                                 set joins [lremove $joins [lsearch $joins down*]]
                                 set bmap $botmap
                                 set blims $blims_bot
-                                if {![dict get $o_opts_table -show_edge]} {
-                                    set blims [struct::set difference $blims [dict get $::textblock::class::table_edge_parts bottom$opt_posn] ]
+                                if {![tcl::dict::get $o_opts_table -show_edge]} {
+                                    set blims [struct::set difference $blims [tcl::dict::get $::textblock::class::table_edge_parts bottom$opt_posn] ]
                                 }
                             } else {
                                 set bmap $midmap
                                 set blims $blims_mid ;#will only be reduced from boxlimits if -show_seps was processed above
-                                if {![dict get $o_opts_table -show_edge]} {
-                                    set blims [struct::set difference $blims [dict get $::textblock::class::table_edge_parts middle$opt_posn] ]
+                                if {![tcl::dict::get $o_opts_table -show_edge]} {
+                                    set blims [struct::set difference $blims [tcl::dict::get $::textblock::class::table_edge_parts middle$opt_posn] ]
                                 }
                             }
-                            append part_body [textblock::frame -type [dict get $ftypes body] -width [expr {$colwidth+2}] -blockalign $col_blockalign -ansibase $ansibase_final -ansiborder $ansiborder_final -boxlimits $blims -boxmap $bmap -joins $joins $c]\n
+                            append part_body [textblock::frame -type [tcl::dict::get $ftypes body] -width [expr {$colwidth+2}] -blockalign $col_blockalign -ansibase $ansibase_final -ansiborder $ansiborder_final -boxlimits $blims -boxmap $bmap -joins $joins $c]\n
                         }
                         incr r
                     }
@@ -2220,13 +2254,13 @@ namespace eval textblock {
                         #This is because the frame with no data had vertical components made entirely of corner elements
                         #we could just append a newline when -show_edge is zero, but we want the correct width even when empty - for proper column joins when there are colspanned headers.
                         #
-                        if {![dict get $o_opts_table -show_edge]} {
-                            #set blims [struct::set difference $blims [dict get $::textblock::class::table_edge_parts only$opt_posn] ]
-                            #append output [textblock::frame -width [expr {$colwidth + 2}] -type [dict get $ftypes body] -boxlimits $blims -boxmap $onlymap -joins $joins]\n
-                            append part_body [string repeat " " $colwidth] \n
+                        if {![tcl::dict::get $o_opts_table -show_edge]} {
+                            #set blims [struct::set difference $blims [tcl::dict::get $::textblock::class::table_edge_parts only$opt_posn] ]
+                            #append output [textblock::frame -width [expr {$colwidth + 2}] -type [tcl::dict::get $ftypes body] -boxlimits $blims -boxmap $onlymap -joins $joins]\n
+                            append part_body [tcl::string::repeat " " $colwidth] \n
                             set return_bodywidth $colwidth
                         } else {
-                            set emptyframe [textblock::frame -width [expr {$colwidth + 2}] -type [dict get $ftypes body] -boxlimits $blims -boxmap $onlymap -joins $joins]
+                            set emptyframe [textblock::frame -width [expr {$colwidth + 2}] -type [tcl::dict::get $ftypes body] -boxlimits $blims -boxmap $onlymap -joins $joins]
                             append part_body $emptyframe \n
                             set return_bodywidth [textblock::width $emptyframe]
                         }
@@ -2234,38 +2268,46 @@ namespace eval textblock {
                     #assert bodywidth is integer >=0 whether there are rows or not
 
                     #trim only 1 newline
-                    if {[string index $part_body end] eq "\n"} {
-                        set part_body [string range $part_body 0 end-1]
+                    if {[tcl::string::index $part_body end] eq "\n"} {
+                        set part_body [tcl::string::range $part_body 0 end-1]
                     }
                     set return_bodyheight [textblock::height $part_body]
-                    append output $part_body
+                    #append output $part_body
 
                     if {$opt_return eq "string"} {
+                        if {$part_header ne ""} {
+                            set output $part_header
+                            if {$part_body ne ""} {
+                                append output \n $part_body
+                            }
+                        } else {
+                            set output $part_body
+                        }
                         return $output 
                     } else {
-                        return [dict create column $output headerwidth $return_headerwidth headerheight $return_headerheight bodywidth $return_bodywidth bodyheight $return_bodyheight]
+                        return [tcl::dict::create header $part_header body $part_body headerwidth $return_headerwidth headerheight $return_headerheight bodywidth $return_bodywidth bodyheight $return_bodyheight]
                     }
                 }
 
                 method get_column_cells_by_index {index_expression} {
-                    set cidx [lindex [dict keys $o_columndefs] $index_expression]
+                    set cidx [lindex [tcl::dict::keys $o_columndefs] $index_expression]
                     if {$cidx eq ""} {
                         set range ""
-                        if {[dict size $o_columndefs] > 0} {
-                            set range "0..[expr {[dict size $o_columndefs] -1}]"
+                        if {[tcl::dict::size $o_columndefs] > 0} {
+                            set range "0..[expr {[tcl::dict::size $o_columndefs] -1}]"
                         } else {
                             set range empty
                         }
                         error "table::get_column_cells_by_index no such index $index_expression. Valid range is $range"
                     }
                     #assert cidx is integer >=0 
-                    set cdef [dict get $o_columndefs $cidx] 
-                    set headerlist [dict get $cdef -headers] 
+                    set cdef            [tcl::dict::get $o_columndefs $cidx] 
+                    set headerlist      [tcl::dict::get $cdef -headers] 
                     set num_header_rows [my header_count] 
 
-                    set ansibase_body   [dict get $o_opts_table -ansibase_body]
-                    set ansibase_col    [dict get $cdef -ansibase]
-                    set textalign       [dict get $cdef -textalign]
+                    set ansibase_body   [tcl::dict::get $o_opts_table -ansibase_body]
+                    set ansibase_col    [tcl::dict::get $cdef -ansibase]
+                    set textalign       [tcl::dict::get $cdef -textalign]
                     switch -- $textalign {
                         left    {set pad right}
                         right   {set pad left} 
@@ -2274,7 +2316,7 @@ namespace eval textblock {
                         }
                     }
 
-                    set ansibase_header [dict get $o_opts_table -ansibase_header]
+                    set ansibase_header [tcl::dict::get $o_opts_table -ansibase_header]
 
                     #set header_underlay $ansibase_header$cell_line_blank
 
@@ -2283,56 +2325,56 @@ namespace eval textblock {
 
                     #store configured widths so we don't look up for each header line
                     set configured_widths [list]
-                    foreach c [dict keys $o_columndefs] {
+                    foreach c [tcl::dict::keys $o_columndefs] {
                         #lappend configured_widths [my column_width $c]
                         #we don't just want the width of the column in the body - or the headers will get truncated
                         lappend configured_widths [my column_width_configured $c]
                     }
 
-                    set output [dict create] 
-                    dict set output headers [list]
+                    set output [tcl::dict::create] 
+                    tcl::dict::set output headers [list]
 
                     set showing_vseps [my Showing_vseps]
                     for {set hrow 0} {$hrow < $num_header_rows} {incr hrow} {
                         set hdr [lindex $headerlist $hrow]
                         set header_maxdataheight [my header_height $hrow]  ;#from cached headerstates
-                        set headerrow_colspans [dict get $all_colspans $hrow]
+                        set headerrow_colspans [tcl::dict::get $all_colspans $hrow]
                         set this_span [lindex $headerrow_colspans $cidx] 
 
                         #set this_hdrwidth [lindex $configured_widths $cidx] 
                         set this_hdrwidth [my column_datawidth $cidx -headers 1 -colspan $this_span] ;#widest of headers in this col with same span - allows textalign to work with blockalign 
 
-                        set hcell_line_blank [string repeat " " $this_hdrwidth]
+                        set hcell_line_blank [tcl::string::repeat " " $this_hdrwidth]
                         set hcell_lines [lrepeat $header_maxdataheight $hcell_line_blank]
                         set hval_lines [split $hdr \n]
                         set hval_lines [concat $hval_lines $hcell_lines]
                         set hval_lines [lrange $hval_lines 0 $header_maxdataheight-1] ;#vertical align top
                         set hval_block [::join $hval_lines \n]
                         set hcell [textblock::pad $hval_block -width $this_hdrwidth -padchar " " -within_ansi 1 -which $pad]
-                        dict lappend output headers $hcell 
+                        tcl::dict::lappend output headers $hcell 
                     }
 
 
                     #set colwidth [my column_width $cidx]
-                    #set cell_line_blank [string repeat " " $colwidth]
+                    #set cell_line_blank [tcl::string::repeat " " $colwidth]
                     set datawidth [my column_datawidth $cidx -headers 0 -footers 0 -data 1 -cached 1]
-                    set cell_line_blank [string repeat " " $datawidth]
+                    set cell_line_blank [tcl::string::repeat " " $datawidth]
 
 
 
-                    set items [dict get $o_columndata $cidx]
+                    set items [tcl::dict::get $o_columndata $cidx]
                     #puts "---> columndata $o_columndata"
 
-                    #set opt_row_ansibase [dict get $o_rowdefs $r -ansibase]
+                    #set opt_row_ansibase [tcl::dict::get $o_rowdefs $r -ansibase]
                     #set cell_ansibase $ansibase_body$ansibase_col$opt_row_ansibase
 
-                    dict set output cells [list];#ensure we return something for cells key if no items in list
+                    tcl::dict::set output cells [list];#ensure we return something for cells key if no items in list
                     set r 0
                     foreach cval $items {
                         #todo move to row_height method ?
-                        set maxdataheight [dict get $o_rowstates $r -maxheight]
-                        set rowdefminh    [dict get $o_rowdefs $r -minheight]
-                        set rowdefmaxh    [dict get $o_rowdefs $r -maxheight]
+                        set maxdataheight [tcl::dict::get $o_rowstates $r -maxheight]
+                        set rowdefminh    [tcl::dict::get $o_rowdefs $r -minheight]
+                        set rowdefmaxh    [tcl::dict::get $o_rowdefs $r -maxheight]
                         if {"$rowdefminh$rowdefmaxh" ne "" && $rowdefminh eq $rowdefmaxh} { 
                             #an exact height is defined for the row
                             set rowh $rowdefminh
@@ -2369,48 +2411,48 @@ namespace eval textblock {
 
                         set cell [textblock::pad $cval_block -width $datawidth -padchar " " -within_ansi 1 -which $pad]
                         #set cell [textblock::pad $cval_block -width $colwidth -padchar " " -within_ansi 0 -which left]
-                        dict lappend output cells $cell
+                        tcl::dict::lappend output cells $cell
 
                         incr r
                     }
                     return $output
                 }
                 method get_column_values_by_index {index_expression} {
-                    set cidx [lindex [dict keys $o_columndefs] $index_expression]
+                    set cidx [lindex [tcl::dict::keys $o_columndefs] $index_expression]
                     if {$cidx eq ""} {
                         return
                     }
-                    return [dict get $o_columndata $cidx]
+                    return [tcl::dict::get $o_columndata $cidx]
                 }
                 method debug {args} {
                     #nice to lay this out with tables - but this is the one function where we really should provide the ability to avoid tables in case things get really broken (e.g major refactor) 
-                    set defaults [dict create\
+                    set defaults [tcl::dict::create\
                         -usetables 1\
                     ]
-                    dict for {k v} $args {
+                    foreach {k v} $args {
                         switch -- $k {
                             -usetables {}
                             default {
-                                error "table debug unrecognised option '$k'. Known options: [dict keys $defaults]"
+                                error "table debug unrecognised option '$k'. Known options: [tcl::dict::keys $defaults]"
                             }
                         }
                     }
-                    set opts [dict merge $defaults $args]
-                    set opt_usetables [dict get $opts -usetables]
+                    set opts [tcl::dict::merge $defaults $args]
+                    set opt_usetables [tcl::dict::get $opts -usetables]
 
                     puts stdout "rowdefs:      $o_rowdefs"
                     puts stdout "rowstates:    $o_rowstates"
                     #puts stdout "columndefs:   $o_columndefs"
                     puts stdout "columndefs:"
                     if {!$opt_usetables} { 
-                        dict for {k v} $o_columndefs {
+                        tcl::dict::for {k v} $o_columndefs {
                             puts "    $k $v"
                         }
                     } else {
                         set t [textblock::class::table new]
                         $t add_column -headers "Col"
-                        dict for {col coldef} $o_columndefs {
-                            foreach property [dict keys $coldef] {
+                        tcl::dict::for {col coldef} $o_columndefs {
+                            foreach property [tcl::dict::keys $coldef] {
                                 if {$property eq "-ansireset"} {
                                     continue
                                 }
@@ -2420,11 +2462,11 @@ namespace eval textblock {
                         }
 
                         #build our inner tables first so we can sync widths
-                        set col_header_tables [dict create]
-                        set max_widths [dict create 0 0 1 0 2 0 3 0] ;#max inner table column widths
-                        dict for {col coldef} $o_columndefs {
+                        set col_header_tables [tcl::dict::create]
+                        set max_widths [tcl::dict::create 0 0 1 0 2 0 3 0] ;#max inner table column widths
+                        tcl::dict::for {col coldef} $o_columndefs {
                             set row [list $col]
-                            set colheaders [dict get $coldef -headers] 
+                            set colheaders [tcl::dict::get $coldef -headers] 
                             #inner table probably overkill here ..but just as easy
                             set htable [textblock::class::table new]
                             $htable configure -show_header 1 -show_edge 0 -show_hseps 0
@@ -2433,32 +2475,36 @@ namespace eval textblock {
                             $htable add_column -headers WxH
                             $htable add_column -headers span 
                             set hnum 0 
-                            set spans [dict get $o_columndefs $col -header_colspans]
+                            set spans [tcl::dict::get $o_columndefs $col -header_colspans]
                             foreach h $colheaders s $spans {
                                 lassign [textblock::size $h] _w width _h height
                                 $htable add_row [list "$hnum " $h "${width}x${height}" $s]
                                 incr hnum
                             }
                             $htable configure_column 0 -ansibase [a+ web-dimgray]
-                            dict set col_header_tables $col $htable
+                            tcl::dict::set col_header_tables $col $htable
                             set colwidths [$htable column_widths]
                             set icol 0
                             foreach w $colwidths {
-                                if {$w > [dict get $max_widths $icol]} {
-                                    dict set max_widths $icol $w
+                                if {$w > [tcl::dict::get $max_widths $icol]} {
+                                    tcl::dict::set max_widths $icol $w
                                 }
                                 incr icol 
                             }
                         }
 
-                        dict for {col coldef} $o_columndefs {
+                        #safe jumptable test
+                        #dict for {col coldef} $o_columndefs {}
+                        tcl::dict::for {col coldef} $o_columndefs {
                             set row [list $col]
-                            dict for {property val} $coldef {
+                            #safe jumptable test
+                            #dict for {property val} $coldef {}
+                            tcl::dict::for {property val} $coldef {
                                 switch -- $property {
                                     -ansireset {continue}
                                     -headers {
-                                        set htable [dict get $col_header_tables $col]
-                                        dict for {innercol maxw} $max_widths {
+                                        set htable [tcl::dict::get $col_header_tables $col]
+                                        tcl::dict::for {innercol maxw} $max_widths {
                                             $htable configure_column $innercol -minwidth $maxw  -blockalign left
                                         }
                                         lappend row [$htable print] 
@@ -2481,10 +2527,10 @@ namespace eval textblock {
                     }
                     puts stdout "columnstates: $o_columnstates"
                     puts stdout "headerstates: $o_headerstates"
-                    dict for {k coldef} $o_columndefs {
-                        if {[dict exists $o_columndata $k]} {
-                            set headerlist [dict get $coldef -headers]
-                            set coldata [dict get $o_columndata $k] 
+                    tcl::dict::for {k coldef} $o_columndefs {
+                        if {[tcl::dict::exists $o_columndata $k]} {
+                            set headerlist [tcl::dict::get $coldef -headers]
+                            set coldata [tcl::dict::get $o_columndata $k] 
                             set colinfo "rowcount: [llength $coldata]"
                             set allfields [concat $headerlist $coldata]
                             if {[llength $allfields]} {
@@ -2500,8 +2546,8 @@ namespace eval textblock {
                     }
                     set result ""
                     set cols [list]
-                    set max [expr {[dict size $o_columndefs]-1}]
-                    foreach c [dict keys $o_columndefs] {
+                    set max [expr {[tcl::dict::size $o_columndefs]-1}]
+                    foreach c [tcl::dict::keys $o_columndefs] {
                         if {$c == 0} {
                             lappend cols [my get_column_by_index $c -position left] " "
                         } elseif {$c == $max} {
@@ -2510,28 +2556,28 @@ namespace eval textblock {
                             lappend cols [my get_column_by_index $c -position inner] " "
                         }
                     }
-                    append result [textblock::join {*}$cols]
+                    append result [textblock::join -- {*}$cols]
                     return $result
                 }
                 #column width including headers - but without colspan consideration
                 method column_width_configured {index_expression} {
-                    set cidx [lindex [dict keys $o_columndefs] $index_expression]
+                    set cidx [lindex [tcl::dict::keys $o_columndefs] $index_expression]
                     if {$cidx eq ""} {
                         return
                     }
                     #assert cidx is now >=0 integer within the range of defined columns
-                    set cdef        [dict get $o_columndefs $cidx]
-                    set defminw     [dict get $cdef -minwidth]
-                    set defmaxw     [dict get $cdef -maxwidth]
+                    set cdef        [tcl::dict::get $o_columndefs $cidx]
+                    set defminw     [tcl::dict::get $cdef -minwidth]
+                    set defmaxw     [tcl::dict::get $cdef -maxwidth]
                     if {"$defminw$defmaxw" ne "" && $defminw eq $defmaxw} {
                         #an exact width is defined for the column - no need to look at data width
                         set colwidth $defminw
                     } else {
                         #set widest [my column_datawidth $cidx -headers 1 -data 1 -footers 1]
-                        set hwidest [dict get $o_columnstates $cidx maxwidthheaderseen]
+                        set hwidest [tcl::dict::get $o_columnstates $cidx maxwidthheaderseen]
                         #set hwidest [my column_datawidth $cidx -headers 1 -colspan 1 -data 0 -footers 1]
                         #set hwidest_singlespan ??
-                        set bwidest [dict get $o_columnstates $cidx maxwidthbodyseen]
+                        set bwidest [tcl::dict::get $o_columnstates $cidx maxwidthbodyseen]
                         set widest [expr {max($hwidest,$bwidest)}]
                         #todo - predetermine if any items in column contain newlines and are truncated vertically due to o_rowdefs configuration.
                         #if so - a truncated line shouldn't be included in our width calculation
@@ -2561,13 +2607,13 @@ namespace eval textblock {
                 }
 
                 method column_width {index_expression} {
-                    if {[llength $o_calculated_column_widths] != [dict size $o_columndefs]} {
+                    if {[llength $o_calculated_column_widths] != [tcl::dict::size $o_columndefs]} {
                         my calculate_column_widths -algorithm $o_column_width_algorithm
                     }
                     return [lindex $o_calculated_column_widths $index_expression]
                 }
                 method column_widths {} {
-                    if {[llength $o_calculated_column_widths] != [dict size $o_columndefs]} {
+                    if {[llength $o_calculated_column_widths] != [tcl::dict::size $o_columndefs]} {
                         my calculate_column_widths -algorithm $o_column_width_algorithm
                     }
                     return $o_calculated_column_widths
@@ -2584,7 +2630,7 @@ namespace eval textblock {
                         incr twidth [llength $colwidths]
                         incr twidth -1
                     }
-                    if {[dict get $o_opts_table -show_edge]} {
+                    if {[tcl::dict::get $o_opts_table -show_edge]} {
                         incr twidth 2
                     }
                     return $twidth
@@ -2592,22 +2638,22 @@ namespace eval textblock {
 
                 #column *body* content width
                 method basic_column_width {index_expression} {
-                    set cidx [lindex [dict keys $o_columndefs] $index_expression]
+                    set cidx [lindex [tcl::dict::keys $o_columndefs] $index_expression]
                     if {$cidx eq ""} {
                         return
                     }
                     #puts "===column_width $index_expression"
                     #assert cidx is now >=0 integer within the range of defined columns
-                    set cdef [dict get $o_columndefs $cidx]
-                    set defminw     [dict get $cdef -minwidth]
-                    set defmaxw     [dict get $cdef -maxwidth]
+                    set cdef [tcl::dict::get $o_columndefs $cidx]
+                    set defminw     [tcl::dict::get $cdef -minwidth]
+                    set defmaxw     [tcl::dict::get $cdef -maxwidth]
                     if {"$defminw$defmaxw" ne "" && $defminw eq $defmaxw} {
                         #an exact width is defined for the column - no need to look at data width
                         #review - this can result in truncation of spanning headers - even though there is enough width in the span-cell to place the full header
                         set colwidth $defminw
                     } else {
                         #set widest [my column_datawidth $cidx -headers 0 -data 1 -footers 0]
-                        set widest [dict get $o_columnstates $cidx maxwidthbodyseen]
+                        set widest [tcl::dict::get $o_columnstates $cidx maxwidthbodyseen]
                         #todo - predetermine if any items in column contain newlines and are truncated vertically due to o_rowdefs configuration.
                         #if so - a truncated line shouldn't be included in our width calculation
                         if {$defminw eq ""} {
@@ -2633,21 +2679,21 @@ namespace eval textblock {
                         }
                     }
                     set configured_widths [list]
-                    foreach c [dict keys $o_columndefs] {
+                    foreach c [tcl::dict::keys $o_columndefs] {
                         lappend configured_widths [my column_width_configured $c]
                     }
                     set header_colspans [my header_colspans]
                     set width_max $colwidth 
                     set test_width $colwidth
                     set showing_vseps [my Showing_vseps]
-                    dict for {h colspans} $header_colspans {
+                    set thiscol_widest_header [tcl::dict::get $o_columnstates $cidx maxwidthheaderseen]
+                    tcl::dict::for {h colspans} $header_colspans {
                         set spanc [lindex $colspans $cidx]
-                        #set headers [dict get $cdef -headers]
+                        #set headers [tcl::dict::get $cdef -headers]
                         #set thiscol_widest_header 0
                         #if {[llength $headers] > 0} {
                         #    set thiscol_widest_header [tcl::mathfunc::max {*}[lmap v $headers {textblock::width $v}]]
                         #}
-                        set thiscol_widest_header [dict get $o_columnstates $cidx maxwidthheaderseen]
                         if {$spanc eq "1"} {
                             if {$thiscol_widest_header > $colwidth} {
                                 set test_width [expr {max($thiscol_widest_header,$colwidth)}]
@@ -2705,8 +2751,8 @@ namespace eval textblock {
                 }
                 method Showing_vseps {} {
                     #review - show_seps and override mechanism for show_vseps show_hseps - document.
-                    set seps [dict get $o_opts_table -show_seps]
-                    set vseps [dict get $o_opts_table -show_vseps]
+                    set seps [tcl::dict::get $o_opts_table -show_seps]
+                    set vseps [tcl::dict::get $o_opts_table -show_vseps]
                     if {$seps eq ""} {
                         if {$vseps eq "" || $vseps} {
                             return true
@@ -2724,7 +2770,7 @@ namespace eval textblock {
                 }
                 
                 method column_datawidth {index_expression args} {
-                    set opts [dict create\
+                    set opts [tcl::dict::create\
                         -headers 0\
                         -footers 0\
                         -colspan *\
@@ -2732,36 +2778,36 @@ namespace eval textblock {
                         -cached 1\
                     ]
                     #-colspan is relevant to header/footer data only
-                    dict for {k v} $args {
+                    foreach {k v} $args {
                         switch -- $k {
                             -headers - -footers - -colspan - -data - -cached {
-                                dict set opts $k $v
+                                tcl::dict::set opts $k $v
                             }
                             default {
-                                error "column_datawidth unrecognised flag '$k'. Known flags: [dict keys $opts]"
+                                error "column_datawidth unrecognised flag '$k'. Known flags: [tcl::dict::keys $opts]"
                             }
                         }
                     }
-                    set opt_colspan [dict get $opts -colspan]
+                    set opt_colspan [tcl::dict::get $opts -colspan]
 
 
-                    set cidx [lindex [dict keys $o_columndefs] $index_expression]
+                    set cidx [lindex [tcl::dict::keys $o_columndefs] $index_expression]
                     if {$cidx eq ""} {
                         return
                     }
 
-                    if {[dict get $opts -cached]} {
+                    if {[tcl::dict::get $opts -cached]} {
                         set hwidest 0
                         set bwidest 0
                         set fwidest 0
-                        if {[dict get $opts -headers]} {
+                        if {[tcl::dict::get $opts -headers]} {
                             if {$opt_colspan eq "*"} {
-                                set hwidest [dict get $o_columnstates $cidx maxwidthheaderseen]
+                                set hwidest [tcl::dict::get $o_columnstates $cidx maxwidthheaderseen]
                             } else {
-                                set colheaders [dict get $o_columndefs $cidx -headers]
+                                set colheaders [tcl::dict::get $o_columndefs $cidx -headers]
                                 set all_colspans_by_header [my header_colspans]
                                 set hlist [list]
-                                dict for {hrow cspans} $all_colspans_by_header {
+                                tcl::dict::for {hrow cspans} $all_colspans_by_header {
                                     set s [lindex $cspans $cidx]
                                     #todo - map 'all' entries to a number?
                                     #we should build a version of header_colspans that does this
@@ -2769,7 +2815,7 @@ namespace eval textblock {
                                         lappend hlist [lindex $colheaders $hrow]
                                     }
                                 }
-                                #set widest1 [tcl::mathfunc::max {*}[lmap v $cmds  {string length $v}]]
+                                #set widest1 [tcl::mathfunc::max {*}[lmap v $cmds  {tcl::string::length $v}]]
                                 if {[llength $hlist]} {
                                     set hwidest [tcl::mathfunc::max {*}[lmap v $hlist  {textblock::width $v}]]
                                 } else {
@@ -2777,28 +2823,28 @@ namespace eval textblock {
                                 }
                             }
                         }
-                        if {[dict get $opts -data]} {
-                            set bwidest [dict get $o_columnstates $cidx maxwidthbodyseen]
+                        if {[tcl::dict::get $opts -data]} {
+                            set bwidest [tcl::dict::get $o_columnstates $cidx maxwidthbodyseen]
                         }
-                        if {[dict get $opts -footers]} {
+                        if {[tcl::dict::get $opts -footers]} {
                             #TODO!
-                            #set bwidest [dict get $o_columnstates $cidx maxwidthfooterseen]
+                            #set bwidest [tcl::dict::get $o_columnstates $cidx maxwidthfooterseen]
                         }
                         return [expr {max($hwidest,$bwidest,$fwidest)}]
                     }
 
                     #assert cidx is >=0 integer in valid range of keys for o_columndefs
                     set values [list]
-                    if {[dict get $opts -headers]} {
-                        lappend values {*}[dict get $o_columndefs $cidx -headers]
+                    if {[tcl::dict::get $opts -headers]} {
+                        lappend values {*}[tcl::dict::get $o_columndefs $cidx -headers]
                     }
-                    if {[dict get $opts -data]} {
-                        if {[dict exists $o_columndata $cidx]} {
-                            lappend values {*}[dict get $o_columndata $cidx]
+                    if {[tcl::dict::get $opts -data]} {
+                        if {[tcl::dict::exists $o_columndata $cidx]} {
+                            lappend values {*}[tcl::dict::get $o_columndata $cidx]
                         }
                     }
-                    if {[dict get $opts -footers]} {
-                        lappend values {*}[dict get $o_columndefs $cidx -footers]
+                    if {[tcl::dict::get $opts -footers]} {
+                        lappend values {*}[tcl::dict::get $o_columndefs $cidx -footers]
                     }
                     if {[llength $values]} {
                         set widest [tcl::mathfunc::max {*}[lmap v $values {textblock::width $v}]]
@@ -2810,12 +2856,12 @@ namespace eval textblock {
                 #print1 uses basic column joining - useful for testing/debug especially with colspans 
                 method print1 {args} {
                     if {![llength $args]} {
-                        set cols [dict keys $o_columndata]
+                        set cols [tcl::dict::keys $o_columndata]
                     } else {
                         set cols [list]
                         foreach colspec $args {
-                            set allcols [dict keys $o_columndata]
-                            if {[string first .. $colspec] >=0} {
+                            set allcols [tcl::dict::keys $o_columndata]
+                            if {[tcl::string::first .. $colspec] >=0} {
                                 set parts [punk::ansi::ta::_perlish_split {\.\.} $colspec]
                                 if {[llength $parts] != 3} {
                                     error "[namespace::current]::table error invalid print specification '$colspec'"
@@ -2852,20 +2898,20 @@ namespace eval textblock {
                         incr colposn
                     }
                     if {[llength $blocks]} {
-                        return [textblock::join {*}$blocks] 
+                        return [textblock::join -- {*}$blocks] 
                     } else {
                         return "No columns matched"
                     }
                 }
                 method columncalc_spans {allocmethod} {
-                    set colwidths [dict create] ;# to use dict incr 
-                    set colspace_added [dict create]
+                    set colwidths [tcl::dict::create] ;# to use tcl::dict::incr 
+                    set colspace_added [tcl::dict::create]
                     
-                    set ordered_spans [dict create]
-                    dict for {col spandata} [my spangroups] {
+                    set ordered_spans [tcl::dict::create]
+                    tcl::dict::for {col spandata} [my spangroups] {
                         set dwidth [my column_datawidth $col -data 1 -headers 0 -footers 0 -cached 1]
-                        set minwidth [dict get $o_columndefs $col -minwidth]
-                        set maxwidth [dict get $o_columndefs $col -maxwidth]
+                        set minwidth [tcl::dict::get $o_columndefs $col -minwidth]
+                        set maxwidth [tcl::dict::get $o_columndefs $col -maxwidth]
                         if {$minwidth ne ""} {
                             if {$dwidth < $minwidth} {
                                 set dwidth $minwidth
@@ -2876,40 +2922,61 @@ namespace eval textblock {
                                 set dwidth $maxwidth
                             }
                         }
-                        dict set colwidths $col $dwidth ;#spangroups is ordered by column - so colwidths dict will be correctly ordered
-                        dict set colspace_added $col 0 
+                        tcl::dict::set colwidths $col $dwidth ;#spangroups is ordered by column - so colwidths dict will be correctly ordered
+                        tcl::dict::set colspace_added $col 0 
 
-                        set spanlengths [dict get $spandata spanlengths]
+                        set spanlengths [tcl::dict::get $spandata spanlengths]
                         foreach slen $spanlengths {
-                            set spans [dict get $spandata spangroups $slen]
+                            set spans [tcl::dict::get $spandata spangroups $slen]
                             set spans [lsort  -index 7 -integer $spans]
                             foreach s $spans {
-                                set hwidth [dict get $s headerwidth]
-                                set hrow [dict get $s hrow]
-                                set scol [dict get $s startcol]
-                                dict set ordered_spans $scol,$hrow membercols $col $dwidth 
-                                dict set ordered_spans $scol,$hrow headerwidth $hwidth
+                                set hwidth [tcl::dict::get $s headerwidth]
+                                set hrow [tcl::dict::get $s hrow]
+                                set scol [tcl::dict::get $s startcol]
+                                tcl::dict::set ordered_spans $scol,$hrow membercols $col $dwidth 
+                                tcl::dict::set ordered_spans $scol,$hrow headerwidth $hwidth
                             }
                         }
                     }
-                    
-                    dict for {spanid spandata} $ordered_spans {
+
+                    #safe jumptable test 
+                    #dict for {spanid spandata} $ordered_spans {}
+                    tcl::dict::for {spanid spandata} $ordered_spans {
                         lassign [split $spanid ,] startcol hrow
-                        set memcols [dict get $spandata membercols] ;#dict with col and initial width - we ignore initial width, it's there in case we want to allocate space based on initial data width ratios
-                        set colids  [dict keys $memcols]
-                        set hwidth  [dict get $spandata headerwidth]
-                        set num_cols_spanned [dict size $memcols]
+                        set memcols [tcl::dict::get $spandata membercols] ;#dict with col and initial width - we ignore initial width, it's there in case we want to allocate space based on initial data width ratios
+                        set colids  [tcl::dict::keys $memcols]
+                        set hwidth  [tcl::dict::get $spandata headerwidth]
+                        set num_cols_spanned [tcl::dict::size $memcols]
                         if {$num_cols_spanned == 1} {
                             set col [lindex $memcols 0]
-                            set space_to_alloc [expr {$hwidth - [dict get $colwidths $col]}]
+                            set space_to_alloc [expr {$hwidth - [tcl::dict::get $colwidths $col]}]
                             if {$space_to_alloc > 0} { 
-                                dict set colwidths $col $hwidth
-                                dict set colspace_added $col $space_to_alloc
+                                set maxwidth [tcl::dict::get $o_columndefs $col -maxwidth]
+                                if {$maxwidth ne ""} {
+                                    if {$maxwidth > [tcl::dict::get $colwidths $col]} {
+                                        set can_alloc [expr {$maxwidth - [tcl::dict::get $colwidths $col]}]
+                                    } else {
+                                        set can_alloc 0
+                                    }
+                                    set will_alloc [expr {min($space_to_alloc,$can_alloc)}]
+                                } else {
+                                    set will_alloc $space_to_alloc 
+                                }
+                                if {$will_alloc} {
+                                    #tcl::dict::set colwidths $col $hwidth
+                                    tcl::dict::incr colwidths $col $will_alloc
+                                    tcl::dict::set colspace_added $col $will_alloc
+                                }
+                                #log!
+                                #if {$will_alloc < $space_to_alloc} {
+                                #    #todo - debug only
+                                #    puts stderr "max width $maxwidth hit for col $col - cannot allocate extra [expr {$space_to_alloc - $will_alloc}]"
+                                #}
                             }
                         } elseif {$num_cols_spanned > 1} {
                             set spannedwidth 0
                             foreach col $colids {
-                                incr spannedwidth [dict get $colwidths $col]
+                                incr spannedwidth [tcl::dict::get $colwidths $col]
                             }
                             set space_to_alloc [expr {$hwidth - $spannedwidth}]
                             if {[my Showing_vseps]} {
@@ -2918,13 +2985,13 @@ namespace eval textblock {
                             } 
                             #review - we want to reduce overallocation to earlier or later columns - hence the use of colspace_added
                             switch -- $allocmethod {
-                                0 {
+                                least {
                                     #add to least-expanded each time
                                     #safer than method 1 - pretty balanced  
                                     if {$space_to_alloc > 0} {
                                         for {set i 0} {$i < $space_to_alloc} {incr i} {
                                             set ordered_colspace_added [lsort -stride 2 -index 1 -integer $colspace_added]
-                                            set ordered_all_colids [dict keys $ordered_colspace_added]
+                                            set ordered_all_colids [tcl::dict::keys $ordered_colspace_added]
                                             foreach testcolid $ordered_all_colids {
                                                 if {$testcolid in $colids} {
                                                     #assert - we will always find a match
@@ -2932,21 +2999,53 @@ namespace eval textblock {
                                                     break
                                                 }
                                             }
-                                            dict incr colwidths $colid
-                                            dict incr colspace_added $colid
+                                            tcl::dict::incr colwidths $colid
+                                            tcl::dict::incr colspace_added $colid
                                         }
                                     }
                                 }
-                                1 {
+                                least_unmaxed {
+                                    #TODO - fix header truncation/overflow issues when they are restricted by column maxwidth 
+                                    #(we should be able to collapse column width to zero and have header colspans gracefully respond)
+                                    #add to least-expanded each time
+                                    #safer than method 1 - pretty balanced  
+                                    if {$space_to_alloc > 0} {
+                                        for {set i 0} {$i < $space_to_alloc} {incr i} {
+                                            set ordered_colspace_added [lsort -stride 2 -index 1 -integer $colspace_added]
+                                            set ordered_all_colids [tcl::dict::keys $ordered_colspace_added]
+                                            set colid ""
+                                            foreach testcolid $ordered_all_colids {
+                                                set maxwidth [tcl::dict::get $o_columndefs $testcolid -maxwidth]
+                                                set can_alloc [expr {$maxwidth eq "" || $maxwidth > [tcl::dict::get $colwidths $testcolid]}]
+                                                if {$testcolid in $colids} {
+                                                    if {$can_alloc} {
+                                                        set colid $testcolid
+                                                        break
+                                                    } else {
+                                                        #remove from future consideration in for loop
+                                                        #log!
+                                                        #puts stderr "max width $maxwidth hit for col $testcolid"
+                                                        tcl::dict::unset colspace_added $testcolid
+                                                    }
+                                                }
+                                            }
+                                            if {$colid ne ""} {
+                                                tcl::dict::incr colwidths $colid
+                                                tcl::dict::incr colspace_added $colid
+                                            }
+                                        }
+                                    }
+                                }
+                                all {
                                     #adds space to all columns - not just those spanned - risk of underallocating and truncating some headers!
                                     #probably not a good idea for tables with complex headers and spans
                                     while {$space_to_alloc > 0} {
                                         set ordered_colspace_added [lsort -stride 2 -index 1 -integer $colspace_added]
-                                        set ordered_colids [dict keys $ordered_colspace_added]
+                                        set ordered_colids [tcl::dict::keys $ordered_colspace_added]
 
                                         foreach col $ordered_colids  {
-                                            dict incr colwidths $col
-                                            dict incr colspace_added $col 
+                                            tcl::dict::incr colwidths $col
+                                            tcl::dict::incr colspace_added $col 
                                             incr space_to_alloc -1
                                             if {$space_to_alloc == 0} {
                                                 break
@@ -2959,17 +3058,17 @@ namespace eval textblock {
                         }
                     }
 
-                    set column_widths [dict values $colwidths]
+                    set column_widths [tcl::dict::values $colwidths]
                     #todo - -maxwidth etc
-                    set table_minwidth [dict get $o_opts_table -minwidth] ;#min width including frame elements
-                    if {[string is integer -strict $table_minwidth]} {
+                    set table_minwidth [tcl::dict::get $o_opts_table -minwidth] ;#min width including frame elements
+                    if {[tcl::string::is integer -strict $table_minwidth]} {
                         set contentwidth [tcl::mathop::+ {*}$column_widths]
                         set twidth $contentwidth
                         if {[my Showing_vseps]} {
                             incr twidth [llength $column_widths]
                             incr twidth -1
                         }
-                        if {[dict get $o_opts_table -show_edge]} {
+                        if {[tcl::dict::get $o_opts_table -show_edge]} {
                             incr twidth 2
                         }
                         #
@@ -2978,18 +3077,18 @@ namespace eval textblock {
                             set space_to_alloc $shortfall
                             while {$space_to_alloc > 0} {
                                 set ordered_colspace_added [lsort -stride 2 -index 1 -integer $colspace_added]
-                                set ordered_colids [dict keys $ordered_colspace_added]
+                                set ordered_colids [tcl::dict::keys $ordered_colspace_added]
 
                                 foreach col $ordered_colids  {
-                                    dict incr colwidths $col
-                                    dict incr colspace_added $col 
+                                    tcl::dict::incr colwidths $col
+                                    tcl::dict::incr colspace_added $col 
                                     incr space_to_alloc -1
                                     if {$space_to_alloc == 0} {
                                         break
                                     }
                                 }
                             }
-                            set column_widths [dict values $colwidths]
+                            set column_widths [tcl::dict::values $colwidths]
                         }
 
                     }
@@ -2999,11 +3098,11 @@ namespace eval textblock {
 
                 #spangroups keyed by column 
                 method spangroups {} {
-                    set column_count [dict size $o_columndefs]
-                    set spangroups [dict create]
-                    set headerwidths [dict create] ;#key on col,hrow
-                    foreach c [dict keys $o_columndefs] {
-                        dict set spangroups $c [list spanlengths {}]
+                    set column_count [tcl::dict::size $o_columndefs]
+                    set spangroups [tcl::dict::create]
+                    set headerwidths [tcl::dict::create] ;#key on col,hrow
+                    foreach c [tcl::dict::keys $o_columndefs] {
+                        tcl::dict::set spangroups $c [list spanlengths {}]
                         set spanlist [my column_get_spaninfo $c]
                         set index_spanlen_val 5
                         set spanlist [lsort -index $index_spanlen_val -integer $spanlist] 
@@ -3015,37 +3114,37 @@ namespace eval textblock {
                             set sgroup [list]
                             foreach p $spangroup_posns {
                                 set spaninfo [lindex $ungrouped $p]
-                                set hcol [dict get $spaninfo startcol]
-                                set hrow [dict get $spaninfo hrow]
-                                set header [lindex [dict get $o_columndefs $hcol -headers] $hrow]
-                                if {[dict exists $headerwidths $hcol,$hrow]} {
-                                    set hwidth [dict get $headerwidths $hcol,$hrow]
+                                set hcol [tcl::dict::get $spaninfo startcol]
+                                set hrow [tcl::dict::get $spaninfo hrow]
+                                set header [lindex [tcl::dict::get $o_columndefs $hcol -headers] $hrow]
+                                if {[tcl::dict::exists $headerwidths $hcol,$hrow]} {
+                                    set hwidth [tcl::dict::get $headerwidths $hcol,$hrow]
                                 } else {
                                     set hwidth [textblock::width $header]
-                                    dict set headerwidths $hcol,$hrow $hwidth
+                                    tcl::dict::set headerwidths $hcol,$hrow $hwidth
                                 }
                                 lappend spaninfo headerwidth $hwidth
                                 lappend sgroup $spaninfo  
                             }
-                            set spanlengths [dict get $spangroups $c spanlengths]
+                            set spanlengths [tcl::dict::get $spangroups $c spanlengths]
                             lappend spanlengths $spanlen
-                            dict set spangroups $c spanlengths $spanlengths
-                            dict set spangroups $c spangroups $spanlen  $sgroup
+                            tcl::dict::set spangroups $c spanlengths $spanlengths
+                            tcl::dict::set spangroups $c spangroups $spanlen  $sgroup
                             set ungrouped [lremove $ungrouped {*}$spangroup_posns]
                         } 
                     }
                     return $spangroups
                 }
                 method column_get_own_spans {cidx} {
-                    set colspans_for_column [dict get $o_columndefs $cidx -header_colspans]
+                    set colspans_for_column [tcl::dict::get $o_columndefs $cidx -header_colspans]
                 }
                 method column_get_spaninfo {cidx} {
                     set spans_by_header [my header_colspans]
-                    set colspans_for_column [dict get $o_columndefs $cidx -header_colspans]
+                    set colspans_for_column [tcl::dict::get $o_columndefs $cidx -header_colspans]
                     set spaninfo [list]
-                    set numcols [dict size $o_columndefs]
+                    set numcols [tcl::dict::size $o_columndefs]
                     #note that 'all' can occur in positions other than column 0 - meaning all remaining
-                    dict for {hrow rawspans} $spans_by_header {
+                    tcl::dict::for {hrow rawspans} $spans_by_header {
                         set thiscol_spanval [lindex $rawspans $cidx]
                         if {$thiscol_spanval eq "all" || $thiscol_spanval > 0} {
                             set spanstartcol $cidx ;#own column
@@ -3075,22 +3174,22 @@ namespace eval textblock {
                     return $spaninfo
                 }
                 method calculate_column_widths {args} {
-                    set column_count [dict size $o_columndefs]
+                    set column_count [tcl::dict::size $o_columndefs]
 
-                    set opts [dict create\
+                    set opts [tcl::dict::create\
                         -algorithm $o_column_width_algorithm\
                     ]
-                    dict for {k v} $args {
+                    foreach {k v} $args {
                         switch -- $k {
                             -algorithm {
-                                dict set opts $k $v
+                                tcl::dict::set opts $k $v
                             }
                             default {
-                                error "Unknown option '$k'. Known options: [dict keys $opts]"
+                                error "Unknown option '$k'. Known options: [tcl::dict::keys $opts]"
                             }
                         }
                     }
-                    set opt_algorithm [dict get $opts -algorithm]
+                    set opt_algorithm [tcl::dict::get $opts -algorithm]
                     #puts stderr "--- recalculating column widths -algorithm $opt_algorithm"
                     set known_algorithms [list basic simplistic span span2]
                     switch -- $opt_algorithm {
@@ -3114,13 +3213,14 @@ namespace eval textblock {
                         }
                         span {
                             #widest of smallest spans first method 
-                            set calcresult [my columncalc_spans 0]
-                            set o_calculated_column_widths [dict get $calcresult colwidths]
+                            #set calcresult [my columncalc_spans least]
+                            set calcresult [my columncalc_spans least_unmaxed]
+                            set o_calculated_column_widths [tcl::dict::get $calcresult colwidths]
                         }
                         span2 {
                             #allocates more evenly - but truncates headers sometimes
-                            set calcresult [my columncalc_spans 1]
-                            set o_calculated_column_widths [dict get $calcresult colwidths]
+                            set calcresult [my columncalc_spans all]
+                            set o_calculated_column_widths [tcl::dict::get $calcresult colwidths]
                         }
                         default {
                             error "calculate_column_widths unknown algorithm $opt_algorithm. Known algorithms: $known_algorithms"
@@ -3130,17 +3230,17 @@ namespace eval textblock {
                     set o_column_width_algorithm $opt_algorithm
                     return $o_calculated_column_widths
                 }
-                method print {args} {
+                method print2 {args} {
                     variable full_column_cache 
-                    set full_column_cache [dict create]
+                    set full_column_cache [tcl::dict::create]
 
                     if {![llength $args]} {
-                        set cols [dict keys $o_columndata]
+                        set cols [tcl::dict::keys $o_columndata]
                     } else {
                         set cols [list]
                         foreach colspec $args {
-                            set allcols [dict keys $o_columndata]
-                            if {[string first .. $colspec] >=0} {
+                            set allcols [tcl::dict::keys $o_columndata]
+                            if {[tcl::string::first .. $colspec] >=0} {
                                 set parts [punk::ansi::ta::_perlish_split {\.\.} $colspec]
                                 if {[llength $parts] != 3} {
                                     error "[namespace::current]::table error invalid print specification '$colspec'"
@@ -3177,21 +3277,21 @@ namespace eval textblock {
                         }
                         #lappend blocks [my get_column_by_index $c {*}$flags]
                         #todo - only check and store in cache if table has header or footer colspans > 1
-                        if {[dict exists $full_column_cache $c]} {
+                        if {[tcl::dict::exists $full_column_cache $c]} {
                             #puts "!!print used full_column_cache for $c"
-                            set columninfo [dict get $full_column_cache $c]
+                            set columninfo [tcl::dict::get $full_column_cache $c]
                         } else {
                             set columninfo [my get_column_by_index $c -return dict {*}$flags]
-                            dict set full_column_cache $c $columninfo
+                            tcl::dict::set full_column_cache $c $columninfo
                         }
-                        set nextcol     [dict get $columninfo column]
-                        set bodywidth   [dict get $columninfo bodywidth] 
+                        set nextcol     [tcl::string::cat [tcl::dict::get $columninfo header] \n [tcl::dict::get $columninfo body]]
+                        set bodywidth   [tcl::dict::get $columninfo bodywidth] 
 
                         if {$table eq ""} {
                             set table $nextcol 
                             set height [textblock::height $table] ;#only need to get height once at start
                         } else {
-                            set nextcol [textblock::join [textblock::block $padwidth $height $TSUB] $nextcol]
+                            set nextcol [textblock::join -- [textblock::block $padwidth $height $TSUB] $nextcol]
                             set table [overtype::renderspace -overflow 1 -experimental test_mode -transparent $TSUB $table[unset table] $nextcol]
                             #JMN
 
@@ -3204,24 +3304,255 @@ namespace eval textblock {
 
                     if {[llength $cols]} {
                         #return [textblock::join {*}$blocks] 
-                        if {[dict get $o_opts_table -show_edge]} {
+                        if {[tcl::dict::get $o_opts_table -show_edge]} {
+                            #title is considered part of the edge ?
+                            set offset 1  ;#make configurable?
+                            set titlepad [tcl::string::repeat $TSUB $offset]
+                            if {[tcl::dict::get $o_opts_table -title] ne ""} {
+                                set titlealign [tcl::dict::get $o_opts_table -titlealign]
+                                switch -- $titlealign {
+                                    left {
+                                        set tstring $titlepad[tcl::dict::get $o_opts_table -title]
+                                    }
+                                    right {
+                                        set tstring [tcl::dict::get $o_opts_table -title]$titlepad
+                                    }
+                                    default {
+                                        set tstring [tcl::dict::get $o_opts_table -title]
+                                    }
+                                }
+                                set opt_titletransparent [tcl::dict::get $o_opts_table -titletransparent]
+                                switch -- $opt_titletransparent {
+                                    0 { 
+                                        set mapchar ""
+                                    }
+                                    1 {
+                                        set mapchar " "
+                                    }
+                                    default {
+                                        #won't work if not a single char - review - check also frame behaviour
+                                        set mapchar $opt_titletransparent
+                                    }
+                                }
+                                if {$mapchar ne ""} {
+                                    set tstring [tcl::string::map [list $mapchar $TSUB] $tstring]
+                                }
+                                set table [overtype::block -blockalign $titlealign -transparent $TSUB  $table[unset table] $tstring]
+                            }
+                        }
+                        return $table
+                    } else {
+                        return "No columns matched"
+                    }
+                }
+
+                # using -startcolumn to do slightly less work
+                method print3 {args} {
+                    if {![llength $args]} {
+                        set cols [tcl::dict::keys $o_columndata]
+                    } else {
+                        set cols [list]
+                        foreach colspec $args {
+                            set allcols [tcl::dict::keys $o_columndata]
+                            if {[tcl::string::first .. $colspec] >=0} {
+                                set parts [punk::ansi::ta::_perlish_split {\.\.} $colspec]
+                                if {[llength $parts] != 3} {
+                                    error "[namespace::current]::table error invalid print specification '$colspec'"
+                                }
+                                lassign $parts from _dd to
+                                if {$from eq ""}    {set from 0}
+                                if {$to eq ""}      {set to end}
+
+                                set indices [lrange $allcols $from $to]
+                                lappend cols {*}$indices
+                            } else {
+                                set c [lindex $allcols $colspec]
+                                if {$c ne ""} {
+                                    lappend cols $c
+                                }
+                            }
+                        }
+                    }
+                    set blocks [list]
+                    set numposns [llength $cols]
+                    set colposn  0 
+                    set padwidth 0
+                    set table ""
+                    foreach c $cols {
+                        set flags [list]
+                        if {$colposn == 0 && $colposn == $numposns-1} {
+                            set flags [list -position solo]
+                        } elseif {$colposn == 0} {
+                            set flags [list -position left]
+                        } elseif {$colposn == $numposns-1} {
+                            set flags [list -position right]
+                        } else {
+                            set flags [list -position inner]
+                        }
+                        set columninfo [my get_column_by_index $c -return dict {*}$flags]
+                        set nextcol     [tcl::string::cat [tcl::dict::get $columninfo header] \n [tcl::dict::get $columninfo body]]
+                        set bodywidth   [tcl::dict::get $columninfo bodywidth] 
+
+                        if {$table eq ""} {
+                            set table $nextcol 
+                            set height [textblock::height $table] ;#only need to get height once at start
+                        } else {
+                            set table [overtype::renderspace -startcolumn [expr {$padwidth + 1}] -overflow 1 -experimental test_mode -transparent $TSUB $table $nextcol]
+
+                            #set nextcol [textblock::join [textblock::block $padwidth $height $TSUB] $nextcol]
+                            #set table [overtype::renderspace -overflow 1 -experimental test_mode -transparent $TSUB $table[unset table] $nextcol]
+                            #JMN
+
+                            #set nextcol [textblock::join [textblock::block $padwidth $height "\uFFFF"] $nextcol]
+                            #set table [overtype::renderspace -overflow 1 -experimental test_mode -transparent \uFFFF $table $nextcol]
+                        }
+                        incr padwidth $bodywidth 
+                        incr colposn
+                    }
+
+                    if {[llength $cols]} {
+                        #return [textblock::join {*}$blocks] 
+                        if {[tcl::dict::get $o_opts_table -show_edge]} {
+                            #title is considered part of the edge ?
+                            set offset 1  ;#make configurable?
+                            set titlepad [tcl::string::repeat $TSUB $offset]
+                            if {[tcl::dict::get $o_opts_table -title] ne ""} {
+                                set titlealign [tcl::dict::get $o_opts_table -titlealign]
+                                switch -- $titlealign {
+                                    left {
+                                        set tstring $titlepad[tcl::dict::get $o_opts_table -title]
+                                    }
+                                    right {
+                                        set tstring [tcl::dict::get $o_opts_table -title]$titlepad
+                                    }
+                                    default {
+                                        set tstring [tcl::dict::get $o_opts_table -title]
+                                    }
+                                }
+                                set opt_titletransparent [tcl::dict::get $o_opts_table -titletransparent]
+                                switch -- $opt_titletransparent {
+                                    0 { 
+                                        set mapchar ""
+                                    }
+                                    1 {
+                                        set mapchar " "
+                                    }
+                                    default {
+                                        #won't work if not a single char - review - check also frame behaviour
+                                        set mapchar $opt_titletransparent
+                                    }
+                                }
+                                if {$mapchar ne ""} {
+                                    set tstring [tcl::string::map [list $mapchar $TSUB] $tstring]
+                                }
+                                set table [overtype::block -blockalign $titlealign -transparent $TSUB  $table[unset table] $tstring]
+                            }
+                        }
+                        return $table
+                    } else {
+                        return "No columns matched"
+                    }
+                }
+
+                #print headers and body using different join mechanisms
+                # using -startcolumn to do slightly less work
+                method print {args} {
+                    if {![llength $args]} {
+                        set cols [tcl::dict::keys $o_columndata]
+                    } else {
+                        set cols [list]
+                        foreach colspec $args {
+                            set allcols [tcl::dict::keys $o_columndata]
+                            if {[tcl::string::first .. $colspec] >=0} {
+                                set parts [punk::ansi::ta::_perlish_split {\.\.} $colspec]
+                                if {[llength $parts] != 3} {
+                                    error "[namespace::current]::table error invalid print specification '$colspec'"
+                                }
+                                lassign $parts from _dd to
+                                if {$from eq ""}    {set from 0}
+                                if {$to eq ""}      {set to end}
+
+                                set indices [lrange $allcols $from $to]
+                                lappend cols {*}$indices
+                            } else {
+                                set c [lindex $allcols $colspec]
+                                if {$c ne ""} {
+                                    lappend cols $c
+                                }
+                            }
+                        }
+                    }
+                    set numposns [llength $cols]
+                    set colposn  0 
+                    set padwidth 0
+                    set header_build ""
+                    set body_blocks [list]
+                    set headerheight 0
+                    foreach c $cols {
+                        set flags [list]
+                        if {$colposn == 0 && $colposn == $numposns-1} {
+                            set flags [list -position solo]
+                        } elseif {$colposn == 0} {
+                            set flags [list -position left]
+                        } elseif {$colposn == $numposns-1} {
+                            set flags [list -position right]
+                        } else {
+                            set flags [list -position inner]
+                        }
+                        set columninfo [my get_column_by_index $c -return dict {*}$flags]
+                        #set nextcol         [tcl::dict::get $columninfo column]
+                        set bodywidth       [tcl::dict::get $columninfo bodywidth] 
+                        set headerheight    [tcl::dict::get $columninfo headerheight]
+                        #set nextcol_lines   [split $nextcol \n]
+                        #set nextcol_header  [join [lrange $nextcol_lines 0 $headerheight-1] \n]
+                        #set nextcol_body    [join [lrange $nextcol_lines $headerheight end] \n]
+                        set nextcol_header  [tcl::dict::get $columninfo header]
+                        set nextcol_body    [tcl::dict::get $columninfo body]
+
+                        if {$header_build eq "" && ![llength $body_blocks]} {
+                            set header_build $nextcol_header 
+                            lappend body_blocks $nextcol_body
+                        } else {
+                            if {$headerheight > 0} {
+                                set header_build [overtype::renderspace -startcolumn [expr {$padwidth + 1}] -overflow 1 -experimental test_mode -transparent $TSUB $header_build[unset header_build] $nextcol_header[unset nextcol_header]]
+                            }
+                            lappend body_blocks $nextcol_body
+                            #set body_build [textblock::join $body_build[unset body_build] $nextcol_body]
+                        }
+                        incr padwidth $bodywidth 
+                        incr colposn
+                    }
+                    if {![llength $body_blocks]} {
+                        set body_build ""
+                    } else {
+                        #body blocks should not be ragged - so can use join_basic
+                        set body_build [textblock::join_basic -- {*}$body_blocks]
+                    }
+                    if {$headerheight > 0} {
+                        set table [tcl::string::cat $header_build \n $body_build]
+                    } else {
+                        set table $body_build
+                    }
+
+                    if {[llength $cols]} {
+                        if {[tcl::dict::get $o_opts_table -show_edge]} {
                             #title is considered part of the edge ?
                             set offset 1  ;#make configurable?
-                            set titlepad [string repeat $TSUB $offset]
-                            if {[dict get $o_opts_table -title] ne ""} {
-                                set titlealign [dict get $o_opts_table -titlealign]
+                            set titlepad [tcl::string::repeat $TSUB $offset]
+                            if {[tcl::dict::get $o_opts_table -title] ne ""} {
+                                set titlealign [tcl::dict::get $o_opts_table -titlealign]
                                 switch -- $titlealign {
                                     left {
-                                        set tstring $titlepad[dict get $o_opts_table -title]
+                                        set tstring $titlepad[tcl::dict::get $o_opts_table -title]
                                     }
                                     right {
-                                        set tstring [dict get $o_opts_table -title]$titlepad
+                                        set tstring [tcl::dict::get $o_opts_table -title]$titlepad
                                     }
                                     default {
-                                        set tstring [dict get $o_opts_table -title]
+                                        set tstring [tcl::dict::get $o_opts_table -title]
                                     }
                                 }
-                                set opt_titletransparent [dict get $o_opts_table -titletransparent]
+                                set opt_titletransparent [tcl::dict::get $o_opts_table -titletransparent]
                                 switch -- $opt_titletransparent {
                                     0 { 
                                         set mapchar ""
@@ -3235,7 +3566,7 @@ namespace eval textblock {
                                     }
                                 }
                                 if {$mapchar ne ""} {
-                                    set tstring [string map [list $mapchar $TSUB] $tstring]
+                                    set tstring [tcl::string::map [list $mapchar $TSUB] $tstring]
                                 }
                                 set table [overtype::block -blockalign $titlealign -transparent $TSUB  $table[unset table] $tstring]
                             }
@@ -3263,17 +3594,17 @@ namespace eval textblock {
 #
 #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 *}
-        namespace import ::term::ansi::code::macros::cd::*
-        namespace eval ::term::ansi::code::macros::cd {namespace export -clear}
+tcl::namespace::eval textblock {
+    tcl::namespace::export block width
+    tcl::namespace::eval cd {
+        #todo - save and restore existing tcl::namespace::export in case macros::cd has default exports in future
+        tcl::namespace::eval ::term::ansi::code::macros::cd {tcl::namespace::export *}
+        tcl::namespace::import ::term::ansi::code::macros::cd::*
+        tcl::namespace::eval ::term::ansi::code::macros::cd {tcl::namespace::export -clear}
     }
     proc spantest {} {
-        set t [list_as_table 5 {a b c d e aa bb cc dd ee X Y} -return object]
-        $t configure_column 0 -headers {span3 span4 span5/5 "span-all etc blah 123 hmmmmm" span2}
+        set t [list_as_table -columns 5 -return tableobject {a b c d e aa bb cc dd ee X Y}]
+        $t configure_column 0 -headers [list span3 "1-span4\n2-span4 second line" span5/5 "span-all etc blah 123 hmmmmm" span2]
         $t configure_column 0 -header_colspans {3 4 5 all 2}
         $t configure_column 2 -headers {"" "" "" "" c2span2_etc}
         $t configure_column 2 -header_colspans {0 0 0 0 2}
@@ -3283,7 +3614,7 @@ namespace eval textblock {
 
     #more complex colspans 
     proc spantest2 {} {
-        set t [list_as_table 5 {a b c d e aa bb cc dd ee X Y} -return object]
+        set t [list_as_table -columns 5 -return tableobject {a b c d e aa bb cc dd ee X Y}]
         $t configure_column 0 -headers {c0span3 c0span4 c0span1 "c0span-all etc blah 123 hmmmmm" c0span2}
         $t configure_column 0 -header_colspans {3 4 1 all 2}
         $t configure_column 1 -header_colspans {0 0 2 0 0}
@@ -3294,7 +3625,7 @@ namespace eval textblock {
         return $t
     }
     proc spantest3 {} {
-        set t [list_as_table 5 {a b c d e aa bb cc dd ee X Y} -return object]
+        set t [list_as_table -columns 5 -return tableobjec {a b c d e aa bb cc dd ee X Y}]
         $t configure_column 0 -headers {c0span3 c0span4 c0span1 "c0span-all etc blah 123 hmmmmm" "c0span2 etc blah" c0span1}
         $t configure_column 0 -header_colspans {3 4 1 all 2 1}
         $t configure_column 1 -header_colspans {0 0 4 0 0 1}
@@ -3311,24 +3642,23 @@ namespace eval textblock {
     proc periodic {args} {
         #For an impressive interactive terminal app (javascript)
         # see: https://github.com/spirometaxas/periodic-table-cli
-
-        set opts [dict create\
-            -return "string"\
-            -compact 1\
-            -forcecolour 0\
-        ]
-        dict for {k v} $args {
-            switch -- $k {
-                -return - -compact - -forcecolour {
-                    dict set opts $k $v
-                }
-                default {
-                    "textblock::periodic unknown option '$k'. Known options: [dict keys $opts]"
-                }
-            }
-        }
-        set opt_return  [dict get $opts -return]
-        if {[dict get $opts -forcecolour]} {
+        set opts [dict get [punk::args::get_dict {
+            *proc -name textblock::periodic -help "A rudimentary periodic table
+            This is primarily a test of textblock::class::table"
+
+            -return         -default table\
+                            -choices {table tableobject}\
+                            -help "default choice 'table' returns the displayable table output"
+            -compact        -default 1  -type boolean  -help "compact true defaults: -show_vseps 0 -show_header 0 -show_edge 0"
+            -show_vseps     -default "" -type boolean
+            -show_header    -default "" -type boolean
+            -show_edge      -default "" -type boolean
+            -forcecolour    -default 0 -type boolean               -help "If punk::colour is off - this enables the produced table to still be ansi coloured"
+            *values -min 0 -max 0 
+        } $args] opts]
+
+        set opt_return  [tcl::dict::get $opts -return]
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc forcecolour
         } else {
             set fc ""
@@ -3350,82 +3680,82 @@ namespace eval textblock {
 
         set type_colours [list]
 
-        set ecat [dict create]
+        set ecat [tcl::dict::create]
 
         set cat_alkaline_earth [list Be Mg Ca Sr Ba Ra]
         set ansi [a+ {*}$fc web-black Web-gold]
         set val [list ansi $ansi cat alkaline_earth]
         foreach e $cat_alkaline_earth {
-            dict set ecat $e $val 
+            tcl::dict::set ecat $e $val 
         }
 
         set cat_reactive_nonmetal [list H C N O F P S Cl Se Br I]
         set ansi [a+ {*}$fc web-black Web-lightgreen] 
         set val [list ansi $ansi cat reactive_nonmetal]
         foreach e $cat_reactive_nonmetal {
-            dict set ecat $e $val
+            tcl::dict::set ecat $e $val
         }
 
         set cat [list Li Na K Rb Cs Fr]
         set ansi [a+ {*}$fc web-black Web-Khaki] 
         set val [list ansi $ansi cat alkali_metals]
         foreach e $cat {
-            dict set ecat $e $val
+            tcl::dict::set ecat $e $val
         }
 
         set cat [list Sc Ti V Cr Mn Fe Co Ni Cu Zn Y Zr Nb Mo Tc Ru Rh Pd Ag Cd Hf Ta W Re Os Ir Pt Au Hg Rf Db Sg Bh Hs] 
         set ansi [a+ {*}$fc web-black Web-lightsalmon] 
         set val [list ansi $ansi cat transition_metals]
         foreach e $cat {
-            dict set ecat $e $val
+            tcl::dict::set ecat $e $val
         }
 
         set cat [list Al Ga In Sn Tl Pb Bi Po]
         set ansi [a+ {*}$fc web-black Web-lightskyblue] 
         set val [list ansi $ansi cat post_transition_metals]
         foreach e $cat {
-            dict set ecat $e $val
+            tcl::dict::set ecat $e $val
         }
 
         set cat [list B Si Ge As Sb Te At]
         set ansi [a+ {*}$fc web-black Web-turquoise] 
         set val [list ansi $ansi cat metalloids]
         foreach e $cat {
-            dict set ecat $e $val
+            tcl::dict::set ecat $e $val
         }
 
         set cat [list He Ne Ar Kr Xe Rn]
         set ansi [a+ {*}$fc web-black Web-orchid] 
         set val [list ansi $ansi cat noble_gases]
         foreach e $cat {
-            dict set ecat $e $val
+            tcl::dict::set ecat $e $val
         }
 
         set cat [list Ac Th Pa U Np Pu Am Cm Bk Cf Es Fm Md No Lr]
         set ansi [a+ {*}$fc web-black Web-plum] 
         set val [list ansi $ansi cat actinoids]
         foreach e $cat {
-            dict set ecat $e $val
+            tcl::dict::set ecat $e $val
         }
 
         set cat [list La Ce Pr Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu]
         set ansi [a+ {*}$fc web-black Web-tan] 
         set val [list ansi $ansi cat lanthanoids]
         foreach e $cat {
-            dict set ecat $e $val
+            tcl::dict::set ecat $e $val
         }
 
-        set cat [list Mt Ds Rg Cn Nh Fl Mc Lv Ts Og]
         set ansi [a+ {*}$fc web-black Web-whitesmoke] 
         set val [list ansi $ansi cat other]
-        foreach e $cat {
-            dict set ecat $e $val
+        foreach e [list Mt Ds Rg Cn Nh Fl Mc Lv Ts Og] {
+            tcl::dict::set ecat $e $val
         }
 
         set elements1 [list]
+        set RST [a+]
         foreach e $elements {
-            if {[dict exists $ecat $e]} {
-                set ansi [dict get $ecat $e ansi]
+            if {[tcl::dict::exists $ecat $e]} {
+                set ansi [tcl::dict::get $ecat $e ansi]
                 #lappend elements1 [textblock::pad $ansi$e -width 2 -which right]
                 #no need to pad here - table column_configure -textalign default of left will do the work of padding right anyway
                 lappend elements1 $ansi$e
@@ -3434,7 +3764,8 @@ namespace eval textblock {
             }
         }
 
-        set t [list_as_table 19 $elements1 -return obj]
+        set t [list_as_table -columns 19 -return tableobject $elements1]
+        #(defaults to show_hseps 0)
 
         #todo - keep simple table with symbols as base -  map symbols to descriptions etc for more verbose table options
 
@@ -3448,80 +3779,157 @@ namespace eval textblock {
         for {set c 0} {$c < $ccount} {incr c} {
             $t configure_column $c -minwidth 3
         }
-        if {[dict get $opts -compact]} {
-            $t configure -show_hseps 0 -show_header 0 -show_edge 0
+        if {[tcl::dict::get $opts -compact]} {
+            #compact defaults - but let explicit arguments override
+            set conf [dict create -show_vseps 0 -show_header 0 -show_edge 0]
         } else {
-            $t configure -show_header 1
+            set conf [dict create -show_vseps 1 -show_header 1 -show_edge 1]
         }
+        dict for {k v} $conf {
+            if {[dict get $opts $k] ne ""} {
+                dict set conf $k [dict get $opts $k] 
+            }
+        }
+        $t configure {*}[dict get $conf] 
 
-        if {$opt_return eq "string"} {
-            $t configure \
-            -frametype_header light\
-            -ansiborder_header [a+ {*}$fc web-white]\
-            -ansibase_header [a+ {*}$fc Web-black]\
-            -ansibase_body [a+ {*}$fc Web-black]\
-            -ansiborder_body [a+ {*}$fc web-black]\
-            -frametype block
+        $t configure \
+        -frametype_header light\
+        -ansiborder_header [a+ {*}$fc web-white]\
+        -ansibase_header [a+ {*}$fc Web-black]\
+        -ansibase_body [a+ {*}$fc Web-black]\
+        -ansiborder_body [a+ {*}$fc web-black]\
+        -frametype block
 
+        if {$opt_return eq "table"} {
             set output [textblock::frame -ansiborder [a+ {*}$fc Web-black web-cornflowerblue] -type heavy -title "[a+ {*}$fc Web-black] Periodic Table " [$t print]]
+            $t destroy
             return $output
         }
         return $t
     }
 
-    proc list_as_table {table_or_colcount datalist args} {
-        set defaults [dict create\
-            -return string\
-            -frametype \uFFEF\
-            -show_edge \uFFEF\
-            -show_seps \uFFEF\
-        ]
-        set opts $defaults
-        foreach {k v} $args {
-            switch -- $k {
-                -return - -show_edge - -show_seps - -frametype {
-                    dict set opts $k $v
-                }
-                default {
-                    error "unrecognised option '$k'. Known options [dict keys $defaults]"
-                }
-            }
-        }
+    proc list_as_table {args} {
+        set argd [punk::args::get_dict [string map [list <ftypes> $::textblock::frametypes] {
+            -return     -default table -choices {table tableobject}
+            -frametype  -default ""                 -help "frame type: <ftypes> or dict for custom frame" 
+            -show_edge  -default "" -type boolean   -help "show outer border of table"
+            -show_seps  -default "" -type boolean 
+            -show_vseps -default "" -type boolean   -help "Show vertical table separators" 
+            -show_hseps -default "" -type boolean   -help "Show horizontal table separators
+            (default 0 if no existing -table supplied)"
+            -table      -default "" -type string    -help "existing table object to use"
+            -headers    -default ""                 -help "list of header values. Must match number of columns"
+            -action     -default "append" -choices {append replace} -help "row insertion method if existing -table is supplied
+            if append is chosen the new values will always start at the first column"
+            -columns    -default "" -type integer   -help "Number of table columns
+            Will default to 2 if not using an existing -table object"
+            *values
+            datalist    -default {}                 -help "flat list of table cell values which will be wrapped based on -columns value"
+        }] $args]
+        set opts [dict get $argd opts]
+        set datalist [dict get $argd values datalist]
+
+        set existing_table [dict get $opts -table]
+        set opt_columns [dict get $opts -columns]
+        #set opts [tcl::dict::create\
+        #    -return string\
+        #    -frametype \uFFEF\
+        #    -show_edge \uFFEF\
+        #    -show_seps \uFFEF\
+        #]
+        #foreach {k v} $args {
+        #    switch -- $k {
+        #        -return - -show_edge - -show_seps - -frametype {
+        #            tcl::dict::set opts $k $v
+        #        }
+        #        default {
+        #            error "unrecognised option '$k'. Known options [tcl::dict::keys $opts]"
+        #        }
+        #    }
+        #}
         
         set count [llength $datalist]
 
         set is_new_table 0
-        if {[string is integer -strict $table_or_colcount]} {
-            set cols $table_or_colcount
+        if {$existing_table ne ""} {
+            if {[tcl::namespace::tail [info object class $existing_table]] ne "table"} {
+                error "textblock::list_as_table error -table must be an existing table object (e.g set t \[textblock::class::table new\])"
+            }
+            set t $existing_table
+            foreach prop {-frametype -show_edge -show_seps -show_vseps -show_hseps} {
+                if {[tcl::dict::get $opts $prop] ne ""} {
+                    $t configure $prop [tcl::dict::get $opts $prop]
+                }
+            }
+            if {[dict get $opts -action] eq "replace"} {
+                $t row_clear
+            }
+            set cols [$t column_count]
+            if {[tcl::string::is integer -strict $opt_columns]} {
+                if {$opt_columns > $cols} {
+                    set extra [expr {$opt_columns - $cols}]
+                    for {set c 0} {$c < $extra} {incr c} {
+                        $t add_column
+                    }
+                } elseif {$opt_columns < $cols} {
+                    #todo - auto add blank values in the datalist
+                    error "Number of columns requested: $opt_columns is less than existing number of columns $cols - not yet supported"
+                }
+                set cols [$t column_count]
+            }
+        } else {
             set is_new_table 1
+            if {[tcl::string::is integer -strict $opt_columns]} {
+                set cols $opt_columns
+            } else {
+                #review
+                set cols 2 ;#seems a reasonable default 
+            }
             #defaults for new table only
-            if {[dict get $opts -frametype] eq "\uFFEF"} {
-                dict set opts -frametype "light"
+            if {[tcl::dict::get $opts -frametype] eq ""} {
+                tcl::dict::set opts -frametype "light"
             }
-            if {[dict get $opts -show_edge] eq "\uFFEF"} {
-                dict set opts -show_edge 1
+            if {[tcl::dict::get $opts -show_edge] eq ""} {
+                tcl::dict::set opts -show_edge 1
             }
-            if {[dict get $opts -show_seps] eq "\uFFEF"} {
-                dict set opts -show_seps 1
+            if {[tcl::dict::get $opts -show_seps] eq ""} {
+                tcl::dict::set opts -show_seps 1
             }
-            set t [textblock::class::table new -show_header 0 -show_edge [dict get $opts -show_edge] -frametype [dict get $opts -frametype] -show_seps [dict get $opts -show_seps]]
-            for {set c 0} {$c < $cols} {incr c} {
-                $t add_column -headers [list $c]
+            if {[tcl::dict::get $opts -show_vseps] eq ""} {
+                tcl::dict::set opts -show_vseps 1
             }
-        } else {
-            if {[namespace tail [info object class $table_or_colcount]] ne "table"} {
-                error "textblock::list_as_table error - table_or_colcount must be an integer or an existing table object"
+            if {[tcl::dict::get $opts -show_hseps] eq ""} {
+                tcl::dict::set opts -show_hseps 0
             }
-            set t $table_or_colcount
-            if {[dict get $opts -frametype] ne "\uFFEF"} {
-                $t configure -frametype [dict get $opts -frametype]
+            set headers {}
+            set show_header 0
+            if {[tcl::dict::get $opts -headers] ne ""} {
+                set headers [dict get $opts -headers]
+                if {[llength $headers] ne $cols} {
+                    error "list_as_table number of headers ([llength $headers]) must match number of columns ($cols)"
+                }
+                set show_header 1
             }
-            if {[dict get $opts -show_edge] ne "\uFFEF"} {
-                $t configure -show_edge [dict get $opts -show_edge] 
+
+            set t [textblock::class::table new\
+                -show_header $show_header\
+                -show_edge  [tcl::dict::get $opts -show_edge]\
+                -frametype  [tcl::dict::get $opts -frametype]\
+                -show_seps  [tcl::dict::get $opts -show_seps]\
+                -show_vseps [tcl::dict::get $opts -show_vseps]\
+                -show_hseps [tcl::dict::get $opts -show_hseps]\
+            ]
+            if {[llength $headers]} {
+                for {set c 0} {$c < $cols} {incr c} {
+                    $t add_column -headers [lindex $headers $c]
+                }
+            } else {
+                for {set c 0} {$c < $cols} {incr c} {
+                    $t add_column -headers [list $c]
+                }
             }
-            $t row_clear
-            set cols [$t column_count]
         }
+
         set full_rows [expr {$count / $cols}]
         set last_items [expr {$count % $cols}]
 
@@ -3549,7 +3957,7 @@ namespace eval textblock {
             $t add_row $row
         }
         #puts stdout $rowdata 
-        if {[dict get $opts -return] eq "string"} {
+        if {[tcl::dict::get $opts -return] eq "table"} {
             set result [$t print]
             if {$is_new_table} {
                 $t destroy
@@ -3570,22 +3978,22 @@ namespace eval textblock {
             error "textblock::block blockheight must be a positive integer"
         }
         if {$char eq ""} {return ""}
-        #using string length is ok 
-        if {[string length $char] == 1} {
-            set row [string repeat $char $blockwidth]
+        #using tcl::string::length is ok 
+        if {[tcl::string::length $char] == 1} {
+            set row [tcl::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 last \n $charblock] >= 0} {
+            set charblock [tcl::string::map [list \r\n \n] $char] 
+            if {[tcl::string::last \n $charblock] >= 0} {
                 if {$blockwidth > 1} {
                     #set row [.= val $charblock {*}[lrepeat [expr {$blockwidth -1}] |> piper_blockjoin $charblock]] ;#building a repeated "|> command arg" list to evaluate as a pipeline. (from before textblock::join could take arbitrary num of blocks )
-                    set row [textblock::join {*}[lrepeat $blockwidth $charblock]]
+                    set row [textblock::join_basic -- {*}[lrepeat $blockwidth $charblock]]
                 } else {
                     set row $charblock
                 }
             } else {
-                set row [string repeat $char $blockwidth]
+                set row [tcl::string::repeat $char $blockwidth]
             }
             set mtrx [lrepeat $blockheight $row]
             return [::join $mtrx \n]
@@ -3640,22 +4048,22 @@ namespace eval textblock {
 
             set clist [list]
             for {set i 0} {$i <$size} {incr i} {
-                set colour2 [string map [list rainbow [lindex $rainbow_list $i]] $colour]
+                set colour2 [tcl::string::map [list rainbow [lindex $rainbow_list $i]] $colour]
                 set ansi [a+ {*}$colour2]
                 
                 set ansicode [punk::ansi::codetype::sgr_merge_list "" $ansi]
                 lappend clist ${ansicode}$c$RST
             }
             if {"noreset" in $colour} {
-                return [textblock::join -ansiresets 0 {*}$clist]
+                return [textblock::join_basic -ansiresets 0 -- {*}$clist]
             } else {
-                return [textblock::join {*}$clist]
+                return [textblock::join_basic -- {*}$clist]
             }
         } elseif {"rainbow" in $colour} {
             #direction must be horizontal
             set block "" 
             for {set r 0} {$r < $size} {incr r} {
-                set colour2 [string map [list rainbow [lindex $rainbow_list $r]] $colour]
+                set colour2 [tcl::string::map [list rainbow [lindex $rainbow_list $r]] $colour]
                 set ansi [a+ {*}$colour2]
                 set ansicode [punk::ansi::codetype::sgr_merge_list "" $ansi]
                 set row "$ansicode"
@@ -3665,13 +4073,13 @@ namespace eval textblock {
                 append row $RST
                 append block $row\n
             }
-            set block [string trimright $block \n]
+            set block [tcl::string::trimright $block \n]
             return $block
         } else {
             #row first - 
             set rows [list]
             foreach ch $charsubset {
-                lappend rows [string repeat $ch $size]
+                lappend rows [tcl::string::repeat $ch $size]
             }
             set block [::join $rows \n]
             if {$colour ne ""} {
@@ -3689,8 +4097,8 @@ namespace eval textblock {
             return 0
         }
         #textutil::tabify is a reasonable hack when there are no ansi SGR codes - but probably not always what we want even then - review
-        if {[string last \t $textblock] >= 0} {
-            if {[info exists punk::console::tabwidth]} {
+        if {[tcl::string::last \t $textblock] >= 0} {
+            if {[tcl::info::exists punk::console::tabwidth]} {
                 set tw $::punk::console::tabwidth
             } else {
                 set tw 8
@@ -3698,32 +4106,33 @@ namespace eval textblock {
             set textblock [textutil::tabify::untabify2 $textblock $tw] 
         }
         if {[punk::ansi::ta::detect $textblock]} {
-            set textblock [punk::ansi::stripansi $textblock]
+            #stripansiraw slightly faster than stripansi - and won't affect width (avoid detect_g0/conversions)
+            set textblock [punk::ansi::stripansiraw $textblock]
         }
-        if {[string last \n $textblock] >= 0} {
+        if {[tcl::string::last \n $textblock] >= 0} {
             return [tcl::mathfunc::max {*}[lmap v [split $textblock \n] {::punk::char::ansifreestring_width $v}]]
         }
         return [punk::char::ansifreestring_width $textblock] 
     } 
     #when we know the block is uniform in width - just examine topline
     proc widthtopline {textblock} {
-        set firstnl [string first \n $textblock]
+        set firstnl [tcl::string::first \n $textblock]
         if {$firstnl >= 0} {
-            set tl [string range $textblock 0 $firstnl]
+            set tl [tcl::string::range $textblock 0 $firstnl]
         } else {
             set tl $textblock
         }
         if {[punk::ansi::ta::detect $tl]} {
-            set tl [punk::ansi::stripansi $tl]
+            set tl [punk::ansi::stripansiraw $tl]
         }
         return [punk::char::ansifreestring_width $tl] 
     }
-    #uses tcl's string length on each line. Length will include chars in ansi codes etc - this is not a 'width' determining function.
+    #uses tcl's tcl::string::length on each line. Length will include chars in ansi codes etc - this is not a 'width' determining function.
     proc string_length_line_max textblock {
-        tcl::mathfunc::max {*}[lmap v [split $textblock \n] {string length $v}]
+        tcl::mathfunc::max {*}[lmap v [split $textblock \n] {tcl::string::length $v}]
     }
     proc string_length_line_min textblock {
-        tcl::mathfunc::min {*}[lmap v [split $textblock \n] {string length $v}]
+        tcl::mathfunc::min {*}[lmap v [split $textblock \n] {tcl::string::length $v}]
     }
     proc height {textblock} {
         #This is the height as it will/would-be rendered - not the number of input lines purely in terms of le
@@ -3732,38 +4141,38 @@ namespace eval textblock {
         #vertical tab on a proper terminal should move directly down.
         #Whether or not the terminal in use actually does this - we need to calculate as if it does. (there might not even be a terminal)
 
-        set num_le [expr {[string length $textblock]-[string length [string map [list \n {} \v {}] $textblock]]}] ;#faster than splitting into single-char list
+        set num_le [expr {[tcl::string::length $textblock]-[tcl::string::length [tcl::string::map [list \n {} \v {}] $textblock]]}] ;#faster than splitting into single-char list
         return [expr {$num_le + 1}] ;# one line if no le - 2 if there is one trailing le even if no data follows le
     }
     #MAINTENANCE - same as overtype::blocksize?
     proc size {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
+            return [tcl::dict::create width 0 height 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
         }
-        #strangely - string last (windows tcl8.7 anway) is faster than string first for large strings when the needle not in the haystack
-        if {[string last \t $textblock] >= 0} {
-            if {[info exists punk::console::tabwidth]} {
+        #strangely - tcl::string::last (windows tcl8.7 anway) is faster than tcl::string::first for large strings when the needle not in the haystack
+        if {[tcl::string::last \t $textblock] >= 0} {
+            if {[tcl::info::exists punk::console::tabwidth]} {
                 set tw $::punk::console::tabwidth
             } else {
                 set tw 8
             }
             set textblock [textutil::tabify::untabify2 $textblock $tw]
         }
-        #stripansi on entire block in one go rather than line by line - result should be the same - review - make tests
+        #stripansiraw on entire block in one go rather than line by line - result should be the same - review - make tests
         if {[punk::ansi::ta::detect $textblock]} {
-            set textblock [punk::ansi::stripansi $textblock]
+            set textblock [punk::ansi::stripansiraw $textblock]
         }
-        if {[string last \n $textblock] >= 0} {
+        if {[tcl::string::last \n $textblock] >= 0} {
             #set width [tcl::mathfunc::max {*}[lmap v [punk::lib::lines_as_list -- $textblock] {::punk::char::ansifreestring_width $v}]]
             set width [tcl::mathfunc::max {*}[lmap v [split $textblock \n] {::punk::char::ansifreestring_width $v}]]
         } else {
             set width [punk::char::ansifreestring_width $textblock] 
         }
-        set num_le [expr {[string length $textblock]-[string length [string map [list \n {} \v {}] $textblock]]}] ;#faster than splitting into single-char list
+        set num_le [expr {[tcl::string::length $textblock]-[tcl::string::length [tcl::string::map [list \n {} \v {}] $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
+        return [tcl::dict::create width $width height $height] ;#maintain order in 'image processing' standard width then height - caller may use lassign [tcl::dict::values [blocksize <data>]] width height
     }
     #must be able to handle block as string with or without newlines
     #if no newlines - attempt to treat as a list
@@ -3773,13 +4182,13 @@ namespace eval textblock {
         if {$block eq ""} {
             return 0
         }
-        if {[info exists punk::console::tabwidth]} {
+        if {[tcl::info::exists punk::console::tabwidth]} {
             set tw $::punk::console::tabwidth
         } else {
             set tw 8
         }
         set block [textutil::tabify::untabify2 $block $tw]
-        if {[string last \n $block] >= 0} {
+        if {[tcl::string::last \n $block] >= 0} {
             return [tcl::mathfunc::max {*}[lmap v [punk::lib::lines_as_list -- $block] {::punk::char::string_width [stripansi $v]}]]
         }
         if {[catch {llength $block}]} {
@@ -3787,17 +4196,17 @@ namespace eval textblock {
         }
         if {[llength $block] == 0} {
             #could be just a whitespace string
-            return [string length $block]
+            return [tcl::string::length $block]
         }
         return [tcl::mathfunc::max {*}[lmap v $block {::punk::char::string_width [stripansi $v]}]]
     }
 
     #we shouldn't make textblock depend on the punk pipeline system
-    #pipealias ::textblock::padleft .= {list $input [string repeat " " $indent]} |/0,padding/1> punk:lib::lines_as_list -- |> .= {lmap v $data {overtype::right $padding $v}} |> punk::lib::list_as_lines -- <input/0,indent/1|
-    #pipealias ::textblock::padright .= {list $input [string repeat " " $colsize]} |/0,padding/1> punk::lib::lines_as_list -- |> .= {lmap v $data {overtype::left $padding $v}} |> punk::lib::list_as_lines -- <input/0,colsize/1|
+    #pipealias ::textblock::padleft .= {list $input [tcl::string::repeat " " $indent]} |/0,padding/1> punk:lib::lines_as_list -- |> .= {lmap v $data {overtype::right $padding $v}} |> punk::lib::list_as_lines -- <input/0,indent/1|
+    #pipealias ::textblock::padright .= {list $input [tcl::string::repeat " " $colsize]} |/0,padding/1> punk::lib::lines_as_list -- |> .= {lmap v $data {overtype::left $padding $v}} |> punk::lib::list_as_lines -- <input/0,colsize/1|
 
     proc ::textblock::pad {block args} {
-        set opts [dict create\
+        set opts [tcl::dict::create\
             -padchar " "\
             -which  "right"\
             -width  ""\
@@ -3811,7 +4220,7 @@ namespace eval textblock {
         foreach {k v} $args {
             switch -- $k {
                 -padchar - -which - -width - -overflow - -within_ansi {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
                     error "textblock::pad unrecognised option '$k'. Usage: $usage"
@@ -3819,13 +4228,13 @@ namespace eval textblock {
             }
         }
         # -- --- --- --- --- --- --- --- --- ---
-        set padchar         [dict get $opts -padchar]
+        set padchar         [tcl::dict::get $opts -padchar]
         #if padchar width (screen width) > 1 - length calculations will not be correct
-        #we will allow tokens longer than 1 - as the caller may want to post-process on the token whilst preserving previous leading/trailing spaces, e.g with a string map  
+        #we will allow tokens longer than 1 - as the caller may want to post-process on the token whilst preserving previous leading/trailing spaces, e.g with a tcl::string::map  
         #The caller may also use ansi within the padchar - although it's unlikely to be efficient.
         # -- --- --- --- --- --- --- --- --- ---
         set known_whiches [list l left r right c center centre]
-        set opt_which           [string tolower [dict get $opts -which]]
+        set opt_which           [tcl::string::tolower [tcl::dict::get $opts -which]]
         switch -- $opt_which {
             center - centre - c {
                 set which c 
@@ -3841,20 +4250,20 @@ namespace eval textblock {
             }
         }
         # -- --- --- --- --- --- --- --- --- ---
-        set opt_width           [dict get $opts -width]
+        set opt_width           [tcl::dict::get $opts -width]
         switch -- $opt_width {
             "" - auto {
                 set width auto
             }
             default {
-                if {![string is integer -strict $opt_width] || $opt_width < 0} {
+                if {![tcl::string::is integer -strict $opt_width] || $opt_width < 0} {
                     error "textblock::pad -width must be an integer >=0"
                 }
                 set width $opt_width
             }
         }
         # -- --- --- --- --- --- --- --- --- ---
-        set opt_withinansi     [dict get $opts -within_ansi]
+        set opt_withinansi     [tcl::dict::get $opts -within_ansi]
         switch -- $opt_withinansi {
             0 - 1 {}
             default {
@@ -3872,7 +4281,7 @@ namespace eval textblock {
 
         if {$block eq ""} {
             #we need to treat as a line
-            return [string repeat $padchar $width] 
+            return [tcl::string::repeat $padchar $width] 
         }
 
         #review - tcl format can only pad with zeros or spaces?
@@ -3883,7 +4292,7 @@ namespace eval textblock {
             if {($padchar eq " " || $padchar eq "0") && ![punk::ansi::ta::detect $block]} {
                 #This will still be wrong for example with diacritics on terminals that don't collapse the space following a diacritic, and don't correctly report cursor position
                 #(i.e as at 2024 - lots of them) wezterm on windows at least does the right thing.
-                set block [string map [list \r\n \n] $block]
+                set block [tcl::string::map [list \r\n \n] $block]
                 if {$which eq "l"} {
                     set fmt "%+${padchar}*s"
                 } else {
@@ -3892,7 +4301,7 @@ namespace eval textblock {
                 foreach ln [split $block \n] {
                     #set lnwidth [punk::char::ansifreestring_width $ln]
                     set lnwidth [punk::char::grapheme_width_cached $ln]
-                    set lnlen [string length $ln]
+                    set lnlen [tcl::string::length $ln]
                     set diff [expr $lnwidth - $lnlen]
                     #we need trickwidth to get format to pad a string with a different terminal width compared to string length
                     set trickwidth [expr {$width - $diff}] ;#may 'subtract' a positive or negative int (ie will add to trickwidth if negative)
@@ -3902,15 +4311,21 @@ namespace eval textblock {
             }
         }
 
+        #todo? special case trailing double-reset - insert between resets?
         set lnum 0
-        set parts [punk::ansi::ta::split_codes $block]
+        if {[punk::ansi::ta::detect $block]} {
+            set parts [punk::ansi::ta::split_codes $block]
+        } else {
+            #single plaintext part
+            set parts [list $block]
+        }
         set line_chunks [list] 
         set line_len 0
         foreach {pt ansi} $parts {
             if {$pt ne ""} {
-                set has_nl [expr {[string last \n $pt]>=0}]
+                set has_nl [expr {[tcl::string::last \n $pt]>=0}]
                 if {$has_nl} {
-                    set pt [string map [list \r\n \n] $pt]
+                    set pt [tcl::string::map [list \r\n \n] $pt]
                     set partlines [split $pt \n]
                 } else {
                     set partlines [list $pt]
@@ -3925,7 +4340,7 @@ namespace eval textblock {
                         #do padding
                         set missing [expr {$width - $line_len}]
                         if {$missing > 0} {
-                            set pad [string repeat $padchar $missing]
+                            set pad [tcl::string::repeat $padchar $missing]
                             switch -- $which-$opt_withinansi {
                                 r-0 {
                                     lappend line_chunks $pad
@@ -3982,7 +4397,7 @@ namespace eval textblock {
         #pad last line
         set missing [expr {$width - $line_len}]
         if {$missing > 0} {
-            set pad [string repeat $padchar $missing]
+            set pad [tcl::string::repeat $padchar $missing]
             switch -- $which-$opt_withinansi {
                 r-0 {
                    lappend line_chunks $pad
@@ -4064,7 +4479,7 @@ namespace eval textblock {
 
         set testlist [list "within_ansi 0" $left0 $right0 "within_ansi 1" $left1 $right1 "within_ansi 2" $left2 $right2] 
 
-        set t [textblock::list_as_table 3 $testlist -return object]
+        set t [textblock::list_as_table -columns 3 -return tableobject $testlist]
         $t configure_column 0 -headers [list "ansi"]
         $t configure_column 1 -headers [list "Left"]
         $t configure_column 2 -headers [list "Right"]
@@ -4074,44 +4489,44 @@ namespace eval textblock {
     }
 
     proc pad_test_blocklist {blocklist args} {
-        set opts [dict create\
+        set opts [tcl::dict::create\
             -description ""\
             -blockheaders ""\
         ]
         foreach {k v} $args {
             switch -- $k {
                 -description - -blockheaders {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "pad_test_blocklist unrecognised option '$k'. Known options: [dict keys $opts]"
+                    error "pad_test_blocklist unrecognised option '$k'. Known options: [tcl::dict::keys $opts]"
                 }
             }
         }
-        set opt_blockheaders [dict get $opts -blockheaders]
-        set bheaders [dict create]
+        set opt_blockheaders [tcl::dict::get $opts -blockheaders]
+        set bheaders [tcl::dict::create]
         if {$opt_blockheaders ne ""} {
             set b 0
             foreach h $opt_blockheaders {
                 if {$b < [llength $blocklist]} {
-                    dict set bheaders $b $h
+                    tcl::dict::set bheaders $b $h
                 }
                 incr b
             }
         }
 
         set b 0
-        set blockinfo [dict create]
+        set blockinfo [tcl::dict::create]
         foreach block $blocklist {
             set width [textblock::width $block]
-            dict set blockinfo $b width $width
+            tcl::dict::set blockinfo $b width $width
             set padtowidth [expr {$width + 3}]
-            dict set blockinfo $b left0 [textblock::pad $block -width $padtowidth -padchar . -which left -within_ansi 0]
-            dict set blockinfo $b left1 [textblock::pad $block -width $padtowidth -padchar . -which left -within_ansi 1]
-            dict set blockinfo $b left2 [textblock::pad $block -width $padtowidth -padchar . -which left -within_ansi 2]
-            dict set blockinfo $b right0 [textblock::pad $block -width $padtowidth -padchar . -which right -within_ansi 0]
-            dict set blockinfo $b right1 [textblock::pad $block -width $padtowidth -padchar . -which right -within_ansi 1]
-            dict set blockinfo $b right2 [textblock::pad $block -width $padtowidth -padchar . -which right -within_ansi 2]
+            tcl::dict::set blockinfo $b left0 [textblock::pad $block -width $padtowidth -padchar . -which left -within_ansi 0]
+            tcl::dict::set blockinfo $b left1 [textblock::pad $block -width $padtowidth -padchar . -which left -within_ansi 1]
+            tcl::dict::set blockinfo $b left2 [textblock::pad $block -width $padtowidth -padchar . -which left -within_ansi 2]
+            tcl::dict::set blockinfo $b right0 [textblock::pad $block -width $padtowidth -padchar . -which right -within_ansi 0]
+            tcl::dict::set blockinfo $b right1 [textblock::pad $block -width $padtowidth -padchar . -which right -within_ansi 1]
+            tcl::dict::set blockinfo $b right2 [textblock::pad $block -width $padtowidth -padchar . -which right -within_ansi 2]
             incr b
         }
 
@@ -4125,16 +4540,16 @@ namespace eval textblock {
         #we need to textblock::join each item to ensure we don't get the table's own textblock::pad interfering
         #(basically a mechanism to add extra resets at start and end of each line)
         #dict for {b bdict} $blockinfo {
-        #    lappend r0 [textblock::join [dict get $blockinfo $b left0]] [textblock::join [dict get $blockinfo $b right0]]
-        #    lappend r1 [textblock::join [dict get $blockinfo $b left1]] [textblock::join [dict get $blockinfo $b right1]]
-        #    lappend r2 [textblock::join [dict get $blockinfo $b left2]] [textblock::join [dict get $blockinfo $b right2]] 
+        #    lappend r0 [textblock::join [tcl::dict::get $blockinfo $b left0]] [textblock::join [tcl::dict::get $blockinfo $b right0]]
+        #    lappend r1 [textblock::join [tcl::dict::get $blockinfo $b left1]] [textblock::join [tcl::dict::get $blockinfo $b right1]]
+        #    lappend r2 [textblock::join [tcl::dict::get $blockinfo $b left2]] [textblock::join [tcl::dict::get $blockinfo $b right2]] 
         #}
 
         #2 - the more useful one?
-        dict for {b bdict} $blockinfo {
-            lappend r0 [dict get $blockinfo $b left0] [dict get $blockinfo $b right0]
-            lappend r1 [dict get $blockinfo $b left1] [dict get $blockinfo $b right1]
-            lappend r2 [dict get $blockinfo $b left2] [dict get $blockinfo $b right2] 
+        tcl::dict::for {b bdict} $blockinfo {
+            lappend r0 [tcl::dict::get $blockinfo $b left0] [tcl::dict::get $blockinfo $b right0]
+            lappend r1 [tcl::dict::get $blockinfo $b left1] [tcl::dict::get $blockinfo $b right1]
+            lappend r2 [tcl::dict::get $blockinfo $b left2] [tcl::dict::get $blockinfo $b right2] 
             lappend r3 "" ""
         }
 
@@ -4142,12 +4557,12 @@ namespace eval textblock {
 
         set column_ansi [a+ web-white Web-Gray]
 
-        set t [textblock::list_as_table [expr {1 + (2 * [dict size $blockinfo])}] $rows -return object]
-        $t configure_column 0 -headers [list [dict get $opts -description] "within_ansi"] -ansibase $column_ansi
+        set t [textblock::list_as_table -columns [expr {1 + (2 * [tcl::dict::size $blockinfo])}] -return tableobject $rows]
+        $t configure_column 0 -headers [list [tcl::dict::get $opts -description] "within_ansi"] -ansibase $column_ansi
         set col 1
-        dict for {b bdict} $blockinfo {
-            if {[dict exists $bheaders $b]} {
-                set hdr [dict get $bheaders $b]
+        tcl::dict::for {b bdict} $blockinfo {
+            if {[tcl::dict::exists $bheaders $b]} {
+                set hdr [tcl::dict::get $bheaders $b]
             } else {
                 set hdr "Block $b"
             }
@@ -4203,7 +4618,7 @@ namespace eval textblock {
 
     #playing with syntax
 
-   # pipealias ::textblock::join_width .= {list $lhs [string repeat " " $w1] $rhs [string repeat " " $w2]} {|
+   # pipealias ::textblock::join_width .= {list $lhs [tcl::string::repeat " " $w1] $rhs [tcl::string::repeat " " $w2]} {|
    #             /2,col1/1,col2/3
    #             >} punk::lib::lines_as_list -- {|
    #             data2
@@ -4212,7 +4627,7 @@ namespace eval textblock {
    #             >} punk::lib::list_as_lines -- <lhs/0,w1/1,rhs/2,w2/3|
    #             
 
-   # pipealias ::textblock::joinpair .= {list $lhs [string repeat " " [width $lhs]] $rhs [string repeat " " [width $rhs]]} {|
+   # pipealias ::textblock::joinpair .= {list $lhs [tcl::string::repeat " " [width $lhs]] $rhs [tcl::string::repeat " " [width $rhs]]} {|
    #             /2,col1/1,col2/3
    #             >} .=> punk::lib::lines_as_list -- {|
    #             data2
@@ -4226,12 +4641,12 @@ namespace eval textblock {
             -ansiresets -default 1 -type integer
             blocks -type string -multiple 1
         } $args] _o opts _v values
-        set blocks [dict get $values blocks]
+        set blocks [tcl::dict::get $values blocks]
 
         set idx 0
         set fordata [list]
         foreach b $blocks {
-            set c($idx) [string repeat " " [width $b]]
+            set c($idx) [tcl::string::repeat " " [width $b]]
             lappend fordata "v($idx)" [punk::lib::lines_as_list {*}$opts -- $b] 
             incr idx
         }
@@ -4246,14 +4661,56 @@ namespace eval textblock {
         return [punk::lib::list_as_lines -- $outlines]
     }
 
+    #join without regard to each line length in a block (no padding added to make each block uniform)
+    proc ::textblock::join_basic {args} {
+            #*proc -name textblock::join_basic -help "Join blocks line by line but don't add padding on each line to enforce uniform width.
+            #    Already uniform blocks will join faster than textblock::join, and ragged blocks will join in a ragged manner
+            #"
+        set argd [punk::args::get_dict {
+            -ansiresets -type any -default auto
+            blocks      -type any -multiple 1
+        } $args] 
+        set ansiresets  [tcl::dict::get $argd opts -ansiresets]
+        set blocks      [tcl::dict::get $argd values blocks]
+
+        #-ansireplays is always on (if ansi detected) 
+
+        # -- is a legimate block
+        #this makes for a somewhat messy api.. -- is required if first block is actually -- (or the very unlikely case the first block is intended to be -ansiresets)
+
+        if {![llength $blocks]} {
+            return
+        }
+        set idx 0
+        set fordata [list]
+        set colindices [list]
+        foreach b $blocks {
+            if {[punk::ansi::ta::detect $b]} {
+                lappend fordata "v($idx)" [punk::lib::lines_as_list -ansireplays 1 -ansiresets $ansiresets -- $b] 
+            } else {
+                lappend fordata "v($idx)" [split $b \n]
+            }
+            lappend colindices $idx
+            incr idx
+        }
+        set outlines [list]
+        foreach {*}$fordata {
+            set row {} 
+            foreach colidx $colindices {
+                lappend row $v($colidx)
+            }
+            lappend outlines [::join $row ""]
+        }
+        return [::join $outlines \n]
+    }
     #for joining 'rendered' blocks of plain or ansi text. Being 'rendered' means they are without ansi movement sequences as these have been processed 
     #they may however still be 'ragged' ie differing line lengths
     proc ::textblock::join {args} {
         #set argd [punk::args::get_dict {
         #    blocks -type string -multiple 1
         #} $args] 
-        #set opts   [dict get $argd opts]
-        #set blocks [dict get $argd values blocks]
+        #set opts   [tcl::dict::get $argd opts]
+        #set blocks [tcl::dict::get $argd values blocks]
 
         #-ansireplays is always on (if ansi detected) 
 
@@ -4287,8 +4744,8 @@ namespace eval textblock {
         set fordata [list]
         set colindices [list]
         foreach b $blocks {
-            set w($idx) [width $b] ;#we need the width of a rendered block for per-row renderline calls
-            #set c($idx) [string repeat " " [set w($idx)]]
+            set w($idx) [width $b] ;#we need the width of a rendered block for per-row renderline calls or padding
+            #set c($idx) [tcl::string::repeat " " [set w($idx)]]
             #fairly commonly a block may be a vertical list of chars e.g something like 1\n2\n3  or -\n-\n-\n- 
             #for determining a shortcut to avoid unnecessary ta::detect - (e.g width <=1) we can't use result of textblock::width as it strips ansi. 
             #testing of any decent size block line by line - even with max_string_length_line is slower than ta::detect anyway.
@@ -4320,7 +4777,7 @@ namespace eval textblock {
         set trimlines "" 
     }
 
-    #pipealias ::textblock::join_right .= {list $lhs [string repeat " " [width $lhs]] $rhs [string repeat " " [width $rhs]]} {|
+    #pipealias ::textblock::join_right .= {list $lhs [tcl::string::repeat " " [width $lhs]] $rhs [tcl::string::repeat " " [width $rhs]]} {|
     #            /2,col1/1,col2/3
     #            >} .=> punk::lib::lines_as_list -- {|
     #            data2
@@ -4329,19 +4786,19 @@ namespace eval textblock {
     #            >} punk::lib::list_as_lines <lhs/0,rhs/1|            
 
     proc example {args} {
-        set opts [dict create -forcecolour 0]
+        set opts [tcl::dict::create -forcecolour 0]
         foreach {k v} $args {
             switch -- $k {
                 -forcecolour {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "textblock::example unrecognised option '$k'. Known-options: [dict keys $opts]"
+                    error "textblock::example unrecognised option '$k'. Known-options: [tcl::dict::keys $opts]"
                 }
             }
         }
         set opt_forcecolour 0
-        if {[dict get $opts -forcecolour]} {
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc forcecolour
             set opt_forcecolour 1
         } else {
@@ -4356,22 +4813,22 @@ namespace eval textblock {
         set blue [a+ {*}$fc blue];set blueb [a+ {*}$fc blue bold]
         set RST [a]
         set gr0 [punk::ansi::g0 abcdefghijklm\nnopqrstuvwxyz]
-        set punks [textblock::join $pleft $pright]
+        set punks [textblock::join -- $pleft $pright]
         set pleft_greenb $greenb$pleft$RST 
         set pright_redb  $redb$pright$RST
         set prightair_cyanb $cyanb$prightair$RST
-        set cpunks [textblock::join $pleft_greenb $pright_redb]
+        set cpunks [textblock::join -- $pleft_greenb $pright_redb]
         set out ""
         append out $punks \n
         append out $cpunks \n
-        append out [textblock::join $punks $cpunks] \n
-        set 2frames_a [textblock::join [textblock::frame $cpunks] [textblock::frame $punks]]
+        append out [textblock::join -- $punks $cpunks] \n
+        set 2frames_a [textblock::join -- [textblock::frame $cpunks] [textblock::frame $punks]]
         append out $2frames_a \n
-        set 2frames_b [textblock::join [textblock::frame -ansiborder $cyanb -title "plainpunks" $punks] [textblock::frame -ansiborder $greenb -title "fancypunks" $cpunks]]
+        set 2frames_b [textblock::join -- [textblock::frame -ansiborder $cyanb -title "plainpunks" $punks] [textblock::frame -ansiborder $greenb -title "fancypunks" $cpunks]]
         append out [textblock::frame -title "punks" $2frames_b\n$RST$2frames_a] \n
-        set fancy [overtype::right  [overtype::left [textblock::frame -ansiborder [a+ green bold] -type heavy -title ${redb}PATTERN$RST -subtitle ${redb}PUNK$RST $prightair_cyanb] "$blueb\n\n\P\nU\nN\nK$RST"] "$blueb\n\nL\nI\nF\nE"]
+        set fancy [overtype::right [overtype::left [textblock::frame -ansiborder [a+ green bold] -type heavy -title ${redb}PATTERN$RST -subtitle ${redb}PUNK$RST $prightair_cyanb] "$blueb\n\n\P\nU\nN\nK$RST"] "$blueb\n\nL\nI\nF\nE"]
         set spantable [[spantest] print]
-        append out [textblock::join $fancy "  " $spantable] \n
+        append out [textblock::join -- $fancy "  " $spantable] \n
         #append out [textblock::frame -title gr $gr0]
         append out [textblock::periodic -forcecolour $opt_forcecolour]
         return $out
@@ -4393,25 +4850,25 @@ namespace eval textblock {
     }
     proc table {args} {
         upvar ::textblock::class::opts_table_defaults toptdefaults
-        set defaults [dict create\
+        set defaults [tcl::dict::create\
             -rows [list]\
             -headers [list]\
             -return string\
         ]
 
 
-        set defaults [dict merge $defaults $toptdefaults] ;# -title -frametype -show_header etc
-        set opts [dict merge $defaults $args]
+        set defaults [tcl::dict::merge $defaults $toptdefaults] ;# -title -frametype -show_header etc
+        set opts [tcl::dict::merge $defaults $args]
         # -- --- --- ---
-        set opt_return  [dict get $opts -return]
-        set opt_rows    [dict get $opts -rows]
-        set opt_headers [dict get $opts -headers]
+        set opt_return  [tcl::dict::get $opts -return]
+        set opt_rows    [tcl::dict::get $opts -rows]
+        set opt_headers [tcl::dict::get $opts -headers]
         # -- --- --- ---
-        set topts [dict create]
-        set toptkeys [dict keys $toptdefaults]
-        dict for {k v} $opts {
+        set topts [tcl::dict::create]
+        set toptkeys [tcl::dict::keys $toptdefaults]
+        tcl::dict::for {k v} $opts {
             if {$k in $toptkeys} {
-                dict set topts $k $v
+                tcl::dict::set topts $k $v
             }
         }
         set t [textblock::class::table new {*}$topts]
@@ -4451,8 +4908,8 @@ namespace eval textblock {
     }
     proc frametype {f} {
         variable frametypes
-        set default_custom [dict create hl " " vl " " tlc " " trc " " blc " " brc " "]
-        set custom_keys [list hl hlt hlb vl vll vlr tlc trc blc brc]
+        set default_custom [tcl::dict::create hl " " vl " " tlc " " trc " " blc " " brc " "]
+        #set custom_keys [list hl hlt hlb vl vll vlr tlc trc blc brc]
         if {$f ni $frametypes} {
             set is_custom_dict_ok 1
             if {[llength $f] %2 == 0} {
@@ -4473,13 +4930,13 @@ namespace eval textblock {
             if {!$is_custom_dict_ok} {
                 error "frame option -type must be one of known types: $frametypes or a dictionary with any of keys hl,hlt,hlb,vl,vll,vlr,tlc,trc,blc,brc"
             }
-            set custom_frame [dict merge $default_custom $f]
-            return [dict create category custom type $custom_frame]
+            set custom_frame [tcl::dict::merge $default_custom $f]
+            return [tcl::dict::create category custom type $custom_frame]
         } else {
-            return [dict create category predefined type $f]
+            return [tcl::dict::create category predefined type $f]
         }
     } 
-    variable framedef_cache [dict create]
+    variable framedef_cache [tcl::dict::create]
     proc framedef {f args} {
         #unicode box drawing only provides enough characters for seamless joining of unicode boxes light and heavy.
         #e.g with characters such as \u2539 Box Drawings Right Light and Left Up Heavy.
@@ -4487,25 +4944,25 @@ namespace eval textblock {
         #the arc set can't even join to itself e.g with curved equivalents of T-like shapes
         variable framedef_cache
         set cache_key [concat $f $args]
-        if {[dict exists $framedef_cache $cache_key]} {
-            return  [dict get $framedef_cache $cache_key]
+        if {[tcl::dict::exists $framedef_cache $cache_key]} {
+            return  [tcl::dict::get $framedef_cache $cache_key]
         }
-        set opts [dict create\
+        set opts [tcl::dict::create\
             -joins ""\
             -boxonly 0\
         ]
         foreach {k v} $args {
             switch -- $k {
                 -joins - -boxonly {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "framedef unknown option '$k'. Known options [dict keys $opts]"
+                    error "framedef unknown option '$k'. Known options [tcl::dict::keys $opts]"
                 }
             }
         }
-        set joins   [dict get $opts -joins]
-        set boxonly [dict get $opts -boxonly]
+        set joins   [tcl::dict::get $opts -joins]
+        set boxonly [tcl::dict::get $opts -boxonly]
 
         
         #sorted order down left right up
@@ -4518,11 +4975,11 @@ namespace eval textblock {
         set join_directions [list]
         #targets - light,heavy (double?) - seem to be some required glyphs missing from unicode
         #e.g down-light, up-heavy
-        set join_targets [dict create left "" down "" right "" up ""]
+        set join_targets [tcl::dict::create left "" down "" right "" up ""]
         foreach jt $joins {
             lassign [split $jt -] direction target 
             if {$target ne ""} {
-                dict set join_targets $direction $target
+                tcl::dict::set join_targets $direction $target
             }
             lappend join_directions $direction
         }
@@ -4732,7 +5189,7 @@ namespace eval textblock {
                 #set targetdown,targetleft,targetright,targetup vars
                 #default empty targets to current box type 'light'
                 foreach dir {down left right up} {
-                    set target [dict get $join_targets $dir]
+                    set target [tcl::dict::get $join_targets $dir]
                     switch -- $target {
                         "" - light {
                             set target$dir light 
@@ -4969,7 +5426,7 @@ namespace eval textblock {
                 #set targetdown,targetleft,targetright,targetup vars
                 #default empty targets to current box type 'heavy'
                 foreach dir {down left right up} {
-                    set target [dict get $join_targets $dir]
+                    set target [tcl::dict::get $join_targets $dir]
                     switch -- $target {
                         "" - heavy {
                             set target$dir heavy 
@@ -5204,7 +5661,7 @@ namespace eval textblock {
                 #set targetdown,targetleft,targetright,targetup vars
                 #default empty targets to current box type 'double'
                 foreach dir {down left right up} {
-                    set target [dict get $join_targets $dir]
+                    set target [tcl::dict::get $join_targets $dir]
                     switch -- $target {
                         "" - double {
                             set target$dir double
@@ -5450,7 +5907,7 @@ namespace eval textblock {
                 #set targetdown,targetleft,targetright,targetup vars
                 #default empty targets to current box type 'arc'
                 foreach dir {down left right up} {
-                    set target [dict get $join_targets $dir]
+                    set target [tcl::dict::get $join_targets $dir]
                     switch -- $target {
                         "" - arc {
                             set target$dir self 
@@ -5582,28 +6039,28 @@ namespace eval textblock {
                 set vlrj $vlr
             }
             default {
-                set default_custom [dict create hl " " vl " " tlc " " trc " " blc " " brc " "]
-                set custom_frame [dict merge $default_custom $f]
-                dict with custom_frame {} ;#extract keys as vars
+                set default_custom [tcl::dict::create hl " " vl " " tlc " " trc " " blc " " brc " "]
+                set custom_frame [tcl::dict::merge $default_custom $f]
+                tcl::dict::with custom_frame {} ;#extract keys as vars
 
-                if {[dict exists $custom_frame hlt]} {
-                    set hlt [dict get $custom_frame hlt]
+                if {[tcl::dict::exists $custom_frame hlt]} {
+                    set hlt [tcl::dict::get $custom_frame hlt]
                 } else {
                     set hlt $hl
                 }
-                if {[dict exists $custom_frame hlb]} {
-                    set hlb [dict get $custom_frame hlb]
+                if {[tcl::dict::exists $custom_frame hlb]} {
+                    set hlb [tcl::dict::get $custom_frame hlb]
                 } else {
                     set hlb $hl
                 }
 
-                if {[dict exists $custom_frame vll]} {
-                    set vll [dict get $custom_frame vll]
+                if {[tcl::dict::exists $custom_frame vll]} {
+                    set vll [tcl::dict::get $custom_frame vll]
                 } else {
                     set vll $vl
                 }
-                if {[dict exists $custom_frame vlr]} {
-                    set vlr [dict get $custom_frame vlr]
+                if {[tcl::dict::exists $custom_frame vlr]} {
+                    set vlr [tcl::dict::get $custom_frame vlr]
                 } else {
                     set vlr $vl
                 }
@@ -5615,15 +6072,15 @@ namespace eval textblock {
             }
         }
         if {$boxonly} {
-            set result [dict create\
+            set result [tcl::dict::create\
                 tlc $tlc hlt $hlt trc $trc\
                 vll $vll          vlr $vlr\
                 blc $blc hlb $hlb brc $brc\
             ]
-            dict set framedef_cache $cache_key $result
+            tcl::dict::set framedef_cache $cache_key $result
             return $result
         } else {
-            set result [dict create\
+            set result [tcl::dict::create\
                 tlc $tlc hlt $hlt trc $trc\
                 vll $vll          vlr $vlr\
                 blc $blc hlb $hlb brc $brc\
@@ -5632,13 +6089,13 @@ namespace eval textblock {
                 vllj $vllj\
                 vlrj $vlrj\
             ]
-            dict set framedef_cache $cache_key $result
+            tcl::dict::set framedef_cache $cache_key $result
             return $result
         }
     }
 
     variable frame_cache
-    set frame_cache [dict create]
+    set frame_cache [tcl::dict::create]
     proc frame_cache {{action ""}} {
         if {$action ni [list clear ""]} {
             error "frame_cache action '$action' not understood. Valid actions: clear"
@@ -5646,33 +6103,35 @@ namespace eval textblock {
         variable frame_cache
         set out ""
         if {[catch {
-            set termwidth [dict get [punk::console::get_size] columns]
+            set termwidth [tcl::dict::get [punk::console::get_size] columns]
         }]} {
             set termwidth 80
         }
 
-        dict for {k v} $frame_cache {
+        tcl::dict::for {k v} $frame_cache {
             lassign $v _f frame _used used
-            #set fwidth [textblock::widthtopline $frame] 
+            set fwidth [textblock::widthtopline $frame] 
             #review - are cached frames uniform width lines? 
-            set fwidth [textblock::width $frame]
+            #set fwidth [textblock::width $frame]
             set frameinfo "$k used:$used "
-            set allinone_width [expr {[string length $frameinfo] + $fwidth}]
+            set allinone_width [expr {[tcl::string::length $frameinfo] + $fwidth}]
             if {$allinone_width >= $termwidth} {
                 #split across 2 lines
                 append out "$frameinfo\n" 
                 append out $frame \n
             } else {
-                append out [textblock::join $frameinfo $frame]\n
+                append out [textblock::join -- $frameinfo $frame]\n
             }
             append out \n ;# frames used to build tables often have joins - keep a line in between for clarity
         }
         if {$action eq "clear"} {
-            set frame_cache [dict create]
+            set frame_cache [tcl::dict::create]
             append out \nCLEARED
         }
         return $out
     }
+
+
     #options before content argument - which is allowed to be absent
     #frame performance (noticeable with complex tables even of modest size) is improved significantly by frame_cache - but is still (2024) a fairly expensive operation.
     #
@@ -5683,6 +6142,27 @@ namespace eval textblock {
     # - but we would need to maintain support for the rendered-string based operations too.
     proc frame {args} {
         variable frametypes
+
+        #counterintuitively - in-proc dict create each time is generally slightly faster than linked namespace var
+        set opts [tcl::dict::create\
+            -etabs 0\
+            -type light\
+            -boxlimits [list hl vl tlc blc trc brc]\
+            -boxmap {}\
+            -joins [list]\
+            -title ""\
+            -subtitle ""\
+            -width ""\
+            -height ""\
+            -ansiborder ""\
+            -ansibase ""\
+            -blockalign "centre"\
+            -textalign "left"\
+            -ellipsis 1\
+            -usecache 1\
+            -buildcache 1\
+        ]
+
         set expect_optval 0
         set argposn 0
         set pmax [expr {[llength $args]-1}]
@@ -5692,7 +6172,7 @@ namespace eval textblock {
         foreach a $args {
             if {!$expect_optval} {
                 if {$argposn < $pmax} {
-                    if {[string match -* $a]} {
+                    if {[tcl::string::match -* $a]} {
                         set expect_optval 1
                         lappend arglist $a
                     } else {
@@ -5716,50 +6196,32 @@ namespace eval textblock {
         }
         #todo args -justify left|centre|right (center)
 
-        set opts [dict create\
-            -etabs 0\
-            -type light\
-            -boxlimits [list hl vl tlc blc trc brc]\
-            -boxmap {}\
-            -joins [list]\
-            -title ""\
-            -subtitle ""\
-            -width ""\
-            -height ""\
-            -ansiborder ""\
-            -ansibase ""\
-            -blockalign "centre"\
-            -textalign "left"\
-            -ellipsis 1\
-            -usecache 1\
-            -buildcache 1\
-        ]
         #todo -blockalignbias -textalignbias?
         #use -buildcache 1 with -usecache 0 for debugging cache issues so we can inspect using textblock::frame_cache
         foreach {k v} $arglist {
             switch -- $k {
                 -etabs - -type - -boxlimits - -boxmap - -joins - -title - -subtitle - -width - -height - -ansiborder - -ansibase - -blockalign - -textalign - -ellipsis - -usecache - -buildcache {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "frame option '$k' not understood. Valid options are [dict keys $opts]"
+                    error "frame option '$k' not understood. Valid options are [tcl::dict::keys $opts]"
                 }
             }
         }
         # -- --- --- --- --- --- 
-        set opt_etabs       [dict get $opts -etabs]
-        set opt_type        [dict get $opts -type]
-        set opt_boxlimits   [dict get $opts -boxlimits]
-        set opt_joins       [dict get $opts -joins]
-        set opt_boxmap      [dict get $opts -boxmap]
-        set opt_usecache    [dict get $opts -usecache]
-        set opt_buildcache  [dict get $opts -buildcache]
+        set opt_etabs       [tcl::dict::get $opts -etabs]
+        set opt_type        [tcl::dict::get $opts -type]
+        set opt_boxlimits   [tcl::dict::get $opts -boxlimits]
+        set opt_joins       [tcl::dict::get $opts -joins]
+        set opt_boxmap      [tcl::dict::get $opts -boxmap]
+        set opt_usecache    [tcl::dict::get $opts -usecache]
+        set opt_buildcache  [tcl::dict::get $opts -buildcache]
         set usecache $opt_usecache ;#may need to override
         set buildcache $opt_buildcache
         set custom_keys [list hl hlt hlb vl vll vlr tlc trc blc brc]
 
         set known_frametypes $frametypes ;# light, heavey etc as defined in textblock::frametypes variable
-        set default_custom [dict create hl " " vl " " tlc " " trc " " blc " " brc " "]
+        set default_custom [tcl::dict::create hl " " vl " " tlc " " trc " " blc " " brc " "]
 
         lassign [textblock::frametype $opt_type] _cat category _type ftype
         if {$category eq "custom"} {
@@ -5819,7 +6281,9 @@ namespace eval textblock {
             error "frame option -joins '$opt_joins' must contain only values from the set: left,right,up,down with targets heavy,light,ascii,altg,arc,double,block,block1,custom e.g down-light"
         }
         set is_boxmap_ok 1
-        dict for {boxelement subst} $opt_boxmap {
+        #safe jumptable test
+        #dict for {boxelement subst} $opt_boxmap {}
+        tcl::dict::for {boxelement subst} $opt_boxmap {
             switch -- $boxelement {
                 hl - hlt - hlb - vl - vll - vlr - tlc - trc - blc - brc {}
                 default {
@@ -5842,11 +6306,11 @@ namespace eval textblock {
         set join_directions [list]
         #targets - light,heavy (double?) - seem to be some required glyphs missing from unicode
         #e.g down-light, up-heavy
-        set join_targets [dict create left "" down "" right "" up ""]
+        set join_targets [tcl::dict::create left "" down "" right "" up ""]
         foreach jt $opt_joins {
             lassign [split $jt -] direction target 
             if {$target ne ""} {
-                dict set join_targets $direction $target
+                tcl::dict::set join_targets $direction $target
             }
             lappend join_directions $direction
         }
@@ -5855,12 +6319,12 @@ namespace eval textblock {
 
 
         # -- --- --- --- --- --- 
-        set opt_title     [dict get $opts -title]
-        set opt_subtitle  [dict get $opts -subtitle]
-        set opt_width     [dict get $opts -width]
-        set opt_height    [dict get $opts -height]
+        set opt_title     [tcl::dict::get $opts -title]
+        set opt_subtitle  [tcl::dict::get $opts -subtitle]
+        set opt_width     [tcl::dict::get $opts -width]
+        set opt_height    [tcl::dict::get $opts -height]
         # -- --- --- --- --- ---
-        set opt_blockalign     [dict get $opts -blockalign]
+        set opt_blockalign     [tcl::dict::get $opts -blockalign]
         switch -- $opt_blockalign {
             left - right - centre - center {}
             default {
@@ -5869,7 +6333,7 @@ namespace eval textblock {
         }
         #these are all valid commands for overtype::<cmd>
         # -- --- --- --- --- --- 
-        set opt_textalign      [dict get $opts -textalign]
+        set opt_textalign      [tcl::dict::get $opts -textalign]
         switch -- $opt_textalign {
             left - right - centre - center {}
             default {
@@ -5878,14 +6342,14 @@ namespace eval textblock {
         }
         # -- --- --- --- --- --- 
 
-        set opt_ansiborder [dict get $opts -ansiborder]
-        set opt_ansibase   [dict get $opts -ansibase] ;#experimental
-        set opt_ellipsis   [dict get $opts -ellipsis]
+        set opt_ansiborder [tcl::dict::get $opts -ansiborder]
+        set opt_ansibase   [tcl::dict::get $opts -ansibase] ;#experimental
+        set opt_ellipsis   [tcl::dict::get $opts -ellipsis]
         # -- --- --- --- --- ---
 
         if {$has_contents} {
-            if {[string last \t $contents] >= 0} {
-                if {[info exists punk::console::tabwidth]} {
+            if {[tcl::string::last \t $contents] >= 0} {
+                if {[tcl::info::exists punk::console::tabwidth]} {
                     set tw $::punk::console::tabwidth
                 } else {
                     set tw 8
@@ -5894,7 +6358,7 @@ namespace eval textblock {
                     set contents [textutil::tabify::untabify2 $contents $tw]
                 }
             }
-            set contents [string map [list \r\n \n] $contents]
+            set contents [tcl::string::map [list \r\n \n] $contents]
             set actual_contentwidth [textblock::width $contents] ;#length of longest line in contents (contents can be ragged)
             set actual_contentheight [textblock::height $contents]
         } else {
@@ -5934,6 +6398,7 @@ namespace eval textblock {
         #set cache_key [concat $arglist $frame_inner_width $frame_inner_height]
         set hashables [concat $arglist $frame_inner_width $frame_inner_height]
         package require md5
+        #set hash $hashables
         set hash [md5::md5 -hex $hashables] ;#need fast and unique to content - not cryptographic - review
         set cache_key "$hash-$frame_inner_width-$frame_inner_height-actualcontentwidth:$actual_contentwidth"
         #should be in a unicode private range different to that used in table construction
@@ -5966,8 +6431,8 @@ namespace eval textblock {
                 set cache_key [a+ Web-steelblue web-black]$cache_key[a]
             } else {
                 #actual_contentwidth is narrower than frame - check template's patternwidth 
-                if {[dict exists $frame_cache $cache_key]} {
-                    set cache_patternwidth [dict get $frame_cache $cache_key patternwidth]
+                if {[tcl::dict::exists $frame_cache $cache_key]} {
+                    set cache_patternwidth [tcl::dict::get $frame_cache $cache_key patternwidth]
                 } else {
                     set cache_patternwidth $actual_contentwidth
                 }
@@ -5988,11 +6453,11 @@ namespace eval textblock {
         #set usecache 0
 
         set is_cached 0
-        if {$usecache && [dict exists $frame_cache $cache_key]} {
-            set cache_patternwidth [dict get $frame_cache $cache_key patternwidth]
-            set template [dict get $frame_cache $cache_key frame]
-            set used [dict get $frame_cache $cache_key used]
-            dict set frame_cache $cache_key used [expr {$used+1}] ;#update existing record 
+        if {$usecache && [tcl::dict::exists $frame_cache $cache_key]} {
+            set cache_patternwidth [tcl::dict::get $frame_cache $cache_key patternwidth]
+            set template [tcl::dict::get $frame_cache $cache_key frame]
+            set used [tcl::dict::get $frame_cache $cache_key used]
+            tcl::dict::set frame_cache $cache_key used [expr {$used+1}] ;#update existing record 
             set is_cached 1
 
         }
@@ -6000,8 +6465,8 @@ namespace eval textblock {
         # -- --- --- --- --- --- --- --- ---
         if {!$is_cached} {
             set rst [a]
-            #set column [string repeat " " $frame_inner_width] ;#default - may need to override for custom frame
-            set underlayline [string repeat " " $frame_inner_width]
+            #set column [tcl::string::repeat " " $frame_inner_width] ;#default - may need to override for custom frame
+            set underlayline [tcl::string::repeat " " $frame_inner_width]
             set underlay [::join [lrepeat $linecount $underlayline] \n]
 
 
@@ -6009,11 +6474,11 @@ namespace eval textblock {
             set vlr_width 1
 
             set framedef [textblock::framedef $framedef -joins $opt_joins]
-            dict with framedef {} ;#extract vll,hlt,tlc etc vars
+            tcl::dict::with framedef {} ;#extract vll,hlt,tlc etc vars
 
             #puts "---> $opt_boxmap"
             #review - we handle double-wide in custom frames - what about for boxmaps?
-            dict for {boxelement sub} $opt_boxmap {
+            tcl::dict::for {boxelement sub} $opt_boxmap {
                 if {$boxelement eq "vl"} {
                     set vll $sub
                     set vlr $sub
@@ -6057,48 +6522,48 @@ namespace eval textblock {
                         set tbarwidth [expr {$opt_width - $tlc_width - $trc_width}]
                         set bbarwidth [expr {$opt_width - $blc_width - $brc_width}]
                     }
-                    #set column [string repeat " " $frame_inner_width]
-                    set underlayline [string repeat " " $frame_inner_width]
+                    #set column [tcl::string::repeat " " $frame_inner_width]
+                    set underlayline [tcl::string::repeat " " $frame_inner_width]
                     set underlay [::join [lrepeat $linecount $underlayline] \n]
                     #cache?
 
                     if {$hlt_width == 1} {
-                        set tbar [string repeat $hlt $tbarwidth]
+                        set tbar [tcl::string::repeat $hlt $tbarwidth]
                     } else {
-                        #possibly mixed width chars that make up hlt - string range won't get width right
-                        set blank [string repeat " " $tbarwidth]
+                        #possibly mixed width chars that make up hlt - tcl::string::range won't get width right
+                        set blank [tcl::string::repeat " " $tbarwidth]
                         if {$hlt_width > 0} {
                             set count [expr {($tbarwidth / $hlt_width) + 1}]
                         } else {
                             set count 0
                         }
-                        set tbar [string repeat $hlt $count]
-                        #set tbar [string range $tbar 0 $tbarwidth-1]
+                        set tbar [tcl::string::repeat $hlt $count]
+                        #set tbar [tcl::string::range $tbar 0 $tbarwidth-1]
                         set tbar [overtype::left -overflow 0 -exposed1 " " -exposed2 " " $blank $tbar];#spaces for exposed halves of 2w chars instead of default replacement character
                     }
                     if {$hlb_width == 1} {
-                        set bbar [string repeat $hlb $bbarwidth]
+                        set bbar [tcl::string::repeat $hlb $bbarwidth]
                     } else {
-                        set blank [string repeat " " $bbarwidth]
+                        set blank [tcl::string::repeat " " $bbarwidth]
                         if {$hlb_width > 0} {
                             set count [expr {($bbarwidth / $hlb_width) + 1}]
                         } else {
                             set count 0
                         }
-                        set bbar [string repeat $hlb $count]
-                        #set bbar [string range $bbar 0 $bbarwidth-1]
+                        set bbar [tcl::string::repeat $hlb $count]
+                        #set bbar [tcl::string::range $bbar 0 $bbarwidth-1]
                         set bbar [overtype::left -overflow 0 -exposed1 " " -exposed2 " " $blank $bbar]
                     }
                 }
                 altg {
-                    set tbar [string repeat $hlt $frame_inner_width]
+                    set tbar [tcl::string::repeat $hlt $frame_inner_width]
                     set tbar [cd::groptim $tbar]
-                    set bbar [string repeat $hlb $frame_inner_width] 
+                    set bbar [tcl::string::repeat $hlb $frame_inner_width] 
                     set bbar [cd::groptim $bbar]
                 }
                 default {
-                    set tbar [string repeat $hlt $frame_inner_width]
-                    set bbar [string repeat $hlb $frame_inner_width]
+                    set tbar [tcl::string::repeat $hlt $frame_inner_width]
+                    set bbar [tcl::string::repeat $hlb $frame_inner_width]
                     
                 }
             }
@@ -6145,10 +6610,10 @@ namespace eval textblock {
                 set rightborder 0
             }
             #keep lhs/rhs separate? can we do vertical text on sidebars?
-            set lhs [string repeat $vll\n $linecount]
-            set lhs [string range $lhs 0 end-1]
-            set rhs [string repeat $vlr\n $linecount]
-            set rhs [string range $rhs 0 end-1]
+            set lhs [tcl::string::repeat $vll\n $linecount]
+            set lhs [tcl::string::range $lhs 0 end-1]
+            set rhs [tcl::string::repeat $vlr\n $linecount]
+            set rhs [tcl::string::range $rhs 0 end-1]
 
 
             if {$opt_ansiborder ne ""} {
@@ -6169,38 +6634,38 @@ namespace eval textblock {
             foreach lim $unspecified_limits {
                 switch -- $lim {
                     vll {
-                        set blank_vll [string repeat " " $vll_width]
-                        set lhs [string repeat $blank_vll\n $linecount]
-                        set lhs [string range $lhs 0 end-1]
+                        set blank_vll [tcl::string::repeat " " $vll_width]
+                        set lhs [tcl::string::repeat $blank_vll\n $linecount]
+                        set lhs [tcl::string::range $lhs 0 end-1]
                     }
                     vlr {
-                        set blank_vlr [string repeat " " $vlr_width]
-                        set rhs [string repeat $blank_vlr\n $linecount]
-                        set rhs [string range $rhs 0 end-1]
+                        set blank_vlr [tcl::string::repeat " " $vlr_width]
+                        set rhs [tcl::string::repeat $blank_vlr\n $linecount]
+                        set rhs [tcl::string::range $rhs 0 end-1]
                     }
                     hlt {
                         set bar_width [punk::ansi::printing_length $tbar]
-                        set tbar [string repeat " " $bar_width]
+                        set tbar [tcl::string::repeat " " $bar_width]
                     }
                     tlc {
                         set tlc_width [punk::ansi::printing_length $tlc]
-                        set tlc [string repeat " " $tlc_width]
+                        set tlc [tcl::string::repeat " " $tlc_width]
                     }
                     trc {
                         set trc_width [punk::ansi::printing_length $trc]
-                        set trc [string repeat " " $trc_width]
+                        set trc [tcl::string::repeat " " $trc_width]
                     }
                     hlb {
                         set bar_width [punk::ansi::printing_length $bbar]
-                        set bbar [string repeat " " $bar_width]
+                        set bbar [tcl::string::repeat " " $bar_width]
                     }
                     blc {
                         set blc_width [punk::ansi::printing_length $blc]
-                        set blc [string repeat " " $blc_width]
+                        set blc [tcl::string::repeat " " $blc_width]
                     }
                     brc {
                         set brc_width [punk::ansi::printing_length $brc]
-                        set brc [string repeat " " $brc_width]
+                        set brc [tcl::string::repeat " " $brc_width]
                     }
                 }
             }
@@ -6259,12 +6724,12 @@ namespace eval textblock {
                 #set textaligned_contents [textblock::pad $contents -width $actual_contentwidth -which $pad -within_ansi 1]
                 #set inner [overtype::block -blockalign $opt_blockalign -ellipsis $opt_ellipsis $opt_ansibase$underlay$rstbase $opt_ansibase$textaligned_contents]
 
-                set cache_contentline [string repeat $FSUB $actual_contentwidth]
+                set cache_contentline [tcl::string::repeat $FSUB $actual_contentwidth]
                 set cache_patternwidth $actual_contentwidth
                 set cache_contentpattern [::join [lrepeat $linecount $cache_contentline] \n]
                 set cache_inner [overtype::block -blockalign $opt_blockalign -ellipsis $opt_ellipsis $opt_ansibase$underlay$rstbase $opt_ansibase$cache_contentpattern]
                 #after overtype::block - our actual patternwidth may be less
-                set cache_patternwidth [string length [lindex [regexp -inline "\[^$FSUB]*(\[$FSUB]*).*" $cache_inner] 1]]
+                set cache_patternwidth [tcl::string::length [lindex [regexp -inline "\[^$FSUB]*(\[$FSUB]*).*" $cache_inner] 1]]
 
                 if {$leftborder && $rightborder} { 
                     #set bodyparts [list $lhs $inner $rhs]
@@ -6320,10 +6785,10 @@ namespace eval textblock {
 
         #use the same mechanism to build the final frame - whether from cache or template 
         if {$actual_contentwidth == 0} {
-            set fs [string map [list $FSUB " "] $template]
+            set fs [tcl::string::map [list $FSUB " "] $template]
         } else {
             set resultlines [list]
-            set overwritable [string repeat $FSUB $cache_patternwidth]
+            set overwritable [tcl::string::repeat $FSUB $cache_patternwidth]
             set contentindex 0
             switch -- $opt_textalign {
                 left    {set pad right}
@@ -6332,7 +6797,7 @@ namespace eval textblock {
             }
 
             #review
-            if {[string is integer -strict $opt_height] && $actual_contentheight < ($opt_height -2)} {
+            if {[tcl::string::is integer -strict $opt_height] && $actual_contentheight < ($opt_height -2)} {
                 set diff [expr {($opt_height -2) - $actual_contentheight}]
                 append contents [::join [lrepeat $diff \n] ""]
             }
@@ -6344,24 +6809,25 @@ namespace eval textblock {
             if {$paddedwidth > $cache_patternwidth} {
                 set paddedcontents [overtype::renderspace -width $cache_patternwidth "" $paddedcontents]
             }
-            set contentblock [textblock::join $paddedcontents] ;#make sure each line has ansi replays
+            #important to supply end of opts -- to textblock::join - particularly here with arbitrary data
+            set contentblock [textblock::join -- $paddedcontents] ;#make sure each line has ansi replays
 
             set tlines [split $template \n]
 
             #we will need to strip off the leading reset on each line when stitching together with template lines so that ansibase can come into play too.
             #after textblock::join the reset will be a separate code ie should be exactly ESC[0m
             set R [a]
-            set rlen [string length $R]
+            set rlen [tcl::string::length $R]
             set clines [split $contentblock \n]
 
             foreach tline $tlines {
-                if {[string first $FSUB $tline] >= 0} {
+                if {[tcl::string::first $FSUB $tline] >= 0} {
                     set content_line [lindex $clines $contentindex]
-                    if {[string first $R $content_line] == 0} {
-                        set content_line [string range $content_line $rlen end]
+                    if {[tcl::string::first $R $content_line] == 0} {
+                        set content_line [tcl::string::range $content_line $rlen end]
                     }
                     #make sure to replay opt_ansibase to the right of the replacement
-                    lappend resultlines [string map [list $overwritable $content_line$opt_ansibase] $tline]
+                    lappend resultlines [tcl::string::map [list $overwritable $content_line$opt_ansibase] $tline]
                     incr contentindex
                 } else {
                     lappend resultlines $tline
@@ -6375,7 +6841,7 @@ namespace eval textblock {
             return $fs 
         } else {
             if {$buildcache} {
-                dict set frame_cache $cache_key [list frame $template used 0 patternwidth $cache_patternwidth]
+                tcl::dict::set frame_cache $cache_key [list frame $template used 0 patternwidth $cache_patternwidth]
             }
             return $fs
         }
@@ -6388,8 +6854,8 @@ namespace eval textblock {
         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 opts [tcl::dict::merge $defaults $args]
+        set opt_max_cross_size [tcl::dict::get $opts -max_cross_size]
 
         #set fit_size [punk::lib::greatestOddFactor $size]
         set fit_size $size 
@@ -6447,14 +6913,14 @@ namespace eval textblock {
             #append onecross [::join $r ""] \n
             lappend crossrows [::join $r ""]
         }
-        #set onecross [string trimright $onecross \n]
+        #set onecross [tcl::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 row [textblock::join -- {*}[lrepeat $crosscount $onecross]]
             set rows [lrepeat $crosscount $row]
             set out [::join $rows \n]
         } else {
@@ -6473,12 +6939,12 @@ namespace eval textblock {
         #return [list $b1 $b2 $result]
         return [ansistring VIEW $result]
     }
-    namespace import ::punk::ansi::stripansi
+    tcl::namespace::import ::punk::ansi::stripansi
 }
 
 
-namespace eval ::textblock::piper {
-    namespace export *
+tcl::namespace::eval ::textblock::piper {
+    tcl::namespace::export *
     proc join {rhs pipelinedata} {
         tailcall ::textblock::join -- $pipelinedata $rhs
     }
@@ -6489,7 +6955,7 @@ interp alias {} piper_blockjoin {} ::textblock::piper::join
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide textblock [namespace eval textblock {
+package provide textblock [tcl::namespace::eval textblock {
     variable version
     set version 0.1.1 
 }]
diff --git a/src/bootsupport/modules/textutil/wcswidth-35.2.tm b/src/bootsupport/modules/textutil/wcswidth-35.2.tm
new file mode 100644
index 0000000..a8afafe
--- /dev/null
+++ b/src/bootsupport/modules/textutil/wcswidth-35.2.tm
@@ -0,0 +1,2252 @@
+###
+# 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>
+# Author: Andreas Kupries <andreas.kupries@gmail.com>
+###
+package require Tcl 8.5
+package provide textutil::wcswidth 35.2
+namespace eval ::textutil {}
+
+proc ::textutil::wcswidth_type c {
+  if {$c <= 9734} {
+    if {$c <= 8318} {
+      if {$c <= 465} {
+	if {$c <= 252} {
+	  if {$c <= 208} {
+	    if {$c <= 175} {
+	      if {$c <= 168} {
+		if {$c <= 164} {
+		  if {$c <= 163} {
+		    if {$c <= 161} {
+		      if {$c <= 160} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 166} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 172} {
+		  if {$c <= 170} {
+		    if {$c <= 169} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 174} { return A } else { return N }
+		}
+	      }
+	    } else {
+	      if {$c <= 191} {
+		if {$c <= 186} {
+		  if {$c <= 181} {
+		    if {$c <= 180} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 187} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 207} {
+		  if {$c <= 198} {
+		    if {$c <= 197} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 237} {
+	      if {$c <= 230} {
+		if {$c <= 225} {
+		  if {$c <= 221} {
+		    if {$c <= 216} {
+		      if {$c <= 214} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 229} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 235} {
+		  if {$c <= 234} {
+		    if {$c <= 231} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 246} {
+		if {$c <= 241} {
+		  if {$c <= 240} {
+		    if {$c <= 239} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 243} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 251} {
+		  if {$c <= 250} { return A } else { return N }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 318} {
+	    if {$c <= 283} {
+	      if {$c <= 273} {
+		if {$c <= 257} {
+		  if {$c <= 256} {
+		    if {$c <= 254} {
+		      if {$c <= 253} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 272} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 282} {
+		  if {$c <= 275} {
+		    if {$c <= 274} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 304} {
+		if {$c <= 298} {
+		  if {$c <= 295} {
+		    if {$c <= 293} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 299} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 312} {
+		  if {$c <= 311} {
+		    if {$c <= 307} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 357} {
+	      if {$c <= 332} {
+		if {$c <= 327} {
+		  if {$c <= 324} {
+		    if {$c <= 323} {
+		      if {$c <= 322} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 331} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 339} {
+		  if {$c <= 337} {
+		    if {$c <= 333} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 462} {
+		if {$c <= 363} {
+		  if {$c <= 362} {
+		    if {$c <= 359} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 461} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 464} {
+		  if {$c <= 463} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 944} {
+	  if {$c <= 712} {
+	    if {$c <= 476} {
+	      if {$c <= 471} {
+		if {$c <= 469} {
+		  if {$c <= 468} {
+		    if {$c <= 467} {
+		      if {$c <= 466} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 470} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 474} {
+		  if {$c <= 473} {
+		    if {$c <= 472} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 475} { return N } else { return A }
+		}
+	      }
+	    } else {
+	      if {$c <= 707} {
+		if {$c <= 608} {
+		  if {$c <= 593} {
+		    if {$c <= 592} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 609} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 711} {
+		  if {$c <= 710} {
+		    if {$c <= 708} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 734} {
+	      if {$c <= 727} {
+		if {$c <= 719} {
+		  if {$c <= 717} {
+		    if {$c <= 716} {
+		      if {$c <= 715} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 720} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 733} {
+		  if {$c <= 732} {
+		    if {$c <= 731} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 929} {
+		if {$c <= 879} {
+		  if {$c <= 767} {
+		    if {$c <= 735} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 912} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 937} {
+		  if {$c <= 930} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 8221} {
+	    if {$c <= 4351} {
+	      if {$c <= 1039} {
+		if {$c <= 1024} {
+		  if {$c <= 969} {
+		    if {$c <= 962} {
+		      if {$c <= 961} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 1025} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 1105} {
+		  if {$c <= 1104} {
+		    if {$c <= 1103} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8214} {
+		if {$c <= 8208} {
+		  if {$c <= 8207} {
+		    if {$c <= 4447} { return W } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8210} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8219} {
+		  if {$c <= 8217} {
+		    if {$c <= 8215} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 8244} {
+	      if {$c <= 8239} {
+		if {$c <= 8227} {
+		  if {$c <= 8226} {
+		    if {$c <= 8223} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8231} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8243} {
+		  if {$c <= 8241} {
+		    if {$c <= 8240} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8254} {
+		if {$c <= 8251} {
+		  if {$c <= 8250} {
+		    if {$c <= 8245} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8253} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8308} {
+		  if {$c <= 8307} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    } else {
+      if {$c <= 8775} {
+	if {$c <= 8657} {
+	  if {$c <= 8485} {
+	    if {$c <= 8453} {
+	      if {$c <= 8363} {
+		if {$c <= 8360} {
+		  if {$c <= 8324} {
+		    if {$c <= 8320} {
+		      if {$c <= 8319} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8361} { return H } else { return N }
+		}
+	      } else {
+		if {$c <= 8451} {
+		  if {$c <= 8450} {
+		    if {$c <= 8364} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8452} { return N } else { return A }
+		}
+	      }
+	    } else {
+	      if {$c <= 8469} {
+		if {$c <= 8466} {
+		  if {$c <= 8457} {
+		    if {$c <= 8456} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8467} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8482} {
+		  if {$c <= 8480} {
+		    if {$c <= 8470} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 8559} {
+	      if {$c <= 8538} {
+		if {$c <= 8530} {
+		  if {$c <= 8491} {
+		    if {$c <= 8490} {
+		      if {$c <= 8486} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8532} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8555} {
+		  if {$c <= 8543} {
+		    if {$c <= 8542} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8601} {
+		if {$c <= 8585} {
+		  if {$c <= 8584} {
+		    if {$c <= 8569} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8591} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8633} {
+		  if {$c <= 8631} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 8725} {
+	    if {$c <= 8710} {
+	      if {$c <= 8703} {
+		if {$c <= 8678} {
+		  if {$c <= 8660} {
+		    if {$c <= 8659} {
+		      if {$c <= 8658} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8679} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8707} {
+		  if {$c <= 8705} {
+		    if {$c <= 8704} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8719} {
+		if {$c <= 8715} {
+		  if {$c <= 8714} {
+		    if {$c <= 8712} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8718} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8724} {
+		  if {$c <= 8721} {
+		    if {$c <= 8720} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 8742} {
+	      if {$c <= 8738} {
+		if {$c <= 8732} {
+		  if {$c <= 8730} {
+		    if {$c <= 8729} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8736} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8741} {
+		  if {$c <= 8740} {
+		    if {$c <= 8739} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8759} {
+		if {$c <= 8750} {
+		  if {$c <= 8749} {
+		    if {$c <= 8748} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8755} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8765} {
+		  if {$c <= 8763} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 9203} {
+	  if {$c <= 8853} {
+	    if {$c <= 8809} {
+	      if {$c <= 8799} {
+		if {$c <= 8785} {
+		  if {$c <= 8780} {
+		    if {$c <= 8779} {
+		      if {$c <= 8776} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8786} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8807} {
+		  if {$c <= 8803} {
+		    if {$c <= 8801} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8835} {
+		if {$c <= 8815} {
+		  if {$c <= 8813} {
+		    if {$c <= 8811} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8833} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8852} {
+		  if {$c <= 8839} {
+		    if {$c <= 8837} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 8987} {
+	      if {$c <= 8895} {
+		if {$c <= 8869} {
+		  if {$c <= 8868} {
+		    if {$c <= 8857} {
+		      if {$c <= 8856} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8894} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8985} {
+		  if {$c <= 8978} {
+		    if {$c <= 8977} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 9199} {
+		if {$c <= 9192} {
+		  if {$c <= 9002} {
+		    if {$c <= 9000} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9196} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 9202} {
+		  if {$c <= 9200} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 9659} {
+	    if {$c <= 9621} {
+	      if {$c <= 9587} {
+		if {$c <= 9547} {
+		  if {$c <= 9450} {
+		    if {$c <= 9449} {
+		      if {$c <= 9311} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9551} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 9617} {
+		  if {$c <= 9615} {
+		    if {$c <= 9599} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 9649} {
+		if {$c <= 9634} {
+		  if {$c <= 9633} {
+		    if {$c <= 9631} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9641} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 9655} {
+		  if {$c <= 9653} {
+		    if {$c <= 9651} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 9681} {
+	      if {$c <= 9672} {
+		if {$c <= 9665} {
+		  if {$c <= 9663} {
+		    if {$c <= 9661} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9669} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 9677} {
+		  if {$c <= 9675} {
+		    if {$c <= 9674} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 9724} {
+		if {$c <= 9710} {
+		  if {$c <= 9701} {
+		    if {$c <= 9697} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9711} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 9732} {
+		  if {$c <= 9726} { return W } else { return N }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    }
+  } else {
+    if {$c <= 65497} {
+      if {$c <= 10070} {
+	if {$c <= 9918} {
+	  if {$c <= 9829} {
+	    if {$c <= 9791} {
+	      if {$c <= 9749} {
+		if {$c <= 9743} {
+		  if {$c <= 9741} {
+		    if {$c <= 9737} {
+		      if {$c <= 9736} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9747} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 9757} {
+		  if {$c <= 9756} {
+		    if {$c <= 9755} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9758} { return A } else { return N }
+		}
+	      }
+	    } else {
+	      if {$c <= 9811} {
+		if {$c <= 9794} {
+		  if {$c <= 9793} {
+		    if {$c <= 9792} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9799} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 9826} {
+		  if {$c <= 9825} {
+		    if {$c <= 9823} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 9875} {
+	      if {$c <= 9839} {
+		if {$c <= 9837} {
+		  if {$c <= 9835} {
+		    if {$c <= 9834} {
+		      if {$c <= 9830} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9838} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 9874} {
+		  if {$c <= 9855} {
+		    if {$c <= 9854} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 9897} {
+		if {$c <= 9888} {
+		  if {$c <= 9887} {
+		    if {$c <= 9885} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9889} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 9916} {
+		  if {$c <= 9899} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 9978} {
+	    if {$c <= 9955} {
+	      if {$c <= 9939} {
+		if {$c <= 9933} {
+		  if {$c <= 9925} {
+		    if {$c <= 9923} {
+		      if {$c <= 9919} { return A } else { return N }
+		    } else {
+		      return W
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9934} { return W } else { return A }
+		}
+	      } else {
+		if {$c <= 9954} {
+		  if {$c <= 9953} {
+		    if {$c <= 9940} { return W } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 9971} {
+		if {$c <= 9962} {
+		  if {$c <= 9961} {
+		    if {$c <= 9959} { return N } else { return A }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 9969} { return A } else { return W }
+		}
+	      } else {
+		if {$c <= 9977} {
+		  if {$c <= 9973} {
+		    if {$c <= 9972} { return A } else { return W }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 10044} {
+	      if {$c <= 9993} {
+		if {$c <= 9988} {
+		  if {$c <= 9983} {
+		    if {$c <= 9981} {
+		      if {$c <= 9980} { return A } else { return W }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9989} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 10024} {
+		  if {$c <= 10023} {
+		    if {$c <= 9995} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 10062} {
+		if {$c <= 10060} {
+		  if {$c <= 10059} {
+		    if {$c <= 10045} { return A } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 10061} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 10069} {
+		  if {$c <= 10066} { return N } else { return W }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 12771} {
+	  if {$c <= 11930} {
+	    if {$c <= 11034} {
+	      if {$c <= 10159} {
+		if {$c <= 10132} {
+		  if {$c <= 10111} {
+		    if {$c <= 10101} {
+		      if {$c <= 10071} { return W } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 10135} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 10175} {
+		  if {$c <= 10174} {
+		    if {$c <= 10160} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 11093} {
+		if {$c <= 11088} {
+		  if {$c <= 11087} {
+		    if {$c <= 11036} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 11092} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 11929} {
+		  if {$c <= 11903} {
+		    if {$c <= 11097} { return A } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 12438} {
+	      if {$c <= 12287} {
+		if {$c <= 12271} {
+		  if {$c <= 12245} {
+		    if {$c <= 12031} {
+		      if {$c <= 12019} { return W } else { return N }
+		    } else {
+		      return W
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 12283} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 12352} {
+		  if {$c <= 12350} {
+		    if {$c <= 12288} { return F } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 12592} {
+		if {$c <= 12548} {
+		  if {$c <= 12543} {
+		    if {$c <= 12440} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 12591} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 12687} {
+		  if {$c <= 12686} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 65039} {
+	    if {$c <= 42182} {
+	      if {$c <= 19903} {
+		if {$c <= 12871} {
+		  if {$c <= 12831} {
+		    if {$c <= 12830} {
+		      if {$c <= 12783} { return N } else { return W }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 12879} { return A } else { return W }
+		}
+	      } else {
+		if {$c <= 42127} {
+		  if {$c <= 42124} {
+		    if {$c <= 19967} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 57343} {
+		if {$c <= 44031} {
+		  if {$c <= 43388} {
+		    if {$c <= 43359} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 55203} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 65023} {
+		  if {$c <= 64255} {
+		    if {$c <= 63743} { return A } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 65376} {
+	      if {$c <= 65126} {
+		if {$c <= 65106} {
+		  if {$c <= 65071} {
+		    if {$c <= 65049} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 65107} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 65280} {
+		  if {$c <= 65131} {
+		    if {$c <= 65127} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return F
+		}
+	      }
+	    } else {
+	      if {$c <= 65487} {
+		if {$c <= 65479} {
+		  if {$c <= 65473} {
+		    if {$c <= 65470} { return H } else { return N }
+		  } else {
+		    return H
+		  }
+		} else {
+		  if {$c <= 65481} { return N } else { return H }
+		}
+	      } else {
+		if {$c <= 65495} {
+		  if {$c <= 65489} { return N } else { return H }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    } else {
+      if {$c <= 127991} {
+	if {$c <= 127247} {
+	  if {$c <= 110580} {
+	    if {$c <= 94193} {
+	      if {$c <= 65532} {
+		if {$c <= 65511} {
+		  if {$c <= 65510} {
+		    if {$c <= 65503} {
+		      if {$c <= 65500} { return H } else { return N }
+		    } else {
+		      return F
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 65518} { return H } else { return N }
+		}
+	      } else {
+		if {$c <= 94180} {
+		  if {$c <= 94175} {
+		    if {$c <= 65533} { return A } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 94191} { return N } else { return W }
+		}
+	      }
+	    } else {
+	      if {$c <= 101631} {
+		if {$c <= 100351} {
+		  if {$c <= 100343} {
+		    if {$c <= 94207} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 101589} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 110579} {
+		  if {$c <= 110575} {
+		    if {$c <= 101640} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 110959} {
+	      if {$c <= 110927} {
+		if {$c <= 110591} {
+		  if {$c <= 110590} {
+		    if {$c <= 110588} {
+		      if {$c <= 110587} { return W } else { return N }
+		    } else {
+		      return W
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 110882} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 110951} {
+		  if {$c <= 110947} {
+		    if {$c <= 110930} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 127183} {
+		if {$c <= 126980} {
+		  if {$c <= 126979} {
+		    if {$c <= 111355} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 127182} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 127242} {
+		  if {$c <= 127231} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 127589} {
+	    if {$c <= 127487} {
+	      if {$c <= 127374} {
+		if {$c <= 127343} {
+		  if {$c <= 127337} {
+		    if {$c <= 127279} {
+		      if {$c <= 127277} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 127373} { return A } else { return W }
+		}
+	      } else {
+		if {$c <= 127404} {
+		  if {$c <= 127386} {
+		    if {$c <= 127376} { return A } else { return W }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 127560} {
+		if {$c <= 127547} {
+		  if {$c <= 127503} {
+		    if {$c <= 127490} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 127551} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 127583} {
+		  if {$c <= 127569} {
+		    if {$c <= 127567} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 127903} {
+	      if {$c <= 127798} {
+		if {$c <= 127788} {
+		  if {$c <= 127776} {
+		    if {$c <= 127743} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 127797} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 127891} {
+		  if {$c <= 127869} {
+		    if {$c <= 127868} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 127984} {
+		if {$c <= 127955} {
+		  if {$c <= 127950} {
+		    if {$c <= 127946} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 127967} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 127988} {
+		  if {$c <= 127987} { return N } else { return W }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 129008} {
+	  if {$c <= 128591} {
+	    if {$c <= 128335} {
+	      if {$c <= 128254} {
+		if {$c <= 128065} {
+		  if {$c <= 128064} {
+		    if {$c <= 128063} {
+		      if {$c <= 128062} { return W } else { return N }
+		    } else {
+		      return W
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 128252} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 128334} {
+		  if {$c <= 128330} {
+		    if {$c <= 128317} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 128406} {
+		if {$c <= 128378} {
+		  if {$c <= 128377} {
+		    if {$c <= 128359} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 128404} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 128506} {
+		  if {$c <= 128420} {
+		    if {$c <= 128419} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 128735} {
+	      if {$c <= 128722} {
+		if {$c <= 128716} {
+		  if {$c <= 128715} {
+		    if {$c <= 128709} {
+		      if {$c <= 128639} { return N } else { return W }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 128719} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 128732} {
+		  if {$c <= 128727} {
+		    if {$c <= 128724} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 128991} {
+		if {$c <= 128755} {
+		  if {$c <= 128748} {
+		    if {$c <= 128746} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 128764} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 129007} {
+		  if {$c <= 129003} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 129733} {
+	    if {$c <= 129660} {
+	      if {$c <= 129535} {
+		if {$c <= 129349} {
+		  if {$c <= 129339} {
+		    if {$c <= 129338} {
+		      if {$c <= 129291} { return N } else { return W }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 129350} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 129655} {
+		  if {$c <= 129652} {
+		    if {$c <= 129647} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 129711} {
+		if {$c <= 129679} {
+		  if {$c <= 129670} {
+		    if {$c <= 129663} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 129708} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 129727} {
+		  if {$c <= 129722} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 196607} {
+	      if {$c <= 129775} {
+		if {$c <= 129759} {
+		  if {$c <= 129753} {
+		    if {$c <= 129743} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 129767} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 196605} {
+		  if {$c <= 131071} {
+		    if {$c <= 129782} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 1048573} {
+		if {$c <= 917999} {
+		  if {$c <= 917759} {
+		    if {$c <= 262141} { return W } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 983039} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 1114109} {
+		  if {$c <= 1048575} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    }
+  }
+}
+
+proc ::textutil::wcswidth_char c {
+  if {$c <= 94193} {
+    if {$c <= 10160} {
+      if {$c <= 9934} {
+	if {$c <= 9799} {
+	  if {$c <= 9199} {
+	    if {$c <= 9000} {
+	      if {$c <= 8985} {
+		if {$c <= 4447} {
+		  if {$c <= 4351} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 8987} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 9196} {
+		if {$c <= 9192} {
+		  if {$c <= 9002} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 9726} {
+	      if {$c <= 9203} {
+		if {$c <= 9202} {
+		  if {$c <= 9200} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 9724} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 9749} {
+		if {$c <= 9747} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 9897} {
+	    if {$c <= 9875} {
+	      if {$c <= 9855} {
+		if {$c <= 9854} {
+		  if {$c <= 9811} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 9874} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 9889} {
+		if {$c <= 9888} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 9923} {
+	      if {$c <= 9918} {
+		if {$c <= 9916} {
+		  if {$c <= 9899} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 9933} {
+		if {$c <= 9925} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 9995} {
+	  if {$c <= 9977} {
+	    if {$c <= 9969} {
+	      if {$c <= 9961} {
+		if {$c <= 9940} {
+		  if {$c <= 9939} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 9962} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 9973} {
+		if {$c <= 9972} {
+		  if {$c <= 9971} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 9988} {
+	      if {$c <= 9981} {
+		if {$c <= 9980} {
+		  if {$c <= 9978} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 9993} {
+		if {$c <= 9989} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 10069} {
+	    if {$c <= 10061} {
+	      if {$c <= 10059} {
+		if {$c <= 10024} {
+		  if {$c <= 10023} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 10060} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 10066} {
+		if {$c <= 10062} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 10135} {
+	      if {$c <= 10132} {
+		if {$c <= 10071} {
+		  if {$c <= 10070} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 10159} { return 1 } else { return 2 }
+	    }
+	  }
+	}
+      }
+    } else {
+      if {$c <= 12831} {
+	if {$c <= 12283} {
+	  if {$c <= 11903} {
+	    if {$c <= 11087} {
+	      if {$c <= 11034} {
+		if {$c <= 10175} {
+		  if {$c <= 10174} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 11036} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 11093} {
+		if {$c <= 11092} {
+		  if {$c <= 11088} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 12031} {
+	      if {$c <= 12019} {
+		if {$c <= 11930} {
+		  if {$c <= 11929} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 12271} {
+		if {$c <= 12245} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 12591} {
+	    if {$c <= 12440} {
+	      if {$c <= 12352} {
+		if {$c <= 12350} {
+		  if {$c <= 12287} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 12438} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 12548} {
+		if {$c <= 12543} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 12771} {
+	      if {$c <= 12687} {
+		if {$c <= 12686} {
+		  if {$c <= 12592} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 12830} {
+		if {$c <= 12783} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 65049} {
+	  if {$c <= 43359} {
+	    if {$c <= 42124} {
+	      if {$c <= 19903} {
+		if {$c <= 12879} {
+		  if {$c <= 12871} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 19967} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 42182} {
+		if {$c <= 42127} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 63743} {
+	      if {$c <= 55203} {
+		if {$c <= 44031} {
+		  if {$c <= 43388} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 65039} {
+		if {$c <= 64255} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 65376} {
+	    if {$c <= 65127} {
+	      if {$c <= 65107} {
+		if {$c <= 65106} {
+		  if {$c <= 65071} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 65126} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 65280} {
+		if {$c <= 65131} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 94180} {
+	      if {$c <= 94175} {
+		if {$c <= 65510} {
+		  if {$c <= 65503} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 94191} { return 1 } else { return 2 }
+	    }
+	  }
+	}
+      }
+    }
+  } else {
+    if {$c <= 128254} {
+      if {$c <= 127503} {
+	if {$c <= 110930} {
+	  if {$c <= 110580} {
+	    if {$c <= 101631} {
+	      if {$c <= 100351} {
+		if {$c <= 100343} {
+		  if {$c <= 94207} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 101589} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 110579} {
+		if {$c <= 110575} {
+		  if {$c <= 101640} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 110591} {
+	      if {$c <= 110590} {
+		if {$c <= 110588} {
+		  if {$c <= 110587} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 110927} {
+		if {$c <= 110882} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 127183} {
+	    if {$c <= 126979} {
+	      if {$c <= 110959} {
+		if {$c <= 110951} {
+		  if {$c <= 110947} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 111355} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 127182} {
+		if {$c <= 126980} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 127386} {
+	      if {$c <= 127376} {
+		if {$c <= 127374} {
+		  if {$c <= 127373} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 127490} {
+		if {$c <= 127487} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 127903} {
+	  if {$c <= 127776} {
+	    if {$c <= 127569} {
+	      if {$c <= 127560} {
+		if {$c <= 127551} {
+		  if {$c <= 127547} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 127567} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 127743} {
+		if {$c <= 127589} {
+		  if {$c <= 127583} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 127868} {
+	      if {$c <= 127798} {
+		if {$c <= 127797} {
+		  if {$c <= 127788} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 127891} {
+		if {$c <= 127869} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 127991} {
+	    if {$c <= 127984} {
+	      if {$c <= 127955} {
+		if {$c <= 127950} {
+		  if {$c <= 127946} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 127967} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 127988} {
+		if {$c <= 127987} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 128065} {
+	      if {$c <= 128064} {
+		if {$c <= 128063} {
+		  if {$c <= 128062} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 128252} { return 2 } else { return 1 }
+	    }
+	  }
+	}
+      }
+    } else {
+      if {$c <= 129008} {
+	if {$c <= 128715} {
+	  if {$c <= 128406} {
+	    if {$c <= 128359} {
+	      if {$c <= 128334} {
+		if {$c <= 128330} {
+		  if {$c <= 128317} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 128335} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 128404} {
+		if {$c <= 128378} {
+		  if {$c <= 128377} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 128591} {
+	      if {$c <= 128506} {
+		if {$c <= 128420} {
+		  if {$c <= 128419} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 128709} {
+		if {$c <= 128639} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 128746} {
+	    if {$c <= 128727} {
+	      if {$c <= 128722} {
+		if {$c <= 128719} {
+		  if {$c <= 128716} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 128724} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 128735} {
+		if {$c <= 128732} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 128991} {
+	      if {$c <= 128764} {
+		if {$c <= 128755} {
+		  if {$c <= 128748} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 129007} {
+		if {$c <= 129003} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 129711} {
+	  if {$c <= 129652} {
+	    if {$c <= 129350} {
+	      if {$c <= 129339} {
+		if {$c <= 129338} {
+		  if {$c <= 129291} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 129349} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 129647} {
+		if {$c <= 129535} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 129670} {
+	      if {$c <= 129663} {
+		if {$c <= 129660} {
+		  if {$c <= 129655} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 129708} {
+		if {$c <= 129679} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 129775} {
+	    if {$c <= 129753} {
+	      if {$c <= 129733} {
+		if {$c <= 129727} {
+		  if {$c <= 129722} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 129743} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 129767} {
+		if {$c <= 129759} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 196607} {
+	      if {$c <= 196605} {
+		if {$c <= 131071} {
+		  if {$c <= 129782} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 262141} { return 2 } else { 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
+}
+
+# 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
+return
diff --git a/src/vendormodules/overtype-1.6.3.tm b/src/vendormodules/overtype-1.6.3.tm
index ef12e95..d7e25d6 100644
--- a/src/vendormodules/overtype-1.6.3.tm
+++ b/src/vendormodules/overtype-1.6.3.tm
@@ -65,7 +65,15 @@ package require punk::assertion
 #*** !doctools
 #[list_end]
 
-
+#PERFORMANCE notes
+#overtype is very performance sensitive - used in ansi output all over the place ie needs to be optimised
+#NOTE use of tcl::dict::for tcl::string::range etc instead of ensemble versions. This is for the many tcl 8.6/8.7 interps which don't compile ensemble commands when in safe interps
+#similar for tcl::namespace::eval - but this is at least on some versions of Tcl - faster even in a normal interp. Review to see if that holds for Tcl 9.
+#for string map:  when there are exactly 2 elements - it is faster to use a literal which has a special case optimisation in the c code
+#ie use tcl::string::map {\n ""} ...  instead of tcl::string::map [list \n ""] ...
+#note that we can use unicode (e.g \uFF31) and other escapes such as \t within these curly braces - we don't have to use double quotes
+#generally using 'list' is preferred for the map as less error prone.
+#can also use: tcl::string::map "token $var" ..   but be careful regarding quoting and whitespace in var. This should be used sparingly if at all.
 
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
@@ -78,10 +86,10 @@ package require punk::assertion
 #
 #todo - ellipsis truncation indicator for center,right
 
-#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
+#v1.4 2023-07 - naive ansi color handling - todo - fix tcl::string::range 
 # - need to extract and replace ansi codes?
 
-namespace eval overtype {
+tcl::namespace::eval overtype {
     namespace import ::punk::assertion::assert
     punk::assertion::active true 
 
@@ -90,7 +98,7 @@ namespace eval overtype {
 	namespace export *
     variable default_ellipsis_horizontal "..." ;#fallback 
     variable default_ellipsis_vertical "..." 
-    namespace eval priv {
+    tcl::namespace::eval priv {
         proc _init {} {
             upvar ::overtype::default_ellipsis_horizontal e_h
             upvar ::overtype::default_ellipsis_vertical e_v
@@ -112,18 +120,18 @@ proc overtype::about {} {
 	return "Simple text formatting. Author JMN. BSD-License"
 }
 
-namespace eval overtype {
-    variable grapheme_widths [dict create]
+tcl::namespace::eval overtype {
+    variable grapheme_widths [tcl::dict::create]
 
     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 
+    tcl::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 "\{" "\}"]
+    #tcl::dict::set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
+    tcl::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\
+    set  ansi_2byte_codes_dict [tcl::dict::create\
         "reset_terminal"            "\u001bc"\
         "save_cursor_posn"          "\u001b7"\
         "restore_cursor_posn"       "\u001b8"\
@@ -166,7 +174,7 @@ namespace eval overtype {
 #            #2nd byte - done.
 #            set in_escapesequence 0
 #        } elseif {$in_escapesequence != 0} {
-#            set escseq [dict get $escape_terminals $in_escapesequence]
+#            set escseq [tcl::dict::get $escape_terminals $in_escapesequence]
 #            if {$u in $escseq} {
 #                set in_escapesequence 0
 #            } elseif {$uv in $escseq} {
@@ -206,7 +214,7 @@ proc overtype::string_columns {text} {
 #These have similar algorithms/requirements - and should be refactored to be argument-wrappers over a function called something like overtype::renderblock 
 #overtype::renderblock could render the input to a defined (possibly overflowing in x or y) rectangle overlapping the underlay.
 #(i.e not even necessariy having it's top left within the underlay)
-namespace eval overtype::priv {
+tcl::namespace::eval overtype::priv {
 }
 
 #could return larger than colwidth
@@ -232,7 +240,7 @@ proc _get_row_append_column {row} {
     }
 }
 
-namespace eval overtype {
+tcl::namespace::eval overtype {
     #*** !doctools
     #[subsection {Namespace overtype}]
     #[para] Core API functions for overtype 
@@ -240,7 +248,7 @@ namespace eval overtype {
 
 
 
-    #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
+    #tcl::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
     #render onto an already-rendered (ansi already processed) 'underlay' string, a possibly ansi-laden 'overlay' string.
     #The underlay and overlay can be multiline blocks of text of varying line lengths.
     #The overlay may just be an ansi-colourised block - or may contain ansi cursor movements and cursor save/restore calls - in which case the apparent length and width of the overlay can't be determined as if it was a block of text.
@@ -260,7 +268,7 @@ namespace eval overtype {
             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\
+        set opts [tcl::dict::create\
             -bias       ignored\
             -width      \uFFEF\
             -height     \uFFEF\
@@ -278,31 +286,33 @@ namespace eval overtype {
         ]
         #-ellipsis args not used if -wrap is true
         set argsflags [lrange $args 0 end-2]
-        dict for {k v} $argsflags {
+        foreach {k v} $argsflags {
             switch -- $k {
-                -looplimit - -width - -height - -bias - -wrap - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -appendlines - -transparent - -exposed1 - -exposed2 - -experimental {}
+                -looplimit - -width - -height - -bias - -wrap - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -appendlines - -transparent - -exposed1 - -exposed2 - -experimental {
+                    tcl::dict::set opts $k $v
+                }
                 default {
-                    set known_opts [dict keys $defaults]
+                    set known_opts [tcl::dict::keys $opts]
                     error "overtype::renderspace unknown option '$k'. Known options: $known_opts"
                 }
             }
         }
-        set opts [dict merge $defaults $argsflags]
+        #set opts [tcl::dict::merge $defaults $argsflags]
         # -- --- --- --- --- ---
-        set opt_overflow        [dict get $opts -overflow] 
+        set opt_overflow        [tcl::dict::get $opts -overflow] 
         #####
         # review -wrap should map onto DECAWM terminal mode - the wrap 2 idea may not fit in with this?.
-        set opt_wrap            [dict get $opts -wrap]  ;#wrap 1 is hard wrap cutting word at exact column, or 1 column early for 2w-glyph, wrap 2 is for language-based word-wrap algorithm (todo)
+        set opt_wrap            [tcl::dict::get $opts -wrap]  ;#wrap 1 is hard wrap cutting word at exact column, or 1 column early for 2w-glyph, wrap 2 is for language-based word-wrap algorithm (todo)
         #####
         #for repl - standard output line indicator is a dash - todo, add a different indicator for a continued line.
-        set opt_width           [dict get $opts -width]
-        set opt_height          [dict get $opts -height]
-        set opt_appendlines     [dict get $opts -appendlines]
-        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 opt_width           [tcl::dict::get $opts -width]
+        set opt_height          [tcl::dict::get $opts -height]
+        set opt_appendlines     [tcl::dict::get $opts -appendlines]
+        set opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1] ;#widechar_exposed_left  - todo
+        set opt_exposed2        [tcl::dict::get $opts -exposed2] ;#widechar_exposed_right - todo
         # -- --- --- --- --- ---
 
         # ----------------------------
@@ -312,7 +322,7 @@ namespace eval overtype {
         set test_mode 1
         set info_mode 0
         set edit_mode 0
-        set opt_experimental   [dict get $opts -experimental]
+        set opt_experimental   [tcl::dict::get $opts -experimental]
         foreach o $opt_experimental {
             switch -- $o {
                 test_mode {
@@ -343,9 +353,8 @@ namespace eval overtype {
         set reverse_mode 0
         
 
-        set norm [list \r\n \n]
-        set underblock [string map $norm $underblock]
-        set overblock  [string map $norm $overblock]
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $overblock]
 
 
         #set underlines [split $underblock \n]
@@ -393,7 +402,7 @@ namespace eval overtype {
 
         #a hack until we work out how to avoid infinite loops... 
         #
-        set looplimit [dict get $opts -looplimit]
+        set looplimit [tcl::dict::get $opts -looplimit]
         if {$looplimit eq "\uFFEF"} {
             #looping for each char is worst case (all newlines?) - anything over that is an indication of something broken?
             #do we need any margin above the length? (telnet mapscii.me test)
@@ -424,7 +433,7 @@ namespace eval overtype {
                         }
                         set sequence_split [punk::ansi::ta::split_codes_single $ln]  ;#use split_codes Not split_codes_single?
                         set lastpt [lindex $inputchunks end]
-                        lset inputchunks end [string cat $lastpt [lindex $sequence_split 0]]
+                        lset inputchunks end [tcl::string::cat $lastpt [lindex $sequence_split 0]]
                         lappend inputchunks {*}[lrange $sequence_split 1 end]
                         incr i
                     }
@@ -438,7 +447,7 @@ namespace eval overtype {
                         lappend lflines $ln
                     }
                     if {[llength $lflines]} {
-                        lset lflines end [string range [lindex $lflines end] 0 end-1]
+                        lset lflines end [tcl::string::range [lindex $lflines end] 0 end-1]
                     }
                     set inputchunks $lflines[unset lflines]
 
@@ -451,11 +460,11 @@ namespace eval overtype {
         #lassign [blocksize $overblock] _w overblock_width _h overblock_height
 
 
-        set replay_codes_underlay [dict create 1 ""] 
+        set replay_codes_underlay [tcl::dict::create 1 ""] 
         #lappend replay_codes_overlay ""
         set replay_codes_overlay ""
         set unapplied ""
-        set cursor_saved_position [dict create] 
+        set cursor_saved_position [tcl::dict::create] 
         set cursor_saved_attributes ""
 
 
@@ -470,7 +479,7 @@ namespace eval overtype {
             set col 1
         }
 
-        set instruction_stats [dict create]
+        set instruction_stats [tcl::dict::create]
 
         set loop 0
         #while {$overidx < [llength $inputchunks]} { }
@@ -489,10 +498,10 @@ namespace eval overtype {
             #renderline pads each underaly line to width with spaces and should track where end of data is
 
 
-            #set overtext [string cat [lindex $replay_codes_overlay $overidx] $overtext]
-            set overtext [string cat $replay_codes_overlay $overtext]
-            if {[dict exists $replay_codes_underlay $row]} {
-                set undertext [string cat [dict get $replay_codes_underlay $row] $undertext]
+            #set overtext [tcl::string::cat [lindex $replay_codes_overlay $overidx] $overtext]
+            set overtext [tcl::string::cat $replay_codes_overlay $overtext]
+            if {[tcl::dict::exists $replay_codes_underlay $row]} {
+                set undertext [tcl::string::cat [tcl::dict::get $replay_codes_underlay $row] $undertext]
             }
             #review insert_mode. As an 'overtype' function whose main function is not interactive keystrokes - insert is secondary - 
             #but even if we didn't want it as an option to the function call - to process ansi adequately we need to support IRM (insertion-replacement mode) ESC [ 4 h|l
@@ -512,25 +521,25 @@ namespace eval overtype {
                                      $undertext\
                                      $overtext\
                     ]
-            set instruction         [dict get $rinfo instruction]
-            set insert_mode         [dict get $rinfo insert_mode]
-            set autowrap_mode       [dict get $rinfo autowrap_mode] ;#
-            #set reverse_mode        [dict get $rinfo reverse_mode];#how to support in rendered linelist? we need to examine all pt/code blocks and flip each SGR stack?
-            set rendered            [dict get $rinfo result]
-            set overflow_right      [dict get $rinfo overflow_right]
-            set overflow_right_column      [dict get $rinfo overflow_right_column]
-            set unapplied           [dict get $rinfo unapplied]
-            set unapplied_list           [dict get $rinfo unapplied_list]
-            set post_render_col          [dict get $rinfo cursor_column]
-            set post_render_row          [dict get $rinfo cursor_row]
-            set c_saved_pos         [dict get $rinfo cursor_saved_position]
-            set c_saved_attributes  [dict get $rinfo cursor_saved_attributes]
-            set visualwidth         [dict get $rinfo visualwidth]
-            set insert_lines_above  [dict get $rinfo insert_lines_above]
-            set insert_lines_below  [dict get $rinfo insert_lines_below]
-            dict set replay_codes_underlay [expr {$renderedrow+1}] [dict get $rinfo replay_codes_underlay]
-            #lset replay_codes_overlay [expr $overidx+1] [dict get $rinfo replay_codes_overlay]
-            set replay_codes_overlay  [dict get $rinfo replay_codes_overlay]
+            set instruction         [tcl::dict::get $rinfo instruction]
+            set insert_mode         [tcl::dict::get $rinfo insert_mode]
+            set autowrap_mode       [tcl::dict::get $rinfo autowrap_mode] ;#
+            #set reverse_mode        [tcl::dict::get $rinfo reverse_mode];#how to support in rendered linelist? we need to examine all pt/code blocks and flip each SGR stack?
+            set rendered            [tcl::dict::get $rinfo result]
+            set overflow_right      [tcl::dict::get $rinfo overflow_right]
+            set overflow_right_column      [tcl::dict::get $rinfo overflow_right_column]
+            set unapplied           [tcl::dict::get $rinfo unapplied]
+            set unapplied_list           [tcl::dict::get $rinfo unapplied_list]
+            set post_render_col          [tcl::dict::get $rinfo cursor_column]
+            set post_render_row          [tcl::dict::get $rinfo cursor_row]
+            set c_saved_pos         [tcl::dict::get $rinfo cursor_saved_position]
+            set c_saved_attributes  [tcl::dict::get $rinfo cursor_saved_attributes]
+            set visualwidth         [tcl::dict::get $rinfo visualwidth]
+            set insert_lines_above  [tcl::dict::get $rinfo insert_lines_above]
+            set insert_lines_below  [tcl::dict::get $rinfo insert_lines_below]
+            tcl::dict::set replay_codes_underlay [expr {$renderedrow+1}] [tcl::dict::get $rinfo replay_codes_underlay]
+            #lset replay_codes_overlay [expr $overidx+1] [tcl::dict::get $rinfo replay_codes_overlay]
+            set replay_codes_overlay  [tcl::dict::get $rinfo replay_codes_overlay]
 
 
 
@@ -542,7 +551,7 @@ namespace eval overtype {
             }
             #--
 
-            if {[dict size $c_saved_pos] >= 1} {
+            if {[tcl::dict::size $c_saved_pos] >= 1} {
                 set cursor_saved_position $c_saved_pos
                 set cursor_saved_attributes $c_saved_attributes
             }
@@ -557,7 +566,7 @@ namespace eval overtype {
 
                 #todo - handle potential insertion mode as above for cursor restore?
                 #keeping separate branches for debugging - review and merge as appropriate when stable
-                dict incr instruction_stats $instruction 
+                tcl::dict::incr instruction_stats $instruction 
                 switch -- $instruction {
                     {} {
                         if {$test_mode == 0} {
@@ -657,15 +666,15 @@ namespace eval overtype {
                         #testfile belinda.ans uses this
 
                         #puts stdout "[a+ blue bold]CURSOR_RESTORE[a]"
-                        if {[dict exists $cursor_saved_position row]} {
-                            set row [dict get $cursor_saved_position row]
-                            set col [dict get $cursor_saved_position column]
+                        if {[tcl::dict::exists $cursor_saved_position row]} {
+                            set row [tcl::dict::get $cursor_saved_position row]
+                            set col [tcl::dict::get $cursor_saved_position column]
                             #puts stdout "restoring: row $row col $col [ansistring VIEW $cursor_saved_attributes] [a] unapplied [ansistring VIEWCODES $unapplied]"
                             #set nextprefix $cursor_saved_attributes
                             #lset replay_codes_overlay [expr $overidx+1] $cursor_saved_attributes 
-                            set replay_codes_overlay [dict get $rinfo replay_codes_overlay]$cursor_saved_attributes
+                            set replay_codes_overlay [tcl::dict::get $rinfo replay_codes_overlay]$cursor_saved_attributes
                             #set replay_codes_overlay $cursor_saved_attributes
-                            set cursor_saved_position [dict create]
+                            set cursor_saved_position [tcl::dict::create]
                             set cursor_saved_attributes ""
                         } else {
                             #TODO
@@ -684,10 +693,10 @@ namespace eval overtype {
 
                             puts stdout ">>>[a+ red bold]overflow_right during restore_cursor[a]"
 
-                            set sub_info [overtype::renderline -info 1 -width $colwidth -insert_mode $insert_mode -autowrap_mode $autowrap_mode  -overflow [dict get $opts -overflow] "" $overflow_right]
-                            set foldline [dict get $sub_info result]
-                            set insert_mode [dict get $sub_info insert_mode] ;#probably not needed.. 
-                            set autowrap_mode [dict get $sub_info autowrap_mode] ;#nor this..
+                            set sub_info [overtype::renderline -info 1 -width $colwidth -insert_mode $insert_mode -autowrap_mode $autowrap_mode  -overflow [tcl::dict::get $opts -overflow] "" $overflow_right]
+                            set foldline [tcl::dict::get $sub_info result]
+                            set insert_mode [tcl::dict::get $sub_info insert_mode] ;#probably not needed.. 
+                            set autowrap_mode [tcl::dict::get $sub_info autowrap_mode] ;#nor this..
                             linsert outputlines $renderedrow $foldline
                             #review - row & col set by restore - but not if there was no save..
                         }
@@ -957,7 +966,7 @@ namespace eval overtype {
                             #this works for test_mode (which should become the default) - but could give a bad result otherwise - review - add tests fix.
                             set col $post_render_col
                             #set unapplied ""             ;#this seems wrong?
-                            #set unapplied [string range $unapplied 1 end] 
+                            #set unapplied [tcl::string::range $unapplied 1 end] 
                             #The overflow can only be triggered by a grapheme (todo cluster?) - but our unapplied could contain SGR codes prior to the grapheme that triggered overflow - so we need to skip beyond any SGRs
                             #There may be more than one, because although the stack leading up to overflow may have been merged - codes between the last column and the overflowing grapheme will remain separate
                             #We don't expect any movement or other ANSI codes - as if they came before the grapheme, they would have triggered a different instruction to 'overflow'
@@ -1034,7 +1043,7 @@ namespace eval overtype {
 
             if {!$opt_overflow && !$autowrap_mode} {
                 #not allowed to overflow column or wrap therefore we get overflow data to truncate 
-                if {[dict get $opts -ellipsis]} {
+                if {[tcl::dict::get $opts -ellipsis]} {
                     set show_ellipsis 1
                     if {!$opt_ellipsiswhitespace} {
                         #we don't want ellipsis if only whitespace was lost
@@ -1045,11 +1054,11 @@ namespace eval overtype {
                         if {$unapplied ne ""} {
                             append lostdata $unapplied
                         }
-                        if {[string trim $lostdata] eq ""} {
+                        if {[tcl::string::trim $lostdata] eq ""} {
                             set show_ellipsis 0
                         }
-                        #set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim [punk::ansi::stripansi $lostdata]] eq ""} {
+                        #set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[tcl::string::trim [punk::ansi::stripansi $lostdata]] eq ""} {
                             set show_ellipsis 0
                         }
                     }
@@ -1113,9 +1122,9 @@ namespace eval overtype {
                 append debugmsg "test_mode:$test_mode\n"
                 append debugmsg "data_mode:$data_mode\n"
                 append debugmsg "opt_appendlines:$opt_appendlines\n"
-                append debugmsg "prev_row :[dict get $LASTCALL -cursor_row]\n"
-                append debugmsg "prev_col :[dict get $LASTCALL -cursor_column]\n"
-                dict for {k v} $rinfo {
+                append debugmsg "prev_row :[tcl::dict::get $LASTCALL -cursor_row]\n"
+                append debugmsg "prev_col :[tcl::dict::get $LASTCALL -cursor_column]\n"
+                tcl::dict::for {k v} $rinfo {
                     append debugmsg "${Y}$k   [ansistring VIEW -lf 1 -vt 1 $v]$RST" \n
                 }
                 append debugmsg "${Y}[string repeat - [string length $sep_header]]$RST" \n
@@ -1148,7 +1157,7 @@ namespace eval overtype {
         foreach {underblock overblock} [lrange $args end-1 end] break
 
         #todo - vertical vs horizontal overflow for blocks
-        set defaults [dict create\
+        set opts [tcl::dict::create\
             -bias       left\
             -ellipsis   0\
             -ellipsistext   $default_ellipsis_horizontal\
@@ -1159,29 +1168,30 @@ namespace eval overtype {
             -exposed2 \uFFFD\
         ]
         set argsflags [lrange $args 0 end-2]
-        dict for {k v} $argsflags {
+        foreach {k v} $argsflags {
             switch -- $k {
-                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 {}
+                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 {
+                    tcl::dict::set opts $k $v
+                }
                 default {
-                    set known_opts [dict keys $defaults]
+                    set known_opts [tcl::dict::keys $opts]
                     error "overtype::centre unknown option '$k'. Known options: $known_opts"
                 }
             }
         }
-        set opts [dict merge $defaults $argsflags]
+        #set opts [tcl::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 opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsis        [tcl::dict::get $opts -ellipsis]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1]
+        set opt_exposed2        [tcl::dict::get $opts -exposed2]
         # -- --- --- --- --- ---
 
 
-        set norm [list \r\n \n]
-        set underblock [string map $norm $underblock]
-        set overblock  [string map $norm $overblock]
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $overblock]
 
         set underlines [split $underblock \n]
         #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
@@ -1197,7 +1207,7 @@ namespace eval overtype {
                 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"} {
+                if {[tcl::string::tolower [tcl::dict::get $opts -bias]] eq "left"} {
                     set left_exposed $beforehalf
                 } else {
                     #bias to the right
@@ -1223,30 +1233,30 @@ namespace eval overtype {
                 set udiff [expr {$colwidth - $ulen}]
                 set undertext "$undertext[string repeat { } $udiff]"
             }
-            set undertext [string cat $replay_codes_underlay $undertext]
-            set overtext  [string cat $replay_codes_overlay $overtext]
+            set undertext [tcl::string::cat $replay_codes_underlay $undertext]
+            set overtext  [tcl::string::cat $replay_codes_overlay $overtext]
 
             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 rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -overflow [dict get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-                set rendered        [dict get $rinfo result]
-                set overflow_right  [dict get $rinfo overflow_right]
-                set unapplied       [dict get $rinfo unapplied]
+                set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -overflow [tcl::dict::get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+                set rendered        [tcl::dict::get $rinfo result]
+                set overflow_right  [tcl::dict::get $rinfo overflow_right]
+                set unapplied       [tcl::dict::get $rinfo unapplied]
                 #todo - get replay_codes from overflow_right instead of wherever it was truncated?
 
                 #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 {![tcl::dict::get $opts -overflow]} {
+                    #lappend outputlines [tcl::string::range $overtext 0 [expr {$colwidth - 1}]]
+                    #set overtext [tcl::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
-                            #don't use string range on ANSI data
-                            #set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                            #don't use tcl::string::range on ANSI data
+                            #set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
                             set lostdata ""
                             if {$overflow_right ne ""} {
                                 append lostdata $overflow_right
@@ -1254,7 +1264,7 @@ namespace eval overtype {
                             if {$unapplied ne ""} {
                                 append lostdata $unapplied
                             }
-                            if {[string trim $lostdata] eq ""} {
+                            if {[tcl::string::trim $lostdata] eq ""} {
                                 set show_ellipsis 0
                             }
                         }
@@ -1269,10 +1279,10 @@ namespace eval overtype {
                 #background block is wider than or equal to data for this line
                 #lappend outputlines [renderline -insert_mode 0 -startcolumn [expr {$left_exposed + 1}] -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
                 set rinfo [renderline -info 1 -insert_mode 0 -startcolumn [expr {$left_exposed + 1}] -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-                lappend outputlines  [dict get $rinfo result]
+                lappend outputlines  [tcl::dict::get $rinfo result]
             }
-            set replay_codes_underlay [dict get $rinfo replay_codes_underlay]
-            set replay_codes_overlay [dict get $rinfo replay_codes_overlay]
+            set replay_codes_underlay [tcl::dict::get $rinfo replay_codes_underlay]
+            set replay_codes_overlay [tcl::dict::get $rinfo replay_codes_overlay]
         }
         return [join $outputlines \n]
     }
@@ -1290,7 +1300,7 @@ namespace eval overtype {
         }
         foreach {underblock overblock} [lrange $args end-1 end] break
 
-        set defaults [dict create\
+        set opts [tcl::dict::create\
             -bias       ignored\
             -ellipsis   0\
             -ellipsistext   $default_ellipsis_horizontal\
@@ -1302,30 +1312,31 @@ namespace eval overtype {
             -align  "left"\
         ]
         set argsflags [lrange $args 0 end-2]
-        dict for {k v} $argsflags {
+        tcl::dict::for {k v} $argsflags {
             switch -- $k {
-                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -align {}
+                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -align {
+                    tcl::dict::set opts $k $v
+                }
                 default {
-                    set known_opts [dict keys $defaults]
+                    set known_opts [tcl::dict::keys $opts]
                     error "overtype::centre unknown option '$k'. Known options: $known_opts"
                 }
             }
         }
-        set opts [dict merge $defaults $argsflags]
+        #set opts [tcl::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 opt_align           [dict get $opts -align]
+        set opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsis         [tcl::dict::get $opts -ellipsis]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_overflow        [tcl::dict::get $opts -overflow]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1]
+        set opt_exposed2        [tcl::dict::get $opts -exposed2]
+        set opt_align           [tcl::dict::get $opts -align]
         # -- --- --- --- --- ---
         
-        set norm [list \r\n \n]
-        set underblock [string map $norm $underblock]
-        set overblock  [string map $norm $overblock]
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $overblock]
 
         set underlines [split $underblock \n]
         #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
@@ -1375,27 +1386,27 @@ namespace eval overtype {
                 set startoffset 0 ;#negative?
             }
 
-            set undertext [string cat $replay_codes_underlay $undertext]
-            set overtext [string cat $replay_codes_overlay $overtext]
+            set undertext [tcl::string::cat $replay_codes_underlay $undertext]
+            set overtext [tcl::string::cat $replay_codes_overlay $overtext]
 
             set overflowlength [expr {$overtext_datalen - $colwidth}]
             if {$overflowlength > 0} {	
                 #raw overtext wider than undertext column
                 set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -startcolumn [expr {1 + $startoffset}] $undertext $overtext]
-                set replay_codes          [dict get $rinfo replay_codes]
-                set rendered [dict get $rinfo result]
+                set replay_codes          [tcl::dict::get $rinfo replay_codes]
+                set rendered [tcl::dict::get $rinfo result]
                 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 lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                            if {[tcl::string::trim $lostdata] eq ""} {
                                 set show_ellipsis 0
                             }
                         }
                         if {$show_ellipsis} {
-                            set ellipsis [string cat $replay_codes $opt_ellipsistext]
+                            set ellipsis [tcl::string::cat $replay_codes $opt_ellipsistext]
                             #todo - overflow on left if allign = right??
                             set rendered [overtype::right $rendered $ellipsis]
                         }
@@ -1407,11 +1418,11 @@ namespace eval overtype {
                 #lappend outputlines [renderline -insert_mode 0 -transparent $opt_transparent -startcolumn [expr {$left_exposed + 1}] $undertext $overtext]
                 #Note - we still need overflow here - as although the overtext is short - it may oveflow due to the startoffset
                 set rinfo [renderline -info 1  -insert_mode 0 -transparent $opt_transparent -overflow $opt_overflow -startcolumn [expr {$left_exposed + 1 + $startoffset}] $undertext $overtext]
-                lappend outputlines  [dict get $rinfo result]
+                lappend outputlines  [tcl::dict::get $rinfo result]
             }
-            set replay_codes          [dict get $rinfo replay_codes]
-            set replay_codes_underlay [dict get $rinfo replay_codes_underlay]
-            set replay_codes_overlay  [dict get $rinfo replay_codes_overlay]
+            set replay_codes          [tcl::dict::get $rinfo replay_codes]
+            set replay_codes_underlay [tcl::dict::get $rinfo replay_codes_underlay]
+            set replay_codes_overlay  [tcl::dict::get $rinfo replay_codes_overlay]
         }
 
         return [join $outputlines \n]
@@ -1430,7 +1441,7 @@ namespace eval overtype {
         }
         foreach {underblock overblock} [lrange $args end-1 end] break
 
-        set defaults [dict create\
+        set defaults [tcl::dict::create\
             -ellipsis   0\
             -ellipsistext   $default_ellipsis_horizontal\
             -ellipsiswhitespace 0\
@@ -1445,34 +1456,36 @@ namespace eval overtype {
             -blockvertical "top"\
         ]
         set argsflags [lrange $args 0 end-2]
-        dict for {k v} $argsflags {
+        set opts $defaults
+        tcl::dict::for {k v} $argsflags {
             switch -- $k {
-                -blockalignbias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -textalign - -blockalign - -blockvertical {}
+                -blockalignbias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -textalign - -blockalign - -blockvertical {
+                    tcl::dict::set opts $k $v
+                }
                 default {
-                    set known_opts [dict keys $defaults]
+                    set known_opts [tcl::dict::keys $defaults]
                     error "overtype::block unknown option '$k'. Known options: $known_opts"
                 }
             }
         }
-        set opts [dict merge $defaults $argsflags]
+        #set opts [tcl::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 opt_textalign       [dict get $opts -textalign]
-        set opt_blockalign      [dict get $opts -blockalign]
+        set opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsis         [tcl::dict::get $opts -ellipsis]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_overflow        [tcl::dict::get $opts -overflow]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1]
+        set opt_exposed2        [tcl::dict::get $opts -exposed2]
+        set opt_textalign       [tcl::dict::get $opts -textalign]
+        set opt_blockalign      [tcl::dict::get $opts -blockalign]
         if {$opt_blockalign eq "center"} {
             set opt_blockalign "centre"
         }
         # -- --- --- --- --- ---
         
-        set norm [list \r\n \n]
-        set underblock [string map $norm $underblock]
-        set overblock  [string map $norm $overblock]
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $overblock]
 
         set underlines [split $underblock \n]
         #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
@@ -1497,7 +1510,7 @@ namespace eval overtype {
                         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 -blockalignbias]] eq "left"} {
+                        if {[tcl::string::tolower [tcl::dict::get $opts -blockalignbias]] eq "left"} {
                             set left_exposed $beforehalf
                         } else {
                             #bias to the right
@@ -1552,24 +1565,24 @@ namespace eval overtype {
                 set startoffset 0 ;#negative?
             }
 
-            set undertext [string cat $replay_codes_underlay $undertext]
-            set overtext [string cat $replay_codes_overlay $overtext]
+            set undertext [tcl::string::cat $replay_codes_underlay $undertext]
+            set overtext [tcl::string::cat $replay_codes_overlay $overtext]
 
             set overflowlength [expr {$overtext_datalen - $colwidth}]
             if {$overflowlength > 0} {	
                 #raw overtext wider than undertext column
                 set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -startcolumn [expr {1 + $startoffset}] $undertext $overtext]
-                set replay_codes    [dict get $rinfo replay_codes]
-                set rendered        [dict get $rinfo result]
-                set overflow_right  [dict get $rinfo overflow_right]
-                set unapplied       [dict get $rinfo unapplied]
+                set replay_codes    [tcl::dict::get $rinfo replay_codes]
+                set rendered        [tcl::dict::get $rinfo result]
+                set overflow_right  [tcl::dict::get $rinfo overflow_right]
+                set unapplied       [tcl::dict::get $rinfo unapplied]
                 if {!$opt_overflow} {
                     if {$opt_ellipsis} {
                         set show_ellipsis 1
                         if {!$opt_ellipsiswhitespace} {
                             #we don't want ellipsis if only whitespace was lost
-                            #don't use string range on ANSI data
-                            #set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
+                            #don't use tcl::string::range on ANSI data
+                            #set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
                             set lostdata ""
                             if {$overflow_right ne ""} {
                                 append lostdata $overflow_right
@@ -1577,7 +1590,7 @@ namespace eval overtype {
                             if {$unapplied ne ""} {
                                 append lostdata $unapplied
                             }
-                            if {[string trim $lostdata] eq ""} {
+                            if {[tcl::string::trim $lostdata] eq ""} {
                                 set show_ellipsis 0
                             }
                         }
@@ -1590,13 +1603,13 @@ namespace eval overtype {
                     #    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 lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                    #        if {[tcl::string::trim $lostdata] eq ""} {
                     #            set show_ellipsis 0
                     #        }
                     #    }
                     #    if {$show_ellipsis} {
-                    #        set ellipsis [string cat $replay_codes $opt_ellipsistext]
+                    #        set ellipsis [tcl::string::cat $replay_codes $opt_ellipsistext]
                     #        #todo - overflow on left if allign = right??
                     #        set rendered [overtype::right $rendered $ellipsis]
                     #    }
@@ -1608,13 +1621,13 @@ namespace eval overtype {
                 #lappend outputlines [renderline -insert_mode 0 -transparent $opt_transparent -startcolumn [expr {$left_exposed + 1}] $undertext $overtext]
                 #Note - we still need overflow here - as although the overtext is short - it may oveflow due to the startoffset
                 set rinfo [renderline -info 1  -insert_mode 0 -transparent $opt_transparent -overflow $opt_overflow -startcolumn [expr {$left_exposed + 1 + $startoffset}] $undertext $overtext]
-                set overflow_right  [dict get $rinfo overflow_right]
-                set unapplied       [dict get $rinfo unapplied]
-                lappend outputlines [dict get $rinfo result]
+                set overflow_right  [tcl::dict::get $rinfo overflow_right]
+                set unapplied       [tcl::dict::get $rinfo unapplied]
+                lappend outputlines [tcl::dict::get $rinfo result]
             }
-            set replay_codes          [dict get $rinfo replay_codes]
-            set replay_codes_underlay [dict get $rinfo replay_codes_underlay]
-            set replay_codes_overlay  [dict get $rinfo replay_codes_overlay]
+            set replay_codes          [tcl::dict::get $rinfo replay_codes]
+            set replay_codes_underlay [tcl::dict::get $rinfo replay_codes_underlay]
+            set replay_codes_overlay  [tcl::dict::get $rinfo replay_codes_overlay]
         }
 
         return [join $outputlines \n]
@@ -1661,7 +1674,7 @@ namespace eval overtype {
         #    error "overtype::renderline not allowed to contain newlines"
         #}
 
-        set defaults [dict create\
+        set defaults [tcl::dict::create\
             -etabs         0\
             -width         \uFFEF\
             -overflow      0\
@@ -1688,41 +1701,41 @@ namespace eval overtype {
         #todo - return info about such grapheme 'cuts' in -info structure and/or create option to raise an error
 
         set argsflags [lrange $args 0 end-2]
-        dict for {k v} $argsflags {
+        tcl::dict::for {k v} $argsflags {
             switch -- $k {
                 -experimental - -cp437 - -width - -overflow - -transparent - -startcolumn - -cursor_column - -cursor_row - -insert_mode - -autowrap_mode - -reverse_mode - -info - -exposed1 - -exposed2 - -cursor_restore_attributes {}
                 default {
-                    set known_opts [dict keys $defaults]
+                    set known_opts [tcl::dict::keys $defaults]
                     error "overtype::renderline unknown option '$k'. Known options: $known_opts"
                 }
             }
         }
-        set opts [dict merge $defaults $argsflags]
+        set opts [tcl::dict::merge $defaults $argsflags]
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_width               [dict get $opts -width]
-        set opt_etabs               [dict get $opts -etabs]
-        set opt_overflow            [dict get $opts -overflow]
-        set opt_colstart            [dict get $opts -startcolumn] ;#lhs limit for overlay - an offset to cursor_column  - first visible column is 1.  0 or < 0 are before the start of the underlay 
-        set opt_colcursor           [dict get $opts -cursor_column];#start cursor column relative to overlay
-        set opt_row_context         [dict get $opts -cursor_row]
+        set opt_width               [tcl::dict::get $opts -width]
+        set opt_etabs               [tcl::dict::get $opts -etabs]
+        set opt_overflow            [tcl::dict::get $opts -overflow]
+        set opt_colstart            [tcl::dict::get $opts -startcolumn] ;#lhs limit for overlay - an offset to cursor_column  - first visible column is 1.  0 or < 0 are before the start of the underlay 
+        set opt_colcursor           [tcl::dict::get $opts -cursor_column];#start cursor column relative to overlay
+        set opt_row_context         [tcl::dict::get $opts -cursor_row]
         if {[string length $opt_row_context]} {
-            if {![string is integer -strict $opt_row_context] || $opt_row_context <1 } {
+            if {![tcl::string::is integer -strict $opt_row_context] || $opt_row_context <1 } {
                 error "overtype::renderline -cursor_row must be empty for unspecified/unknown or a non-zero positive integer. received: '$opt_row_context'"
             }
         }
         # -- --- --- --- --- --- --- --- --- --- --- --- 
         #The _mode flags correspond to terminal modes that can be set/reset via escape sequences (e.g DECAWM wraparound mode)
-        set opt_insert_mode         [dict get $opts -insert_mode];#should usually be 1 for each new line in editor mode but must be initialised to 1 externally (review)
+        set opt_insert_mode         [tcl::dict::get $opts -insert_mode];#should usually be 1 for each new line in editor mode but must be initialised to 1 externally (review)
         #default is for overtype
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_autowrap_mode       [dict get $opts -autowrap_mode] ;#DECAWM - char or movement can go beyond leftmost/rightmost col to prev/next line
-        set opt_reverse_mode        [dict get $opts -reverse_mode]  ;#DECSNM
+        set opt_autowrap_mode       [tcl::dict::get $opts -autowrap_mode] ;#DECAWM - char or movement can go beyond leftmost/rightmost col to prev/next line
+        set opt_reverse_mode        [tcl::dict::get $opts -reverse_mode]  ;#DECSNM
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set temp_cursor_saved       [dict get $opts -cursor_restore_attributes]
+        set temp_cursor_saved       [tcl::dict::get $opts -cursor_restore_attributes]
 
         set test_mode 0
-        set cp437_glyphs [dict get $opts -cp437] 
-        foreach e [dict get $opts -experimental] {
+        set cp437_glyphs [tcl::dict::get $opts -cp437] 
+        foreach e [tcl::dict::get $opts -experimental] {
             switch -- $e {
                 test_mode {
                     set test_mode 1
@@ -1731,16 +1744,16 @@ namespace eval overtype {
             }
         }
         set test_mode 1  ;#try to elminate
-        set cp437_map [dict create]
+        set cp437_map [tcl::dict::create]
         if {$cp437_glyphs} {
             set cp437_map [set ::punk::ansi::cp437_map]
             #for cp437 images we need to map these *after* splitting ansi
             #some old files might use newline for its glyph.. but we can't easily support that.
             #Not sure how old files did it.. maybe cr lf in sequence was newline and any lone cr or lf were displayed as glyphs?
-            dict unset cp437_map \n
+            tcl::dict::unset cp437_map \n
         }
 
-        set opt_transparent         [dict get $opts -transparent]  
+        set opt_transparent         [tcl::dict::get $opts -transparent]  
         if {$opt_transparent eq "0"} {
             set do_transparency 0
         } else {
@@ -1750,10 +1763,10 @@ namespace eval overtype {
             }
         }
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_returnextra         [dict get $opts -info]
+        set opt_returnextra         [tcl::dict::get $opts -info]
         # -- --- --- --- --- --- --- --- --- --- --- ---
-        set opt_exposed1            [dict get $opts -exposed1]
-        set opt_exposed2            [dict get $opts -exposed2]
+        set opt_exposed1            [tcl::dict::get $opts -exposed1]
+        set opt_exposed2            [tcl::dict::get $opts -exposed2]
         # -- --- --- --- --- --- --- --- --- --- --- ---
 
         if {$opt_row_context eq ""} {
@@ -1814,7 +1827,7 @@ namespace eval overtype {
             #pt = plain text
             #append pt_underchars $pt
             if {$cp437_glyphs} {
-                set pt [string map $cp437_map $pt]
+                set pt [tcl::string::map $cp437_map $pt]
             }
             foreach grapheme [punk::char::grapheme_split $pt] {
                 #an ugly hack to serve *some* common case ascii quickly with byte-compiled literal switch - feels dirty.
@@ -1868,8 +1881,8 @@ namespace eval overtype {
 
             #only stack SGR (graphics rendition) codes - not title sets, cursor moves etc 
             if {$code ne ""} {
-                set c1c2 [string range $code 0 1]
-                set leadernorm [string range [string map [list\
+                set c1c2 [tcl::string::range $code 0 1]
+                set leadernorm [tcl::string::range [tcl::string::map [list\
                     \x1b\[      7CSI\
                     \x9b        8CSI\
                     \x1b\(      7GFX\
@@ -1880,11 +1893,11 @@ namespace eval overtype {
                         #need to exclude certain leaders after the lb e.g < for SGR 1006 mouse 
                         #REVIEW - what else could end in m but be mistaken as a normal SGR code here?
                         set maybemouse ""
-                        if {[string index $c1c2 0] eq "\x1b"} {
-                            set maybemouse [string index $code 2]
+                        if {[tcl::string::index $c1c2 0] eq "\x1b"} {
+                            set maybemouse [tcl::string::index $code 2]
                         }
                         
-                        if {$maybemouse ne "<" && [string index $code end] eq "m"} {
+                        if {$maybemouse ne "<" && [tcl::string::index $code end] eq "m"} {
                             if {[punk::ansi::codetype::is_sgr_reset $code]} {
                                 set u_codestack [list "\x1b\[m"]
                             } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
@@ -1898,7 +1911,7 @@ namespace eval overtype {
                         }
                     }
                     7GFX {
-                        switch -- [string index $code 2] {
+                        switch -- [tcl::string::index $code 2] {
                             "0" {
                                 set u_gx_stack [list gx0_on] ;#we'd better use a placeholder - or debugging will probably get into a big mess
                             }
@@ -2035,7 +2048,7 @@ namespace eval overtype {
 
             #todo - wrap in test for empty pt (we used split_codes_single - and it may be common for sgr sequences to be unmerged and so have empty pts between)
             if {$cp437_glyphs} {
-                set pt [string map $cp437_map $pt]
+                set pt [tcl::string::map $cp437_map $pt]
             }
             append pt_overchars $pt
             #will get empty pt between adjacent codes
@@ -2099,8 +2112,8 @@ namespace eval overtype {
         #set replay_codes_overlay [join $o_codestack ""]
         set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}$o_codestack]
 
-        #if {[dict exists $overstacks $max_overlay_grapheme_index]} {
-        #    set replay_codes_overlay [join [dict get $overstacks $max_overlay_grapheme_index] ""]
+        #if {[tcl::dict::exists $overstacks $max_overlay_grapheme_index]} {
+        #    set replay_codes_overlay [join [tcl::dict::get $overstacks $max_overlay_grapheme_index] ""]
         #} else {
         #    set replay_codes_overlay ""
         #}
@@ -2188,7 +2201,7 @@ namespace eval overtype {
                     #This is hard to process in any standard manner - but I think the Hyper behaviour of doing what it was intended is perhaps most reasonable
                     #We will map it to the same behaviour as lf here for now... but we need also to consider the equivalent ANSI sequence: \x1bE 
 
-                    set chtest [string map [list \n <lf> \x85 <lf> \b <bs> \r <cr> \v <vt> \x7f <del>] $ch]
+                    set chtest [tcl::string::map [list \n <lf> \x85 <lf> \b <bs> \r <cr> \v <vt> \x7f <del>] $ch]
                     #puts --->chtest:$chtest
                     #specials - each shoud have it's own test of what to do if it happens after overflow_idx reached
                     switch -- $chtest {
@@ -2276,7 +2289,7 @@ namespace eval overtype {
                                         #review split 2w overflow?
                                         #we don't want to make the decision here to split a 2w into replacement characters at end of line and beginning of next line
                                         #better to consider the overlay char as unable to be applied to the line
-                                        #render empty string to column(?) - and reduce overlay grapheme index by one so that the current ch goes into unapplied
+                                        #render empty  column(?) - and reduce overlay grapheme index by one so that the current ch goes into unapplied
                                         #throwing back to caller with instruction complicates its job - but is necessary to avoid making decsions for it here.
                                         priv::render_addchar $idx "" [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
                                         #change the overflow_idx
@@ -2315,7 +2328,7 @@ namespace eval overtype {
                                 #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
                                 if {$idx > [llength $outcols]-1} {
                                     lappend outcols " "
-                                    #dict set understacks $idx [list] ;#review - use idx-1 codestack?
+                                    #tcl::dict::set understacks $idx [list] ;#review - use idx-1 codestack?
                                     lset understacks $idx [list]
                                     incr idx
                                     incr cursor_column
@@ -2343,7 +2356,7 @@ namespace eval overtype {
                                         if {[grapheme_width_cached $ch] == 1} {
                                             if {!$insert_mode} {
                                                 #normal singlewide transparent overlay onto double-wide underlay 
-                                                set next_pt_overchar [string index $pt_overchars $idx_over+1] ;#lookahead of next plain-text char in overlay
+                                                set next_pt_overchar [tcl::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
@@ -2354,7 +2367,7 @@ namespace eval overtype {
                                                         incr cursor_column
                                                     } 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] [dict get $overstacks_gx $idx_over] $insert_mode
+                                                        #priv::render_addchar $idx $opt_exposed1 [tcl::dict::get $overstacks $idx_over] [tcl::dict::get $overstacks_gx $idx_over] $insert_mode
                                                         priv::render_addchar $idx $opt_exposed1 [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
                                                         incr idx
                                                         incr cursor_column
@@ -2519,13 +2532,13 @@ namespace eval overtype {
 
                     #todo - consider CSI s DECSLRM vs ansi.sys \x1b\[s  - we need \x1b\[s for oldschool ansi art - but may have to enable only for that.
                     #we should probably therefore reverse this mapping so that x1b7 x1b8 are the primary codes for save/restore
-                    set code [string map [list \x1b7 \x1b\[s \x1b8 \x1b\[u ] $code]
+                    set code [tcl::string::map [list \x1b7 \x1b\[s \x1b8 \x1b\[u ] $code]
 
 
-                    set c1 [string index $code 0]
-                    set c1c2c3 [string range $code 0 2]
+                    set c1 [tcl::string::index $code 0]
+                    set c1c2c3 [tcl::string::range $code 0 2]
                     #set re_ST_open {(?:\033P|\u0090|\033X|\u0098|\033\^|\u009e|\033_|\u009f)} 
-                    set leadernorm [string range [string map [list\
+                    set leadernorm [tcl::string::range [tcl::string::map [list\
                         \x1b\[<     1006\
                         \x1b\[      7CSI\
                         \x9b        8CSI\
@@ -2539,16 +2552,16 @@ namespace eval overtype {
                         1006 {
                             #https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
                             #SGR (1006) CSI < followed by colon separated encoded-button-value,px,py ordinates and final M for button press m for button release
-                            set codenorm [string cat $leadernorm [string range $code 3 end]]
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 3 end]]
                         }
                         7CSI - 7OSC {
-                            set codenorm [string cat $leadernorm [string range $code 2 end]]
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 2 end]]
                         }
                         7ESC {
-                            set codenorm [string cat $leadernorm [string range $code 1 end]]
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 1 end]]
                         }
                         8CSI - 8OSC {
-                            set codenorm [string cat $leadernorm [string range $code 1 end]]
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 1 end]]
                         }
                         default {
                             #we haven't made a mapping for this
@@ -2561,7 +2574,7 @@ namespace eval overtype {
                         1006 {
                             #TODO
                             #
-                            switch -- [string index $codenorm end] {
+                            switch -- [tcl::string::index $codenorm end] {
                                 M {
                                     puts stderr "mousedown $codenorm"
                                 }
@@ -2572,9 +2585,9 @@ namespace eval overtype {
 
                         }
                         {7CSI} - {8CSI} {
-                            set param [string range $codenorm 4 end-1]
-                            #puts stdout "--> CSI [string index $leadernorm 0] bit param:$param"
-                            switch -- [string index $codenorm end] {
+                            set param [tcl::string::range $codenorm 4 end-1]
+                            #puts stdout "--> CSI [tcl::string::index $leadernorm 0] bit param:$param"
+                            switch -- [tcl::string::index $codenorm end] {
                                 D {
                                     #Col move
                                     #puts stdout "<-back"
@@ -2679,8 +2692,8 @@ namespace eval overtype {
                                                 #puts "idxstart:$idxstart idxend:$idxend outcols[llength $outcols] undercols:[llength $undercols]"
                                                 incr idx $moveend
                                                 incr cursor_column $moveend
-                                                #if {[dict exists $understacks $idx]} {
-                                                #    set stackinfo [dict get $understacks $idx] ;#use understack at end - which may or may not have already been replaced by stack from overtext
+                                                #if {[tcl::dict::exists $understacks $idx]} {
+                                                #    set stackinfo [tcl::dict::get $understacks $idx] ;#use understack at end - which may or may not have already been replaced by stack from overtext
                                                 #} else {
                                                 #    set stackinfo [list]
                                                 #}
@@ -2690,7 +2703,7 @@ namespace eval overtype {
                                                     set stackinfo [list]
                                                 }
                                                 if {$idx < [llength $understacks_gx]} {
-                                                    #set gxstackinfo [dict get $understacks_gx $idx]
+                                                    #set gxstackinfo [tcl::dict::get $understacks_gx $idx]
                                                     set gxstackinfo [lindex $understacks_gx $idx]
                                                 } else {
                                                     set gxstackinfo [list]
@@ -3000,8 +3013,8 @@ namespace eval overtype {
                                     #$re_mode if first after CSI is "?"  
                                     #some docs mention ESC=<mode>h|l  - not seen on windows terminals.. review
                                     #e.g https://www2.math.upenn.edu/~kazdan/210/computer/ansi.html
-                                    if {[string index $codenorm 4] eq "?"} {
-                                        set num [string range $codenorm 5 end-1] ;#param between ? and h|l
+                                    if {[tcl::string::index $codenorm 4] eq "?"} {
+                                        set num [tcl::string::range $codenorm 5 end-1] ;#param between ? and h|l
                                         #lassign $matchinfo _match num type
                                         switch -- $num {
                                             5 {
@@ -3062,7 +3075,7 @@ namespace eval overtype {
                         } 
                         7ESC {
                             #$re_other_single
-                            switch -- [string index $codenorm end] {
+                            switch -- [tcl::string::index $codenorm end] {
                                 D {
                                     #\x84
                                     #index (IND)
@@ -3158,7 +3171,7 @@ namespace eval overtype {
 
             set gxleader ""
             if {$i < [llength $understacks_gx]} {
-                #set g0 [dict get $understacks_gx $i]
+                #set g0 [tcl::dict::get $understacks_gx $i]
                 set g0 [lindex $understacks_gx $i]
                 if {$g0 ne $prev_g0} {
                     if {$g0 eq [list "gx0_on"]} {
@@ -3174,7 +3187,7 @@ namespace eval overtype {
 
             set sgrleader ""
             if {$i < [llength $understacks]} {
-                #set cstack [dict get $understacks $i]
+                #set cstack [tcl::dict::get $understacks $i]
                 set cstack [lindex $understacks $i]
                 if {$cstack ne $prevstack} {
                     if {[llength $prevstack] && ![llength $cstack]} {
@@ -3228,7 +3241,7 @@ namespace eval overtype {
                 append outstring $gxleader
                 append outstring $sgrleader
                 if {$idx+1 < $cursor_column} {
-                    append outstring [string map [list "\u0000" " "] $ch]
+                    append outstring [tcl::string::map {\u0000 " "} $ch]
                 } else {
                     append outstring $ch
                 }
@@ -3237,16 +3250,16 @@ namespace eval overtype {
         }
         #flower.ans good test for null handling - reverse line building
         if {![ansistring length $overflow_right]} {
-            set outstring [string trimright $outstring "\u0000"]
+            set outstring [tcl::string::trimright $outstring "\u0000"]
         }
-        set outstring [string map [list "\u0000" " "] $outstring] 
-        set overflow_right [string trimright $overflow_right "\u0000"]
-        set overflow_right [string map [list "\u0000" " "] $overflow_right] 
+        set outstring [tcl::string::map {\u0000 " "} $outstring] 
+        set overflow_right [tcl::string::trimright $overflow_right "\u0000"]
+        set overflow_right [tcl::string::map {\u0000 " "} $overflow_right] 
 
         set replay_codes ""
         if {[llength $understacks] > 0} {
             if {$overflow_idx == -1} {
-                #set tail_idx [dict size $understacks]
+                #set tail_idx [tcl::dict::size $understacks]
                 set tail_idx [llength $understacks]
             } else {
                 set tail_idx [llength $undercols]
@@ -3289,7 +3302,7 @@ namespace eval overtype {
             }  else {
                 set overflow_right_column [expr {$overflow_idx+1}]
             }
-            set result [dict create\
+            set result [tcl::dict::create\
                 result $outstring\
                 visualwidth [punk::ansi::printing_length $outstring]\
                 instruction $instruction\
@@ -3325,14 +3338,14 @@ namespace eval overtype {
                         set viewop VIEWSTYLE ;#ansi colorise the characters within the output with preceding codes, stacking codes only within each dict value - may not be same SGR effect as the effect in-situ. 
                     }
                 }
-                dict set result result                  [ansistring $viewop -lf 1 -vt 1 [dict get $result result]]
-                dict set result overflow_right          [ansistring VIEW -lf 1 -vt 1 [dict get $result overflow_right]]
-                dict set result unapplied               [ansistring VIEW -lf 1 -vt 1 [dict get $result unapplied]]
-                dict set result unapplied_list          [ansistring VIEW -lf 1 -vt 1 [dict get $result unapplied_list]]
-                dict set result replay_codes            [ansistring $viewop -lf 1 -vt 1 [dict get $result replay_codes]]
-                dict set result replay_codes_underlay   [ansistring $viewop -lf 1 -vt 1 [dict get $result replay_codes_underlay]]
-                dict set result replay_codes_overlay    [ansistring $viewop -lf 1 -vt 1 [dict get $result replay_codes_overlay]]
-                dict set result cursor_saved_attributes [ansistring $viewop -lf 1 -vt 1 [dict get $result cursor_saved_attributes]] 
+                tcl::dict::set result result                  [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result result]]
+                tcl::dict::set result overflow_right          [ansistring VIEW -lf 1 -vt 1 [tcl::dict::get $result overflow_right]]
+                tcl::dict::set result unapplied               [ansistring VIEW -lf 1 -vt 1 [tcl::dict::get $result unapplied]]
+                tcl::dict::set result unapplied_list          [ansistring VIEW -lf 1 -vt 1 [tcl::dict::get $result unapplied_list]]
+                tcl::dict::set result replay_codes            [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result replay_codes]]
+                tcl::dict::set result replay_codes_underlay   [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result replay_codes_underlay]]
+                tcl::dict::set result replay_codes_overlay    [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result replay_codes_overlay]]
+                tcl::dict::set result cursor_saved_attributes [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result cursor_saved_attributes]] 
                 return $result
             }
         } else {
@@ -3345,7 +3358,7 @@ namespace eval overtype {
     #[list_end] [comment {--- end definitions namespace overtype ---}]
 } 
 
-namespace eval overtype::piper {
+tcl::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}
@@ -3369,19 +3382,19 @@ namespace eval overtype::piper {
 proc overtype::transparentline {args} {
     foreach {under over} [lrange $args end-1 end] break
     set argsflags [lrange $args 0 end-2]
-    set defaults [dict create\
+    set defaults [tcl::dict::create\
         -transparent 1\
         -exposed 1 " "\
         -exposed 2 " "\
     ]
-    set newargs [dict merge $defaults $argsflags]
+    set newargs [tcl::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 {
+tcl::namespace::eval overtype::piper {
     proc renderline {args} {
         if {[llength $args] < 2} {
             error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
@@ -3398,11 +3411,11 @@ interp alias "" piper_renderline "" overtype::piper::renderline
 #(a cache of ansifreestring_width calls - as these are quite regex heavy)
 proc overtype::grapheme_width_cached {ch} {
     variable grapheme_widths
-    if {[dict exists $grapheme_widths $ch]} {
-        return [dict get $grapheme_widths $ch]
+    if {[tcl::dict::exists $grapheme_widths $ch]} {
+        return [tcl::dict::get $grapheme_widths $ch]
     }
     set width [punk::char::ansifreestring_width $ch]
-    dict set grapheme_widths $ch $width
+    tcl::dict::set grapheme_widths $ch $width
     return $width
 }
 
@@ -3420,7 +3433,7 @@ proc overtype::test_renderline {} {
 #block width and height can be tricky. e.g \v handled differently on different terminal emulators and can affect both
 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
+        return [tcl::dict::create width 0 height 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
     }
     if {[string first \t $textblock] >= 0} {
         if {[info exists punk::console::tabwidth]} {
@@ -3435,7 +3448,7 @@ proc overtype::blocksize {textblock} {
         set textblock [punk::ansi::stripansi $textblock]
     }
     if {[string first \n $textblock] >= 0} {
-        set num_le [expr {[string length $textblock]-[string length [string map [list \n {}] $textblock]]}] ;#faster than splitting into single-char list
+        set num_le [expr {[string length $textblock]-[string length [tcl::string::map {\n {}} $textblock]]}] ;#faster than splitting into single-char list
         set width [tcl::mathfunc::max {*}[lmap v [split $textblock \n] {::punk::char::ansifreestring_width $v}]]
     } else {
         set num_le 0
@@ -3444,22 +3457,22 @@ proc overtype::blocksize {textblock} {
     #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
+    return [tcl::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 {
-    variable cache_is_sgr [dict create]
+tcl::namespace::eval overtype::priv {
+    variable cache_is_sgr [tcl::dict::create]
 
     #we are likely to be asking the same question of the same ansi codes repeatedly
     #caching the answer saves some regex expense - possibly a few uS to lookup vs under 1uS
     #todo - test if still worthwhile after a large cache is built up. (limit cache size?)
     proc is_sgr {code} {
         variable cache_is_sgr
-        if {[dict exists $cache_is_sgr $code]} {
-            return [dict get $cache_is_sgr $code]
+        if {[tcl::dict::exists $cache_is_sgr $code]} {
+            return [tcl::dict::get $cache_is_sgr $code]
         } 
         set answer [punk::ansi::codetype::is_sgr $code]
-        dict set cache_is_sgr $code $answer
+        tcl::dict::set cache_is_sgr $code $answer
         return $answer
     }
     proc render_unapplied {overlay_grapheme_control_list gci} {
@@ -3564,7 +3577,7 @@ namespace eval overtype::priv {
         upvar understacks_gx gxstacks
         #ECH clears character attributes from erased character positions
         #ECH accepts 0 or empty parameter, which is equivalent to 1. Caller should do that mapping and only supply 1 or greater.
-        if {![string is integer -strict $count] || $count < 1} {
+        if {![tcl::string::is integer -strict $count] || $count < 1} {
             error "render_erasechar count must be integer >= 1"
         }
         set start $i
@@ -3639,13 +3652,13 @@ namespace eval overtype::priv {
 
 
 # -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype {
+tcl::namespace::eval overtype {
 	interp alias {} ::overtype::center {} ::overtype::centre
 }
 
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide overtype [namespace eval overtype {
+package provide overtype [tcl::namespace::eval overtype {
     variable version
     set version 1.6.3 
 }]
diff --git a/src/vendormodules/overtype-1.6.4.tm b/src/vendormodules/overtype-1.6.4.tm
new file mode 100644
index 0000000..4287632
--- /dev/null
+++ b/src/vendormodules/overtype-1.6.4.tm
@@ -0,0 +1,3685 @@
+# -*- 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.6.4
+# Meta platform     tcl
+# Meta license      BSD 
+# @@ Meta End
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin overtype_module_overtype 0 1.6.4]
+#[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::lib   ;#required for lines_as_list
+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
+package require punk::assertion
+#*** !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]
+
+#PERFORMANCE notes
+#overtype is very performance sensitive - used in ansi output all over the place ie needs to be optimised
+#NOTE use of tcl::dict::for tcl::string::range etc instead of ensemble versions. This is for the many tcl 8.6/8.7 interps which don't compile ensemble commands when in safe interps
+#similar for tcl::namespace::eval - but this is at least on some versions of Tcl - faster even in a normal interp. Review to see if that holds for Tcl 9.
+#for string map:  when there are exactly 2 elements - it is faster to use a literal which has a special case optimisation in the c code
+#ie use tcl::string::map {\n ""} ...  instead of tcl::string::map [list \n ""] ...
+#note that we can use unicode (e.g \uFF31) and other escapes such as \t within these curly braces - we don't have to use double quotes
+#generally using 'list' is preferred for the map as less error prone.
+#can also use: tcl::string::map "token $var" ..   but be careful regarding quoting and whitespace in var. This should be used sparingly if at all.
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !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 tcl::string::range 
+# - need to extract and replace ansi codes?
+
+tcl::namespace::eval overtype {
+    namespace import ::punk::assertion::assert
+    punk::assertion::active true 
+
+    namespace path ::punk::lib
+
+	namespace export *
+    variable default_ellipsis_horizontal "..." ;#fallback 
+    variable default_ellipsis_vertical "..." 
+    tcl::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"
+}
+
+tcl::namespace::eval overtype {
+    variable grapheme_widths [tcl::dict::create]
+
+    variable escape_terminals
+    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
+    tcl::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 "\{" "\}"]
+    #tcl::dict::set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
+    tcl::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 [tcl::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 [tcl::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"
+        set text [punk::ansi::stripansi $text]
+    }
+    return [punk::char::ansifreestring_width $text]
+}
+
+#todo - consider a way to merge overtype::left/centre/right
+#These have similar algorithms/requirements - and should be refactored to be argument-wrappers over a function called something like overtype::renderblock 
+#overtype::renderblock could render the input to a defined (possibly overflowing in x or y) rectangle overlapping the underlay.
+#(i.e not even necessariy having it's top left within the underlay)
+tcl::namespace::eval overtype::priv {
+}
+
+#could return larger than colwidth
+proc _get_row_append_column {row} {
+    upvar outputlines outputlines 
+    set idx [expr {$row -1}]
+    if {$row <= 1 || $row > [llength $outputlines]} {
+        return 1
+    } else {
+        upvar opt_overflow opt_overflow
+        upvar colwidth colwidth
+        set existinglen [punk::ansi::printing_length [lindex $outputlines $idx]]
+        set endpos [expr {$existinglen +1}]
+        if {$opt_overflow} {
+            return $endpos
+        } else {
+            if {$endpos > $colwidth} {
+                return $colwidth + 1
+            } else {
+                return $endpos
+            }
+        }
+    }
+}
+
+tcl::namespace::eval overtype {
+    #*** !doctools
+    #[subsection {Namespace overtype}]
+    #[para] Core API functions for overtype 
+    #[list_begin definitions]
+
+
+
+    #tcl::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
+    #render onto an already-rendered (ansi already processed) 'underlay' string, a possibly ansi-laden 'overlay' string.
+    #The underlay and overlay can be multiline blocks of text of varying line lengths.
+    #The overlay may just be an ansi-colourised block - or may contain ansi cursor movements and cursor save/restore calls - in which case the apparent length and width of the overlay can't be determined as if it was a block of text.
+    #This is a single-shot rendering of strings - ie there is no way to chain another call containing a cursor-restore to previously rendered output and have it know about any cursor-saves in the first call.
+    # a cursor start position other than top-left is a possible addition to consider.
+    #see editbuf in punk::repl for a more stateful ansi-processor. Both systems use loops over overtype::renderline 
+    proc renderspace {args} {
+        #*** !doctools
+        #[call [fun overtype::renderspace] [arg args] ]
+        #[para]	usage: ?-transparent [lb]0|1[rb]? ?-overflow [lb]1|0[rb]? ?-ellipsis [lb]1|0[rb]? ?-ellipsistext ...? undertext overtext
+
+        # @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 opts [tcl::dict::create\
+            -bias       ignored\
+            -width      \uFFEF\
+            -height     \uFFEF\
+            -startcolumn    1\
+            -wrap       0\
+            -ellipsis   0\
+            -ellipsistext   $default_ellipsis_horizontal\
+            -ellipsiswhitespace 0\
+            -overflow   0\
+            -appendlines  1\
+            -transparent 0\
+            -exposed1 \uFFFD\
+            -exposed2 \uFFFD\
+            -experimental  0\
+            -looplimit  \uFFEF\
+        ]
+        #-ellipsis args not used if -wrap is true
+        set argsflags [lrange $args 0 end-2]
+        foreach {k v} $argsflags {
+            switch -- $k {
+                -looplimit - -width - -height - -startcolumn - -bias - -wrap - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -appendlines - -transparent - -exposed1 - -exposed2 - -experimental {
+                    tcl::dict::set opts $k $v
+                }
+                default {
+                    error "overtype::renderspace unknown option '$k'. Known options: [tcl::dict::keys $opts]"
+                }
+            }
+        }
+        #set opts [tcl::dict::merge $defaults $argsflags]
+        # -- --- --- --- --- ---
+        set opt_overflow        [tcl::dict::get $opts -overflow] 
+        #####
+        # review -wrap should map onto DECAWM terminal mode - the wrap 2 idea may not fit in with this?.
+        set opt_wrap            [tcl::dict::get $opts -wrap]  ;#wrap 1 is hard wrap cutting word at exact column, or 1 column early for 2w-glyph, wrap 2 is for language-based word-wrap algorithm (todo)
+        #####
+        #for repl - standard output line indicator is a dash - todo, add a different indicator for a continued line.
+        set opt_width           [tcl::dict::get $opts -width]
+        set opt_height          [tcl::dict::get $opts -height]
+        set opt_startcolumn     [tcl::dict::get $opts -startcolumn]
+        set opt_appendlines     [tcl::dict::get $opts -appendlines]
+        set opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1] ;#widechar_exposed_left  - todo
+        set opt_exposed2        [tcl::dict::get $opts -exposed2] ;#widechar_exposed_right - todo
+        # -- --- --- --- --- ---
+
+        # ----------------------------
+        #  -experimental dev flag to set flags etc
+        # ----------------------------
+        set data_mode 0
+        set test_mode 1
+        set info_mode 0
+        set edit_mode 0
+        set opt_experimental   [tcl::dict::get $opts -experimental]
+        foreach o $opt_experimental {
+            switch -- $o {
+                test_mode {
+                    set test_mode 1
+                    set info_mode 1
+                }
+                old_mode {
+                    set test_mode 0
+                    set info_mode 1
+                }
+                data_mode {
+                    set data_mode 1
+                }
+                info_mode {
+                    set info_mode 1
+                }
+                edit_mode {
+                    set edit_mode 1
+                }
+            }
+        }
+        set test_mode 1 ;#try to eliminate
+        # ----------------------------
+
+        #modes
+        set insert_mode 0 ;#can be toggled by insert key or ansi IRM sequence ESC [ 4 h|l
+        set autowrap_mode $opt_wrap
+        set reverse_mode 0
+        
+
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $overblock]
+
+
+        #set underlines [split $underblock \n]
+
+        #underblock is a 'rendered' block - so width height make sense
+        #colwidth & colheight were originally named with reference to rendering into a 'column' of output e.g  a table column - before cursor row/col was implemented.
+        #The naming is now confusing. It should be something like renderwidth renderheight ?? review 
+        
+        if {$opt_width eq "\uFFEF" || $opt_height eq "\uFFEF"} {
+            lassign [blocksize $underblock] _w colwidth _h colheight
+            if {$opt_width ne "\uFFEF"} {
+                set colwidth $opt_width
+            }
+            if {$opt_height ne "\uFFEF"} {
+                set colheight $opt_height
+            }
+        } else {
+            set colwidth $opt_width
+            set colheight $opt_height
+        }
+
+        # -- --- --- --- 
+        #REVIEW - do we need ansi resets in the underblock?
+        if {$underblock eq ""} {
+            set underlines [lrepeat $colheight ""]
+        } else {
+            set underlines [split $underblock \n]
+        }
+        #if {$underblock eq ""} {
+        #    set blank "\x1b\[0m\x1b\[0m"
+        #    #set underlines [list "\x1b\[0m\x1b\[0m"]
+        #    set underlines [lrepeat $colheight $blank]
+        #} else {
+        #    #lines_as_list -ansiresets 1 will do nothing if -ansiresets 1 isn't specified - REVIEW
+        #    set underlines [lines_as_list -ansiresets 1 $underblock]
+        #}
+        # -- --- --- --- 
+
+        #todo - reconsider the 'line' as the natural chunking mechanism for the overlay.
+        #In practice an overlay ANSI stream can be a single line with ansi moves/restores etc - or even have no moves or newlines, just relying on wrapping at the output colwidth
+        #In such cases - we process the whole shebazzle for the first output line - only reducing by the applied amount at the head each time, reprocessing the long tail each time.
+        #(in cases where there are interline moves or cursor jumps anyway)
+        #This works - but doesn't seem efficient.
+        #On the other hand.. maybe it depends on the data. For simpler files it's more efficient than splitting first
+
+        #a hack until we work out how to avoid infinite loops... 
+        #
+        set looplimit [tcl::dict::get $opts -looplimit]
+        if {$looplimit eq "\uFFEF"} {
+            #looping for each char is worst case (all newlines?) - anything over that is an indication of something broken?
+            #do we need any margin above the length? (telnet mapscii.me test)
+            set looplimit [expr {[tcl::string::length $overblock] + 10}]
+        }
+
+        if {!$test_mode} {
+            set inputchunks [split $overblock \n]
+        } else {
+            set scheme 3
+            switch -- $scheme {
+                0 {
+                    #one big chunk
+                    set inputchunks [list $overblock]
+                }
+                1 {
+                    set inputchunks [punk::ansi::ta::split_codes $overblock]
+                }
+                2 {
+
+                    #split into lines if possible first - then into plaintext/ansi-sequence chunks ?
+                    set inputchunks [list ""] ;#put an empty plaintext split in for starters
+                    set i 1
+                    set lines [split $overblock \n]
+                    foreach ln $lines {
+                        if {$i < [llength $lines]} {
+                            append ln \n
+                        }
+                        set sequence_split [punk::ansi::ta::split_codes_single $ln]  ;#use split_codes Not split_codes_single?
+                        set lastpt [lindex $inputchunks end]
+                        lset inputchunks end [tcl::string::cat $lastpt [lindex $sequence_split 0]]
+                        lappend inputchunks {*}[lrange $sequence_split 1 end]
+                        incr i
+                    }
+                }
+                3 {
+                    #it turns out line based chunks are faster than the above.. probably because some of those end up doing the regex splitting twice 
+                    set lflines [list]
+                    set inputchunks [split $overblock \n]
+                    foreach ln $inputchunks {
+                        append ln \n
+                        lappend lflines $ln
+                    }
+                    if {[llength $lflines]} {
+                        lset lflines end [tcl::string::range [lindex $lflines end] 0 end-1]
+                    }
+                    set inputchunks $lflines[unset lflines]
+
+                }
+            }
+        }
+
+
+        #overblock height/width isn't useful in the presence of an ansi input overlay with movements. The number of lines may bear little relationship to the output height
+        #lassign [blocksize $overblock] _w overblock_width _h overblock_height
+
+
+        set replay_codes_underlay [tcl::dict::create 1 ""] 
+        #lappend replay_codes_overlay ""
+        set replay_codes_overlay ""
+        set unapplied ""
+        set cursor_saved_position [tcl::dict::create] 
+        set cursor_saved_attributes ""
+
+
+        set outputlines $underlines 
+        set overidx 0
+
+        #underlines are not necessarily processed in order - depending on cursor-moves applied from overtext
+        set row 1
+        if {$data_mode} {
+            set col [_get_row_append_column $row] 
+        } else {
+            set col $opt_startcolumn 
+        }
+
+        set instruction_stats [tcl::dict::create]
+
+        set loop 0
+        #while {$overidx < [llength $inputchunks]} { }
+
+        while {[llength $inputchunks]} {
+            #set overtext  [lindex $inputchunks $overidx]; lset inputchunks $overidx ""
+            set overtext [lpop inputchunks 0]
+            if {![tcl::string::length $overtext]} {
+                incr loop
+                continue
+            } 
+            #puts "----->[ansistring VIEW -lf 1 -vt 1 -nul 1 $overtext]<----"
+            set undertext [lindex $outputlines [expr {$row -1}]] 
+            set renderedrow $row
+
+            #renderline pads each underaly line to width with spaces and should track where end of data is
+
+
+            #set overtext [tcl::string::cat [lindex $replay_codes_overlay $overidx] $overtext]
+            set overtext [tcl::string::cat $replay_codes_overlay $overtext]
+            if {[tcl::dict::exists $replay_codes_underlay $row]} {
+                set undertext [tcl::string::cat [tcl::dict::get $replay_codes_underlay $row] $undertext]
+            }
+            #review insert_mode. As an 'overtype' function whose main function is not interactive keystrokes - insert is secondary - 
+            #but even if we didn't want it as an option to the function call - to process ansi adequately we need to support IRM (insertion-replacement mode) ESC [ 4 h|l
+            set LASTCALL [list -info 1 -insert_mode $insert_mode -autowrap_mode $autowrap_mode -transparent $opt_transparent -width $colwidth  -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -cursor_column $col -cursor_row $row $undertext $overtext]
+            set rinfo [renderline   -experimental $opt_experimental\
+                                    -info 1\
+                                    -insert_mode $insert_mode\
+                                    -cursor_restore_attributes $cursor_saved_attributes\
+                                    -autowrap_mode $autowrap_mode\
+                                    -transparent $opt_transparent\
+                                    -width $colwidth\
+                                    -exposed1 $opt_exposed1\
+                                    -exposed2 $opt_exposed2\
+                                    -overflow $opt_overflow\
+                                    -cursor_column $col\
+                                    -cursor_row $row\
+                                     $undertext\
+                                     $overtext\
+                    ]
+            set instruction                 [tcl::dict::get $rinfo instruction]
+            set insert_mode                 [tcl::dict::get $rinfo insert_mode]
+            set autowrap_mode               [tcl::dict::get $rinfo autowrap_mode] ;#
+            #set reverse_mode                [tcl::dict::get $rinfo reverse_mode];#how to support in rendered linelist? we need to examine all pt/code blocks and flip each SGR stack?
+            set rendered                    [tcl::dict::get $rinfo result]
+            set overflow_right              [tcl::dict::get $rinfo overflow_right]
+            set overflow_right_column       [tcl::dict::get $rinfo overflow_right_column]
+            set unapplied                   [tcl::dict::get $rinfo unapplied]
+            set unapplied_list              [tcl::dict::get $rinfo unapplied_list]
+            set post_render_col             [tcl::dict::get $rinfo cursor_column]
+            set post_render_row             [tcl::dict::get $rinfo cursor_row]
+            set c_saved_pos                 [tcl::dict::get $rinfo cursor_saved_position]
+            set c_saved_attributes          [tcl::dict::get $rinfo cursor_saved_attributes]
+            set visualwidth                 [tcl::dict::get $rinfo visualwidth]
+            set insert_lines_above          [tcl::dict::get $rinfo insert_lines_above]
+            set insert_lines_below          [tcl::dict::get $rinfo insert_lines_below]
+            tcl::dict::set replay_codes_underlay [expr {$renderedrow+1}] [tcl::dict::get $rinfo replay_codes_underlay]
+            #lset replay_codes_overlay [expr $overidx+1] [tcl::dict::get $rinfo replay_codes_overlay]
+            set replay_codes_overlay        [tcl::dict::get $rinfo replay_codes_overlay]
+
+
+
+            #-- todo - detect looping properly
+            if {$row > 1 && $overtext ne "" && $unapplied eq $overtext && $post_render_row == $row && $instruction eq ""} {
+                puts stderr "overtype::renderspace loop?"
+                puts [ansistring VIEW $rinfo]
+                break
+            }
+            #--
+
+            if {[tcl::dict::size $c_saved_pos] >= 1} {
+                set cursor_saved_position $c_saved_pos
+                set cursor_saved_attributes $c_saved_attributes
+            }
+
+
+            set overflow_handled 0
+
+
+
+            set nextprefix ""
+
+
+                #todo - handle potential insertion mode as above for cursor restore?
+                #keeping separate branches for debugging - review and merge as appropriate when stable
+                tcl::dict::incr instruction_stats $instruction 
+                switch -- $instruction {
+                    {} {
+                        if {$test_mode == 0} {
+                            incr row
+                            if {$data_mode} {
+                                set col [_get_row_append_column $row] 
+                                if {$col > $colwidth} {
+
+                                }
+                            } else {
+                                set col 1
+                            }
+                        } else {
+                            #lf included in data
+                            set row $post_render_row
+                            set col $post_render_col
+
+                            #set col 1
+                            #if {$post_render_row != $renderedrow} {
+                            #    set col 1
+                            #} else {
+                            #    set col $post_render_col
+                            #}
+                        }
+                    }
+                    up {
+
+                        #renderline knows it's own line number, and knows not to go above row l
+                        #it knows that a move whilst 1-beyond the width conflicts with the linefeed and reduces the move by one accordingly.
+                        #row returned should be correct.
+                        #column may be the overflow column - as it likes to report that to the caller.
+
+                        #Note that an ansi up sequence after last column going up to a previous line and also beyond the last column, will result in the next grapheme going onto the following line.
+                        #this seems correct - as the column remains beyond the right margin so subsequent chars wrap  (?) review
+                        #puts stderr "up $post_render_row"
+                        #puts stderr "$rinfo"
+
+                        #puts stdout "1 row:$row col $col" 
+                        set row $post_render_row
+                        #data_mode (naming?) determines if we move to end of existing data or not.
+                        #data_mode 0 means ignore existing line length and go to exact column
+                        #set by -experimental flag
+                        if {$data_mode == 0} {
+                            set col $post_render_col
+                        } else {
+                            #This doesn't really work if columns are pre-filled with spaces..we can't distinguish them from data 
+                            #we need renderline to return the number of the maximum column filled (or min if we ever do r-to-l)
+                            set existingdata [lindex $outputlines [expr {$post_render_row -1}]] 
+                            set lastdatacol [punk::ansi::printing_length $existingdata]
+                            if {$lastdatacol < $colwidth} {
+                                set col [expr {$lastdatacol+1}]
+                            } else {
+                                set col $colwidth 
+                            }
+                        }
+                        
+                        #puts stdout "2 row:$row col $col" 
+                        #puts stdout "-----------------------"
+                        #puts stdout $rinfo
+                        #flush stdout
+                    }
+                    down {
+                        if {$data_mode == 0} {
+                            #renderline doesn't know how far down we can go..
+                            if {$post_render_row > [llength $outputlines]} {
+                                if {$opt_appendlines} {
+                                    set diff [expr {$post_render_row - [llength $outputlines]}]
+                                    if {$diff > 0} {
+                                        lappend outputlines {*}[lrepeat $diff ""]
+                                    }
+                                    lappend outputlines ""
+                                }
+                            }
+                            set row $post_render_row 
+                            set col $post_render_col
+                        } else {
+                            if {$post_render_row > [llength $outputlines]} {
+                                if {$opt_appendlines} {
+                                    set diff [expr {$post_render_row - [llength $outputlines]}]
+                                    if {$diff > 0} {
+                                        lappend outputlines {*}[lrepeat $diff ""]
+                                    }
+                                    lappend outputlines ""
+                                }
+                            }
+                            set existingdata [lindex $outputlines [expr {$post_render_row -1}]] 
+                            set lastdatacol [punk::ansi::printing_length $existingdata]
+                            if {$lastdatacol < $colwidth} {
+                                set col [expr {$lastdatacol+1}]
+                            } else {
+                                set col $colwidth 
+                            }
+
+                        }
+                    }
+                    restore_cursor {
+                        #testfile belinda.ans uses this
+
+                        #puts stdout "[a+ blue bold]CURSOR_RESTORE[a]"
+                        if {[tcl::dict::exists $cursor_saved_position row]} {
+                            set row [tcl::dict::get $cursor_saved_position row]
+                            set col [tcl::dict::get $cursor_saved_position column]
+                            #puts stdout "restoring: row $row col $col [ansistring VIEW $cursor_saved_attributes] [a] unapplied [ansistring VIEWCODES $unapplied]"
+                            #set nextprefix $cursor_saved_attributes
+                            #lset replay_codes_overlay [expr $overidx+1] $cursor_saved_attributes 
+                            set replay_codes_overlay [tcl::dict::get $rinfo replay_codes_overlay]$cursor_saved_attributes
+                            #set replay_codes_overlay $cursor_saved_attributes
+                            set cursor_saved_position [tcl::dict::create]
+                            set cursor_saved_attributes ""
+                        } else {
+                            #TODO
+                            #?restore without save?
+                            #should move to home position and reset ansi SGR?
+                            #puts stderr "overtype::renderspace cursor_restore without save data available"
+                        }
+                        #If we were inserting prior to hitting the cursor_restore - there could be overflow_right data - generally the overtype functions aren't for inserting - but ansi can enable it
+                        #if we were already in overflow when cursor_restore was hit - it shouldn't have been processed as an action - just stored.
+                        if {!$overflow_handled && $overflow_right ne ""} {
+                            #wrap before restore? -  possible effect on saved cursor position
+                            #this overflow data has previously been rendered so has no cursor movements or further save/restore operations etc
+                            #we can just insert another call to renderline  to solve this.. ?
+                            #It would perhaps be more properly handled as a queue of instructions from our initial renderline call 
+                            #we don't need to worry about overflow next call (?)- but we should carry forward our gx and ansi stacks
+
+                            puts stdout ">>>[a+ red bold]overflow_right during restore_cursor[a]"
+
+                            set sub_info [overtype::renderline -info 1 -width $colwidth -insert_mode $insert_mode -autowrap_mode $autowrap_mode  -overflow [tcl::dict::get $opts -overflow] "" $overflow_right]
+                            set foldline [tcl::dict::get $sub_info result]
+                            set insert_mode [tcl::dict::get $sub_info insert_mode] ;#probably not needed.. 
+                            set autowrap_mode [tcl::dict::get $sub_info autowrap_mode] ;#nor this..
+                            linsert outputlines $renderedrow $foldline
+                            #review - row & col set by restore - but not if there was no save..
+                        }
+                        set overflow_handled 1
+
+                    }
+                    move {
+                        ########
+                        if {$post_render_row > [llength $outputlines]} {
+                            #Ansi moves need to create new lines ?
+                            #if {$opt_appendlines} {
+                            #    set diff [expr {$post_render_row - [llength $outputlines]}]
+                            #    if {$diff > 0} {
+                            #        lappend outputlines {*}[lrepeat $diff ""]
+                            #    }
+                            #    set row $post_render_row
+                            #} else {
+                                set row [llength $outputlines]
+                            #}
+                        } else {
+                            set row $post_render_row
+                        }
+                        #######
+                        set col $post_render_col
+                        #overflow + unapplied?
+                    }
+                    lf_start {
+                        #raw newlines - must be test_mode
+                        # ----------------------
+                        #test with fruit.ans
+                        #test - treating as newline below...
+                        #append rendered $overflow_right
+                        #set overflow_right ""
+                        set row $renderedrow
+                        incr row 
+                        if {$row > [llength $outputlines]} {
+                            lappend outputlines ""
+                        }
+                        set col $opt_startcolumn 
+                        # ----------------------
+                    }
+                    lf_mid {
+
+                            if 0 {
+                                #set rhswidth [punk::ansi::printing_length $overflow_right]
+                                #only show debug when we have overflow?
+                                set lhs [overtype::left -width 40 -wrap 1 "" [ansistring VIEWSTYLE -nul 1 -lf 1 -vt 1 $rendered]]
+                                set lhs [textblock::frame -title "rendered $visualwidth cols" -subtitle "row-$renderedrow" $lhs]
+
+                                set rhs ""
+                                if {$overflow_right ne ""} {
+                                    set rhs [overtype::left -width 40 -wrap 1 "" [ansistring VIEWSTYLE -nul 1 -lf 1 -vt 1 $overflow_right]]
+                                    set rhs [textblock::frame -title overflow_right $rhs]
+                                }
+                                puts [textblock::join $lhs " $post_render_col " $rhs]
+                            }
+
+                            if {!$test_mode} {
+                                #rendered 
+                                append rendered $overflow_right
+                                #set replay_codes_overlay "" 
+                                set overflow_right ""
+
+
+                                set row $renderedrow
+
+                                set col $opt_startcolumn 
+                                incr row 
+                                #only add newline if we're at the bottom
+                                if {$row > [llength $outputlines]} {
+                                    lappend outputlines {*}[lrepeat 1 ""]
+                                }
+                            } else {
+                                set edit_mode 0
+                                if {$edit_mode} {
+                                    set inputchunks [linsert $inputchunks 0 $overflow_right$unapplied]
+                                    set overflow_right ""
+                                    set unapplied ""
+                                    set row $post_render_row
+                                    #set col $post_render_col
+                                    set col $opt_startcolumn 
+                                    if {$row > [llength $outputlines]} {
+                                        lappend outputlines {*}[lrepeat 1 ""]
+                                    }
+                                } else {
+                                    append rendered $overflow_right
+                                    set overflow_right ""
+                                    set row $post_render_row
+                                    set col $opt_startcolumn 
+                                    if {$row > [llength $outputlines]} {
+                                        lappend outputlines {*}[lrepeat 1 ""]
+                                    }
+                                }
+                            }
+                    }
+                    lf_overflow {
+                            #linefeed after colwidth e.g at column 81 for an 80 col width
+                            #we may also have other control sequences that came after col 80 e.g cursor save
+
+                            if 0 {
+                            set lhs [overtype::left -width 40 -wrap 1 "" [ansistring VIEWSTYLE -nul 1 -lf 1 -vt 1 $rendered]]
+                            set lhs [textblock::frame -title "rendered $visualwidth cols" -subtitle "row-$renderedrow" $lhs]
+                            set rhs ""
+
+                            #assertion - there should be no overflow..
+                            puts $lhs
+                            }
+                            assert {$overflow_right eq ""} lf_overflow should not get data in overflow_right
+
+                            set row $post_render_row
+                            #set row $renderedrow
+                            #incr row 
+                            #only add newline if we're at the bottom
+                            if {$row > [llength $outputlines]} {
+                                lappend outputlines {*}[lrepeat 1 ""]
+                            }
+                            set col $opt_startcolumn 
+
+                    }
+                    newlines_above {
+                        #we get a newlines_above instruction when <lf> received at column 1
+                        #In some cases we want to treat that as request to insert a new blank line above, and move our row 1 down (staying with the data)
+                        #in other cases - we want to treat <lf> at column 1 the same as any other <lf>
+
+                        puts "--->newlines_above"
+                        puts "rinfo: $rinfo"
+                        #renderline doesn't advance the row for us - the caller has the choice to implement or not
+                        set row $post_render_row
+                        set col $post_render_col
+                        if {$insert_lines_above > 0} {
+                            set row $renderedrow
+                            set outputlines [linsert $outputlines $renderedrow-1 {*}[lrepeat $insert_lines_above ""]] 
+                            incr row [expr {$insert_lines_above -1}] ;#we should end up on the same line of text (at a different index), with new empties inserted above
+                            #? set row $post_render_row #can renderline tell us?
+                        }
+                    }
+                    newlines_below {
+                        #obsolete? - use for ANSI insert lines sequence
+                        if {$data_mode == 0} {
+                            puts --->nl_below
+                            set row $post_render_row
+                            set col $post_render_col
+                            if {$insert_lines_below == 1} {
+                                if {$test_mode == 0} {
+                                    set row $renderedrow
+                                    set outputlines [linsert $outputlines [expr {$renderedrow }] {*}[lrepeat $insert_lines_below ""]] ;#note - linsert can add to end too
+                                    incr row $insert_lines_below
+                                    set col $opt_startcolumn 
+                                } else {
+                                    #set lhs [overtype::left -width 40 -wrap 1 "" [ansistring VIEWSTYLE -lf 1 -vt 1 $rendered]]
+                                    #set lhs [textblock::frame -title rendered -subtitle "row-$renderedrow" $lhs]
+                                    #set rhs ""
+                                    #if {$overflow_right ne ""} {
+                                    #    set rhs [overtype::left -width 40 -wrap 1 "" [ansistring VIEWSTYLE -lf 1 -vt 1 $overflow_right]]
+                                    #    set rhs [textblock::frame -title overflow_right $rhs]
+                                    #}
+                                    #puts [textblock::join $lhs $rhs]
+
+                                    #rendered 
+                                    append rendered $overflow_right
+                                    #
+
+
+                                    set overflow_right ""
+                                    set row $renderedrow
+                                    #only add newline if we're at the bottom
+                                    if {$row > [llength $outputlines]} {
+                                        lappend outputlines {*}[lrepeat $insert_lines_below ""]
+                                    }
+                                    incr row $insert_lines_below
+                                    set col $opt_startcolumn 
+
+
+
+                                }
+                            }
+                        } else {
+                            set row $post_render_row
+                            if {$post_render_row > [llength $outputlines]} {
+                                if {$opt_appendlines} {
+                                    set diff [expr {$post_render_row - [llength $outputlines]}]
+                                    if {$diff > 0} {
+                                        lappend outputlines {*}[lrepeat $diff ""]
+                                    }
+                                    lappend outputlines ""
+                                }
+                            } else {
+                                set existingdata [lindex $outputlines [expr {$post_render_row -1}]] 
+                                set lastdatacol [punk::ansi::printing_length $existingdata]
+                                if {$lastdatacol < $colwidth} {
+                                    set col [expr {$lastdatacol+1}]
+                                } else {
+                                    set col $colwidth 
+                                }
+                            }
+                        }
+                    }
+                    wrapmoveforward {
+                        #doesn't seem to be used by fruit.ans testfile
+                        #used by dzds.ans
+                        #note that cursor_forward may move deep into the next line - or even span multiple lines !TODO
+                        set c $colwidth 
+                        set r $post_render_row
+                        if {$post_render_col > $colwidth} {
+                            set i $c
+                            while {$i <= $post_render_col} {
+                                if {$c == $colwidth+1} {
+                                    incr r
+                                    if {$opt_appendlines} {
+                                        if {$r < [llength $outputlines]} {
+                                            lappend outputlines ""
+                                        }
+                                    }
+                                    set c $opt_startcolumn 
+                                } else {
+                                    incr c
+                                }    
+                                incr i
+                            }
+                            set col $c
+                        } else {
+                            #why are we getting this instruction then?
+                            puts stderr "wrapmoveforward - test"
+                            set r [expr {$post_render_row +1}]
+                            set c $post_render_col 
+                        }
+                        set row $r
+                        set col $c
+                    }
+                    wrapmovebackward {
+                        set c $colwidth
+                        set r $post_render_row
+                        if {$post_render_col < 1} {
+                            set c 1 
+                            set i $c
+                            while {$i >= $post_render_col} {
+                                if {$c == 0} {
+                                    if {$r > 1} {
+                                        incr r -1
+                                        set c $colwidth
+                                    } else {
+                                        #leave r at 1 set c 1
+                                        #testfile besthpav.ans first line top left border alignment
+                                        set c 1
+                                        break
+                                    }
+                                } else {
+                                    incr c -1
+                                }
+                                incr i -1
+                            }
+                            set col $c
+                        } else {
+                            puts stderr "Wrapmovebackward - but postrendercol >= 1???"
+                        }
+                        set row $r
+                        set col $c
+                    }
+                    overflow {
+                        #normal single-width grapheme overflow
+                        #puts "----normal overflow --- [ansistring VIEWSTYLE -lf 1 -nul 1 -vt 1 $rendered]"
+                        set row $post_render_row  ;#renderline will not advance row when reporting overflow char
+                        if {$autowrap_mode} {
+                            incr row
+                            set col $opt_startcolumn ;#whether wrap or not - next data is at column 1  ??
+                        } else {
+                            #this works for test_mode (which should become the default) - but could give a bad result otherwise - review - add tests fix.
+                            set col $post_render_col
+                            #set unapplied ""             ;#this seems wrong?
+                            #set unapplied [tcl::string::range $unapplied 1 end] 
+                            #The overflow can only be triggered by a grapheme (todo cluster?) - but our unapplied could contain SGR codes prior to the grapheme that triggered overflow - so we need to skip beyond any SGRs
+                            #There may be more than one, because although the stack leading up to overflow may have been merged - codes between the last column and the overflowing grapheme will remain separate
+                            #We don't expect any movement or other ANSI codes - as if they came before the grapheme, they would have triggered a different instruction to 'overflow'
+                            set idx 0
+                            set next_grapheme_index -1
+                            foreach u $unapplied_list {
+                                if {![punk::ansi::ta::detect $u]} {
+                                    set next_grapheme_index $idx
+                                    break
+                                }
+                                incr idx
+                            }
+                            assert {$next_grapheme_index >= 0}
+                            #drop the overflow grapheme - keeping all codes in place.
+                            set unapplied [join [lreplace $unapplied_list $next_grapheme_index $next_grapheme_index] ""]
+                            #we need to run the reduced unapplied on the same line - further graphemes will just overflow again, but codes or control chars could trigger jumps to other lines
+
+                            set overflow_handled 1
+                            #handled by dropping overflow if any 
+                        }
+                    }
+                    overflow_splitchar {
+                        set row $post_render_row  ;#renderline will not advance row when reporting overflow char
+
+                        #2nd half of grapheme would overflow - treggering grapheme is returned in unapplied. There may also be overflow_right from earlier inserts
+                        #todo - consider various options .. re-render a single trailing space or placeholder on same output line, etc
+                        if {$autowrap_mode} {
+                            if {$colwidth < 2} {
+                                #edge case of rendering to a single column output - any 2w char will just cause a loop if we don't substitute with something, or drop the character
+                                set idx 0
+                                set triggering_grapheme_index -1
+                                foreach u $unapplied_list {
+                                    if {![punk::ansi::ta::detect $u]} {
+                                        set triggering_grapheme_index $idx
+                                        break
+                                    }
+                                    incr idx
+                                }
+                                set unapplied [join [lreplace $unapplied_list $triggering_grapheme_index $triggering_grapheme_index $opt_exposed1] ""]
+                            } else {
+                                set col  $opt_startcolumn
+                                incr row
+                            }
+                        } else {
+                            set overflow_handled 1
+                            #handled by dropping entire overflow if any  
+                            if {$colwidth < 2} {
+                                set idx 0
+                                set triggering_grapheme_index -1
+                                foreach u $unapplied_list {
+                                    if {![punk::ansi::ta::detect $u]} {
+                                        set triggering_grapheme_index $idx
+                                        break
+                                    }
+                                    incr idx
+                                }
+                                set unapplied [join [lreplace $unapplied_list $triggering_grapheme_index $triggering_grapheme_index $opt_exposed1] ""]
+                            }
+                        }
+
+                    }
+                    vt {
+
+                        #can vt add a line like a linefeed can?
+                        set row $post_render_row
+                        set col $post_render_col
+                    }
+                    default {
+                        puts stderr "overtype::renderspace unhandled renderline instruction '$instruction'"
+                    }
+
+                }
+
+
+            if {!$opt_overflow && !$autowrap_mode} {
+                #not allowed to overflow column or wrap therefore we get overflow data to truncate 
+                if {[tcl::dict::get $opts -ellipsis]} {
+                    set show_ellipsis 1
+                    if {!$opt_ellipsiswhitespace} {
+                        #we don't want ellipsis if only whitespace was lost
+                        set lostdata ""
+                        if {$overflow_right ne ""} {
+                            append lostdata $overflow_right
+                        }
+                        if {$unapplied ne ""} {
+                            append lostdata $unapplied
+                        }
+                        if {[tcl::string::trim $lostdata] eq ""} {
+                            set show_ellipsis 0
+                        }
+                        #set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                        if {[tcl::string::trim [punk::ansi::stripansi $lostdata]] eq ""} {
+                            set show_ellipsis 0
+                        }
+                    }
+                    if {$show_ellipsis} {
+                        set rendered [overtype::right $rendered $opt_ellipsistext]
+                    }
+                    set overflow_handled 1
+                } else {
+                    #no wrap - no ellipsis - silently truncate
+                    set overflow_handled 1
+                }
+            }
+
+
+
+            if {$renderedrow <= [llength $outputlines]} {
+                lset outputlines [expr {$renderedrow-1}] $rendered
+            } else {
+                if {$opt_appendlines} {
+                    lappend outputlines $rendered
+                } else {
+                    #? 
+                    lset outputlines [expr {$renderedrow-1}] $rendered
+                }
+            }
+
+            if {!$overflow_handled} {
+                append nextprefix $overflow_right
+            }
+
+            append nextprefix $unapplied
+
+            if 0 {
+            if {$nextprefix ne ""} {
+                set nextoveridx [expr {$overidx+1}]
+                if {$nextoveridx  >= [llength $inputchunks]} {
+                    lappend inputchunks $nextprefix
+                } else {
+                    #lset overlines $nextoveridx $nextprefix[lindex $overlines $nextoveridx]
+                    set inputchunks [linsert $inputchunks $nextoveridx $nextprefix]
+                }
+            }
+            }
+
+            if {$nextprefix ne ""} {
+                set inputchunks [linsert $inputchunks 0 $nextprefix]
+            }
+
+
+            incr overidx
+            incr loop
+            if {$loop >= $looplimit} {
+                puts stderr "overtype::renderspace looplimit reached ($looplimit)"
+                lappend outputlines "[a+ red bold]<truncated> - looplimit $looplimit reached[a]"
+                set Y [a+ yellow bold]
+                set RST [a]
+                set sep_header ----DEBUG-----
+                set debugmsg ""
+                append debugmsg "${Y}${sep_header}${RST}" \n
+                append debugmsg "looplimit $looplimit reached\n"
+                append debugmsg "test_mode:$test_mode\n"
+                append debugmsg "data_mode:$data_mode\n"
+                append debugmsg "opt_appendlines:$opt_appendlines\n"
+                append debugmsg "prev_row :[tcl::dict::get $LASTCALL -cursor_row]\n"
+                append debugmsg "prev_col :[tcl::dict::get $LASTCALL -cursor_column]\n"
+                tcl::dict::for {k v} $rinfo {
+                    append debugmsg "${Y}$k   [ansistring VIEW -lf 1 -vt 1 $v]$RST" \n
+                }
+                append debugmsg "${Y}[string repeat - [string length $sep_header]]$RST" \n
+
+                puts stdout $debugmsg
+                #todo - config regarding error dumps rather than just dumping in working dir 
+                set fd [open [pwd]/error_overtype.txt w]
+                puts $fd $debugmsg
+                close $fd
+                error $debugmsg
+                break
+            }
+        }
+        
+        set result [join $outputlines \n]
+        if {$info_mode} {
+            #emit to debug window like basictelnet does? make debug configurable as syslog or even a telnet server to allow on 2nd window?
+            #append result \n$instruction_stats\n
+        }
+        return $result
+    }
+
+    #todo - left-right ellipsis ?
+    proc 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 opts [tcl::dict::create\
+            -bias       left\
+            -ellipsis   0\
+            -ellipsistext   $default_ellipsis_horizontal\
+            -ellipsiswhitespace 0\
+            -overflow   0\
+            -transparent 0\
+            -exposed1 \uFFFD\
+            -exposed2 \uFFFD\
+        ]
+        set argsflags [lrange $args 0 end-2]
+        foreach {k v} $argsflags {
+            switch -- $k {
+                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 {
+                    tcl::dict::set opts $k $v
+                }
+                default {
+                    set known_opts [tcl::dict::keys $opts]
+                    error "overtype::centre unknown option '$k'. Known options: $known_opts"
+                }
+            }
+        }
+        #set opts [tcl::dict::merge $defaults $argsflags]
+        # -- --- --- --- --- ---
+        set opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsis        [tcl::dict::get $opts -ellipsis]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1]
+        set opt_exposed2        [tcl::dict::get $opts -exposed2]
+        # -- --- --- --- --- ---
+
+
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $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 {[tcl::string::tolower [tcl::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]
+        if {[punk::ansi::ta::detect_sgr [lindex $overlines 0]]} {
+            set replay_codes "[punk::ansi::a]"
+        } else {
+            set replay_codes ""
+        }
+        set replay_codes_underlay ""
+        set replay_codes_overlay ""
+        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 undertext [tcl::string::cat $replay_codes_underlay $undertext]
+            set overtext  [tcl::string::cat $replay_codes_overlay $overtext]
+
+            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 rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -overflow [tcl::dict::get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+                set rendered        [tcl::dict::get $rinfo result]
+                set overflow_right  [tcl::dict::get $rinfo overflow_right]
+                set unapplied       [tcl::dict::get $rinfo unapplied]
+                #todo - get replay_codes from overflow_right instead of wherever it was truncated?
+
+                #overlay line data is wider - trim if overflow not specified in opts - and overtype an ellipsis at right if it was specified
+                if {![tcl::dict::get $opts -overflow]} {
+                    #lappend outputlines [tcl::string::range $overtext 0 [expr {$colwidth - 1}]]
+                    #set overtext [tcl::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
+                            #don't use tcl::string::range on ANSI data
+                            #set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                            set lostdata ""
+                            if {$overflow_right ne ""} {
+                                append lostdata $overflow_right
+                            }
+                            if {$unapplied ne ""} {
+                                append lostdata $unapplied
+                            }
+                            if {[tcl::string::trim $lostdata] eq ""} {
+                                set show_ellipsis 0
+                            }
+                        }
+                        if {$show_ellipsis} {
+                            set rendered [overtype::right $rendered $opt_ellipsistext]
+                        }
+                    }
+                }
+                lappend outputlines $rendered
+                #lappend outputlines [renderline -insert_mode 0 -transparent $opt_transparent $undertext $overtext]
+            } else {
+                #background block is wider than or equal to data for this line
+                #lappend outputlines [renderline -insert_mode 0 -startcolumn [expr {$left_exposed + 1}] -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+                set rinfo [renderline -info 1 -insert_mode 0 -startcolumn [expr {$left_exposed + 1}] -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
+                lappend outputlines  [tcl::dict::get $rinfo result]
+            }
+            set replay_codes_underlay [tcl::dict::get $rinfo replay_codes_underlay]
+            set replay_codes_overlay [tcl::dict::get $rinfo replay_codes_overlay]
+        }
+        return [join $outputlines \n]
+    }
+
+    #overtype::right  is for a rendered ragged underblock and a rendered ragged overblock
+    #ie we can determine the block width for bost by examining the lines and picking the longest.
+    #
+    proc 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]? ?-transparent 0|<char>? undertext overtext}
+        }
+        foreach {underblock overblock} [lrange $args end-1 end] break
+
+        set opts [tcl::dict::create\
+            -bias       ignored\
+            -ellipsis   0\
+            -ellipsistext   $default_ellipsis_horizontal\
+            -ellipsiswhitespace 0\
+            -overflow   0\
+            -transparent 0\
+            -exposed1 \uFFFD\
+            -exposed2 \uFFFD\
+            -align  "left"\
+        ]
+        set argsflags [lrange $args 0 end-2]
+        tcl::dict::for {k v} $argsflags {
+            switch -- $k {
+                -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -align {
+                    tcl::dict::set opts $k $v
+                }
+                default {
+                    set known_opts [tcl::dict::keys $opts]
+                    error "overtype::centre unknown option '$k'. Known options: $known_opts"
+                }
+            }
+        }
+        #set opts [tcl::dict::merge $defaults $argsflags]
+        # -- --- --- --- --- ---
+        set opt_transparent     [tcl::dict::get $opts -transparent]
+        set opt_ellipsis         [tcl::dict::get $opts -ellipsis]
+        set opt_ellipsistext    [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_overflow        [tcl::dict::get $opts -overflow]
+        set opt_exposed1        [tcl::dict::get $opts -exposed1]
+        set opt_exposed2        [tcl::dict::get $opts -exposed2]
+        set opt_align           [tcl::dict::get $opts -align]
+        # -- --- --- --- --- ---
+        
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $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 {max(0,$colwidth - $overblock_width)}]
+        set left_exposed $under_exposed_max 
+
+
+
+        set outputlines [list]
+        if {[punk::ansi::ta::detect_sgr [lindex $overlines 0]]} {
+            set replay_codes "[punk::ansi::a]"
+        } else {
+            set replay_codes ""
+        }
+        set replay_codes_underlay ""
+        set replay_codes_overlay ""
+        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
+                append undertext [string repeat { } $udiff]
+            }
+            if {$overtext_datalen < $overblock_width} {
+                set odiff [expr {$overblock_width - $overtext_datalen}]
+                switch -- $opt_align {
+                    left {
+                        set startoffset 0 
+                    }
+                    right {
+                        set startoffset  $odiff 
+                    }
+                    default {
+                        set half [expr {$odiff / 2}]
+                        #set lhs [string repeat { } $half]
+                        #set righthalf [expr {$odiff - $half}] ;#remainder - may be one more - so we are biased left
+                        #set rhs [string repeat { } $righthalf]
+                        set startoffset $half 
+                    }
+                }
+            } else {
+                set startoffset 0 ;#negative?
+            }
+
+            set undertext [tcl::string::cat $replay_codes_underlay $undertext]
+            set overtext [tcl::string::cat $replay_codes_overlay $overtext]
+
+            set overflowlength [expr {$overtext_datalen - $colwidth}]
+            if {$overflowlength > 0} {	
+                #raw overtext wider than undertext column
+                set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -startcolumn [expr {1 + $startoffset}] $undertext $overtext]
+                set replay_codes          [tcl::dict::get $rinfo replay_codes]
+                set rendered [tcl::dict::get $rinfo result]
+                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 [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                            if {[tcl::string::trim $lostdata] eq ""} {
+                                set show_ellipsis 0
+                            }
+                        }
+                        if {$show_ellipsis} {
+                            set ellipsis [tcl::string::cat $replay_codes $opt_ellipsistext]
+                            #todo - overflow on left if allign = right??
+                            set rendered [overtype::right $rendered $ellipsis]
+                        }
+                    }
+                }
+                lappend outputlines $rendered
+            } else {
+                #padded overtext 
+                #lappend outputlines [renderline -insert_mode 0 -transparent $opt_transparent -startcolumn [expr {$left_exposed + 1}] $undertext $overtext]
+                #Note - we still need overflow here - as although the overtext is short - it may oveflow due to the startoffset
+                set rinfo [renderline -info 1  -insert_mode 0 -transparent $opt_transparent -overflow $opt_overflow -startcolumn [expr {$left_exposed + 1 + $startoffset}] $undertext $overtext]
+                lappend outputlines  [tcl::dict::get $rinfo result]
+            }
+            set replay_codes          [tcl::dict::get $rinfo replay_codes]
+            set replay_codes_underlay [tcl::dict::get $rinfo replay_codes_underlay]
+            set replay_codes_overlay  [tcl::dict::get $rinfo replay_codes_overlay]
+        }
+
+        return [join $outputlines \n]
+    }
+
+    proc left {args} {
+        overtype::block -blockalign left {*}$args
+    }
+    #overtype a (possibly ragged) underblock with a (possibly ragged) overblock
+    proc block {args} {
+        variable default_ellipsis_horizontal
+        # @d !todo - implement overflow, length checks etc
+
+        if {[llength $args] < 2} {
+            error {usage: ?-blockalign left|centre|right? ?-textalign left|centre|right?  ?-overflow [1|0]? ?-transparent 0|<char>? undertext overtext}
+        }
+        #foreach {underblock overblock} [lrange $args end-1 end] break
+        lassign [lrange $args end-1 end] underblock overblock
+
+        set opts [tcl::dict::create\
+            -ellipsis   0\
+            -ellipsistext   $default_ellipsis_horizontal\
+            -ellipsiswhitespace 0\
+            -overflow   0\
+            -transparent 0\
+            -exposed1 \uFFFD\
+            -exposed2 \uFFFD\
+            -textalign  "left"\
+            -textvertical "top"\
+            -blockalign "left"\
+            -blockalignbias left\
+            -blockvertical "top"\
+        ]
+        set argsflags [lrange $args 0 end-2]
+        tcl::dict::for {k v} $argsflags {
+            switch -- $k {
+                -blockalignbias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -textalign - -blockalign - -blockvertical {
+                    tcl::dict::set opts $k $v
+                }
+                default {
+                    error "overtype::block unknown option '$k'. Known options: [tcl::dict::keys $opts]"
+                }
+            }
+        }
+        # -- --- --- --- --- ---
+        set opt_transparent         [tcl::dict::get $opts -transparent]
+        set opt_ellipsis            [tcl::dict::get $opts -ellipsis]
+        set opt_ellipsistext        [tcl::dict::get $opts -ellipsistext]
+        set opt_ellipsiswhitespace  [tcl::dict::get $opts -ellipsiswhitespace]
+        set opt_overflow            [tcl::dict::get $opts -overflow]
+        set opt_exposed1            [tcl::dict::get $opts -exposed1]
+        set opt_exposed2            [tcl::dict::get $opts -exposed2]
+        set opt_textalign           [tcl::dict::get $opts -textalign]
+        set opt_blockalign          [tcl::dict::get $opts -blockalign]
+        if {$opt_blockalign eq "center"} {
+            set opt_blockalign "centre"
+        }
+        # -- --- --- --- --- ---
+        
+        set underblock [tcl::string::map {\r\n \n} $underblock]
+        set overblock  [tcl::string::map {\r\n \n} $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 {max(0,$colwidth - $overblock_width)}]
+
+        switch -- $opt_blockalign {
+            left {
+                set left_exposed 0
+            }
+            right {
+                set left_exposed $under_exposed_max 
+            }
+            centre {
+                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 {[tcl::string::tolower [tcl::dict::get $opts -blockalignbias]] eq "left"} {
+                            set left_exposed $beforehalf
+                        } else {
+                            #bias to the right
+                            set left_exposed [expr {$beforehalf + 1}]
+                        }
+                    }
+                } else {
+                    set left_exposed 0
+                }
+            }
+            default {
+                set left_exposed 0
+            }
+        }
+
+
+
+        set outputlines [list]
+        if {[punk::ansi::ta::detect_sgr [lindex $overlines 0]]} {
+            set replay_codes "[punk::ansi::a]"
+        } else {
+            set replay_codes ""
+        }
+        set replay_codes_underlay ""
+        set replay_codes_overlay ""
+        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
+                append undertext [string repeat { } $udiff]
+            }
+            if {$overtext_datalen < $overblock_width} {
+                set odiff [expr {$overblock_width - $overtext_datalen}]
+                switch -- $opt_textalign {
+                    left {
+                        set startoffset 0 
+                    }
+                    right {
+                        set startoffset  $odiff 
+                    }
+                    default {
+                        set half [expr {$odiff / 2}]
+                        #set lhs [string repeat { } $half]
+                        #set righthalf [expr {$odiff - $half}] ;#remainder - may be one more - so we are biased left
+                        #set rhs [string repeat { } $righthalf]
+                        set startoffset $half 
+                    }
+                }
+            } else {
+                set startoffset 0 ;#negative?
+            }
+
+            set undertext   [tcl::string::cat $replay_codes_underlay    $undertext]
+            set overtext    [tcl::string::cat $replay_codes_overlay     $overtext]
+
+            set overflowlength [expr {$overtext_datalen - $colwidth}]
+            if {$overflowlength > 0} {	
+                #raw overtext wider than undertext column
+                set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -startcolumn [expr {1 + $startoffset}] $undertext $overtext]
+                set replay_codes    [tcl::dict::get $rinfo replay_codes]
+                set rendered        [tcl::dict::get $rinfo result]
+                set overflow_right  [tcl::dict::get $rinfo overflow_right]
+                set unapplied       [tcl::dict::get $rinfo unapplied]
+                if {!$opt_overflow} {
+                    if {$opt_ellipsis} {
+                        set show_ellipsis 1
+                        if {!$opt_ellipsiswhitespace} {
+                            #we don't want ellipsis if only whitespace was lost
+                            #don't use tcl::string::range on ANSI data
+                            #set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                            set lostdata ""
+                            if {$overflow_right ne ""} {
+                                append lostdata $overflow_right
+                            }
+                            if {$unapplied ne ""} {
+                                append lostdata $unapplied
+                            }
+                            if {[tcl::string::trim $lostdata] eq ""} {
+                                set show_ellipsis 0
+                            }
+                        }
+                        if {$show_ellipsis} {
+                            set rendered [overtype::block -blockalign right $rendered $opt_ellipsistext]
+                        }
+                    }
+
+                    #if {$opt_ellipsis} {
+                    #    set show_ellipsis 1
+                    #    if {!$opt_ellipsiswhitespace} {
+                    #        #we don't want ellipsis if only whitespace was lost
+                    #        set lostdata [tcl::string::range $overtext end-[expr {$overflowlength-1}] end]
+                    #        if {[tcl::string::trim $lostdata] eq ""} {
+                    #            set show_ellipsis 0
+                    #        }
+                    #    }
+                    #    if {$show_ellipsis} {
+                    #        set ellipsis [tcl::string::cat $replay_codes $opt_ellipsistext]
+                    #        #todo - overflow on left if allign = right??
+                    #        set rendered [overtype::right $rendered $ellipsis]
+                    #    }
+                    #}
+                }
+                lappend outputlines $rendered
+            } else {
+                #padded overtext 
+                #lappend outputlines [renderline -insert_mode 0 -transparent $opt_transparent -startcolumn [expr {$left_exposed + 1}] $undertext $overtext]
+                #Note - we still need overflow here - as although the overtext is short - it may oveflow due to the startoffset
+                set rinfo [renderline -info 1  -insert_mode 0 -transparent $opt_transparent -overflow $opt_overflow -startcolumn [expr {$left_exposed + 1 + $startoffset}] $undertext $overtext]
+                set overflow_right  [tcl::dict::get $rinfo overflow_right]
+                set unapplied       [tcl::dict::get $rinfo unapplied]
+                lappend outputlines [tcl::dict::get $rinfo result]
+            }
+            set replay_codes          [tcl::dict::get $rinfo replay_codes]
+            set replay_codes_underlay [tcl::dict::get $rinfo replay_codes_underlay]
+            set replay_codes_overlay  [tcl::dict::get $rinfo replay_codes_overlay]
+        }
+
+        return [join $outputlines \n]
+    }
+    # ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
+    # renderline written from a left-right line orientation perspective as a first-shot at getting something useful. 
+    # ultimately right-to-left, top-to-bottom and bottom-to-top are probably needed. 
+    # ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
+    #
+    #
+    #-returnextra enables returning of overflow and length
+    #review - use punk::ansi::ta::detect to short-circuit processing and do simpler string calcs as an optimisation?
+    #review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
+    #(could render it by faking it with sixels and a lot of work - find/make a sixel font and ensure it's exactly 2 cols per char)
+    #todo - review transparency issues with single/double width characters
+    #bidi - need a base direction and concept of directional runs for RTL vs LTR - may be best handled at another layer?
+    proc renderline {args} {
+        #*** !doctools
+        #[call [fun overtype::renderline] [arg args] ]
+        #[para] renderline is the core engine for overtype string processing (frames & textblocks), and the raw mode commandline repl for the Tcl Punk Shell
+        #[para] It is also a central part of an ansi (micro) virtual terminal-emulator of sorts 
+        #[para] This system does a half decent job at rendering 90's ANSI art to manipulable colour text blocks that can be joined & framed for layout display within a unix or windows terminal
+        #[para] Renderline helps maintain ANSI text styling reset/replay codes so that the styling of one block doesn't affect another.
+        #[para] Calling on the punk::ansi library - it can coalesce codes to keep the size down.
+        #[para] It is a giant mess of doing exactly what common wisdom says not to do... lots at once.
+        #[para] renderline is part of the Unicode and ANSI aware Overtype system which 'renders' a block of text onto a static underlay
+        #[para] The underlay is generally expected to be an ordered set of lines or a rectangular text block analogous to a terminal screen - but it can also be ragged in line length, or just blank.
+        #[para] The overlay couuld be similar - in which case it may often be used to overwrite a column or section of the underlay.
+        #[para] The overlay could however be a sequence of ANSI-laden text that jumps all over the place. 
+        #
+        #[para] renderline itself only deals with a single line - or sometimes a single character.  It is generally called from a loop that does further terminal-like or textblock processing.
+        #[para] By suppyling the -info 1 option - it can return various fields indicating the state of the render.
+        #[para] The main 3 are the result, overflow_right, and unapplied.
+        #[para] Renderline handles cursor movements from either keystrokes or ANSI sequences but for a full system the aforementioned loop will need to be in place to manage the set of lines under manipulation.
+
+        if {[llength $args] < 2} {
+            error {usage: ?-info 0|1? ?-startcolumn <int>? ?-cursor_column <int>? ?-cursor_row <int>|""? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? undertext overtext}
+        }
+        lassign [lrange $args end-1 end] under over
+        if {[string first \n $under] >= 0} {
+            error "overtype::renderline not allowed to contain newlines in undertext"
+        }
+        #if {[string first \n $over] >=0 || [string first \n $under] >= 0} {
+        #    error "overtype::renderline not allowed to contain newlines"
+        #}
+
+        #generally faster to create a new dict in the proc than to use a namespace variable to create dict once and link to variable (2024 8.6/8.7)
+        set opts [tcl::dict::create\
+            -etabs         0\
+            -width         \uFFEF\
+            -overflow      0\
+            -transparent   0\
+            -startcolumn   1\
+            -cursor_column 1\
+            -cursor_row    ""\
+            -insert_mode   1\
+            -autowrap_mode 1\
+            -reverse_mode  0\
+            -info          0\
+            -exposed1      \uFFFD\
+            -exposed2      \uFFFD\
+            -cursor_restore_attributes ""\
+            -cp437         0\
+            -experimental  {}\
+        ]
+        #-cursor_restore_attributes only - for replay stack - position and actual setting/restoring handled by throwback to caller
+
+        #cursor_row, when numeric will allow detection of certain row moves that are still within our row - allowing us to avoid an early return
+        #An empty string for cursor_row tells us we have no info about our own row context, and to return with an unapplied string if any row move occurs
+
+        #exposed1 and exposed2 for first and second col of underying 2wide char which is truncated by transparency or overflow
+        #todo - return info about such grapheme 'cuts' in -info structure and/or create option to raise an error
+
+        set argsflags [lrange $args 0 end-2]
+        tcl::dict::for {k v} $argsflags {
+            switch -- $k {
+                -experimental - -cp437 - -width - -overflow - -transparent - -startcolumn - -cursor_column - -cursor_row - -insert_mode - -autowrap_mode - -reverse_mode - -info - -exposed1 - -exposed2 - -cursor_restore_attributes {
+                    tcl::dict::set opts $k $v
+                }
+                default {
+                    error "overtype::renderline unknown option '$k'. Known options: [tcl::dict::keys $opts]"
+                }
+            }
+        }
+        # -- --- --- --- --- --- --- --- --- --- --- ---
+        set opt_width               [tcl::dict::get $opts -width]
+        set opt_etabs               [tcl::dict::get $opts -etabs]
+        set opt_overflow            [tcl::dict::get $opts -overflow]
+        set opt_colstart            [tcl::dict::get $opts -startcolumn] ;#lhs limit for overlay - an offset to cursor_column  - first visible column is 1.  0 or < 0 are before the start of the underlay 
+        set opt_colcursor           [tcl::dict::get $opts -cursor_column];#start cursor column relative to overlay
+        set opt_row_context         [tcl::dict::get $opts -cursor_row]
+        if {[string length $opt_row_context]} {
+            if {![tcl::string::is integer -strict $opt_row_context] || $opt_row_context <1 } {
+                error "overtype::renderline -cursor_row must be empty for unspecified/unknown or a non-zero positive integer. received: '$opt_row_context'"
+            }
+        }
+        # -- --- --- --- --- --- --- --- --- --- --- --- 
+        #The _mode flags correspond to terminal modes that can be set/reset via escape sequences (e.g DECAWM wraparound mode)
+        set opt_insert_mode         [tcl::dict::get $opts -insert_mode];#should usually be 1 for each new line in editor mode but must be initialised to 1 externally (review)
+        #default is for overtype
+        # -- --- --- --- --- --- --- --- --- --- --- ---
+        set opt_autowrap_mode       [tcl::dict::get $opts -autowrap_mode] ;#DECAWM - char or movement can go beyond leftmost/rightmost col to prev/next line
+        set opt_reverse_mode        [tcl::dict::get $opts -reverse_mode]  ;#DECSNM
+        # -- --- --- --- --- --- --- --- --- --- --- ---
+        set temp_cursor_saved       [tcl::dict::get $opts -cursor_restore_attributes]
+
+        set test_mode 0
+        set cp437_glyphs [tcl::dict::get $opts -cp437] 
+        foreach e [tcl::dict::get $opts -experimental] {
+            switch -- $e {
+                test_mode {
+                    set test_mode 1
+                    set cp437_glyphs 1
+                }
+            }
+        }
+        set test_mode 1  ;#try to elminate
+        set cp437_map [tcl::dict::create]
+        if {$cp437_glyphs} {
+            set cp437_map [set ::punk::ansi::cp437_map]
+            #for cp437 images we need to map these *after* splitting ansi
+            #some old files might use newline for its glyph.. but we can't easily support that.
+            #Not sure how old files did it.. maybe cr lf in sequence was newline and any lone cr or lf were displayed as glyphs?
+            tcl::dict::unset cp437_map \n
+        }
+
+        set opt_transparent         [tcl::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         [tcl::dict::get $opts -info]
+        # -- --- --- --- --- --- --- --- --- --- --- ---
+        set opt_exposed1            [tcl::dict::get $opts -exposed1]
+        set opt_exposed2            [tcl::dict::get $opts -exposed2]
+        # -- --- --- --- --- --- --- --- --- --- --- ---
+
+        if {$opt_row_context eq ""} {
+            set cursor_row 1
+        } else {
+            set cursor_row $opt_row_context
+        }
+
+
+        #-----
+        #
+        if {[info exists punk::console::tabwidth]} {
+            #punk console is updated if punk::console::set_tabstop_width is used or rep is started/restarted
+            #It is way too slow to test the current width by querying the terminal here - so it could conceivably get out of sync
+            #todo - we also need to handle the new threaded repl where console config is in a different thread.
+            # - also - concept of sub-regions being mini-consoles with their own settings - 'id' for console, or use in/out channels as id?
+            set tw $::punk::console::tabwidth
+        } else {
+            set tw 8
+        }
+
+        set overdata $over
+        if {!$cp437_glyphs} {
+            #REVIEW!  tabify will give different answers for an ANSI colourised string vs plain text
+            if {!$opt_etabs} {
+                if {[string first \t $under] >= 0} {
+                    #set under [textutil::tabify::untabify2 $under]
+                    set under [textutil::tabify::untabifyLine $under $tw] 
+                }
+                if {[string first \t $over] >= 0} {
+                    #set overdata [textutil::tabify::untabify2 $over]
+                    set overdata [textutil::tabify::untabifyLine $over $tw]
+                }
+            }
+        }
+        #-------
+
+        #ta_detect ansi and do simpler processing?
+
+        #we repeat tests for grapheme width in different loops - rather than create another datastructure to store widths based on column,
+        #we'll  use the grapheme_width_cached function as a lookup table of all graphemes encountered - as there will often be repeats in different positions anyway.
+
+        # -- --- --- --- --- --- --- ---
+        if {$under ne ""} {
+            if {[punk::ansi::ta::detect $under]} {
+                set undermap [punk::ansi::ta::split_codes_single $under]
+            } else {
+                #single plaintext part
+                set undermap [list $under]
+            }
+        } else {
+            set undermap [list]
+        }
+        set understacks [list]
+        set understacks_gx [list]
+
+        set i_u -1  ;#underlay may legitimately be empty
+        set undercols [list] 
+        set u_codestack [list]
+        #u_gx_stack probably isn't really a stack -  I don't know if g0 g1 can stack or not - for now we support only g0 anyway
+        set u_gx_stack [list] ;#separate stack for g0 (g1 g2 g3?) graphics on and off (DEC special graphics)
+        #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
+            if {$cp437_glyphs} {
+                set pt [tcl::string::map $cp437_map $pt]
+            }
+            foreach grapheme [punk::char::grapheme_split $pt] {
+                #an ugly hack to serve *some* common case ascii quickly with byte-compiled literal switch - feels dirty.
+                #.. but even 0.5uS per char (grapheme_width_cached) adds up quickly when stitching lots of lines together.
+                switch -- $grapheme {
+                    " " - - - _ - ! - @ - # - $ - % - ^ - & - * - = - + - : - . - , - / - | - ? - 
+                    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 - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 {
+                        set width 1
+                    }
+                    default {
+                        if {$grapheme eq "\u0000"} {
+                            #use null as empty cell representation  - review
+                            #use of this will probably collide with some application at some point
+                            #consider an option to set the empty cell character
+                            set width 1
+                        } else {
+                            set width [grapheme_width_cached $grapheme]
+                            #we still want most controls and other zero-length codepoints such as \u200d  (zero width joiner) to stay zero-length
+                            #we substitute lone ESC that weren't captured within ANSI context as a debugging aid to see malformed ANSI
+                            #todo - default to off and add a  flag (?) to enable this substitution 
+                            set sub_stray_escapes 0
+                            if {$sub_stray_escapes && $width == 0} {
+                                if {$grapheme eq "\x1b"} {
+                                    set gvis [ansistring VIEW $grapheme]
+                                    set grapheme $gvis
+                                    set width 1
+                                }
+                            }
+                        }
+                    }
+                }
+                #set width [grapheme_width_cached $grapheme]
+                incr i_u
+                lappend understacks $u_codestack
+                lappend understacks_gx $u_gx_stack
+                
+                lappend undercols $grapheme
+                if {$width > 1} {
+                    #presumably there are no triple-column or wider unicode chars.. until the aliens arrive.(?)
+                    #but what about emoji combinations etc - can they be wider than 2?
+                    #todo - if -etabs enabled - then we treat \t as the width determined by our elastic tabstop
+                    incr i_u
+                    lappend understacks $u_codestack
+                    lappend understacks_gx $u_gx_stack
+                    lappend undercols ""
+                }
+            }
+
+            #underlay should already have been rendered and not have non-sgr codes - but let's retain the check for them and not stack them if other codes are here
+
+            #only stack SGR (graphics rendition) codes - not title sets, cursor moves etc 
+            if {$code ne ""} {
+                set c1c2 [tcl::string::range $code 0 1]
+
+                set leadernorm [tcl::string::range [tcl::string::map [list\
+                    \x1b\[          7CSI\
+                    \x9b            8CSI\
+                    \x1b\(          7GFX\
+                ] $c1c2] 0 3];# leadernorm is 1st 2 chars mapped to normalised indicator - or is original 2 chars
+
+                switch -- $leadernorm {
+                    7CSI - 8CSI {
+                        #need to exclude certain leaders after the lb e.g < for SGR 1006 mouse 
+                        #REVIEW - what else could end in m but be mistaken as a normal SGR code here?
+                        set maybemouse ""
+                        if {[tcl::string::index $c1c2 0] eq "\x1b"} {
+                            set maybemouse [tcl::string::index $code 2]
+                        }
+                        
+                        if {$maybemouse ne "<" && [tcl::string::index $code end] eq "m"} {
+                            if {[punk::ansi::codetype::is_sgr_reset $code]} {
+                                set u_codestack [list "\x1b\[m"]
+                            } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
+                                set u_codestack [list $code]
+                            } else {
+                                #basic simplification first.. straight dups
+                                set dup_posns [lsearch -all -exact $u_codestack $code] ;#-exact because of square-bracket glob chars
+                                set u_codestack [lremove $u_codestack {*}$dup_posns]
+                                lappend u_codestack $code
+                            }
+                        }
+                    }
+                    7GFX {
+                        switch -- [tcl::string::index $code 2] {
+                            "0" {
+                                set u_gx_stack [list gx0_on] ;#we'd better use a placeholder - or debugging will probably get into a big mess
+                            }
+                            B {
+                                set u_gx_stack [list]
+                            }
+                        }
+                    }
+                    default {
+
+                    }
+
+                }
+
+                #if {[punk::ansi::codetype::is_sgr_reset $code]} {
+                #    #set u_codestack [list]
+                #} elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
+                #} elseif {[punk::ansi::codetype::is_sgr $code]} {
+                #} else {
+                #    #leave SGR stack as is 
+                #    if {[punk::ansi::codetype::is_gx_open $code]} {
+                #    } elseif {[punk::ansi::codetype::is_gx_close $code]} {
+                #    } 
+                #} 
+            }
+            #consider also if there are other codes that should be stacked..?
+        }
+
+        if {!$test_mode} {
+            #fill columns to width with spaces, and carry over stacks - we will have to keep track of where the underlying data ends manually - TODO
+            #Specifying a width is suitable for terminal-like applications and text-blocks
+            if {$opt_width ne "\uFFEF"} {
+                if {[llength $understacks]} {
+                    set cs $u_codestack
+                    set gs $u_gx_stack
+                } else {
+                    set cs [list]
+                    set gs [list]
+                }
+                if {[llength $undercols]< $opt_width} {
+                    set diff [expr {$opt_width- [llength $undercols]}]
+                    if {$diff > 0} {
+                        lappend undercols       {*}[lrepeat $diff " "]
+                        lappend understacks     {*}[lrepeat $diff $cs]
+                        lappend understacks_gx  {*}[lrepeat $diff $gs]
+                    }
+                }
+            }
+        } else {
+            #NULL empty cell indicator
+            if {$opt_width ne "\uFFEF"} {
+                if {[llength $understacks]} {
+                    set cs $u_codestack
+                    set gs $u_gx_stack
+                } else {
+                    set cs [list]
+                    set gs [list]
+                }
+                if {[llength $undercols]< $opt_width} {
+                    set diff [expr {$opt_width- [llength $undercols]}]
+                    if {$diff > 0} {
+                        lappend undercols       {*}[lrepeat $diff "\u0000"]
+                        lappend understacks     {*}[lrepeat $diff $cs]
+                        lappend understacks_gx  {*}[lrepeat $diff $gs]
+                    }
+                }
+            }
+
+        }
+        if {$opt_width ne "\uFFEF"} {
+            set colwidth $opt_width
+        } else {
+            set colwidth [llength $undercols]
+        }
+
+
+        if 0 {
+        # -----------------
+        # if we aren't extending understacks & understacks_gx each time we incr idx above the undercols length.. this doesn't really serve a purpose
+        # Review.
+        # -----------------
+        #replay code for last overlay position in input line
+        # whether or not we get that far - we need to return it for possible replay on next line
+        if {[llength $understacks]} {
+            lappend understacks $u_codestack
+            lappend understacks_gx $u_gx_stack
+        } else {
+            #in case overlay onto emptystring as underlay 
+            lappend understacks [list]
+            lappend understacks_gx [list]
+        }
+        # -----------------
+        }
+
+        #trailing codes in effect for underlay
+        if {[llength $u_codestack]} {
+            #set replay_codes_underlay [join $u_codestack ""]
+            set replay_codes_underlay [punk::ansi::codetype::sgr_merge_list {*}$u_codestack]
+        } else {
+            set replay_codes_underlay ""
+        }
+
+
+        # -- --- --- --- --- --- --- ---
+        ####
+        #if opt_colstart - we need to build a space (or any singlewidth char ?) padding on the left of the right number of columns.
+        #this will be processed as transparent - and handle doublewidth underlay characters appropriately
+        set startpad_overlay [string repeat " " [expr {$opt_colstart -1}]]
+        append startpad_overlay $overdata ;#overdata with left padding spaces based on col-start under will show through for left-padding portion regardless of -transparency
+        if {$startpad_overlay ne ""} {
+            if {[punk::ansi::ta::detect $startpad_overlay]} {
+                set overmap  [punk::ansi::ta::split_codes_single $startpad_overlay]
+            } else {
+                #single plaintext part
+                set overmap [list $startpad_overlay]
+            }
+        } else {
+            set overmap [list]
+        }
+        #set overmap  [punk::ansi::ta::split_codes_single $startpad_overlay]
+        ####
+
+        #???
+        set colcursor $opt_colstart
+        #TODO - make a little virtual column object
+        #we need to refer to column1 or columnmin? or columnmax without calculating offsets due to to startcolumn 
+        #need to lock-down what start column means from perspective of ANSI codes moving around - the offset perspective is unclear and a mess.
+
+
+        #set re_diacritics {[\u0300-\u036f]+|[\u1ab0-\u1aff]+|[\u1dc0-\u1dff]+|[\u20d0-\u20ff]+|[\ufe20-\ufe2f]+} 
+        #as at 2024-02 punk::char::grapheme_split uses these - not aware of more complex graphemes
+
+        set overstacks [list]
+        set overstacks_gx [list]
+
+        set o_codestack [list]; #SGR codestack (not other codes such as movement,insert key etc)
+        set o_gxstack   [list]
+        set pt_overchars ""
+        set i_o 0 
+        set overlay_grapheme_control_list [list] ;#tag each with g, sgr or other.  'other' are things like cursor-movement or insert-mode or codes we don't recognise/use 
+        #experiment
+        set overlay_grapheme_control_stacks [list]
+        foreach {pt code} $overmap {
+
+            #todo - wrap in test for empty pt (we used split_codes_single - and it may be common for sgr sequences to be unmerged and so have empty pts between)
+            if {$cp437_glyphs} {
+                set pt [tcl::string::map $cp437_map $pt]
+            }
+            append pt_overchars $pt
+            #will get empty pt between adjacent codes
+            foreach grapheme [punk::char::grapheme_split $pt] {
+                lappend overstacks $o_codestack
+                lappend overstacks_gx $o_gxstack
+                incr i_o 
+                lappend overlay_grapheme_control_list [list g $grapheme]
+                lappend overlay_grapheme_control_stacks $o_codestack
+            }
+
+            #only stack SGR (graphics rendition) codes - not title sets, cursor moves etc 
+            #order of if-else based on assumptions:
+            # that pure resets are fairly common - more so than leading resets with other info
+            # that non-sgr codes are not that common, so ok to check for resets before verifying it is actually SGR at all.
+            if {$code ne ""} {
+                lappend overlay_grapheme_control_stacks $o_codestack
+                #there will always be an empty code at end due to foreach on 2 vars with odd-sized list ending with pt (overmap coming from perlish split) 
+                if {[punk::ansi::codetype::is_sgr_reset $code]} {
+                    set o_codestack [list "\x1b\[m"]  ;#reset better than empty list - fixes some ansi art issues
+                    lappend overlay_grapheme_control_list [list sgr $code]
+                } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
+                    set o_codestack [list $code]
+                    lappend overlay_grapheme_control_list [list sgr $code]
+                } elseif {[priv::is_sgr $code]} {
+                    #basic simplification first - remove straight dupes
+                    set dup_posns [lsearch -all -exact $o_codestack $code] ;#must be -exact because of square-bracket glob chars
+                    set o_codestack [lremove $o_codestack {*}$dup_posns]
+                    lappend o_codestack $code
+                    lappend overlay_grapheme_control_list [list sgr $code]
+                } elseif {[regexp {\x1b7|\x1b\[s} $code]} {
+                    #experiment
+                    #cursor_save - for the replays review.
+                    #jmn
+                    #set temp_cursor_saved [punk::ansi::codetype::sgr_merge_list {*}$o_codestack]
+                    lappend overlay_grapheme_control_list [list other $code]
+                } elseif {[regexp {\x1b8|\x1b\[u} $code]} {
+                    #experiment
+                    #cursor_restore - for the replays
+                    set o_codestack [list $temp_cursor_saved]    
+                    lappend overlay_grapheme_control_list [list other $code]
+                } else {
+                    if {[punk::ansi::codetype::is_gx_open $code]} {
+                        set o_gxstack [list "gx0_on"]
+                        lappend overlay_grapheme_control_list [list gx0 gx0_on] ;#don't store code - will complicate debugging if we spit it out and jump character sets
+                    } elseif {[punk::ansi::codetype::is_gx_close $code]} {
+                        set o_gxstack [list]
+                        lappend overlay_grapheme_control_list [list gx0 gx0_off] ;#don't store code - will complicate debugging if we spit it out and jump character sets
+                    } else {
+                        lappend overlay_grapheme_control_list [list other $code]
+                    }
+                }
+            }
+
+        }
+        #replay code for last overlay position in input line - should take account of possible trailing sgr code after last grapheme
+        set max_overlay_grapheme_index [expr {$i_o -1}]
+        lappend overstacks $o_codestack
+        lappend overstacks_gx $o_gxstack
+
+        #set replay_codes_overlay [join $o_codestack ""]
+        set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}$o_codestack]
+
+        #if {[tcl::dict::exists $overstacks $max_overlay_grapheme_index]} {
+        #    set replay_codes_overlay [join [tcl::dict::get $overstacks $max_overlay_grapheme_index] ""]
+        #} else {
+        #    set replay_codes_overlay ""
+        #}
+        # -- --- --- --- --- --- --- ---
+
+
+        #potential problem - combinining diacritics directly following control chars like \r \b
+
+        # -- --- ---
+        #we need to initialise overflow_idx before any potential row-movements - as they need to perform a loop break and force in_excess to 1 
+        if {$opt_overflow} {
+            #somewhat counterintuitively - overflow true means we can have lines as long as we want, but either way there can be excess data that needs to be thrown back to the calling loop.
+            set overflow_idx -1
+        } else {
+            #overflow zero - we can't grow beyond our column width - so we get ellipsis or truncation 
+            if {$opt_width ne "\uFFEF"} {
+                set overflow_idx [expr {$opt_width}]
+            } else {
+                #review - this is also the cursor position when adding a char at end of line? 
+                set overflow_idx [expr {[llength $undercols]}] ;#index at which we would be *in* overflow a row move may still override it 
+            }
+        }
+        # -- --- ---
+
+        set outcols $undercols ;#leave undercols as is, outcols can potentially be appended to.
+
+        set unapplied "" ;#if we break for move row (but not for /v ?)
+        set unapplied_list [list]
+
+        set insert_lines_above 0   ;#return key
+        set insert_lines_below 0
+        set instruction "" 
+
+        # -- --- --- 
+        #cursor_save_dec, cursor_restore_dec etc
+        set cursor_restore_required 0
+        set cursor_saved_attributes "" 
+        set cursor_saved_position ""
+        # -- --- --- 
+
+        #set idx 0 ;# line index  (cursor - 1)
+        #set idx [expr {$opt_colstart + $opt_colcursor} -1]
+
+        #idx is the per column output index
+        set idx [expr {$opt_colcursor -1}] ;#don't use opt_colstart here - we have padded and won't start emitting until idx reaches opt_colstart-1
+        #cursor_column is usually one above idx - but we have opt_colstart which is like a margin - todo: remove cursor_column from the following loop and calculate it's offset when breaking or at end. 
+        #(for now we are incrementing/decrementing both in sync - which is a bit silly)
+        set cursor_column $opt_colcursor
+
+        #idx_over is the per grapheme overlay index
+        set idx_over -1
+
+
+        #movements only occur within the overlay range.
+        #an underlay is however not necessary.. e.g
+        #renderline -overflow 1 "" data 
+        #foreach {pt code} $overmap {}
+        set insert_mode $opt_insert_mode ;#default 1
+        set autowrap_mode $opt_autowrap_mode ;#default 1
+
+        #set re_mode        {\x1b\[\?([0-9]*)(h|l)}   ;#e.g DECAWM 
+        #set re_col_move    {\x1b\[([0-9]*)(C|D|G)$}
+        #set re_row_move    {\x1b\[([0-9]*)(A|B)$}
+        #set re_both_move   {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)H$}  ;# or "f"  ?
+        #set re_vt_sequence {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)~$}
+        #set re_cursor_save          {\x1b\[s$}  ;#note probable incompatibility with DECSLRM (set left right margin)!
+        #set re_cursor_restore       {\x1b\[u$}
+        #set re_cursor_save_dec      {\x1b7$}
+        #set re_cursor_restore_dec   {\x1b8$}
+        #set re_other_single         {\x1b(D|M|E)$}
+        #set re_decstbm              {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)r$}  ;#DECSTBM set top and bottom margins
+
+        #puts "-->$overlay_grapheme_control_list<--"
+        #puts "-->overflow_idx: $overflow_idx"
+        for {set gci 0} {$gci < [llength $overlay_grapheme_control_list]} {incr gci} {
+            set gc [lindex $overlay_grapheme_control_list $gci]
+            lassign $gc type item 
+            
+            #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 $overlay_graphemes {}
+            switch -- $type {
+                g { 
+                    set ch $item 
+                    incr idx_over; #idx_over (until unapplied reached anyway) is per *grapheme* in the overlay - not per col. 
+                    if {($idx < ($opt_colstart -1))} {
+                        incr idx [grapheme_width_cached $ch]
+                        continue
+                    }
+                    #set within_undercols [expr {$idx <= [llength $undercols]-1}] ;#within our active data width 
+                    set within_undercols [expr {$idx <= $colwidth-1}]
+
+                    #https://www.enigma.com/resources/blog/the-secret-world-of-newline-characters
+                    #\x85 NEL in the c1 control set is treated by some terminal emulators (e.g Hyper) as a newline,
+                    #on some it's invisble but doesn't change the line, on some it's a visible glyph of width 1.
+                    #This is hard to process in any standard manner - but I think the Hyper behaviour of doing what it was intended is perhaps most reasonable
+                    #We will map it to the same behaviour as lf here for now... but we need also to consider the equivalent ANSI sequence: \x1bE 
+
+                    set chtest [tcl::string::map [list \n <lf> \x85 <lf> \b <bs> \r <cr> \v <vt> \x7f <del>] $ch]
+                    #puts --->chtest:$chtest
+                    #specials - each shoud have it's own test of what to do if it happens after overflow_idx reached
+                    switch -- $chtest {
+                        "<lf>" {
+                            set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci]]
+                            if {$idx == 0} {
+                                #puts "---a <lf> at col 1"
+                                #linefeed at column 1
+                                #leave the overflow_idx    ;#? review
+                                set instruction lf_start  ;#specific instruction for newline at column 1 
+                                priv::render_unapplied $overlay_grapheme_control_list $gci
+                                break
+                            } elseif {$overflow_idx != -1 && $idx == $overflow_idx} {
+                                #linefeed after final column
+                                #puts "---c <lf> at overflow_idx=$overflow_idx" 
+                                incr cursor_row 
+                                set overflow_idx $idx     ;#override overflow_idx even if it was set to -1 due to opt_overflow = 1|2
+                                set instruction lf_overflow ;#only special treatment is to give it it's own instruction in case caller needs to handle differently
+                                priv::render_unapplied $overlay_grapheme_control_list $gci
+                                break
+                            } else {
+                                #linefeed occurred in middle or at end of text
+                                #puts "---mid-or-end-text-linefeed idx:$idx overflow_idx:$overflow_idx"
+                                incr cursor_row 
+                                set overflow_idx $idx     ;#override overflow_idx even if it was set to -1 due to opt_overflow = 1|2
+                                set instruction lf_mid
+                                priv::render_unapplied $overlay_grapheme_control_list $gci
+                                break
+                            }
+
+                        }
+                        "<cr>" {
+                            #will we want/need to use raw <cr> for keypresses in terminal? (terminal with LNM in standard reset mode means enter=<cr> this is the usual config for terminals)
+                            #So far we are assuming the caller has translated to <lf> and handle above..  REVIEW.
+                            
+                            #consider also the old space-carriagereturn softwrap convention used in some terminals.
+                            #In the context of rendering to a block of text - this works similarly in that the space gets eaten so programs emitting space-cr at the terminal width col will pretty much get what they expect. 
+                            set idx [expr {$opt_colstart -1}]
+                            set cursor_column $opt_colstart ;#?
+                        }
+                        "<bs>" {
+                            #literal backspace char - not necessarily from keyboard 
+                            #review - backspace effect on double-width chars - we are taking a column-editing perspective in overtype 
+                            #(important for -transparent option - hence replacement chars for half-exposed etc)
+                            #review - overstrike support as per nroff/less (generally considered an old technology replaced by unicode mechanisms and/or ansi SGR)
+                            if {$idx > ($opt_colstart -1)} {
+                                incr idx -1
+                                incr cursor_column -1
+                            } else {
+                                set flag 0
+                                if $flag {
+                                    #review - conflicting requirements? Need a different sequence for destructive interactive backspace?
+                                    priv::render_unapplied $overlay_grapheme_control_list $gci
+                                    set instruction backspace_at_start
+                                    break
+                                }
+                            }
+                        }
+                        "<del>" {
+                            #literal del character - some terminals send just this for what is generally expected to be a destructive backspace 
+                            #We instead treat this as a pure delete at current cursor position - it is up to the repl or terminal to remap backspace key to a sequence that has the desired effect.
+                            priv::render_delchar $idx
+                        }
+                        "<vt>" {
+                            #end processing this overline. rest of line is remainder. cursor for column as is. 
+                            #REVIEW - this theoretically depends on terminal's vertical tabulation setting (name?)
+                            #e.g it could be configured to jump down 6 rows.
+                            #On the other hand I've seen indications that some modern terminal emulators treat it pretty much as a linefeed.
+                            #todo?
+                            incr cursor_row
+                            set overflow_idx $idx
+                            #idx_over has already been incremented as this is both a movement-control and in some sense a grapheme 
+                            priv::render_unapplied $overlay_grapheme_control_list $gci
+                            set instruction vt
+                            break
+                        }
+                        default {
+                            if {$overflow_idx != -1} {
+                                #review - how to check arbitrary length item such as tab is going to overflow .. before we get to overflow_idx?
+                                #call grapheme_width_cached on each ch, or look for tab specifically as it's currently the only known reason to have a grapheme width > 2?
+                                #we need to decide what a tab spanning the overflow_idx means and how it affects wrap etc etc
+                                if {$idx == $overflow_idx-1} {
+                                    set owidth [grapheme_width_cached $ch]
+                                    if {$owidth == 2} {
+                                        #review split 2w overflow?
+                                        #we don't want to make the decision here to split a 2w into replacement characters at end of line and beginning of next line
+                                        #better to consider the overlay char as unable to be applied to the line
+                                        #render empty  column(?) - and reduce overlay grapheme index by one so that the current ch goes into unapplied
+                                        #throwing back to caller with instruction complicates its job - but is necessary to avoid making decsions for it here.
+                                        priv::render_addchar $idx "" [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                        #change the overflow_idx
+                                        set overflow_idx $idx
+                                        incr idx
+                                        incr idx_over -1 ;#set overlay grapheme index back one so that sgr stack from previous overlay grapheme used 
+                                        priv::render_unapplied $overlay_grapheme_control_list [expr {$gci-1}] ;#note $gci-1 instead of just gci
+                                        #throw back to caller's loop - add instruction to caller as this is not the usual case
+                                        #caller may for example choose to render a single replacement char to this line and omit the grapheme, or wrap it to the next line
+                                        set instruction overflow_splitchar
+                                        break 
+                                    } elseif {$owidth > 2} {
+                                        #? tab?
+                                        #TODO!
+                                        puts stderr "overtype::renderline long overtext grapheme '[ansistring VIEW -lf 1 -vt 1 $ch]' not handled"
+                                        #tab of some length dependent on tabstops/elastic tabstop settings?
+                                    }
+                                } elseif {$idx >= $overflow_idx} {
+                                    #jmn?
+                                    set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci-1]]
+                                    #set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci]]
+                                    #don't incr idx beyond the overflow_idx
+                                    #idx_over already incremented - decrement so current overlay grapheme stacks go to unapplied
+                                    incr idx_over -1
+                                    #priv::render_unapplied $overlay_grapheme_control_list [expr {$gci-1}] ;#back one index here too
+                                    priv::render_this_unapplied $overlay_grapheme_control_list $gci  ;#
+                                    set instruction overflow
+                                    break
+                                }
+                            } else {
+                                #review.
+                                #This corresponds to opt_overflow being true (at least until overflow_idx is in some cases forced to a value when throwing back to calling loop)
+                            }
+
+                            if {($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)
+                                if {$idx > [llength $outcols]-1} {
+                                    lappend outcols " "
+                                    #tcl::dict::set understacks $idx [list] ;#review - use idx-1 codestack?
+                                    lset understacks $idx [list]
+                                    incr idx
+                                    incr cursor_column
+                                } else {
+                                    #todo - punk::char::char_width
+                                    set g [lindex $outcols $idx]
+                                    set uwidth [grapheme_width_cached $g]
+                                    if {[lindex $outcols $idx] eq ""} {
+                                        #2nd col of 2-wide char in underlay 
+                                        incr idx
+                                        incr cursor_column
+                                    } elseif {$uwidth == 0} {
+                                        #e.g control char  ? combining diacritic ?
+                                        incr idx
+                                        incr cursor_column
+                                    } elseif {$uwidth == 1} {
+                                        set owidth [grapheme_width_cached $ch]
+                                        incr idx
+                                        incr cursor_column
+                                        if {$owidth > 1} {
+                                            incr idx
+                                            incr cursor_column
+                                        } 
+                                    } elseif {$uwidth > 1} {
+                                        if {[grapheme_width_cached $ch] == 1} {
+                                            if {!$insert_mode} {
+                                                #normal singlewide transparent overlay onto double-wide underlay 
+                                                set next_pt_overchar [tcl::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
+                                                    incr cursor_column
+                                                } else {
+                                                    if {[regexp $opt_transparent $next_pt_overchar]} {
+                                                        incr idx
+                                                        incr cursor_column
+                                                    } else {
+                                                        #next overlay char is not transparent.. first-half of underlying 2wide char is exposed 
+                                                        #priv::render_addchar $idx $opt_exposed1 [tcl::dict::get $overstacks $idx_over] [tcl::dict::get $overstacks_gx $idx_over] $insert_mode
+                                                        priv::render_addchar $idx $opt_exposed1 [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                                        incr idx
+                                                        incr cursor_column
+                                                    }
+                                                }
+                                            } else {
+                                                #? todo - decide what transparency even means for insert mode
+                                                incr idx
+                                                incr cursor_column
+                                            }
+                                        } else {
+                                            #2wide transparency over 2wide in underlay - review
+                                            incr idx
+                                            incr cursor_column
+                                        }
+                                    }
+                                }
+                            } else {
+
+                                set idxchar [lindex $outcols $idx]
+                                #non-transparent char in overlay or empty cell
+                                if {$idxchar eq "\u0000"} {
+                                    #empty/erased cell indicator
+                                    set uwidth 1
+                                } else {
+                                    set uwidth [grapheme_width_cached $idxchar]
+                                }
+                                if {$within_undercols} {    
+                                    if {$idxchar eq ""} {
+                                        #2nd col of 2wide char in underlay
+                                        if {!$insert_mode} {
+                                            priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] 0 
+                                            #JMN - this has to expose if our startposn chopped an underlay - but not if we already overwrote the first half of the widechar underlay grapheme 
+                                            #e.g renderline \uFF21\uFF21---  a\uFF23\uFF23
+                                            #vs
+                                            #    renderline -startcolumn 2 \uFF21---- \uFF23
+                                            if {[lindex $outcols $idx-1] != ""} {
+                                                #verified it's an empty following a filled - so it's a legit underlay remnant  (REVIEW - when would it not be??)
+                                                #reset previous to an exposed 1st-half - but leave understacks code as is
+                                                priv::render_addchar [expr {$idx-1}] $opt_exposed1 [lindex $understacks $idx-1] [lindex $understacks_gx $idx-1] 0 
+                                            }
+                                            incr idx
+                                        } else {
+                                            set prevcolinfo [lindex $outcols $idx-1]
+                                            #for insert mode - first replace the empty 2ndhalf char with exposed2 before shifting it right 
+                                            #REVIEW - this leaves a replacement character permanently in our columns.. but it is consistent regarding length (?)
+                                            #The alternative is to disallow insertion at a column cursor that is at 2nd half of 2wide char
+                                            #perhaps by inserting after the char - this may be worthwhile - but may cause other surprises 
+                                            #It is perhaps best avoided at another level and try to make renderline do exactly as it's told
+                                            #the advantage of this 2w splitting method is that the inserted character ends up in exactly the column we expect.
+                                            priv::render_addchar $idx $opt_exposed2 [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] 0 ;#replace not insert
+                                            priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] 1 ;#insert - same index
+                                            if {$prevcolinfo ne ""} {
+                                                #we've split the 2wide - it may already have been rendered as an exposed1 - but not for example if our startcolumn was current idx
+                                                priv::render_addchar [expr {$idx-1}] $opt_exposed1 [lindex $understacks $idx-1] [lindex $understacks_gx $idx-1] 0  ;#replace not insert
+                                            } ;# else??
+                                            incr idx
+                                        }
+                                        if {$cursor_column < [llength $outcols] || $overflow_idx == -1} {
+                                            incr cursor_column
+                                        }
+                                    } elseif {$uwidth == 0} {
+                                        #what if this is some other c0/c1 control we haven't handled specifically?
+
+                                        #by emitting a preceding empty-string column - we associate whatever this char is with the preceeding non-zero-length character and any existing zero-lengths that follow it
+                                        #e.g combining diacritic - increment before over char  REVIEW
+                                        #arguably the previous overchar should have done this - ie lookahead for combiners?
+                                        #if we can get a proper grapheme_split function - this should be easier to tidy up.
+                                        priv::render_addchar $idx "" [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                        incr idx
+                                        priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                        incr idx
+                                        incr cursor_column 2
+
+                                        if {$cursor_column > [llength $outcols] && $overflow_idx != -1} {
+                                            set cursor_column [llength $outcols]
+                                        }
+                                    } elseif {$uwidth == 1} {
+                                        #includes null empty cells
+                                        set owidth [grapheme_width_cached $ch]
+                                        if {$owidth == 1} {
+                                            priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                            incr idx
+                                        } else {
+                                            priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                            incr idx
+                                            priv::render_addchar $idx ""  [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                            #if next column in underlay empty - we've overwritten first half of underlying 2wide grapheme
+                                            #replace with rhs exposure in case there are no more overlay graphemes coming - use underlay's stack
+                                            if {([llength $outcols] >= $idx +2) && [lindex $outcols $idx+1] eq ""} {
+                                                priv::render_addchar [expr {$idx+1}] $opt_exposed2 [lindex $understacks $idx+1] [lindex $understacks_gx $idx+1] $insert_mode
+                                            }
+                                            incr idx
+                                        }
+                                        if {($cursor_column < [llength $outcols]) || $overflow_idx == -1 || $test_mode} {
+                                            incr cursor_column
+                                        }
+                                    } elseif {$uwidth > 1} {
+                                        set owidth [grapheme_width_cached $ch]
+                                        if {$owidth == 1} {
+                                            #1wide over 2wide in underlay
+                                            if {!$insert_mode} {
+                                                priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                                incr idx
+                                                incr cursor_column
+                                                priv::render_addchar $idx $opt_exposed2 [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                                #don't incr idx - we are just putting a broken-indication in the underlay - which may get overwritten by next overlay char
+                                            } else {
+                                                #insert mode just pushes all to right - no exposition char here
+                                                priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                                incr idx
+                                                incr cursor_column
+                                            }
+                                        } else {
+                                            #2wide over 2wide
+                                            priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                            incr idx 2 
+                                            incr cursor_column 2
+                                        }
+
+                                        if {$cursor_column > [llength $outcols] && $overflow_idx != -1} {
+                                            set cursor_column [llength $outcols]
+                                        }
+                                    }
+                                } else {
+                                    priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
+                                    incr idx
+                                    incr cursor_column
+                                    if {$overflow_idx !=-1 && !$test_mode} {
+                                        #overflow
+                                        if {$cursor_column > [llength $outcols]} {
+                                            set cursor_column [llength $outcols]
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } ;# end switch
+
+
+                }
+                other {
+                    #todo - consider CSI s DECSLRM vs ansi.sys \x1b\[s  - we need \x1b\[s for oldschool ansi art - but may have to enable only for that.
+                    #we should probably therefore reverse this mapping so that x1b7 x1b8 are the primary codes for save/restore
+                    set code [tcl::string::map [list \x1b7 \x1b\[s \x1b8 \x1b\[u ] $item]
+                    #since this element isn't a grapheme - advance idx_over to next grapheme overlay when about to fill 'unapplied'
+
+                    set matchinfo [list]
+
+                    #remap of DEC cursor_save/cursor_restore from ESC sequence to equivalent CSI
+                    #probably not ideal - consider putting cursor_save/cursor_restore in functions so they can be called from the appropriate switch branch instead of using this mapping
+                    #review - cost/benefit of function calls within these switch-arms instead of inline code?
+
+                    set c1 [tcl::string::index $code 0]
+                    set c1c2c3 [tcl::string::range $code 0 2]
+                    #set re_ST_open {(?:\033P|\u0090|\033X|\u0098|\033\^|\u009e|\033_|\u009f)} 
+                    #tcl 8.7 - faster to use inline list than to store it in a local var outside of loop. 
+                    #(surprising - but presumably )
+                    set leadernorm [tcl::string::range [tcl::string::map [list\
+                        \x1b\[<     1006\
+                        \x1b\[      7CSI\
+                        \x9b        8CSI\
+                        \x1b\]      7OSC\
+                        \x9d        8OSC\
+                        \x1b        7ESC\
+                        ] $c1c2c3] 0 3] ;#leadernorm is 1st 2 chars mapped to 4char normalised indicator - or is original 2 chars 
+
+                    #we leave the tail of the code unmapped for now 
+                    switch -- $leadernorm {
+                        1006 {
+                            #https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+                            #SGR (1006) CSI < followed by colon separated encoded-button-value,px,py ordinates and final M for button press m for button release
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 3 end]]
+                        }
+                        7CSI - 7OSC {
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 2 end]]
+                        }
+                        7ESC {
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 1 end]]
+                        }
+                        8CSI - 8OSC {
+                            set codenorm [tcl::string::cat $leadernorm [tcl::string::range $code 1 end]]
+                        }
+                        default {
+                            #we haven't made a mapping for this
+                            set codenorm $code
+                        }
+                    }
+
+                    #we've mapped 7 and 8bit escapes to values we can handle as literals in switch statements to take advantange of jump tables.
+                    switch -- $leadernorm  {
+                        1006 {
+                            #TODO
+                            #
+                            switch -- [tcl::string::index $codenorm end] {
+                                M {
+                                    puts stderr "mousedown $codenorm"
+                                }
+                                m {
+                                    puts stderr "mouseup $codenorm"
+                                }
+                            }
+
+                        }
+                        {7CSI} - {8CSI} {
+                            set param [tcl::string::range $codenorm 4 end-1]
+                            #puts stdout "--> CSI [tcl::string::index $leadernorm 0] bit param:$param"
+                            switch -- [tcl::string::index $codenorm end] {
+                                D {
+                                    #Col move
+                                    #puts stdout "<-back"
+                                    #cursor back
+                                    #left-arrow/move-back when ltr mode
+                                    set num $param
+                                    if {$num eq ""} {set num 1}
+
+                                    set version 2
+                                    if {$version eq "2"} {
+                                        #todo - startcolumn offset!
+                                        if {$cursor_column - $num >= 1} {
+                                            incr idx -$num
+                                            incr cursor_column -$num
+                                        } else {
+                                            if {!$autowrap_mode} {
+                                            set cursor_column 1 
+                                            set idx 0
+                                            } else {
+                                                set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci]]
+                                                incr cursor_column -$num
+                                                priv::render_unapplied $overlay_grapheme_control_list $gci
+                                                set instruction wrapmovebackward
+                                                break
+                                            }
+                                        }
+                                    } else {
+                                        incr idx -$num
+                                        incr cursor_column -$num
+                                        if {$idx < $opt_colstart-1} {
+                                            #wrap to previous line and position cursor at end of data
+                                            set idx [expr {$opt_colstart-1}]
+                                            set cursor_column $opt_colstart
+                                        }
+                                    }
+                                }
+                                C {
+                                    #Col move
+                                    #puts stdout "->forward"
+                                    #todo - consider right-to-left cursor mode (e.g Hebrew).. some day.
+                                    #cursor forward
+                                    #right-arrow/move forward
+                                    set num $param
+                                    if {$num eq ""} {set num 1}
+                                    
+                                    #todo - retrict to moving 1 position past datalen? restrict to column width? 
+                                    #should ideally wrap to next line when interactive and not on last row
+                                    #(some ansi art seems to expect this behaviour)
+                                    #This presumably depends on the terminal's wrap mode
+                                    #e.g DECAWM autowrap mode
+                                    # CSI ? 7 h  - set: autowrap     (also tput smam)
+                                    # CSI ? 7 l  - reset: no autowrap (also tput rmam)
+                                    set version 2
+                                    if {$version eq "2"} {
+                                        set max [llength $outcols]
+                                        if {$overflow_idx == -1} {
+                                            incr max
+                                        }
+                                        if {$test_mode && $cursor_column == $max+1} {
+                                            #move_forward while in overflow
+                                            incr cursor_column -1
+                                        }
+
+                                        if {($cursor_column + $num) <= $max} {
+                                            incr idx $num
+                                            incr cursor_column $num
+                                        } else {
+                                            if {$autowrap_mode} {
+                                                set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci]]
+                                                #jmn
+                                                if {$idx == $overflow_idx} {
+                                                    incr num
+                                                }
+
+                                                #horizontal movement beyond line extent needs to wrap - throw back to caller
+                                                #we may have both overflow_rightand unapplied data
+                                                #(can have overflow_right if we were in insert_mode and processed chars prior to this movement)
+                                                #leave row as is - caller will need to determine how many rows the column-movement has consumed
+                                                incr cursor_column $num ;#give our caller the necessary info as columns from start of row 
+                                                #incr idx_over
+                                                #should be gci following last one applied 
+                                                priv::render_unapplied $overlay_grapheme_control_list $gci
+                                                set instruction wrapmoveforward
+                                                break
+                                            } else {
+                                                set cursor_column $max 
+                                                set idx [expr {$cursor_column -1}]
+                                            }
+                                        }
+                                    } else {
+                                        if {!$opt_overflow || ($cursor_column + $num) <= [llength $outcols+1]} {
+                                            incr idx $num
+                                            incr cursor_column $num
+                                        } else {
+                                            if {!$insert_mode} {
+                                                #block editing style with arrow keys
+                                                #overtype mode
+                                                set idxstart $idx
+                                                set idxend [llength $outcols]
+                                                set moveend [expr {$idxend - $idxstart}] 
+                                                if {$moveend < 0} {set moveend 0} ;#sanity?
+                                                #puts "idxstart:$idxstart idxend:$idxend outcols[llength $outcols] undercols:[llength $undercols]"
+                                                incr idx $moveend
+                                                incr cursor_column $moveend
+                                                #if {[tcl::dict::exists $understacks $idx]} {
+                                                #    set stackinfo [tcl::dict::get $understacks $idx] ;#use understack at end - which may or may not have already been replaced by stack from overtext
+                                                #} else {
+                                                #    set stackinfo [list]
+                                                #}
+                                                if {$idx < [llength $understacks]} {
+                                                    set stackinfo [lindex $understacks $idx] ;#use understack at end - which may or may not have already been replaced by stack from overtext
+                                                } else {
+                                                    set stackinfo [list]
+                                                }
+                                                if {$idx < [llength $understacks_gx]} {
+                                                    #set gxstackinfo [tcl::dict::get $understacks_gx $idx]
+                                                    set gxstackinfo [lindex $understacks_gx $idx]
+                                                } else {
+                                                    set gxstackinfo [list]
+                                                }
+                                                #pad outcols
+                                                set movemore [expr {$num - $moveend}] 
+                                                #assert movemore always at least 1 or we wouldn't be in this branch
+                                                for {set m 1} {$m <= $movemore} {incr m} {
+                                                    incr idx
+                                                    incr cursor_column
+                                                    priv::render_addchar $idx " " $stackinfo $gxstackinfo $insert_mode
+                                                }
+                                            } else {
+                                                #normal - insert  
+                                                incr idx $num
+                                                incr cursor_column $num
+                                                if {$idx > [llength $outcols]} {
+                                                    set idx [llength $outcols];#allow one beyond - for adding character at end of line
+                                                    set cursor_column [expr {[llength $outcols]+1}]
+                                                }
+                                            }
+                                        }
+                                    }
+                                } 
+                                G {
+                                    #Col move
+                                    #move absolute column
+                                    #adjust to colstart - as column 1 is within overlay
+                                    #???
+                                    set idx [expr {$param + $opt_colstart -1}] 
+                                    set cursor_column $param
+                                    error "renderline absolute col move ESC G unimplemented"
+                                }
+                                A {
+                                    #Row move - up
+                                    set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci]]
+                                    set num $param
+                                    if {$num eq ""} {set num 1}
+                                    incr cursor_row -$num
+
+                                    if {$cursor_row < 1} {
+                                        set cursor_row  1
+                                    }
+
+                                    #ensure rest of *overlay* is emitted to remainder
+                                    incr idx_over
+                                    priv::render_unapplied $overlay_grapheme_control_list $gci
+                                    set instruction up
+                                    #retain cursor_column
+                                    break 
+                                }
+                                B {
+                                    #Row move - down
+                                    set num $param
+                                    set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci]]
+                                    #move down
+                                    if {$num eq ""} {set num 1}
+                                    incr cursor_row $num
+
+
+                                    incr idx_over ;#idx_over hasn't encountered a grapheme and hasn't advanced yet 
+                                    priv::render_unapplied $overlay_grapheme_control_list $gci
+                                    set instruction down
+                                    #retain cursor_column
+                                    break 
+                                }
+                                H - f {
+                                    #$re_both_move
+                                    lassign [split $param {;}] row col
+                                    set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci]]
+                                    #lassign $matchinfo _match row col 
+
+                                    if {$col eq ""} {set col 1}
+                                    set max [llength $outcols]
+                                    if {$overflow_idx == -1} {
+                                        incr max 
+                                    }
+                                    if {$col > $max} {
+                                        set cursor_column  $max
+                                    } else {
+                                        set cursor_column $col
+                                    }
+                                    set idx [expr {$cursor_column -1}]
+
+                                    if {$row eq ""} {set row 1}
+                                    set cursor_row $row
+                                    if {$cursor_row < 1} {
+                                        set cursor_row 1
+                                    }
+
+                                    incr idx_over
+                                    priv::render_unapplied $overlay_grapheme_control_list $gci
+                                    set instruction move
+                                    break
+
+                                }
+                                X {
+                                    puts stderr "X - $param"
+                                    #ECH - erase character
+                                    if {$param eq "" || $param eq "0"} {set param 1}; #param=count of chars to erase
+                                    priv::render_erasechar $idx $param 
+                                    #cursor position doesn't change.
+                                }
+                                r {
+                                    #$re_decstbm
+                                    #https://www.vt100.net/docs/vt510-rm/DECSTBM.html
+                                    #This control function sets the top and bottom margins for the current page. You cannot perform scrolling outside the margins
+                                    lassign [split $param {;}] margin_top margin_bottom
+
+                                    #todo - return these for the caller to process..
+                                    puts stderr "overtype::renderline DECSTBM set top and bottom margin not implemented"
+                                    #Also moves the cursor to col 1 line 1 of the page
+                                    set cursor_column 1
+                                    set cursor_row 1
+
+                                    incr idx_over
+                                    priv::render_unapplied $overlay_grapheme_control_list $gci
+                                    set instruction move  ;#own instruction? decstbm?
+                                    break
+                                }
+                                s {
+                                    # - todo - make ansi.sys CSI s cursor save only apply for certain cases? - may need to support DECSLRM instead which uses same code
+
+                                    #$re_cursor_save
+                                    #cursor save could come after last column  
+                                    if {$overflow_idx != -1 && $idx == $overflow_idx} {
+                                        #bartman2.ans test file - fixes misalignment at bottom of dialog bubble
+                                        #incr cursor_row
+                                        #set cursor_column 1
+                                        #bwings1.ans test file - breaks if we actually incr cursor (has repeated saves)
+                                        set cursor_saved_position [list row [expr {$cursor_row+1}] column 1]
+                                    } else {
+                                        set cursor_saved_position [list row $cursor_row column $cursor_column]
+                                    }
+                                    #there may be overlay stackable codes emitted that aren't in the understacks because they come between the last emmited character and the cursor_save control.
+                                    #we need the SGR and gx overlay codes prior to the cursor_save  
+
+                                    #a real terminal would not be able to know the state of the underlay.. so we should probably ignore it.
+                                    #set sgr_stack [lindex $understacks $idx]
+                                    #set gx_stack [lindex $understacks_gx $idx] ;#not actually a stack - just a boolean state (for now?)
+                                    
+                                    set sgr_stack [list]
+                                    set gx_stack [list]
+
+                                    #we shouldn't need to scan for intermediate cursor save/restores - as restores would throw-back to the calling loop - so our overlay 'line' is since those.
+                                    #The overlay_grapheme_control_list had leading resets from previous lines - so we go back to the beginning not just the first grapheme.
+
+                                    foreach gc [lrange $overlay_grapheme_control_list 0 $gci-1] {
+                                        lassign $gc type code 
+                                        #types g other sgr gx0
+                                        switch -- $type {
+                                            gx0 {
+                                                #code is actually a stand-in for the graphics on/off code  - not the raw code
+                                                #It is either gx0_on or gx0_off 
+                                                set gx_stack [list $code]
+                                            }
+                                            sgr {
+                                                #code is the raw code
+                                                if {[punk::ansi::codetype::is_sgr_reset $code]} {
+                                                    #jmn
+                                                    set sgr_stack [list "\x1b\[m"]
+                                                } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
+                                                    set sgr_stack [list $code]
+                                                    lappend overlay_grapheme_control_list [list sgr $code]
+                                                } elseif {[priv::is_sgr $code]} {
+                                                    #often we don't get resets - and codes just pile up.
+                                                    #as a first step to simplifying - at least remove earlier straight up dupes
+                                                    set dup_posns [lsearch -all -exact $sgr_stack $code] ;#needs -exact - codes have square-brackets (glob chars)
+                                                    set sgr_stack [lremove $sgr_stack {*}$dup_posns]
+                                                    lappend sgr_stack $code
+                                                }
+                                            }
+                                        }
+                                    }
+                                    set cursor_saved_attributes ""
+                                    switch -- [lindex $gx_stack 0] {
+                                        gx0_on {
+                                            append cursor_saved_attributes "\x1b(0"
+                                        }
+                                        gx0_off {
+                                            append cursor_saved_attributes "\x1b(B"
+                                        }
+                                    }
+                                    #append cursor_saved_attributes [join $sgr_stack ""]
+                                    append cursor_saved_attributes [punk::ansi::codetype::sgr_merge_list {*}$sgr_stack]
+
+                                    #as there is apparently only one cursor storage element we don't need to throw back to the calling loop for a save.
+
+                                    #don't incr index - or the save will cause cursor to move to the right
+                                    #carry on 
+                                    
+                                }
+                                u {
+                                    #$re_cursor_restore
+                                    #we are going to jump somewhere.. for now we will assume another line, and process accordingly.
+                                    #The caller has the cursor_saved_position/cursor_saved_attributes if any (?review - if we always pass it back it, we could save some calls for moves in same line)
+                                    #don't set overflow at this point. The existing underlay to the right must be preserved.
+                                    #we only want to jump and render the unapplied at the new location.
+
+                                    #lset overstacks $idx_over [list]
+                                    #set replay_codes_overlay ""        
+
+                                    #if {$cursor_saved_attributes ne ""} {
+                                    #    set replay_codes_overlay $cursor_saved_attributes ;#empty - or last save if it happend in this input chunk
+                                    #} else {
+                                        #jj
+                                        #set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci]]
+                                        set replay_codes_overlay ""
+                                    #}
+                                    
+                                    #like priv::render_unapplied - but without the overlay's ansi reset or gx stacks from before the restore code                     
+                                    incr idx_over
+
+                                    set unapplied ""
+                                    set unapplied_list [list]
+                                    foreach gc [lrange $overlay_grapheme_control_list $gci+1 end] {
+                                        lassign $gc type item
+                                        if {$type eq "gx0"} {
+                                            if {$item eq "gx0_on"} {
+                                                lappend unapplied_list "\x1b(0"
+                                            } elseif {$item eq "gx0_off"} {
+                                                lappend unapplied_list "\x1b(B"
+                                            }
+                                        } else {
+                                            lappend unapplied_list $item
+                                        }
+                                        #incr idx_over
+                                    }
+                                    set unapplied [join $unapplied_list ""]
+                                    #if the save occured within this line - that's ok - it's in the return value list and caller can prepend for the next loop. 
+                                    set instruction restore_cursor 
+                                    break
+                                }
+                                ~ {
+                                    #$re_vt_sequence
+                                    #lassign $matchinfo _match key mod 
+                                    lassign [split $param {;}] key mod
+
+                                    #Note that f1 to f4 show as ESCOP|Q|R|S  (VT220?) but f5+ show as ESC\[15~
+                                    #
+                                    #e.g esc \[2~  insert  esc \[2;2~  shift-insert
+                                    #mod - subtract 1, and then use bitmask
+                                    #shift = 1, (left)Alt = 2, control=4, meta=8  (meta seems to do nothing on many terminals on windows? Intercepted by windows?)
+                                    #puts stderr "vt key:$key mod:$mod  code:[ansistring VIEW $code]" 
+                                    if {$key eq "1"} {
+                                        #home
+                                    } elseif {$key eq "2"} {
+                                        #Insert
+                                        if {$mod eq ""} {
+                                            #no modifier key
+                                            set insert_mode [expr {!$insert_mode}]
+                                            #rather than set the cursor - we return the insert mode state so the caller can decide
+                                        }
+                                    } elseif {$key eq "3"} {
+                                        #Delete - presumably this shifts other chars in the line, with empty cells coming in from the end
+                                        switch -- $mod {
+                                            "" {
+                                                priv::render_delchar $idx
+                                            }
+                                            "5" {
+                                                #ctrl-del - delete to end of word (pwsh) - possibly word on next line if current line empty(?)
+                                            }
+                                        }
+                                    } elseif {$key eq "4"} {
+                                        #End
+                                    } elseif {$key eq "5"} {
+                                        #pgup
+                                    } elseif {$key eq "6"} {
+                                        #pgDn
+                                    } elseif {$key eq "7"} {
+                                        #Home
+                                        #??
+                                        set idx [expr {$opt_colstart -1}]
+                                        set cursor_column 1
+                                    } elseif {$key eq "8"} {
+                                        #End
+                                    } elseif {$key eq "11"} {
+                                        #F1 - or ESCOP  or  e.g shift F1 ESC\[1;2P
+                                    } elseif {$key eq "12"} {
+                                        #F2 - or ESCOQ
+                                    } elseif {$key eq "13"} {
+                                        #F3 - or ESCOR
+                                    } elseif {$key eq "14"} {
+                                        #F4 - or ESCOS
+                                    } elseif {$key eq "15"} {
+                                        #F5 or shift F5 ESC\[15;2~
+                                    } elseif {$key eq "17"} {
+                                        #F6
+                                    } elseif {$key eq "18"} {
+                                        #F7
+                                    } elseif {$key eq "19"} {
+                                        #F8
+                                    } elseif {$key eq "20"} {
+                                        #F9
+                                    } elseif {$key eq "21"} {
+                                        #F10
+                                    } elseif {$key eq "23"} {
+                                        #F11
+                                    } elseif {$key eq "24"} {
+                                        #F12
+                                    }
+
+                                }
+                                h - l {
+                                    #we are matching only last char to get to this arm - but are there other sequences ending in h|l we need to handle?
+
+                                    #$re_mode if first after CSI is "?"  
+                                    #some docs mention ESC=<mode>h|l  - not seen on windows terminals.. review
+                                    #e.g https://www2.math.upenn.edu/~kazdan/210/computer/ansi.html
+                                    if {[tcl::string::index $codenorm 4] eq "?"} {
+                                        set num [tcl::string::range $codenorm 5 end-1] ;#param between ? and h|l
+                                        #lassign $matchinfo _match num type
+                                        switch -- $num {
+                                            5 {
+                                                #DECSNM - reverse video
+                                                #How we simulate this to render within a block of text is an open question.
+                                                #track all SGR stacks and constantly flip based on the current SGR reverse state?
+                                                #It is the job of the calling loop to do this - so at this stage we'll just set the states
+                                                #DECAWM autowrap 
+                                                if {$type eq "h"} {
+                                                    #set (enable)
+                                                    set reverse_mode 1
+                                                } else {
+                                                    #reset (disable)
+                                                    set reverse_mode 0
+                                                }
+
+                                            }
+                                            7 {
+                                                #DECAWM autowrap 
+                                                if {$type eq "h"} {
+                                                    #set (enable)
+                                                    set autowrap_mode 1
+                                                    if {$opt_width ne "\uFFEF"} {
+                                                        set overflow_idx $opt_width
+                                                    } else {
+                                                        #review - this is also the cursor position when adding a char at end of line? 
+                                                        set overflow_idx [expr {[llength $undercols]}] ;#index at which we would be *in* overflow a row move may still override it 
+                                                    }
+                                                    #review - can idx ever be beyond overflow_idx limit when we change e.g with a width setting and cursor movements? presume not - but sanity check for now.
+                                                    if {$idx >= $overflow_idx} {
+                                                        puts stderr "renderline error - idx '$idx' >= overflow_idx '$overflow_idx' - unexpected"
+                                                    }
+                                                } else {
+                                                    #reset (disable)
+                                                    set autowrap_mode 0
+                                                    set overflow_idx -1
+                                                }
+                                            }
+                                            25 {
+                                                if {$type eq "h"} {
+                                                    #visible cursor
+
+                                                } else {
+                                                    #invisible cursor
+
+                                                }
+                                            }
+                                        }
+
+                                    } else {
+                                        puts stderr "overtype::renderline CSI...h|l code [ansistring VIEW -lf 1 -vt 1 -nul 1 $code] not implemented"
+                                    }
+                                }
+                                default {
+                                        puts stderr "overtype::renderline CSI code [ansistring VIEW -lf 1 -vt 1 -nul 1 $code] not implemented"
+                                }
+                            } 
+                        } 
+                        7ESC {
+                            #$re_other_single
+                            switch -- [tcl::string::index $codenorm end] {
+                                D {
+                                    #\x84
+                                    #index (IND)
+                                    #vt102-docs: "Moves cursor down one line in same column. If cursor is at bottom margin, screen performs a scroll-up"
+                                    puts stderr "ESC D not fully implemented"
+                                    incr cursor_row 
+                                    priv::render_unapplied $overlay_grapheme_control_list $gci
+                                    set instruction down
+                                    #retain cursor_column
+                                    break 
+                                }
+                                M {
+                                    #\x8D
+                                    #Reverse Index (RI)
+                                    #vt102-docs: "Moves cursor up one line in same column. If cursor is at top margin, screen performs a scroll-down"
+                                    puts stderr "ESC M not fully implemented"
+
+                                    set replay_codes_overlay [punk::ansi::codetype::sgr_merge_list {*}[lindex $overlay_grapheme_control_stacks $gci]]
+                                    #move up
+                                    incr cursor_row -1
+                                    if {$cursor_row < 1} {
+                                        set cursor_row  1
+                                    }
+                                    #ensure rest of *overlay* is emitted to remainder
+                                    priv::render_unapplied $overlay_grapheme_control_list $gci
+                                    set instruction up  ;#need instruction for scroll-down?
+                                    #retain cursor_column
+                                    break 
+                                }
+                                E {
+                                    #\x85
+                                    #review - is behaviour different to lf?
+                                    #todo - possibly(?) same logic as <lf> handling above. i.e return instruction depends on where column_cursor is at the time we get NEL
+                                    #leave implementation until logic for <lf> is set in stone... still under review
+                                    #It's arguable NEL is a pure cursor movement as opposed to the semantic meaning of crlf or lf in a file.
+                                    # 
+                                    #Next Line (NEL) "Move the cursor to the left margin on the next line. If the cursor is at the bottom margin, scroll the page up"
+                                    puts stderr "ESC E unimplemented"
+
+                                }
+                                default {
+                                    puts stderr "overtype::renderline ESC<x> code [ansistring VIEW -lf 1 -vt 1 -nul 1 $code] not implemented"
+                                }
+                            }
+
+                        }
+                    }
+
+                    #switch -regexp -matchvar matchinfo -- $code\
+                    #$re_mode {
+                    #}\
+                    #default {
+                    #    puts stderr "overtype::renderline code [ansistring VIEW -lf 1 -vt 1 -nul 1 $code] not implemented"
+                    #}
+
+                }
+                default {
+                    #don't need to handle sgr or gx0 types 
+                    #we have our sgr gx0 codes already in stacks for each overlay grapheme
+                }
+            }
+        }
+
+        #--------
+        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
+        }
+        if {$overflow_idx == -1} {
+            #overflow was initially unlimited and hasn't been overridden
+        } else {
+
+        }
+        #--------
+
+
+        #coalesce and replay codestacks for outcols grapheme list
+        set outstring ""  ;#output prior to overflow
+        set overflow_right "" ;#remainder after overflow point reached
+        set i 0
+        set cstack [list]
+        set prevstack [list]
+        set prev_g0 [list]
+        #note overflow_idx may already have been set lower if we had a row move above due to \v or ANSI moves
+        set in_overflow 0 ;#used to stop char-width scanning once in overflow
+        if {$overflow_idx == 0} {
+            #how does caller avoid an infinite loop if they have autowrap on and keep throwing graphemes to the next line?  REVIEW
+            set in_overflow 1
+        }
+        foreach ch $outcols {
+            #puts "---- [ansistring VIEW $ch]"
+
+            set gxleader ""
+            if {$i < [llength $understacks_gx]} {
+                #set g0 [tcl::dict::get $understacks_gx $i]
+                set g0 [lindex $understacks_gx $i]
+                if {$g0 ne $prev_g0} {
+                    if {$g0 eq [list "gx0_on"]} {
+                        set gxleader "\x1b(0"
+                    } else {
+                        set gxleader "\x1b(B"
+                    }
+                }
+                set prev_g0 $g0
+            } else {
+                set prev_g0 [list]
+            }
+
+            set sgrleader ""
+            if {$i < [llength $understacks]} {
+                #set cstack [tcl::dict::get $understacks $i]
+                set cstack [lindex $understacks $i]
+                if {$cstack ne $prevstack} {
+                    if {[llength $prevstack] && ![llength $cstack]} {
+                        #This reset is important e.g testfile fruit.ans - we get overhang on rhs without it. But why is cstack empty?
+                        append sgrleader \033\[m
+                    } else {
+                        append sgrleader [punk::ansi::codetype::sgr_merge_list {*}$cstack]
+                    }
+                }
+                set prevstack $cstack
+            } else {
+                set prevstack [list]
+            }
+
+
+
+            if {$in_overflow} {
+                if {$i == $overflow_idx} {
+                    set 0 [lindex $understacks_gx $i]
+                    set gxleader ""
+                    if {$g0 eq [list "gx0_on"]} {
+                        set gxleader "\x1b(0"
+                    } elseif {$g0 eq [list "gx0_off"]} {
+                        set gxleader "\x1b(B"
+                    }
+                    append overflow_right $gxleader
+                    set cstack [lindex $understacks $i]
+                    set sgrleader ""
+                    #whether cstack is same or differs from previous char's stack - we must have an output at the start of the overflow_right
+                    #if {[llength $prevstack] && ![llength $cstack]} {
+                    #    append sgrleader \033\[m
+                    #}
+                    append sgrleader [punk::ansi::codetype::sgr_merge_list {*}$cstack]
+                    append overflow_right $sgrleader
+                    append overflow_right $ch
+                } else {
+                    append overflow_right $gxleader
+                    append overflow_right $sgrleader
+                    append overflow_right $ch
+                }
+            } else {
+                if {$overflow_idx != -1 && $i+1 == $overflow_idx} {
+                    #one before overflow
+                    #will be in overflow in next iteration
+                    set in_overflow 1
+                    if {[grapheme_width_cached $ch]> 1} {
+                        #we overflowed with second-half of a double-width char - replace first-half with user-supplied exposition char (should be 1 wide)
+                        set ch $opt_exposed1
+                    }
+                }
+                append outstring $gxleader
+                append outstring $sgrleader
+                if {$idx+1 < $cursor_column} {
+                    append outstring [tcl::string::map {\u0000 " "} $ch]
+                } else {
+                    append outstring $ch
+                }
+            }
+            incr i
+        }
+        #flower.ans good test for null handling - reverse line building
+        if {![ansistring length $overflow_right]} {
+            set outstring [tcl::string::trimright $outstring "\u0000"]
+        }
+        set outstring [tcl::string::map {\u0000 " "} $outstring] 
+        set overflow_right [tcl::string::trimright $overflow_right "\u0000"]
+        set overflow_right [tcl::string::map {\u0000 " "} $overflow_right] 
+
+        set replay_codes ""
+        if {[llength $understacks] > 0} {
+            if {$overflow_idx == -1} {
+                #set tail_idx [tcl::dict::size $understacks]
+                set tail_idx [llength $understacks]
+            } else {
+                set tail_idx [llength $undercols]
+            }
+            if {$tail_idx-1 < [llength $understacks]} {
+                #set replay_codes [join [lindex $understacks $tail_idx-1] ""] ;#tail replay codes
+                set replay_codes [punk::ansi::codetype::sgr_merge_list {*}[lindex $understacks $tail_idx-1]] ;#tail replay codes
+            }
+            if {$tail_idx-1 < [llength $understacks_gx]} {
+                set gx0 [lindex $understacks_gx $tail_idx-1]
+                if {$gx0 eq [list "gx0_on"]} {
+                    #if it was on, turn gx0 off at the point we stop processing overlay
+                    append outstring "\x1b(B"
+                }
+            }
+        }
+        if {[string length $overflow_right]} {
+            #puts stderr "remainder:$overflow_right"
+        }
+        #pdict $understacks
+
+        if {[punk::ansi::ta::detect_sgr $outstring]} {
+            append outstring [punk::ansi::a] ;#without this - we would get for example, trailing backgrounds after rightmost column 
+
+            #close off any open gx?
+            #probably should - and overflow_right reopen? 
+        }
+        
+        if {$opt_returnextra} {
+            #replay_codes is the codestack at the boundary - used for ellipsis colouring to match elided text  - review
+            #replay_codes_underlay is the set of codes in effect at the very end of the original underlay
+
+            #review
+            #replay_codes_overlay is the set of codes in effect at the very end of the original overlay (even if not all overlay was applied)
+            #todo - replay_codes for gx0 mode
+
+            #overflow_idx may change during ansi & character processing
+            if {$overflow_idx == -1} {
+                set overflow_right_column ""
+            }  else {
+                set overflow_right_column [expr {$overflow_idx+1}]
+            }
+            set result [tcl::dict::create\
+                result $outstring\
+                visualwidth [punk::ansi::printing_length $outstring]\
+                instruction $instruction\
+                stringlen [string length $outstring]\
+                overflow_right_column $overflow_right_column\
+                overflow_right $overflow_right\
+                unapplied $unapplied\
+                unapplied_list $unapplied_list\
+                insert_mode $insert_mode\
+                autowrap_mode $autowrap_mode\
+                insert_lines_above $insert_lines_above\
+                insert_lines_below $insert_lines_below\
+                cursor_saved_position $cursor_saved_position\
+                cursor_saved_attributes $cursor_saved_attributes\
+                cursor_column   $cursor_column\
+                cursor_row      $cursor_row\
+                opt_overflow    $opt_overflow\
+                replay_codes $replay_codes\
+                replay_codes_underlay $replay_codes_underlay\
+                replay_codes_overlay $replay_codes_overlay\
+            ]
+            if {$opt_returnextra == 1} {
+                return $result
+            } else {
+                #human/debug - map special chars to visual glyphs
+                set viewop VIEW
+                switch -- $opt_returnextra {
+                    2 {
+                        #codes and character data 
+                        set viewop VIEWCODES ;#ansi colorisation of codes - green for SGR, blue/blue reverse for cursor_save/cursor_restore, cyan for movements, orange for others
+                    }
+                    3 {
+                        set viewop VIEWSTYLE ;#ansi colorise the characters within the output with preceding codes, stacking codes only within each dict value - may not be same SGR effect as the effect in-situ. 
+                    }
+                }
+                tcl::dict::set result result                  [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result result]]
+                tcl::dict::set result overflow_right          [ansistring VIEW -lf 1 -vt 1 [tcl::dict::get $result overflow_right]]
+                tcl::dict::set result unapplied               [ansistring VIEW -lf 1 -vt 1 [tcl::dict::get $result unapplied]]
+                tcl::dict::set result unapplied_list          [ansistring VIEW -lf 1 -vt 1 [tcl::dict::get $result unapplied_list]]
+                tcl::dict::set result replay_codes            [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result replay_codes]]
+                tcl::dict::set result replay_codes_underlay   [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result replay_codes_underlay]]
+                tcl::dict::set result replay_codes_overlay    [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result replay_codes_overlay]]
+                tcl::dict::set result cursor_saved_attributes [ansistring $viewop -lf 1 -vt 1 [tcl::dict::get $result cursor_saved_attributes]] 
+                return $result
+            }
+        } else {
+            return $outstring
+        }
+        #return [join $out ""]
+    }
+
+    #*** !doctools
+    #[list_end] [comment {--- end definitions namespace overtype ---}]
+} 
+
+tcl::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: ?-startcolumn <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
+    }
+}
+
+
+# -- --- --- --- --- --- --- --- --- --- ---
+proc overtype::transparentline {args} {
+    foreach {under over} [lrange $args end-1 end] break
+    set argsflags [lrange $args 0 end-2]
+    set defaults [tcl::dict::create\
+        -transparent 1\
+        -exposed 1 " "\
+        -exposed 2 " "\
+    ]
+    set newargs [tcl::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.
+#
+tcl::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 
+
+#intended for single grapheme - but will work for multiple
+#cannot contain ansi or newlines 
+#(a cache of ansifreestring_width calls - as these are quite regex heavy)
+proc overtype::grapheme_width_cached {ch} {
+    variable grapheme_widths
+    if {[tcl::dict::exists $grapheme_widths $ch]} {
+        return [tcl::dict::get $grapheme_widths $ch]
+    }
+    set width [punk::char::ansifreestring_width $ch]
+    tcl::dict::set grapheme_widths $ch $width
+    return $width
+}
+
+
+
+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]
+}
+
+#maintenance warning
+#same as textblock::size - but we don't want that circular dependency
+#block width and height can be tricky. e.g \v handled differently on different terminal emulators and can affect both
+proc overtype::blocksize {textblock} {
+    if {$textblock eq ""} {
+        return [tcl::dict::create width 0 height 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
+    }
+    if {[tcl::string::first \t $textblock] >= 0} {
+        if {[info exists punk::console::tabwidth]} {
+            set tw $::punk::console::tabwidth
+        } else {
+            set tw 8
+        }
+        set textblock [textutil::tabify::untabify2 $textblock $tw]
+    }
+    #stripansi on entire block in one go rather than line by line - result should be the same - review - make tests
+    if {[punk::ansi::ta::detect $textblock]} {
+        set textblock [punk::ansi::stripansi $textblock]
+    }
+    if {[tcl::string::last \n $textblock] >= 0} {
+        set num_le [expr {[tcl::string::length $textblock]-[tcl::string::length [tcl::string::map {\n {}} $textblock]]}] ;#faster than splitting into single-char list
+        set width [tcl::mathfunc::max {*}[lmap v [split $textblock \n] {::punk::char::ansifreestring_width $v}]]
+    } else {
+        set num_le 0
+        set width [punk::char::ansifreestring_width $textblock] 
+    }
+    #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 [tcl::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
+}
+
+tcl::namespace::eval overtype::priv {
+    variable cache_is_sgr [tcl::dict::create]
+
+    #we are likely to be asking the same question of the same ansi codes repeatedly
+    #caching the answer saves some regex expense - possibly a few uS to lookup vs under 1uS
+    #todo - test if still worthwhile after a large cache is built up. (limit cache size?)
+    proc is_sgr {code} {
+        variable cache_is_sgr
+        if {[tcl::dict::exists $cache_is_sgr $code]} {
+            return [tcl::dict::get $cache_is_sgr $code]
+        } 
+        set answer [punk::ansi::codetype::is_sgr $code]
+        tcl::dict::set cache_is_sgr $code $answer
+        return $answer
+    }
+    proc render_unapplied {overlay_grapheme_control_list gci} {
+        upvar idx_over idx_over
+        upvar unapplied unapplied
+        upvar unapplied_list unapplied_list ;#maintaining as a list allows caller to utilize it without having to re-split
+        upvar overstacks overstacks
+        upvar overstacks_gx overstacks_gx
+        upvar overlay_grapheme_control_stacks og_stacks
+
+        #set unapplied [join [lrange $overlay_grapheme_control_list $gci+1 end]]
+        set unapplied ""
+        set unapplied_list [list]
+        #append unapplied [join [lindex $overstacks $idx_over] ""]
+        #append unapplied [punk::ansi::codetype::sgr_merge_list {*}[lindex $overstacks $idx_over]]
+        set sgr_merged  [punk::ansi::codetype::sgr_merge_list {*}[lindex $og_stacks $gci]]
+        if {$sgr_merged ne ""} {
+            lappend unapplied_list  $sgr_merged
+        }
+        switch -- [lindex $overstacks_gx $idx_over] {
+            "gx0_on" {
+                lappend unapplied_list "\x1b(0"
+            }
+            "gx0_off" {
+                lappend unapplied_list "\x1b(B"
+            }
+        }
+
+        foreach gc [lrange $overlay_grapheme_control_list $gci+1 end] {
+            lassign $gc type item
+            #types g other sgr gx0
+            if {$type eq "gx0"} {
+                if {$item eq "gx0_on"} {
+                    lappend unapplied_list "\x1b(0"
+                } elseif {$item eq "gx0_off"} {
+                    lappend unapplied_list "\x1b(B"
+                }
+            } else {
+                lappend unapplied_list $item
+            }
+        }
+        set unapplied [join $unapplied_list ""]
+    }
+
+    #clearer - renders the specific gci forward as unapplied - prefixed with it's merged sgr stack 
+    proc render_this_unapplied {overlay_grapheme_control_list gci} {
+        upvar idx_over idx_over
+        upvar unapplied unapplied
+        upvar unapplied_list unapplied_list
+        upvar overstacks overstacks
+        upvar overstacks_gx overstacks_gx
+        upvar overlay_grapheme_control_stacks og_stacks
+
+        #set unapplied [join [lrange $overlay_grapheme_control_list $gci+1 end]]
+        set unapplied ""
+        set unapplied_list [list]
+
+        set sgr_merged  [punk::ansi::codetype::sgr_merge_list {*}[lindex $og_stacks $gci]]
+        if {$sgr_merged ne ""} {
+            lappend unapplied_list $sgr_merged
+        }
+        switch -- [lindex $overstacks_gx $idx_over] {
+            "gx0_on" {
+                lappend unapplied_list "\x1b(0"
+            }
+            "gx0_off" {
+                lappend unapplied_list "\x1b(B"
+            }
+        }
+
+        foreach gc [lrange $overlay_grapheme_control_list $gci end] {
+            lassign $gc type item
+            #types g other sgr gx0
+            if {$type eq "gx0"} {
+                if {$item eq "gx0_on"} {
+                    lappend unapplied_list "\x1b(0"
+                } elseif {$item eq "gx0_off"} {
+                    lappend unapplied_list "\x1b(B"
+                }
+            } else {
+                lappend unapplied_list $item
+            }
+        }
+        set unapplied [join $unapplied_list ""]
+    }
+    proc render_delchar {i} {
+        upvar outcols o
+        upvar understacks ustacks
+        upvar understacks_gx gxstacks
+        set nxt [llength $o]
+        if {$i < $nxt} {
+            set o [lreplace $o $i $i]
+            set ustacks [lreplace $ustacks $i $i]
+            set gxstacks [lreplace $gxstacks $i $i]
+        } else {
+
+        }
+    }
+    proc render_erasechar {i count} {
+        upvar outcols o
+        upvar understacks ustacks
+        upvar understacks_gx gxstacks
+        #ECH clears character attributes from erased character positions
+        #ECH accepts 0 or empty parameter, which is equivalent to 1. Caller should do that mapping and only supply 1 or greater.
+        if {![tcl::string::is integer -strict $count] || $count < 1} {
+            error "render_erasechar count must be integer >= 1"
+        }
+        set start $i
+        set end [expr {$i + $count -1}]
+        #we restrict ECH to current line - as some terminals do - review - is that the only way it's implemented?
+        if {$i > [llength $o]-1} {
+            return
+        }
+        if {$end > [llength $o]-1} {
+            set end [expr {[llength $o]-1}]
+        }
+        set num [expr {$end - $start + 1}]
+        set o           [lreplace $o $start $end {*}[lrepeat $num \u0000]]  ;#or space?
+        set ustacks     [lreplace $ustacks $start $end {*}[lrepeat $num [list]]]
+        set gxstacks    [lreplace $gxstacks $start $end {*}[lrepeat $num [list]]]
+        return
+    }
+    proc render_setchar {i c } {
+        upvar outcols o
+        lset o $i $c
+    }
+    #is actually addgrapheme?
+    proc render_addchar {i c sgrstack gx0stack {insert_mode 0}} {
+        upvar outcols o
+        upvar understacks ustacks
+        upvar understacks_gx gxstacks
+
+        if 0 {
+        if {$c eq "c"} {
+            puts "i:$i c:$c sgrstack:[ansistring VIEW $sgrstack]"
+            puts "understacks:[ansistring VIEW $ustacks]"
+            upvar overstacks overstacks
+            puts "overstacks:[ansistring VIEW $overstacks]"
+            puts "info level 0:[info level 0]"
+        }
+        }
+
+        set nxt [llength $o] 
+        if {!$insert_mode} {
+            if {$i < $nxt} {
+                #These lists must always be in sync 
+                lset o $i $c
+            } else {
+                lappend o $c
+            }
+            if {$i < [llength $ustacks]} {
+                lset ustacks $i $sgrstack
+                lset gxstacks $i $gx0stack
+            } else {
+                lappend ustacks $sgrstack
+                lappend gxstacks $gx0stack
+            }
+        } else {
+            #insert of single-width vs double-width when underlying is double-width?
+            if {$i < $nxt} {
+                set o [linsert $o $i $c]
+            } else {
+                lappend o $c
+            }
+            if {$i < [llength $ustacks]} {
+                set ustacks [linsert $ustacks $i $sgrstack]
+                set gxstacks [linsert $gxstacks $i $gx0stack]
+            } else {
+                lappend ustacks $sgrstack
+                lappend gxstacks $gx0stack
+            }
+        }
+    }
+
+}
+
+
+
+# -- --- --- --- --- --- --- --- --- --- ---
+tcl::namespace::eval overtype {
+	interp alias {} ::overtype::center {} ::overtype::centre
+}
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Ready   
+package provide overtype [tcl::namespace::eval overtype {
+    variable version
+    set version 1.6.4 
+}]
+return
+
+#*** !doctools
+#[manpage_end]
diff --git a/src/vendormodules/tcltest-2.5.8.tm b/src/vendormodules/tcltest-2.5.8.tm
new file mode 100644
index 0000000..2fc5838
--- /dev/null
+++ b/src/vendormodules/tcltest-2.5.8.tm
@@ -0,0 +1,3588 @@
+# tcltest.tcl --
+#
+#	This file contains support code for the Tcl test suite.  It
+#       defines the tcltest namespace and finds and defines the output
+#       directory, constraints available, output and error channels,
+#	etc. used by Tcl tests.  See the tcltest man page for more
+#	details.
+#
+#       This design was based on the Tcl testing approach designed and
+#       initially implemented by Mary Ann May-Pumphrey of Sun
+#	Microsystems.
+#
+# Copyright © 1994-1997 Sun Microsystems, Inc.
+# Copyright © 1998-1999 Scriptics Corporation.
+# Copyright © 2000 Ajuba Solutions
+# Contributions from Don Porter, NIST, 2002.  (not subject to US copyright)
+# All rights reserved.
+
+namespace eval tcltest {
+
+    # When the version number changes, be sure to update the pkgIndex.tcl file,
+    # and the install directory in the Makefiles.  When the minor version
+    # changes (new feature) be sure to update the man page as well.
+    variable Version 2.5.8
+
+    # Compatibility support for dumb variables defined in tcltest 1
+    # Do not use these.  Call [package require] and [info patchlevel]
+    # yourself.  You don't need tcltest to wrap it for you.
+    variable version [package require Tcl 8.5-]
+    variable patchLevel [info patchlevel]
+
+    # Detect if we can use code points >= \U10000
+    variable fullutf [package vsatisfies $version 8.7-]
+
+##### Export the public tcltest procs; several categories
+    #
+    # Export the main functional commands that do useful things
+    namespace export cleanupTests loadTestedCommands makeDirectory \
+	makeFile removeDirectory removeFile runAllTests test
+
+    # Export configuration commands that control the functional commands
+    namespace export configure customMatch errorChannel interpreter \
+	    outputChannel testConstraint
+
+    # Export commands that are duplication (candidates for deprecation)
+    if {!$fullutf} {
+	namespace export bytestring	;# dups [encoding convertfrom identity]
+    }
+    namespace export debug		;#	[configure -debug]
+    namespace export errorFile		;#	[configure -errfile]
+    namespace export limitConstraints	;#	[configure -limitconstraints]
+    namespace export loadFile		;#	[configure -loadfile]
+    namespace export loadScript		;#	[configure -load]
+    namespace export match		;#	[configure -match]
+    namespace export matchFiles		;#	[configure -file]
+    namespace export matchDirectories	;#	[configure -relateddir]
+    namespace export normalizeMsg	;#	application of [customMatch]
+    namespace export normalizePath	;#	[file normalize] (8.4)
+    namespace export outputFile		;#	[configure -outfile]
+    namespace export preserveCore	;#	[configure -preservecore]
+    namespace export singleProcess	;#	[configure -singleproc]
+    namespace export skip		;#	[configure -skip]
+    namespace export skipFiles		;#	[configure -notfile]
+    namespace export skipDirectories	;#	[configure -asidefromdir]
+    namespace export temporaryDirectory	;#	[configure -tmpdir]
+    namespace export testsDirectory	;#	[configure -testdir]
+    namespace export verbose		;#	[configure -verbose]
+    namespace export viewFile		;#	binary encoding [read]
+    namespace export workingDirectory	;#	[cd] [pwd]
+
+    # Export deprecated commands for tcltest 1 compatibility
+    namespace export getMatchingFiles mainThread restoreState saveState \
+	    threadReap
+
+    # tcltest::normalizePath --
+    #
+    #     This procedure resolves any symlinks in the path thus creating
+    #     a path without internal redirection. It assumes that the
+    #     incoming path is absolute.
+    #
+    # Arguments
+    #     pathVar - name of variable containing path to modify.
+    #
+    # Results
+    #     The path is modified in place.
+    #
+    # Side Effects:
+    #     None.
+    #
+    proc normalizePath {pathVar} {
+	upvar 1 $pathVar path
+	set oldpwd [pwd]
+	catch {cd $path}
+	set path [pwd]
+	cd $oldpwd
+	return $path
+    }
+
+##### Verification commands used to test values of variables and options
+    #
+    # Verification command that accepts everything
+    proc AcceptAll {value} {
+	return $value
+    }
+
+    # Verification command that accepts valid Tcl lists
+    proc AcceptList { list } {
+	return [lrange $list 0 end]
+    }
+
+    # Verification command that accepts a glob pattern
+    proc AcceptPattern { pattern } {
+	return [AcceptAll $pattern]
+    }
+
+    # Verification command that accepts integers
+    proc AcceptInteger { level } {
+	return [incr level 0]
+    }
+
+    # Verification command that accepts boolean values
+    proc AcceptBoolean { boolean } {
+	return [expr {$boolean && $boolean}]
+    }
+
+    # Verification command that accepts (syntactically) valid Tcl scripts
+    proc AcceptScript { script } {
+	if {![info complete $script]} {
+	    return -code error "invalid Tcl script: $script"
+	}
+	return $script
+    }
+
+    # Verification command that accepts (converts to) absolute pathnames
+    proc AcceptAbsolutePath { path } {
+	return [file join [pwd] $path]
+    }
+
+    # Verification command that accepts existing readable directories
+    proc AcceptReadable { path } {
+	if {![file readable $path]} {
+	    return -code error "\"$path\" is not readable"
+	}
+	return $path
+    }
+    proc AcceptDirectory { directory } {
+	set directory [AcceptAbsolutePath $directory]
+	if {![file exists $directory]} {
+	    return -code error "\"$directory\" does not exist"
+	}
+	if {![file isdir $directory]} {
+	    return -code error "\"$directory\" is not a directory"
+	}
+	return [AcceptReadable $directory]
+    }
+
+##### Initialize internal arrays of tcltest, but only if the caller
+    # has not already preinitialized them.  This is done to support
+    # compatibility with older tests that directly access internals
+    # rather than go through command interfaces.
+    #
+    proc ArrayDefault {varName value} {
+	variable $varName
+	if {[array exists $varName]} {
+	    return
+	}
+	if {[info exists $varName]} {
+	    # Preinitialized value is a scalar:  Destroy it!
+	    unset $varName
+	}
+	array set $varName $value
+    }
+
+    # save the original environment so that it can be restored later
+    ArrayDefault originalEnv [array get ::env]
+
+    # initialize numTests array to keep track of the number of tests
+    # that pass, fail, and are skipped.
+    ArrayDefault numTests [list Total 0 Passed 0 Skipped 0 Failed 0]
+
+    # createdNewFiles will store test files as indices and the list of
+    # files (that should not have been) left behind by the test files
+    # as values.
+    ArrayDefault createdNewFiles {}
+
+    # initialize skippedBecause array to keep track of constraints that
+    # kept tests from running; a constraint name of "userSpecifiedSkip"
+    # means that the test appeared on the list of tests that matched the
+    # -skip value given to the flag; "userSpecifiedNonMatch" means that
+    # the test didn't match the argument given to the -match flag; both
+    # of these constraints are counted only if tcltest::debug is set to
+    # true.
+    ArrayDefault skippedBecause {}
+
+    # initialize the testConstraints array to keep track of valid
+    # predefined constraints (see the explanation for the
+    # InitConstraints proc for more details).
+    ArrayDefault testConstraints {}
+
+##### Initialize internal variables of tcltest, but only if the caller
+    # has not already preinitialized them.  This is done to support
+    # compatibility with older tests that directly access internals
+    # rather than go through command interfaces.
+    #
+    proc Default {varName value {verify AcceptAll}} {
+	variable $varName
+	if {![info exists $varName]} {
+	    variable $varName [$verify $value]
+	} else {
+	    variable $varName [$verify [set $varName]]
+	}
+    }
+
+    # Save any arguments that we might want to pass through to other
+    # programs.  This is used by the -args flag.
+    # FINDUSER
+    Default parameters {}
+
+    # Count the number of files tested (0 if runAllTests wasn't called).
+    # runAllTests will set testSingleFile to false, so stats will
+    # not be printed until runAllTests calls the cleanupTests proc.
+    # The currentFailure var stores the boolean value of whether the
+    # current test file has had any failures.  The failFiles list
+    # stores the names of test files that had failures.
+    Default numTestFiles 0 AcceptInteger
+    Default testSingleFile true AcceptBoolean
+    Default currentFailure false AcceptBoolean
+    Default failFiles {} AcceptList
+
+    # Tests should remove all files they create.  The test suite will
+    # check the current working dir for files created by the tests.
+    # filesMade keeps track of such files created using the makeFile and
+    # makeDirectory procedures.  filesExisted stores the names of
+    # preexisting files.
+    #
+    # Note that $filesExisted lists only those files that exist in
+    # the original [temporaryDirectory].
+    Default filesMade {} AcceptList
+    Default filesExisted {} AcceptList
+    proc FillFilesExisted {} {
+	variable filesExisted
+
+	# Save the names of files that already exist in the scratch directory.
+	foreach file [glob -nocomplain -directory [temporaryDirectory] *] {
+	    lappend filesExisted [file tail $file]
+	}
+
+	# After successful filling, turn this into a no-op.
+	proc FillFilesExisted args {}
+    }
+
+    # Kept only for compatibility
+    Default constraintsSpecified {} AcceptList
+    trace add variable constraintsSpecified read [namespace code {
+	    set constraintsSpecified [array names testConstraints] ;#}]
+
+    # tests that use threads need to know which is the main thread
+    Default mainThread 1
+    variable mainThread
+    if {[info commands thread::id] ne {}} {
+	set mainThread [thread::id]
+    } elseif {[info commands testthread] ne {}} {
+	set mainThread [testthread id]
+    }
+
+    # Set workingDirectory to [pwd]. The default output directory for
+    # Tcl tests is the working directory.  Whenever this value changes
+    # change to that directory.
+    variable workingDirectory
+    trace add variable workingDirectory write \
+	    [namespace code {cd $workingDirectory ;#}]
+
+    Default workingDirectory [pwd] AcceptAbsolutePath
+    proc workingDirectory { {dir ""} } {
+	variable workingDirectory
+	if {[llength [info level 0]] == 1} {
+	    return $workingDirectory
+	}
+	set workingDirectory [AcceptAbsolutePath $dir]
+    }
+
+    # Set the location of the execuatble
+    Default tcltest [info nameofexecutable]
+    trace add variable tcltest write [namespace code {testConstraint stdio \
+	    [eval [ConstraintInitializer stdio]] ;#}]
+
+    # save the platform information so it can be restored later
+    Default originalTclPlatform [array get ::tcl_platform]
+
+    # If a core file exists, save its modification time.
+    if {[file exists [file join [workingDirectory] core]]} {
+	Default coreModTime \
+		[file mtime [file join [workingDirectory] core]]
+    }
+
+    # stdout and stderr buffers for use when we want to store them
+    Default outData {}
+    Default errData {}
+
+    # keep track of test level for nested test commands
+    variable testLevel 0
+
+    # the variables and procedures that existed when saveState was called are
+    # stored in a variable of the same name
+    Default saveState {}
+
+    # Internationalization support -- used in [SetIso8859_1_Locale] and
+    # [RestoreLocale]. Those commands are used in cmdIL.test.
+
+    if {![info exists [namespace current]::isoLocale]} {
+	variable isoLocale fr
+	switch -- $::tcl_platform(platform) {
+	    "unix" {
+
+		# Try some 'known' values for some platforms:
+
+		switch -exact -- $::tcl_platform(os) {
+		    "FreeBSD" {
+			set isoLocale fr_FR.ISO_8859-1
+		    }
+		    HP-UX {
+			set isoLocale fr_FR.iso88591
+		    }
+		    Linux -
+		    IRIX {
+			set isoLocale fr
+		    }
+		    default {
+
+			# Works on SunOS 4 and Solaris, and maybe
+			# others...  Define it to something else on your
+			# system if you want to test those.
+
+			set isoLocale iso_8859_1
+		    }
+		}
+	    }
+	    "windows" {
+		set isoLocale French
+	    }
+	}
+    }
+
+    variable ChannelsWeOpened; array set ChannelsWeOpened {}
+    # output goes to stdout by default
+    Default outputChannel stdout
+    proc outputChannel { {filename ""} } {
+	variable outputChannel
+	variable ChannelsWeOpened
+	variable fullutf
+
+	# This is very subtle and tricky, so let me try to explain.
+	# (Hopefully this longer comment will be clear when I come
+	# back in a few months, unlike its predecessor :) )
+	#
+	# The [outputChannel] command (and underlying variable) have to
+	# be kept in sync with the [configure -outfile] configuration
+	# option ( and underlying variable Option(-outfile) ).  This is
+	# accomplished with a write trace on Option(-outfile) that will
+	# update [outputChannel] whenever a new value is written.  That
+	# much is easy.
+	#
+	# The trick is that in order to maintain compatibility with
+	# version 1 of tcltest, we must allow every configuration option
+	# to get its initial value from command line arguments.  This is
+	# accomplished by setting initial read traces on all the
+	# configuration options to parse the command line option the first
+	# time they are read.  These traces are cancelled whenever the
+	# program itself calls [configure].
+	#
+	# OK, then so to support tcltest 1 compatibility, it seems we want
+	# to get the return from [outputFile] to trigger the read traces,
+	# just in case.
+	#
+	# BUT!  A little known feature of Tcl variable traces is that
+	# traces are disabled during the handling of other traces.  So,
+	# if we trigger read traces on Option(-outfile) and that triggers
+	# command line parsing which turns around and sets an initial
+	# value for Option(-outfile) -- <whew!> -- the write trace that
+	# would keep [outputChannel] in sync with that new initial value
+	# would not fire!
+	#
+	# SO, finally, as a workaround, instead of triggering read traces
+	# by invoking [outputFile], we instead trigger the same set of
+	# read traces by invoking [debug].  Any command that reads a
+	# configuration option would do.  [debug] is just a handy one.
+	# The end result is that we support tcltest 1 compatibility and
+	# keep outputChannel and -outfile in sync in all cases.
+	debug
+
+	if {[llength [info level 0]] == 1} {
+	    return $outputChannel
+	}
+	if {[info exists ChannelsWeOpened($outputChannel)]} {
+	    close $outputChannel
+	    unset ChannelsWeOpened($outputChannel)
+	}
+	switch -exact -- $filename {
+	    stderr -
+	    stdout {
+		set outputChannel $filename
+	    }
+	    default {
+		set outputChannel [open $filename a]
+		if {$fullutf} {
+		    fconfigure $outputChannel -profile tcl8 -encoding utf-8
+		}
+		set ChannelsWeOpened($outputChannel) 1
+
+		# If we created the file in [temporaryDirectory], then
+		# [cleanupTests] will delete it, unless we claim it was
+		# already there.
+		set outdir [normalizePath [file dirname \
+			[file join [pwd] $filename]]]
+		if {$outdir eq [temporaryDirectory]} {
+		    variable filesExisted
+		    FillFilesExisted
+		    set filename [file tail $filename]
+		    if {$filename ni $filesExisted} {
+			lappend filesExisted $filename
+		    }
+		}
+	    }
+	}
+	return $outputChannel
+    }
+
+    # errors go to stderr by default
+    Default errorChannel stderr
+    proc errorChannel { {filename ""} } {
+	variable errorChannel
+	variable ChannelsWeOpened
+	variable fullutf
+
+	# This is subtle and tricky.  See the comment above in
+	# [outputChannel] for a detailed explanation.
+	debug
+
+	if {[llength [info level 0]] == 1} {
+	    return $errorChannel
+	}
+	if {[info exists ChannelsWeOpened($errorChannel)]} {
+	    close $errorChannel
+	    unset ChannelsWeOpened($errorChannel)
+	}
+	switch -exact -- $filename {
+	    stderr -
+	    stdout {
+		set errorChannel $filename
+	    }
+	    default {
+		set errorChannel [open $filename a]
+		if {$fullutf} {
+		    fconfigure $errorChannel -profile tcl8 -encoding utf-8
+		}
+		set ChannelsWeOpened($errorChannel) 1
+
+		# If we created the file in [temporaryDirectory], then
+		# [cleanupTests] will delete it, unless we claim it was
+		# already there.
+		set outdir [normalizePath [file dirname \
+			[file join [pwd] $filename]]]
+		if {$outdir eq [temporaryDirectory]} {
+		    variable filesExisted
+		    FillFilesExisted
+		    set filename [file tail $filename]
+		    if {$filename ni $filesExisted} {
+			lappend filesExisted $filename
+		    }
+		}
+	    }
+	}
+	return $errorChannel
+    }
+
+##### Set up the configurable options
+    #
+    # The configurable options of the package
+    variable Option; array set Option {}
+
+    # Usage strings for those options
+    variable Usage; array set Usage {}
+
+    # Verification commands for those options
+    variable Verify; array set Verify {}
+
+    # Initialize the default values of the configurable options that are
+    # historically associated with an exported variable.  If that variable
+    # is already set, support compatibility by accepting its preset value.
+    # Use [trace] to establish ongoing connection between the deprecated
+    # exported variable and the modern option kept as a true internal var.
+    # Also set up usage string and value testing for the option.
+    proc Option {option value usage {verify AcceptAll} {varName {}}} {
+	variable Option
+	variable Verify
+	variable Usage
+	variable OptionControlledVariables
+	variable DefaultValue
+	set Usage($option) $usage
+	set Verify($option) $verify
+	set DefaultValue($option) $value
+	if {[catch {$verify $value} msg]} {
+	    return -code error $msg
+	} else {
+	    set Option($option) $msg
+	}
+	if {[string length $varName]} {
+	    variable $varName
+	    if {[info exists $varName]} {
+		if {[catch {$verify [set $varName]} msg]} {
+		    return -code error $msg
+		} else {
+		    set Option($option) $msg
+		}
+		unset $varName
+	    }
+	    namespace eval [namespace current] \
+	    	    [list upvar 0 Option($option) $varName]
+	    # Workaround for Bug (now Feature Request) 572889.  Grrrr....
+	    # Track all the variables tied to options
+	    lappend OptionControlledVariables $varName
+	    # Later, set auto-configure read traces on all
+	    # of them, since a single trace on Option does not work.
+	    proc $varName {{value {}}} [subst -nocommands {
+		if {[llength [info level 0]] == 2} {
+		    Configure $option [set value]
+		}
+		return [Configure $option]
+	    }]
+	}
+    }
+
+    proc MatchingOption {option} {
+	variable Option
+	set match [array names Option $option*]
+	switch -- [llength $match] {
+	    0 {
+		set sorted [lsort [array names Option]]
+		set values [join [lrange $sorted 0 end-1] ", "]
+		append values ", or [lindex $sorted end]"
+		return -code error "unknown option $option: should be\
+			one of $values"
+	    }
+	    1 {
+		return [lindex $match 0]
+	    }
+	    default {
+		# Exact match trumps ambiguity
+		if {$option in $match} {
+		    return $option
+		}
+		set values [join [lrange $match 0 end-1] ", "]
+		append values ", or [lindex $match end]"
+		return -code error "ambiguous option $option:\
+			could match $values"
+	    }
+	}
+    }
+
+    proc EstablishAutoConfigureTraces {} {
+	variable OptionControlledVariables
+	foreach varName [concat $OptionControlledVariables Option] {
+	    variable $varName
+	    trace add variable $varName read [namespace code {
+		    ProcessCmdLineArgs ;#}]
+	}
+    }
+
+    proc RemoveAutoConfigureTraces {} {
+	variable OptionControlledVariables
+	foreach varName [concat $OptionControlledVariables Option] {
+	    variable $varName
+	    foreach pair [trace info variable $varName] {
+		lassign $pair op cmd
+		if {($op eq "read") &&
+			[string match *ProcessCmdLineArgs* $cmd]} {
+		    trace remove variable $varName $op $cmd
+		}
+	    }
+	}
+	# Once the traces are removed, this can become a no-op
+	proc RemoveAutoConfigureTraces {} {}
+    }
+
+    proc Configure args {
+	variable Option
+	variable Verify
+	set n [llength $args]
+	if {$n == 0} {
+	    return [lsort [array names Option]]
+	}
+	if {$n == 1} {
+	    if {[catch {MatchingOption [lindex $args 0]} option]} {
+		return -code error $option
+	    }
+	    return $Option($option)
+	}
+	while {[llength $args] > 1} {
+	    if {[catch {MatchingOption [lindex $args 0]} option]} {
+		return -code error $option
+	    }
+	    if {[catch {$Verify($option) [lindex $args 1]} value]} {
+		return -code error "invalid $option\
+			value \"[lindex $args 1]\": $value"
+	    }
+	    set Option($option) $value
+	    set args [lrange $args 2 end]
+	}
+	if {[llength $args]} {
+	    if {[catch {MatchingOption [lindex $args 0]} option]} {
+		return -code error $option
+	    }
+	    return -code error "missing value for option $option"
+	}
+    }
+    proc configure args {
+	if {[llength $args] > 1} {
+	    RemoveAutoConfigureTraces
+	}
+	set code [catch {Configure {*}$args} msg]
+	return -code $code $msg
+    }
+
+    proc AcceptVerbose { level } {
+	set level [AcceptList $level]
+	set levelMap {
+	    l list
+	    p pass
+	    b body
+	    s skip
+	    t start
+	    e error
+	    l line
+	    m msec
+	    u usec
+	}
+	set levelRegexp "^([join [dict values $levelMap] |])\$"
+	if {[llength $level] == 1} {
+	    if {![regexp $levelRegexp $level]} {
+		# translate single characters abbreviations to expanded list
+		set level [string map $levelMap [split $level {}]]
+	    }
+	}
+	set valid [list]
+	foreach v $level {
+	    if {[regexp $levelRegexp $v]} {
+		lappend valid $v
+	    }
+	}
+	return $valid
+    }
+
+    proc IsVerbose {level} {
+	variable Option
+	return [expr {$level in $Option(-verbose)}]
+    }
+
+    # Default verbosity is to show bodies of failed tests
+    Option -verbose {body error} {
+	Takes any combination of the values 'p', 's', 'b', 't', 'e' and 'l'.
+	Test suite will display all passed tests if 'p' is specified, all
+	skipped tests if 's' is specified, the bodies of failed tests if
+	'b' is specified, and when tests start if 't' is specified.
+	ErrorInfo is displayed if 'e' is specified. Source file line
+	information of failed tests is displayed if 'l' is specified.
+    } AcceptVerbose verbose
+
+    # Match and skip patterns default to the empty list, except for
+    # matchFiles, which defaults to all .test files in the
+    # testsDirectory and matchDirectories, which defaults to all
+    # directories.
+    Option -match * {
+	Run all tests within the specified files that match one of the
+	list of glob patterns given.
+    } AcceptList match
+
+    Option -skip {} {
+	Skip all tests within the specified tests (via -match) and files
+	that match one of the list of glob patterns given.
+    } AcceptList skip
+
+    Option -file *.test {
+	Run tests in all test files that match the glob pattern given.
+    } AcceptPattern matchFiles
+
+    # By default, skip files that appear to be SCCS lock files.
+    Option -notfile l.*.test {
+	Skip all test files that match the glob pattern given.
+    } AcceptPattern skipFiles
+
+    Option -relateddir * {
+	Run tests in directories that match the glob pattern given.
+    } AcceptPattern matchDirectories
+
+    Option -asidefromdir {} {
+	Skip tests in directories that match the glob pattern given.
+    } AcceptPattern skipDirectories
+
+    # By default, don't save core files
+    Option -preservecore 0 {
+	If 2, save any core files produced during testing in the directory
+	specified by -tmpdir. If 1, notify the user if core files are
+	created.
+    } AcceptInteger preserveCore
+
+    # debug output doesn't get printed by default; debug level 1 spits
+    # up only the tests that were skipped because they didn't match or
+    # were specifically skipped.  A debug level of 2 would spit up the
+    # tcltest variables and flags provided; a debug level of 3 causes
+    # some additional output regarding operations of the test harness.
+    # The tcltest package currently implements only up to debug level 3.
+    Option -debug 0 {
+	Internal debug level
+    } AcceptInteger debug
+
+    proc SetSelectedConstraints args {
+	variable Option
+	foreach c $Option(-constraints) {
+	    testConstraint $c 1
+	}
+    }
+    Option -constraints {} {
+	Do not skip the listed constraints listed in -constraints.
+    } AcceptList
+    trace add variable Option(-constraints) write \
+	    [namespace code {SetSelectedConstraints ;#}]
+
+    # Don't run only the "-constraint" specified tests by default
+    proc ClearUnselectedConstraints args {
+	variable Option
+	variable testConstraints
+	if {!$Option(-limitconstraints)} {return}
+	foreach c [array names testConstraints] {
+	    if {$c ni $Option(-constraints)} {
+		testConstraint $c 0
+	    }
+	}
+    }
+    Option -limitconstraints 0 {
+	whether to run only tests with the constraints
+    } AcceptBoolean limitConstraints
+    trace add variable Option(-limitconstraints) write \
+	    [namespace code {ClearUnselectedConstraints ;#}]
+
+    # A test application has to know how to load the tested commands
+    # into the interpreter.
+    Option -load {} {
+	Specifies the script to load the tested commands.
+    } AcceptScript loadScript
+
+    # Default is to run each test file in a separate process
+    Option -singleproc 0 {
+	whether to run all tests in one process
+    } AcceptBoolean singleProcess
+
+    proc AcceptTemporaryDirectory { directory } {
+	set directory [AcceptAbsolutePath $directory]
+	if {![file exists $directory]} {
+	    file mkdir $directory
+	}
+	set directory [AcceptDirectory $directory]
+	if {![file writable $directory]} {
+	    if {[workingDirectory] eq $directory} {
+		# Special exception: accept the default value
+		# even if the directory is not writable
+		return $directory
+	    }
+	    return -code error "\"$directory\" is not writable"
+	}
+	return $directory
+    }
+
+    # Directory where files should be created
+    Option -tmpdir [workingDirectory] {
+	Save temporary files in the specified directory.
+    } AcceptTemporaryDirectory temporaryDirectory
+    trace add variable Option(-tmpdir) write \
+	    [namespace code {normalizePath Option(-tmpdir) ;#}]
+
+    # Tests should not rely on the current working directory.
+    # Files that are part of the test suite should be accessed relative
+    # to [testsDirectory]
+    Option -testdir [workingDirectory] {
+	Search tests in the specified directory.
+    } AcceptDirectory testsDirectory
+    trace add variable Option(-testdir) write \
+	    [namespace code {normalizePath Option(-testdir) ;#}]
+
+    proc AcceptLoadFile { file } {
+	if {$file eq {}} {return $file}
+	set file [file join [temporaryDirectory] $file]
+	return [AcceptReadable $file]
+    }
+    proc ReadLoadScript {args} {
+	variable Option
+	variable fullutf
+
+	if {$Option(-loadfile) eq {}} {return}
+	set tmp [open $Option(-loadfile) r]
+	if {$fullutf} {
+	    fconfigure $tmp -profile tcl8 -encoding utf-8
+	}
+	loadScript [read $tmp]
+	close $tmp
+    }
+    Option -loadfile {} {
+	Read the script to load the tested commands from the specified file.
+    } AcceptLoadFile loadFile
+    trace add variable Option(-loadfile) write [namespace code ReadLoadScript]
+
+    proc AcceptOutFile { file } {
+	if {[string equal stderr $file]} {return $file}
+	if {[string equal stdout $file]} {return $file}
+	return [file join [temporaryDirectory] $file]
+    }
+
+    # output goes to stdout by default
+    Option -outfile stdout {
+	Send output from test runs to the specified file.
+    } AcceptOutFile outputFile
+    trace add variable Option(-outfile) write \
+	    [namespace code {outputChannel $Option(-outfile) ;#}]
+
+    # errors go to stderr by default
+    Option -errfile stderr {
+	Send errors from test runs to the specified file.
+    } AcceptOutFile errorFile
+    trace add variable Option(-errfile) write \
+	    [namespace code {errorChannel $Option(-errfile) ;#}]
+
+    proc loadIntoChildInterpreter {child args} {
+	variable Version
+	interp eval $child [package ifneeded tcltest $Version]
+	interp eval $child "tcltest::configure {*}{$args}"
+	interp alias $child ::tcltest::ReportToParent \
+	    {} ::tcltest::ReportedFromChild
+    }
+    proc ReportedFromChild {total passed skipped failed because newfiles} {
+	variable numTests
+	variable skippedBecause
+	variable createdNewFiles
+	incr numTests(Total)   $total
+	incr numTests(Passed)  $passed
+	incr numTests(Skipped) $skipped
+	incr numTests(Failed)  $failed
+	foreach {constraint count} $because {
+	    incr skippedBecause($constraint) $count
+	}
+	foreach {testfile created} $newfiles {
+	    lappend createdNewFiles($testfile) {*}$created
+	}
+	return
+    }
+}
+
+#####################################################################
+
+# tcltest::Debug* --
+#
+#     Internal helper procedures to write out debug information
+#     dependent on the chosen level. A test shell may override
+#     them, f.e. to redirect the output into a different
+#     channel, or even into a GUI.
+
+# tcltest::DebugPuts --
+#
+#     Prints the specified string if the current debug level is
+#     higher than the provided level argument.
+#
+# Arguments:
+#     level   The lowest debug level triggering the output
+#     string  The string to print out.
+#
+# Results:
+#     Prints the string. Nothing else is allowed.
+#
+# Side Effects:
+#     None.
+#
+
+proc tcltest::DebugPuts {level string} {
+    variable debug
+    if {$debug >= $level} {
+	puts $string
+    }
+    return
+}
+
+# tcltest::DebugPArray --
+#
+#     Prints the contents of the specified array if the current
+#       debug level is higher than the provided level argument
+#
+# Arguments:
+#     level           The lowest debug level triggering the output
+#     arrayvar        The name of the array to print out.
+#
+# Results:
+#     Prints the contents of the array. Nothing else is allowed.
+#
+# Side Effects:
+#     None.
+#
+
+proc tcltest::DebugPArray {level arrayvar} {
+    variable debug
+
+    if {$debug >= $level} {
+	catch {upvar 1 $arrayvar $arrayvar}
+	parray $arrayvar
+    }
+    return
+}
+
+# Define our own [parray] in ::tcltest that will inherit use of the [puts]
+# defined in ::tcltest.  NOTE: Ought to construct with [info args] and
+# [info default], but can't be bothered now.  If [parray] changes, then
+# this will need changing too.
+auto_load ::parray
+proc tcltest::parray {a {pattern *}} [info body ::parray]
+
+# tcltest::DebugDo --
+#
+#     Executes the script if the current debug level is greater than
+#       the provided level argument
+#
+# Arguments:
+#     level   The lowest debug level triggering the execution.
+#     script  The tcl script executed upon a debug level high enough.
+#
+# Results:
+#     Arbitrary side effects, dependent on the executed script.
+#
+# Side Effects:
+#     None.
+#
+
+proc tcltest::DebugDo {level script} {
+    variable debug
+
+    if {$debug >= $level} {
+	uplevel 1 $script
+    }
+    return
+}
+
+#####################################################################
+
+proc tcltest::Warn {msg} {
+    puts [outputChannel] "WARNING: $msg"
+}
+
+# tcltest::mainThread
+#
+#     Accessor command for tcltest variable mainThread.
+#
+proc tcltest::mainThread { {new ""} } {
+    variable mainThread
+    if {[llength [info level 0]] == 1} {
+	return $mainThread
+    }
+    set mainThread $new
+}
+
+# tcltest::testConstraint --
+#
+#	sets a test constraint to a value; to do multiple constraints,
+#       call this proc multiple times.  also returns the value of the
+#       named constraint if no value was supplied.
+#
+# Arguments:
+#	constraint - name of the constraint
+#       value - new value for constraint (should be boolean) - if not
+#               supplied, this is a query
+#
+# Results:
+#	content of tcltest::testConstraints($constraint)
+#
+# Side effects:
+#	none
+
+proc tcltest::testConstraint {constraint {value ""}} {
+    variable testConstraints
+    variable Option
+    DebugPuts 3 "entering testConstraint $constraint $value"
+    if {[llength [info level 0]] == 2} {
+	return $testConstraints($constraint)
+    }
+    # Check for boolean values
+    if {[catch {expr {$value && 1}} msg]} {
+	return -code error $msg
+    }
+    if {[limitConstraints] && ($constraint ni $Option(-constraints))} {
+	set value 0
+    }
+    set testConstraints($constraint) $value
+}
+
+# tcltest::interpreter --
+#
+#	the interpreter name stored in tcltest::tcltest
+#
+# Arguments:
+#	executable name
+#
+# Results:
+#	content of tcltest::tcltest
+#
+# Side effects:
+#	None.
+
+proc tcltest::interpreter { {interp ""} } {
+    variable tcltest
+    if {[llength [info level 0]] == 1} {
+	return $tcltest
+    }
+    set tcltest $interp
+}
+
+#####################################################################
+
+# tcltest::AddToSkippedBecause --
+#
+#	Increments the variable used to track how many tests were
+#       skipped because of a particular constraint.
+#
+# Arguments:
+#	constraint     The name of the constraint to be modified
+#
+# Results:
+#	Modifies tcltest::skippedBecause; sets the variable to 1 if
+#       didn't previously exist - otherwise, it just increments it.
+#
+# Side effects:
+#	None.
+
+proc tcltest::AddToSkippedBecause { constraint {value 1}} {
+    # add the constraint to the list of constraints that kept tests
+    # from running
+    variable skippedBecause
+
+    if {[info exists skippedBecause($constraint)]} {
+	incr skippedBecause($constraint) $value
+    } else {
+	set skippedBecause($constraint) $value
+    }
+    return
+}
+
+# tcltest::PrintError --
+#
+#	Prints errors to tcltest::errorChannel and then flushes that
+#       channel, making sure that all messages are < 80 characters per
+#       line.
+#
+# Arguments:
+#	errorMsg     String containing the error to be printed
+#
+# Results:
+#	None.
+#
+# Side effects:
+#	None.
+
+proc tcltest::PrintError {errorMsg} {
+    set InitialMessage "Error:  "
+    set InitialMsgLen  [string length $InitialMessage]
+    puts -nonewline [errorChannel] $InitialMessage
+
+    # Keep track of where the end of the string is.
+    set endingIndex [string length $errorMsg]
+
+    if {$endingIndex < (80 - $InitialMsgLen)} {
+	puts [errorChannel] $errorMsg
+    } else {
+	# Print up to 80 characters on the first line, including the
+	# InitialMessage.
+	set beginningIndex [string last " " [string range $errorMsg 0 \
+		[expr {80 - $InitialMsgLen}]]]
+	puts [errorChannel] [string range $errorMsg 0 $beginningIndex]
+
+	while {$beginningIndex ne "end"} {
+	    puts -nonewline [errorChannel] \
+		    [string repeat " " $InitialMsgLen]
+	    if {($endingIndex - $beginningIndex)
+		    < (80 - $InitialMsgLen)} {
+		puts [errorChannel] [string trim \
+			[string range $errorMsg $beginningIndex end]]
+		break
+	    } else {
+		set newEndingIndex [expr {[string last " " \
+			[string range $errorMsg $beginningIndex \
+				[expr {$beginningIndex
+					+ (80 - $InitialMsgLen)}]
+		]] + $beginningIndex}]
+		if {($newEndingIndex <= 0)
+			|| ($newEndingIndex <= $beginningIndex)} {
+		    set newEndingIndex end
+		}
+		puts [errorChannel] [string trim \
+			[string range $errorMsg \
+			    $beginningIndex $newEndingIndex]]
+		set beginningIndex $newEndingIndex
+	    }
+	}
+    }
+    flush [errorChannel]
+    return
+}
+
+# tcltest::SafeFetch --
+#
+#	 The following trace procedure makes it so that we can safely
+#        refer to non-existent members of the testConstraints array
+#        without causing an error.  Instead, reading a non-existent
+#        member will return 0. This is necessary because tests are
+#        allowed to use constraint "X" without ensuring that
+#        testConstraints("X") is defined.
+#
+# Arguments:
+#	n1 - name of the array (testConstraints)
+#       n2 - array key value (constraint name)
+#       op - operation performed on testConstraints (generally r)
+#
+# Results:
+#	none
+#
+# Side effects:
+#	sets testConstraints($n2) to 0 if it's referenced but never
+#       before used
+
+proc tcltest::SafeFetch {n1 n2 op} {
+    variable testConstraints
+    DebugPuts 3 "entering SafeFetch $n1 $n2 $op"
+    if {$n2 eq {}} {return}
+    if {![info exists testConstraints($n2)]} {
+	if {[catch {testConstraint $n2 [eval [ConstraintInitializer $n2]]}]} {
+	    testConstraint $n2 0
+	}
+    }
+}
+
+# tcltest::Asciify --
+#
+#       Transforms the passed string to contain only printable ascii characters.
+#       Useful for printing to terminals. Non-printables are mapped to
+#       \x, \u or \U sequences, except \n.
+#
+# Arguments:
+#       s - string to transform
+#
+# Results:
+#       The transformed strings
+#
+# Side effects:
+#       None.
+
+proc tcltest::Asciify {s} {
+    set print ""
+    foreach c [split $s ""] {
+        if {(($c < "\x7F") && [string is print $c]) || ($c eq "\n")} {
+            append print $c
+        } elseif {$c < "\u0100"} {
+            append print \\x[format %02X [scan $c %c]]
+        } elseif {$c > "\uFFFF"} {
+            append print \\U[format %08X [scan $c %c]]
+        } else {
+            append print \\u[format %04X [scan $c %c]]
+        }
+    }
+    return $print
+}
+
+# tcltest::ConstraintInitializer --
+#
+#	Get or set a script that when evaluated in the tcltest namespace
+#	will return a boolean value with which to initialize the
+#	associated constraint.
+#
+# Arguments:
+#	constraint - name of the constraint initialized by the script
+#	script - the initializer script
+#
+# Results
+#	boolean value of the constraint - enabled or disabled
+#
+# Side effects:
+#	Constraint is initialized for future reference by [test]
+proc tcltest::ConstraintInitializer {constraint {script ""}} {
+    variable ConstraintInitializer
+    DebugPuts 3 "entering ConstraintInitializer $constraint $script"
+    if {[llength [info level 0]] == 2} {
+	return $ConstraintInitializer($constraint)
+    }
+    # Check for boolean values
+    if {![info complete $script]} {
+	return -code error "ConstraintInitializer must be complete script"
+    }
+    set ConstraintInitializer($constraint) $script
+}
+
+# tcltest::InitConstraints --
+#
+# Call all registered constraint initializers to force initialization
+# of all known constraints.
+# See the tcltest man page for the list of built-in constraints defined
+# in this procedure.
+#
+# Arguments:
+#	none
+#
+# Results:
+#	The testConstraints array is reset to have an index for each
+#	built-in test constraint.
+#
+# Side Effects:
+#       None.
+#
+
+proc tcltest::InitConstraints {} {
+    variable ConstraintInitializer
+    initConstraintsHook
+    foreach constraint [array names ConstraintInitializer] {
+	testConstraint $constraint
+    }
+}
+
+proc tcltest::DefineConstraintInitializers {} {
+    ConstraintInitializer singleTestInterp {singleProcess}
+
+    # All the 'pc' constraints are here for backward compatibility and
+    # are not documented.  They have been replaced with equivalent 'win'
+    # constraints.
+
+    ConstraintInitializer unixOnly \
+	    {string equal $::tcl_platform(platform) unix}
+    ConstraintInitializer macOnly \
+	    {string equal $::tcl_platform(platform) macintosh}
+    ConstraintInitializer pcOnly \
+	    {string equal $::tcl_platform(platform) windows}
+    ConstraintInitializer winOnly \
+	    {string equal $::tcl_platform(platform) windows}
+
+    ConstraintInitializer unix {testConstraint unixOnly}
+    ConstraintInitializer mac {testConstraint macOnly}
+    ConstraintInitializer pc {testConstraint pcOnly}
+    ConstraintInitializer win {testConstraint winOnly}
+
+    ConstraintInitializer unixOrPc \
+	    {expr {[testConstraint unix] || [testConstraint pc]}}
+    ConstraintInitializer macOrPc \
+	    {expr {[testConstraint mac] || [testConstraint pc]}}
+    ConstraintInitializer unixOrWin \
+	    {expr {[testConstraint unix] || [testConstraint win]}}
+    ConstraintInitializer macOrWin \
+	    {expr {[testConstraint mac] || [testConstraint win]}}
+    ConstraintInitializer macOrUnix \
+	    {expr {[testConstraint mac] || [testConstraint unix]}}
+
+    ConstraintInitializer nt {string equal $::tcl_platform(os) "Windows NT"}
+    ConstraintInitializer 95 {string equal $::tcl_platform(os) "Windows 95"}
+    ConstraintInitializer 98 {string equal $::tcl_platform(os) "Windows 98"}
+
+    # The following Constraints switches are used to mark tests that
+    # should work, but have been temporarily disabled on certain
+    # platforms because they don't and we haven't gotten around to
+    # fixing the underlying problem.
+
+    ConstraintInitializer tempNotPc {expr {![testConstraint pc]}}
+    ConstraintInitializer tempNotWin {expr {![testConstraint win]}}
+    ConstraintInitializer tempNotMac {expr {![testConstraint mac]}}
+    ConstraintInitializer tempNotUnix {expr {![testConstraint unix]}}
+
+    # The following Constraints switches are used to mark tests that
+    # crash on certain platforms, so that they can be reactivated again
+    # when the underlying problem is fixed.
+
+    ConstraintInitializer pcCrash {expr {![testConstraint pc]}}
+    ConstraintInitializer winCrash {expr {![testConstraint win]}}
+    ConstraintInitializer macCrash {expr {![testConstraint mac]}}
+    ConstraintInitializer unixCrash {expr {![testConstraint unix]}}
+
+    # Skip empty tests
+
+    ConstraintInitializer emptyTest {expr 0}
+
+    # By default, tests that expose known bugs are skipped.
+
+    ConstraintInitializer knownBug {expr 0}
+
+    # By default, non-portable tests are skipped.
+
+    ConstraintInitializer nonPortable {expr 0}
+
+    # By default, extremely slow, extensive or IO-aggressive tests are skipped.
+
+    ConstraintInitializer extensive {expr 0}
+
+    # Some tests require user interaction.
+
+    ConstraintInitializer userInteraction {expr 0}
+
+    # Some tests must be skipped if the interpreter is not in
+    # interactive mode
+
+    ConstraintInitializer interactive \
+	    {expr {[info exists ::tcl_interactive] && $::tcl_interactive}}
+
+    # Some tests can only be run if the installation came from a CD
+    # image instead of a web image.  Some tests must be skipped if you
+    # are running as root on Unix.  Other tests can only be run if you
+    # are running as root on Unix.
+
+    ConstraintInitializer root {expr \
+	    {($::tcl_platform(platform) eq "unix") &&
+		    ($::tcl_platform(user) in {root {}})}}
+    ConstraintInitializer notRoot {expr {![testConstraint root]}}
+
+    # Set nonBlockFiles constraint: 1 means this platform supports
+    # setting files into nonblocking mode.
+
+    ConstraintInitializer nonBlockFiles {
+	    set code [expr {[catch {set f [open defs r]}]
+		    || [catch {fconfigure $f -blocking off}]}]
+	    catch {close $f}
+	    set code
+    }
+
+    # Set asyncPipeClose constraint: 1 means this platform supports
+    # async flush and async close on a pipe.
+    #
+    # Test for SCO Unix - cannot run async flushing tests because a
+    # potential problem with select is apparently interfering.
+    # (Mark Diekhans).
+
+    ConstraintInitializer asyncPipeClose {expr {
+	    !([string equal unix $::tcl_platform(platform)]
+	    && ([catch {exec uname -X | fgrep {Release = 3.2v}}] == 0))}}
+
+    # Test to see if we have a broken version of sprintf with respect
+    # to the "e" format of floating-point numbers.
+
+    ConstraintInitializer eformat {string equal [format %g 5e-5] 5e-05}
+
+    # Test to see if execed commands such as cat, echo, rm and so forth
+    # are present on this machine.
+
+    ConstraintInitializer unixExecs {
+	set code 1
+        if {$::tcl_platform(platform) eq "macintosh"} {
+	    set code 0
+        }
+        if {$::tcl_platform(platform) eq "windows"} {
+	    if {[catch {
+	        set file _tcl_test_remove_me.txt
+	        makeFile {hello} $file
+	    }]} {
+	        set code 0
+	    } elseif {
+	        [catch {exec cat $file}] ||
+	        [catch {exec echo hello}] ||
+	        [catch {exec sh -c echo hello}] ||
+	        [catch {exec wc $file}] ||
+	        [catch {exec sleep 1}] ||
+	        [catch {exec echo abc > $file}] ||
+	        [catch {exec chmod 644 $file}] ||
+	        [catch {exec rm $file}] ||
+	        [llength [auto_execok mkdir]] == 0 ||
+	        [llength [auto_execok fgrep]] == 0 ||
+	        [llength [auto_execok grep]] == 0 ||
+	        [llength [auto_execok ps]] == 0
+	    } {
+	        set code 0
+	    }
+	    removeFile $file
+        }
+	set code
+    }
+
+    ConstraintInitializer stdio {
+	variable fullutf
+
+	set code 0
+	if {![catch {set f [open "|[list [interpreter]]" w]}]} {
+	    if {$fullutf} {
+		fconfigure $f -profile tcl8 -encoding utf-8
+	    }
+	    if {![catch {puts $f exit}]} {
+		if {![catch {close $f}]} {
+		    set code 1
+		}
+	    }
+	}
+	set code
+    }
+
+    # Deliberately call socket with the wrong number of arguments.  The
+    # error message you get will indicate whether sockets are available
+    # on this system.
+
+    ConstraintInitializer socket {
+	catch {socket} msg
+	string compare $msg "sockets are not available on this system"
+    }
+
+    # Check for internationalization
+    ConstraintInitializer hasIsoLocale {
+	if {[llength [info commands testlocale]] == 0} {
+	    set code 0
+	} else {
+	    set code [string length [SetIso8859_1_Locale]]
+	    RestoreLocale
+	}
+	set code
+    }
+
+}
+#####################################################################
+
+# Usage and command line arguments processing.
+
+# tcltest::PrintUsageInfo
+#
+#	Prints out the usage information for package tcltest.  This can
+#	be customized with the redefinition of [PrintUsageInfoHook].
+#
+# Arguments:
+#	none
+#
+# Results:
+#       none
+#
+# Side Effects:
+#       none
+proc tcltest::PrintUsageInfo {} {
+    puts [Usage]
+    PrintUsageInfoHook
+}
+
+proc tcltest::Usage { {option ""} } {
+    variable Usage
+    variable Verify
+    if {[llength [info level 0]] == 1} {
+	set msg "Usage: [file tail [info nameofexecutable]] script "
+	append msg "?-help? ?flag value? ... \n"
+	append msg "Available flags (and valid input values) are:"
+
+	set max 0
+	set allOpts [concat -help [Configure]]
+	foreach opt $allOpts {
+	    set foo [Usage $opt]
+	    lassign $foo x type($opt) usage($opt)
+	    set line($opt) "  $opt $type($opt)  "
+	    set length($opt) [string length $line($opt)]
+	    if {$length($opt) > $max} {set max $length($opt)}
+	}
+	set rest [expr {72 - $max}]
+	foreach opt $allOpts {
+	    append msg \n$line($opt)
+	    append msg [string repeat " " [expr {$max - $length($opt)}]]
+	    set u [string trim $usage($opt)]
+	    catch {append u "  (default: \[[Configure $opt]])"}
+	    regsub -all {\s*\n\s*} $u " " u
+	    while {[string length $u] > $rest} {
+		set break [string wordstart $u $rest]
+		if {$break == 0} {
+		    set break [string wordend $u 0]
+		}
+		append msg [string range $u 0 [expr {$break - 1}]]
+		set u [string trim [string range $u $break end]]
+		append msg \n[string repeat " " $max]
+	    }
+	    append msg $u
+	}
+	return $msg\n
+    } elseif {$option eq "-help"} {
+	return [list -help "" "Display this usage information."]
+    } else {
+	set type [lindex [info args $Verify($option)] 0]
+	return [list $option $type $Usage($option)]
+    }
+}
+
+# tcltest::ProcessFlags --
+#
+#	process command line arguments supplied in the flagArray - this
+#	is called by processCmdLineArgs.  Modifies tcltest variables
+#	according to the content of the flagArray.
+#
+# Arguments:
+#	flagArray - array containing name/value pairs of flags
+#
+# Results:
+#	sets tcltest variables according to their values as defined by
+#       flagArray
+#
+# Side effects:
+#	None.
+
+proc tcltest::ProcessFlags {flagArray} {
+    # Process -help first
+    if {"-help" in $flagArray} {
+	PrintUsageInfo
+	exit 1
+    }
+
+    if {[llength $flagArray] == 0} {
+	RemoveAutoConfigureTraces
+    } else {
+	set args $flagArray
+	while {[llength $args] > 1 && [catch {configure {*}$args} msg]} {
+
+	    # Something went wrong parsing $args for tcltest options
+	    # Check whether the problem is "unknown option"
+	    if {[regexp {^unknown option (\S+):} $msg -> option]} {
+		# Could be this is an option the Hook knows about
+		set moreOptions [processCmdLineArgsAddFlagsHook]
+		if {$option ni $moreOptions} {
+		    # Nope.  Report the error, including additional options,
+		    # but keep going
+		    if {[llength $moreOptions]} {
+			append msg ", "
+			append msg [join [lrange $moreOptions 0 end-1] ", "]
+			append msg "or [lindex $moreOptions end]"
+		    }
+		    Warn $msg
+		}
+	    } else {
+		# error is something other than "unknown option"
+		# notify user of the error; and exit
+		puts [errorChannel] $msg
+		exit 1
+	    }
+
+	    # To recover, find that unknown option and remove up to it.
+	    # then retry
+	    while {[lindex $args 0] ne $option} {
+		set args [lrange $args 2 end]
+	    }
+	    set args [lrange $args 2 end]
+	}
+	if {[llength $args] == 1} {
+	    puts [errorChannel] \
+		    "missing value for option [lindex $args 0]"
+	    exit 1
+	}
+    }
+
+    # Call the hook
+    catch {
+        array set flag $flagArray
+        processCmdLineArgsHook [array get flag]
+    }
+    return
+}
+
+# tcltest::ProcessCmdLineArgs --
+#
+#       This procedure must be run after constraint initialization is
+#	set up (by [DefineConstraintInitializers]) because some constraints
+#	can be overridden.
+#
+#       Perform configuration according to the command-line options.
+#
+# Arguments:
+#	none
+#
+# Results:
+#	Sets the above-named variables in the tcltest namespace.
+#
+# Side Effects:
+#       None.
+#
+
+proc tcltest::ProcessCmdLineArgs {} {
+    variable originalEnv
+    variable testConstraints
+
+    # The "argv" var doesn't exist in some cases, so use {}.
+    if {![info exists ::argv]} {
+	ProcessFlags {}
+    } else {
+	ProcessFlags $::argv
+    }
+
+    # Spit out everything you know if we're at a debug level 2 or
+    # greater
+    DebugPuts 2 "Flags passed into tcltest:"
+    if {[info exists ::env(TCLTEST_OPTIONS)]} {
+	DebugPuts 2 \
+		"    ::env(TCLTEST_OPTIONS): $::env(TCLTEST_OPTIONS)"
+    }
+    if {[info exists ::argv]} {
+	DebugPuts 2 "    argv: $::argv"
+    }
+    DebugPuts    2 "tcltest::debug              = [debug]"
+    DebugPuts    2 "tcltest::testsDirectory     = [testsDirectory]"
+    DebugPuts    2 "tcltest::workingDirectory   = [workingDirectory]"
+    DebugPuts    2 "tcltest::temporaryDirectory = [temporaryDirectory]"
+    DebugPuts    2 "tcltest::outputChannel      = [outputChannel]"
+    DebugPuts    2 "tcltest::errorChannel       = [errorChannel]"
+    DebugPuts    2 "Original environment (tcltest::originalEnv):"
+    DebugPArray  2 originalEnv
+    DebugPuts    2 "Constraints:"
+    DebugPArray  2 testConstraints
+}
+
+#####################################################################
+
+# Code to run the tests goes here.
+
+# tcltest::TestPuts --
+#
+#	Used to redefine puts in test environment.  Stores whatever goes
+#	out on stdout in tcltest::outData and stderr in errData before
+#	sending it on to the regular puts.
+#
+# Arguments:
+#	same as standard puts
+#
+# Results:
+#	none
+#
+# Side effects:
+#       Intercepts puts; data that would otherwise go to stdout, stderr,
+#	or file channels specified in outputChannel and errorChannel
+#	does not get sent to the normal puts function.
+namespace eval tcltest::Replace {
+    namespace export puts
+}
+proc tcltest::Replace::puts {args} {
+    variable [namespace parent]::outData
+    variable [namespace parent]::errData
+    switch [llength $args] {
+	1 {
+	    # Only the string to be printed is specified
+	    append outData [lindex $args 0]\n
+	    return
+	    # return [Puts [lindex $args 0]]
+	}
+	2 {
+	    # Either -nonewline or channelId has been specified
+	    if {[lindex $args 0] eq "-nonewline"} {
+		append outData [lindex $args end]
+		return
+		# return [Puts -nonewline [lindex $args end]]
+	    } else {
+		set channel [lindex $args 0]
+		set newline \n
+	    }
+	}
+	3 {
+	    if {[lindex $args 0] eq "-nonewline"} {
+		# Both -nonewline and channelId are specified, unless
+		# it's an error.  -nonewline is supposed to be argv[0].
+		set channel [lindex $args 1]
+		set newline ""
+	    }
+	}
+    }
+
+    if {[info exists channel]} {
+	if {$channel in [list [[namespace parent]::outputChannel] stdout]} {
+	    append outData [lindex $args end]$newline
+	    return
+	} elseif {$channel in [list [[namespace parent]::errorChannel] stderr]} {
+	    append errData [lindex $args end]$newline
+	    return
+	}
+    }
+
+    # If we haven't returned by now, we don't know how to handle the
+    # input.  Let puts handle it.
+    return [Puts {*}$args]
+}
+
+# tcltest::Eval --
+#
+#	Evaluate the script in the test environment.  If ignoreOutput is
+#       false, store data sent to stderr and stdout in outData and
+#       errData.  Otherwise, ignore this output altogether.
+#
+# Arguments:
+#	script             Script to evaluate
+#       ?ignoreOutput?     Indicates whether or not to ignore output
+#			   sent to stdout & stderr
+#
+# Results:
+#	result from running the script
+#
+# Side effects:
+#	Empties the contents of outData and errData before running a
+#	test if ignoreOutput is set to 0.
+
+proc tcltest::Eval {script {ignoreOutput 1}} {
+    variable outData
+    variable errData
+    DebugPuts 3 "[lindex [info level 0] 0] called"
+    if {!$ignoreOutput} {
+	set outData {}
+	set errData {}
+	rename ::puts [namespace current]::Replace::Puts
+	namespace eval :: [list namespace import [namespace origin Replace::puts]]
+	namespace import Replace::puts
+    }
+    set result [uplevel 1 $script]
+    if {!$ignoreOutput} {
+	namespace forget puts
+	namespace eval :: namespace forget puts
+	rename [namespace current]::Replace::Puts ::puts
+    }
+    return $result
+}
+
+# tcltest::CompareStrings --
+#
+#	compares the expected answer to the actual answer, depending on
+#	the mode provided.  Mode determines whether a regexp, exact,
+#	glob or custom comparison is done.
+#
+# Arguments:
+#	actual - string containing the actual result
+#       expected - pattern to be matched against
+#       mode - type of comparison to be done
+#
+# Results:
+#	result of the match
+#
+# Side effects:
+#	None.
+
+proc tcltest::CompareStrings {actual expected mode} {
+    variable CustomMatch
+    if {![info exists CustomMatch($mode)]} {
+        return -code error "No matching command registered for `-match $mode'"
+    }
+    set match [namespace eval :: $CustomMatch($mode) [list $expected $actual]]
+    if {[catch {expr {$match && $match}} result]} {
+	return -code error "Invalid result from `-match $mode' command: $result"
+    }
+    return $match
+}
+
+# tcltest::customMatch --
+#
+#	registers a command to be called when a particular type of
+#	matching is required.
+#
+# Arguments:
+#	nickname - Keyword for the type of matching
+#	cmd - Incomplete command that implements that type of matching
+#		when completed with expected string and actual string
+#		and then evaluated.
+#
+# Results:
+#	None.
+#
+# Side effects:
+#	Sets the variable tcltest::CustomMatch
+
+proc tcltest::customMatch {mode script} {
+    variable CustomMatch
+    if {![info complete $script]} {
+	return -code error \
+		"invalid customMatch script; can't evaluate after completion"
+    }
+    set CustomMatch($mode) $script
+}
+
+# tcltest::SubstArguments list
+#
+# This helper function takes in a list of words, then perform a
+# substitution on the list as though each word in the list is a separate
+# argument to the Tcl function.  For example, if this function is
+# invoked as:
+#
+#      SubstArguments {$a {$a}}
+#
+# Then it is as though the function is invoked as:
+#
+#      SubstArguments $a {$a}
+#
+# This code is adapted from Paul Duffin's function "SplitIntoWords".
+# The original function can be found  on:
+#
+#      http://purl.org/thecliff/tcl/wiki/858.html
+#
+# Results:
+#     a list containing the result of the substitution
+#
+# Exceptions:
+#     An error may occur if the list containing unbalanced quote or
+#     unknown variable.
+#
+# Side Effects:
+#     None.
+#
+
+proc tcltest::SubstArguments {argList} {
+
+    # We need to split the argList up into tokens but cannot use list
+    # operations as they throw away some significant quoting, and
+    # [split] ignores braces as it should.  Therefore what we do is
+    # gradually build up a string out of whitespace-separated strings.
+    # We cannot use [split] to split the argList into whitespace
+    # separated strings as it throws away the whitespace which maybe
+    # important so we have to do it all by hand.
+
+    set result {}
+    set token ""
+
+    while {[string length $argList]} {
+        # Look for the next word containing a quote: " { }
+        if {[regexp -indices {[^ \t\n]*[\"\{\}]+[^ \t\n]*} \
+		$argList all]} {
+            # Get the text leading up to this word, but not including
+	    # this word, from the argList.
+            set text [string range $argList 0 \
+		    [expr {[lindex $all 0] - 1}]]
+            # Get the word with the quote
+            set word [string range $argList \
+                    [lindex $all 0] [lindex $all 1]]
+
+            # Remove all text up to and including the word from the
+            # argList.
+            set argList [string range $argList \
+                    [expr {[lindex $all 1] + 1}] end]
+        } else {
+            # Take everything up to the end of the argList.
+            set text $argList
+            set word {}
+            set argList {}
+        }
+
+        if {$token ne {}} {
+            # If we saw a word with quote before, then there is a
+            # multi-word token starting with that word.  In this case,
+            # add the text and the current word to this token.
+            append token $text $word
+        } else {
+            # Add the text to the result.  There is no need to parse
+            # the text because it couldn't be a part of any multi-word
+            # token.  Then start a new multi-word token with the word
+            # because we need to pass this token to the Tcl parser to
+            # check for balancing quotes
+            append result $text
+            set token $word
+        }
+
+        if { [catch {llength $token} length] == 0 && $length == 1} {
+            # The token is a valid list so add it to the result.
+            # lappend result [string trim $token]
+            append result \{$token\}
+            set token {}
+        }
+    }
+
+    # If the last token has not been added to the list then there
+    # is a problem.
+    if { [string length $token] } {
+        error "incomplete token \"$token\""
+    }
+
+    return $result
+}
+
+
+# tcltest::test --
+#
+# This procedure runs a test and prints an error message if the test
+# fails.  If verbose has been set, it also prints a message even if the
+# test succeeds.  The test will be skipped if it doesn't match the
+# match variable, if it matches an element in skip, or if one of the
+# elements of "constraints" turns out not to be true.
+#
+# If testLevel is 1, then this is a top level test, and we record
+# pass/fail information; otherwise, this information is not logged and
+# is not added to running totals.
+#
+# Attributes:
+#   Only description is a required attribute.  All others are optional.
+#   Default values are indicated.
+#
+#   constraints -	A list of one or more keywords, each of which
+#			must be the name of an element in the array
+#			"testConstraints".  If any of these elements is
+#			zero, the test is skipped. This attribute is
+#			optional; default is {}
+#   body -	        Script to run to carry out the test.  It must
+#		        return a result that can be checked for
+#		        correctness.  This attribute is optional;
+#                       default is {}
+#   result -	        Expected result from script.  This attribute is
+#                       optional; default is {}.
+#   output -            Expected output sent to stdout.  This attribute
+#                       is optional; default is {}.
+#   errorOutput -       Expected output sent to stderr.  This attribute
+#                       is optional; default is {}.
+#   returnCodes -       Expected return codes.  This attribute is
+#                       optional; default is {0 2}.
+#   errorCode -         Expected error code.  This attribute is
+#                       optional; default is {*}. It is a glob pattern.
+#                       If given, returnCodes defaults to {1}.
+#   setup -             Code to run before $script (above).  This
+#                       attribute is optional; default is {}.
+#   cleanup -           Code to run after $script (above).  This
+#                       attribute is optional; default is {}.
+#   match -             specifies type of matching to do on result,
+#                       output, errorOutput; this must be a string
+#			previously registered by a call to [customMatch].
+#			The strings exact, glob, and regexp are preregistered
+#			by the tcltest package.  Default value is exact.
+#
+# Arguments:
+#   name -		Name of test, in the form foo-1.2.
+#   description -	Short textual description of the test, to
+#  		  	help humans understand what it does.
+#
+# Results:
+#	None.
+#
+# Side effects:
+#       Just about anything is possible depending on the test.
+#
+
+proc tcltest::test {name description args} {
+    global tcl_platform
+    variable testLevel
+    variable coreModTime
+    variable fullutf
+
+    DebugPuts 3 "test $name $args"
+    DebugDo 1 {
+	variable TestNames
+	catch {
+	    puts "test name '$name' re-used; prior use in $TestNames($name)"
+	}
+	set TestNames($name) [info script]
+    }
+
+    FillFilesExisted
+    incr testLevel
+
+    # Predefine everything to null except output and errorOutput.  We
+    # determine whether or not to trap output based on whether or not
+    # these variables (output & errorOutput) are defined.
+    lassign {} constraints setup cleanup body result returnCodes errorCode match
+
+    # Set the default match mode
+    set match exact
+
+    # Set the default match values for return codes (0 is the standard
+    # expected return value if everything went well; 2 represents
+    # 'return' being used in the test script).
+    set returnCodes [list 0 2]
+
+    # Set the default error code pattern
+    set errorCode "*"
+
+    # The old test format can't have a 3rd argument (constraints or
+    # script) that starts with '-'.
+    if {[string match -* [lindex $args 0]] || ([llength $args] <= 1)} {
+	if {[llength $args] == 1} {
+	    set list [SubstArguments [lindex $args 0]]
+	    foreach {element value} $list {
+		set testAttributes($element) $value
+	    }
+	    foreach item {constraints match setup body cleanup \
+		    result returnCodes errorCode output errorOutput} {
+		if {[info exists testAttributes(-$item)]} {
+		    set testAttributes(-$item) [uplevel 1 \
+			    ::concat $testAttributes(-$item)]
+		}
+	    }
+	} else {
+	    array set testAttributes $args
+	}
+
+	set validFlags {-setup -cleanup -body -result -returnCodes \
+		-errorCode -match -output -errorOutput -constraints}
+
+	foreach flag [array names testAttributes] {
+	    if {$flag ni $validFlags} {
+		incr testLevel -1
+		set sorted [lsort $validFlags]
+		set options [join [lrange $sorted 0 end-1] ", "]
+		append options ", or [lindex $sorted end]"
+		return -code error "bad option \"$flag\": must be $options"
+	    }
+	}
+
+	# store whatever the user gave us
+	foreach item [array names testAttributes] {
+	    set [string trimleft $item "-"] $testAttributes($item)
+	}
+
+	# Check the values supplied for -match
+	variable CustomMatch
+	if {$match ni [array names CustomMatch]} {
+	    incr testLevel -1
+	    set sorted [lsort [array names CustomMatch]]
+	    set values [join [lrange $sorted 0 end-1] ", "]
+	    append values ", or [lindex $sorted end]"
+	    return -code error "bad -match value \"$match\":\
+		    must be $values"
+	}
+
+	# Replace symbolic valies supplied for -returnCodes
+	foreach {strcode numcode} {ok 0 normal 0 error 1 return 2 break 3 continue 4} {
+	    set returnCodes [string map -nocase [list $strcode $numcode] $returnCodes]
+	}
+        # errorCode without returnCode 1 is meaningless
+        if {$errorCode ne "*" && 1 ni $returnCodes} {
+            set returnCodes 1
+        }
+    } else {
+	# This is parsing for the old test command format; it is here
+	# for backward compatibility.
+	set result [lindex $args end]
+	if {[llength $args] == 2} {
+	    set body [lindex $args 0]
+	} elseif {[llength $args] == 3} {
+	    set constraints [lindex $args 0]
+	    set body [lindex $args 1]
+	} else {
+	    incr testLevel -1
+	    return -code error "wrong # args:\
+		    should be \"test name desc ?options?\""
+	}
+    }
+
+    if {[Skipped $name $constraints]} {
+	incr testLevel -1
+	return
+    }
+
+    # Save information about the core file.
+    if {[preserveCore]} {
+	if {[file exists [file join [workingDirectory] core]]} {
+	    set coreModTime [file mtime [file join [workingDirectory] core]]
+	}
+    }
+
+    # First, run the setup script (or a hook if it presents):
+    if {[set cmd [namespace which -command [namespace current]::SetupTest]] ne ""} {
+	set setup [list $cmd $setup]
+    }
+    set processTest 1
+    set code [catch {uplevel 1 $setup} setupMsg]
+    if {$code == 1} {
+	set errorInfo(setup) $::errorInfo
+	set errorCodeRes(setup) $::errorCode
+	if {$errorCodeRes(setup) eq "BYPASS-SKIPPED-TEST"} {
+	    _noticeSkipped $name $setupMsg
+	    set processTest [set code 0]
+	}
+    }
+    set setupFailure [expr {$code != 0}]
+
+    # Only run the test body if the setup was successful
+    if {$processTest && !$setupFailure} {
+
+	# Register startup time
+	if {[IsVerbose msec] || [IsVerbose usec]} {
+	    set timeStart [clock microseconds]
+	}
+
+	# Verbose notification of $body start
+	if {[IsVerbose start]} {
+	    puts [outputChannel] "---- $name start"
+	    flush [outputChannel]
+	}
+
+	set command [list [namespace origin RunTest] $name $body]
+	if {[info exists output] || [info exists errorOutput]} {
+	    set testResult [uplevel 1 [list [namespace origin Eval] $command 0]]
+	} else {
+	    set testResult [uplevel 1 [list [namespace origin Eval] $command 1]]
+	}
+	lassign $testResult actualAnswer returnCode
+	if {$returnCode == 1} {
+	    set errorInfo(body) $::errorInfo
+	    set errorCodeRes(body) $::errorCode
+	    if {$errorCodeRes(body) eq "BYPASS-SKIPPED-TEST"} {
+		_noticeSkipped $name $actualAnswer
+		set processTest [set returnCode 0]
+	    }
+	}
+    }
+
+    # check if the return code matched the expected return code
+    set codeFailure 0
+    if {$processTest && !$setupFailure && ($returnCode ni $returnCodes)} {
+	set codeFailure 1
+    }
+    set errorCodeFailure 0
+    if {$processTest && !$setupFailure && !$codeFailure && $returnCode == 1 && \
+                ![string match $errorCode $errorCodeRes(body)]} {
+	set errorCodeFailure 1
+    }
+
+    # If expected output/error strings exist, we have to compare
+    # them.  If the comparison fails, then so did the test.
+    set outputFailure 0
+    variable outData
+    if {$processTest && [info exists output] && !$codeFailure} {
+	if {[set outputCompare [catch {
+	    CompareStrings $outData $output $match
+	} outputMatch]] == 0} {
+	    set outputFailure [expr {!$outputMatch}]
+	} else {
+	    set outputFailure 1
+	}
+    }
+
+    set errorFailure 0
+    variable errData
+    if {$processTest && [info exists errorOutput] && !$codeFailure} {
+	if {[set errorCompare [catch {
+	    CompareStrings $errData $errorOutput $match
+	} errorMatch]] == 0} {
+	    set errorFailure [expr {!$errorMatch}]
+	} else {
+	    set errorFailure 1
+	}
+    }
+
+    # check if the answer matched the expected answer
+    # Only check if we ran the body of the test (no setup failure)
+    if {!$processTest} {
+    	set scriptFailure 0
+    } elseif {$setupFailure || $codeFailure} {
+	set scriptFailure 0
+    } elseif {[set scriptCompare [catch {
+	CompareStrings $actualAnswer $result $match
+    } scriptMatch]] == 0} {
+	set scriptFailure [expr {!$scriptMatch}]
+    } else {
+	set scriptFailure 1
+    }
+
+    # Always run the cleanup script (or a hook if it presents):
+    if {[set cmd [namespace which -command [namespace current]::CleanupTest]] ne ""} {
+	set cleanup [list $cmd $cleanup]
+    }
+    set code [catch {uplevel 1 $cleanup} cleanupMsg]
+    if {$code == 1} {
+	set errorInfo(cleanup) $::errorInfo
+	set errorCodeRes(cleanup) $::errorCode
+    }
+    set cleanupFailure [expr {$code != 0}]
+
+    set coreFailure 0
+    set coreMsg ""
+    # check for a core file first - if one was created by the test,
+    # then the test failed
+    if {[preserveCore]} {
+	if {[file exists [file join [workingDirectory] core]]} {
+	    # There's only a test failure if there is a core file
+	    # and (1) there previously wasn't one or (2) the new
+	    # one is different from the old one.
+	    if {[info exists coreModTime]} {
+		if {$coreModTime != [file mtime \
+			[file join [workingDirectory] core]]} {
+		    set coreFailure 1
+		}
+	    } else {
+		set coreFailure 1
+	    }
+
+	    if {([preserveCore] > 1) && ($coreFailure)} {
+		append coreMsg "\nMoving file to:\
+		    [file join [temporaryDirectory] core-$name]"
+		catch {file rename -force -- \
+		    [file join [workingDirectory] core] \
+		    [file join [temporaryDirectory] core-$name]
+		} msg
+		if {$msg ne {}} {
+		    append coreMsg "\nError:\
+			Problem renaming core file: $msg"
+		}
+	    }
+	}
+    }
+
+    if {[IsVerbose msec] || [IsVerbose usec]} {
+	set t [expr {[clock microseconds] - $timeStart}]
+	if {[IsVerbose usec]} {
+	    puts [outputChannel] "++++ $name took $t \xB5s"
+	}
+	if {[IsVerbose msec]} {
+	    puts [outputChannel] "++++ $name took [expr {round($t/1000.)}] ms"
+	}
+    }
+
+    # if skipped, it is safe to return here
+    if {!$processTest} {
+	incr testLevel -1
+	return
+    }
+
+    # if we didn't experience any failures, then we passed
+    variable numTests
+    if {!($setupFailure || $cleanupFailure || $coreFailure
+	    || $outputFailure || $errorFailure || $codeFailure
+	    || $errorCodeFailure || $scriptFailure)} {
+	if {$testLevel == 1} {
+	    incr numTests(Passed)
+	    if {[IsVerbose pass]} {
+		puts [outputChannel] "++++ $name PASSED"
+	    }
+	}
+	incr testLevel -1
+	return
+    }
+
+    # We know the test failed, tally it...
+    if {$testLevel == 1} {
+	incr numTests(Failed)
+    }
+
+    # ... then report according to the type of failure
+    variable currentFailure true
+    if {![IsVerbose body]} {
+	set body ""
+    }
+    puts [outputChannel] "\n"
+    if {[IsVerbose line]} {
+	if {![catch {set testFrame [info frame -1]}] &&
+		[dict get $testFrame type] eq "source"} {
+	    set testFile [dict get $testFrame file]
+	    set testLine [dict get $testFrame line]
+	} else {
+	    set testFile [file normalize [uplevel 1 {info script}]]
+	    if {[file readable $testFile]} {
+		set testFd [open $testFile r]
+		if {$fullutf} {
+		    fconfigure $testFd -profile tcl8 -encoding utf-8
+		}
+		set testLine [expr {[lsearch -regexp \
+			[split [read $testFd] "\n"] \
+			"^\[ \t\]*test [string map {. \\.} $name] "] + 1}]
+		close $testFd
+	    }
+	}
+	if {[info exists testLine]} {
+	    puts [outputChannel] "$testFile:$testLine: error: test failed:\
+		    $name [string trim $description]"
+	}
+    }
+    puts [outputChannel] "==== $name\
+	    [string trim $description] FAILED"
+    if {[string length $body]} {
+	puts [outputChannel] "==== Contents of test case:"
+	puts [outputChannel] $body
+    }
+    if {$setupFailure} {
+	puts [outputChannel] "---- Test setup\
+		failed:\n$setupMsg"
+	if {[info exists errorInfo(setup)]} {
+	    puts [outputChannel] "---- errorInfo(setup): $errorInfo(setup)"
+	    puts [outputChannel] "---- errorCode(setup): $errorCodeRes(setup)"
+	}
+    }
+    if {$processTest && $scriptFailure} {
+	if {$scriptCompare} {
+	    puts [outputChannel] "---- Error testing result: $scriptMatch"
+	} else {
+	    if {[catch {
+		puts [outputChannel] "---- Result was:\n[Asciify $actualAnswer]"
+	    } errMsg]} {
+		puts [outputChannel] "\n---- Result was:\n<error printing result: $errMsg>"
+	    }
+	    puts [outputChannel] "---- Result should have been\
+		    ($match matching):\n[Asciify $result]"
+	}
+    }
+    if {$errorCodeFailure} {
+	puts [outputChannel] "---- Error code was: '$errorCodeRes(body)'"
+	puts [outputChannel] "---- Error code should have been: '$errorCode'"
+    }
+    if {$codeFailure} {
+	switch -- $returnCode {
+	    0 { set msg "Test completed normally" }
+	    1 { set msg "Test generated error" }
+	    2 { set msg "Test generated return exception" }
+	    3 { set msg "Test generated break exception" }
+	    4 { set msg "Test generated continue exception" }
+	    default { set msg "Test generated exception" }
+	}
+	puts [outputChannel] "---- $msg; Return code was: $returnCode"
+	puts [outputChannel] "---- Return code should have been\
+		one of: $returnCodes"
+	if {[IsVerbose error]} {
+	    if {[info exists errorInfo(body)] && (1 ni $returnCodes)} {
+		puts [outputChannel] "---- errorInfo: $errorInfo(body)"
+		puts [outputChannel] "---- errorCode: $errorCodeRes(body)"
+	    }
+	}
+    }
+    if {$outputFailure} {
+	if {$outputCompare} {
+	    puts [outputChannel] "---- Error testing output: $outputMatch"
+	} else {
+	    puts [outputChannel] "---- Output was:\n$outData"
+	    puts [outputChannel] "---- Output should have been\
+		    ($match matching):\n$output"
+	}
+    }
+    if {$errorFailure} {
+	if {$errorCompare} {
+	    puts [outputChannel] "---- Error testing errorOutput: $errorMatch"
+	} else {
+	    puts [outputChannel] "---- Error output was:\n$errData"
+	    puts [outputChannel] "---- Error output should have\
+		    been ($match matching):\n$errorOutput"
+	}
+    }
+    if {$cleanupFailure} {
+	puts [outputChannel] "---- Test cleanup failed:\n$cleanupMsg"
+	if {[info exists errorInfo(cleanup)]} {
+	    puts [outputChannel] "---- errorInfo(cleanup): $errorInfo(cleanup)"
+	    puts [outputChannel] "---- errorCode(cleanup): $errorCodeRes(cleanup)"
+	}
+    }
+    if {$coreFailure} {
+	puts [outputChannel] "---- Core file produced while running\
+		test!  $coreMsg"
+    }
+    puts [outputChannel] "==== $name FAILED\n"
+
+    incr testLevel -1
+    return
+}
+
+# Skip --
+#
+# Skips a running test and add a reason to skipped "constraints". Can be used
+# to conditional intended abort of the test.
+#
+# Side Effects:  Maintains tally of total tests seen and tests skipped.
+#
+proc tcltest::Skip {reason} {
+    return -code error -errorcode BYPASS-SKIPPED-TEST $reason
+}
+
+proc tcltest::_noticeSkipped {name reason} {
+    variable testLevel
+    variable numTests
+
+    if {[IsVerbose skip]} {
+	puts [outputChannel] "++++ $name SKIPPED: $reason"
+    }
+
+    if {$testLevel == 1} {
+	incr numTests(Skipped)
+	AddToSkippedBecause $reason
+    }
+}
+
+
+# Skipped --
+#
+# Given a test name and it constraints, returns a boolean indicating
+# whether the current configuration says the test should be skipped.
+#
+# Side Effects:  Maintains tally of total tests seen and tests skipped.
+#
+proc tcltest::Skipped {name constraints} {
+    variable testLevel
+    variable numTests
+    variable testConstraints
+
+    if {$testLevel == 1} {
+	incr numTests(Total)
+    }
+    # skip the test if it's name matches an element of skip
+    foreach pattern [skip] {
+	if {[string match $pattern $name]} {
+	    if {$testLevel == 1} {
+		incr numTests(Skipped)
+		DebugDo 1 {AddToSkippedBecause userSpecifiedSkip}
+	    }
+	    return 1
+	}
+    }
+    # skip the test if it's name doesn't match any element of match
+    set ok 0
+    foreach pattern [match] {
+	if {[string match $pattern $name]} {
+	    set ok 1
+	    break
+	}
+    }
+    if {!$ok} {
+	if {$testLevel == 1} {
+	    incr numTests(Skipped)
+	    DebugDo 1 {AddToSkippedBecause userSpecifiedNonMatch}
+	}
+	return 1
+    }
+    if {$constraints eq {}} {
+	# If we're limited to the listed constraints and there aren't
+	# any listed, then we shouldn't run the test.
+	if {[limitConstraints]} {
+	    AddToSkippedBecause userSpecifiedLimitConstraint
+	    if {$testLevel == 1} {
+		incr numTests(Skipped)
+	    }
+	    return 1
+	}
+    } else {
+	# "constraints" argument exists;
+	# make sure that the constraints are satisfied.
+
+	set doTest 0
+        set constraints [string trim $constraints]
+	if {[string match {*[$\[]*} $constraints] != 0} {
+	    # full expression, e.g. {$foo > [info tclversion]}
+	    catch {set doTest [uplevel #0 [list expr $constraints]]}
+	} elseif {[regexp {[^.:_a-zA-Z0-9 \n\r\t]+} $constraints] != 0} {
+	    # something like {a || b} should be turned into
+	    # $testConstraints(a) || $testConstraints(b).
+	    regsub -all {[.\w]+} $constraints {$testConstraints(&)} c
+	    catch {set doTest [eval [list expr $c]]}
+	} elseif {![catch {llength $constraints}]} {
+	    # just simple constraints such as {unixOnly fonts}.
+	    set doTest 1
+	    foreach constraint $constraints {
+		if {(![info exists testConstraints($constraint)]) \
+			|| (!$testConstraints($constraint))} {
+		    set doTest 0
+
+		    # store the constraint that kept the test from
+		    # running
+		    set constraints $constraint
+		    break
+		}
+	    }
+	}
+
+	if {!$doTest} {
+	    _noticeSkipped $name $constraints
+	    return 1
+	}
+    }
+    return 0
+}
+
+# RunTest --
+#
+# This is where the body of a test is evaluated.  The combination of
+# [RunTest] and [Eval] allows the output and error output of the test
+# body to be captured for comparison against the expected values.
+
+proc tcltest::RunTest {name script} {
+    DebugPuts 3 "Running $name {$script}"
+
+    # If there is no "memory" command (because memory debugging isn't
+    # enabled), then don't attempt to use the command.
+
+    if {[llength [info commands memory]] == 1} {
+	memory tag $name
+    }
+
+    # run the test script (or a hook if it presents):
+    if {[set cmd [namespace which -command [namespace current]::EvalTest]] ne ""} {
+	set script [list $cmd $script]
+    }
+    set code [catch {uplevel 1 $script} actualAnswer]
+
+    return [list $actualAnswer $code]
+}
+
+#####################################################################
+
+# tcltest::cleanupTestsHook --
+#
+#	This hook allows a harness that builds upon tcltest to specify
+#       additional things that should be done at cleanup.
+#
+
+if {[llength [info commands tcltest::cleanupTestsHook]] == 0} {
+    proc tcltest::cleanupTestsHook {} {}
+}
+
+# tcltest::cleanupTests --
+#
+# Remove files and dirs created using the makeFile and makeDirectory
+# commands since the last time this proc was invoked.
+#
+# Print the names of the files created without the makeFile command
+# since the tests were invoked.
+#
+# Print the number tests (total, passed, failed, and skipped) since the
+# tests were invoked.
+#
+# Restore original environment (as reported by special variable env).
+#
+# Arguments:
+#      calledFromAllFile - if 0, behave as if we are running a single
+#      test file within an entire suite of tests.  if we aren't running
+#      a single test file, then don't report status.  check for new
+#      files created during the test run and report on them.  if 1,
+#      report collated status from all the test file runs.
+#
+# Results:
+#      None.
+#
+# Side Effects:
+#      None
+#
+
+proc tcltest::cleanupTests {{calledFromAllFile 0}} {
+    variable filesMade
+    variable filesExisted
+    variable createdNewFiles
+    variable testSingleFile
+    variable numTests
+    variable numTestFiles
+    variable failFiles
+    variable skippedBecause
+    variable currentFailure
+    variable originalEnv
+    variable originalTclPlatform
+    variable coreModTime
+
+    FillFilesExisted
+    set testFileName [file tail [info script]]
+
+    # Hook to handle reporting to a parent interpreter
+    if {[llength [info commands [namespace current]::ReportToParent]]} {
+	ReportToParent $numTests(Total) $numTests(Passed) $numTests(Skipped) \
+	    $numTests(Failed) [array get skippedBecause] \
+	    [array get createdNewFiles]
+	set testSingleFile false
+    }
+
+    # Call the cleanup hook
+    cleanupTestsHook
+
+    # Remove files and directories created by the makeFile and
+    # makeDirectory procedures.  Record the names of files in
+    # workingDirectory that were not preexisting, and associate them
+    # with the test file that created them.
+
+    if {!$calledFromAllFile} {
+	foreach file $filesMade {
+	    if {[file exists $file]} {
+		DebugDo 1 {Warn "cleanupTests deleting $file..."}
+		catch {file delete -force -- $file}
+	    }
+	}
+	set currentFiles {}
+	foreach file [glob -nocomplain \
+		-directory [temporaryDirectory] *] {
+	    lappend currentFiles [file tail $file]
+	}
+	set newFiles {}
+	foreach file $currentFiles {
+	    if {$file ni $filesExisted} {
+		lappend newFiles $file
+	    }
+	}
+	set filesExisted $currentFiles
+	if {[llength $newFiles] > 0} {
+	    set createdNewFiles($testFileName) $newFiles
+	}
+    }
+
+    if {$calledFromAllFile || $testSingleFile} {
+
+	# print stats
+
+	puts -nonewline [outputChannel] "$testFileName:"
+	foreach index [list "Total" "Passed" "Skipped" "Failed"] {
+	    puts -nonewline [outputChannel] \
+		    "\t$index\t$numTests($index)"
+	}
+	puts [outputChannel] ""
+
+	# print number test files sourced
+	# print names of files that ran tests which failed
+
+	if {$calledFromAllFile} {
+	    puts [outputChannel] \
+		    "Sourced $numTestFiles Test Files."
+	    set numTestFiles 0
+	    if {[llength $failFiles] > 0} {
+		puts [outputChannel] \
+			"Files with failing tests: $failFiles"
+		set failFiles {}
+	    }
+	}
+
+	# if any tests were skipped, print the constraints that kept
+	# them from running.
+
+	set constraintList [array names skippedBecause]
+	if {[llength $constraintList] > 0} {
+	    puts [outputChannel] \
+		    "Number of tests skipped for each constraint:"
+	    foreach constraint [lsort $constraintList] {
+		puts [outputChannel] \
+			"\t$skippedBecause($constraint)\t$constraint"
+		unset skippedBecause($constraint)
+	    }
+	}
+
+	# report the names of test files in createdNewFiles, and reset
+	# the array to be empty.
+
+	set testFilesThatTurded [lsort [array names createdNewFiles]]
+	if {[llength $testFilesThatTurded] > 0} {
+	    puts [outputChannel] "Warning: files left behind:"
+	    foreach testFile $testFilesThatTurded {
+		puts [outputChannel] \
+			"\t$testFile:\t$createdNewFiles($testFile)"
+		unset createdNewFiles($testFile)
+	    }
+	}
+
+	# reset filesMade, filesExisted, and numTests
+
+	set filesMade {}
+	foreach index [list "Total" "Passed" "Skipped" "Failed"] {
+	    set numTests($index) 0
+	}
+
+	# exit only if running Tk in non-interactive mode
+	# This should be changed to determine if an event
+	# loop is running, which is the real issue.
+	# Actually, this doesn't belong here at all.  A package
+	# really has no business [exit]-ing an application.
+	if {[info exists ::tk_version] && ![testConstraint interactive]} {
+	    exit
+	}
+    } else {
+
+	# if we're deferring stat-reporting until all files are sourced,
+	# then add current file to failFile list if any tests in this
+	# file failed
+
+	if {$currentFailure && ($testFileName ni $failFiles)} {
+	    lappend failFiles $testFileName
+	}
+	set currentFailure false
+
+	# restore the environment to the state it was in before this package
+	# was loaded
+
+	set newEnv {}
+	set changedEnv {}
+	set removedEnv {}
+	foreach index [array names ::env] {
+	    if {![info exists originalEnv($index)]} {
+		lappend newEnv $index
+		unset ::env($index)
+	    }
+	}
+	foreach index [array names originalEnv] {
+	    if {![info exists ::env($index)]} {
+		lappend removedEnv $index
+		set ::env($index) $originalEnv($index)
+	    } elseif {$::env($index) ne $originalEnv($index)} {
+		lappend changedEnv $index
+		set ::env($index) $originalEnv($index)
+	    }
+	}
+	if {[llength $newEnv] > 0} {
+	    puts [outputChannel] \
+		    "env array elements created:\t$newEnv"
+	}
+	if {[llength $changedEnv] > 0} {
+	    puts [outputChannel] \
+		    "env array elements changed:\t$changedEnv"
+	}
+	if {[llength $removedEnv] > 0} {
+	    puts [outputChannel] \
+		    "env array elements removed:\t$removedEnv"
+	}
+
+	set changedTclPlatform {}
+	foreach index [array names originalTclPlatform] {
+	    if {$::tcl_platform($index) \
+		    != $originalTclPlatform($index)} {
+		lappend changedTclPlatform $index
+		set ::tcl_platform($index) $originalTclPlatform($index)
+	    }
+	}
+	if {[llength $changedTclPlatform] > 0} {
+	    puts [outputChannel] "tcl_platform array elements\
+		    changed:\t$changedTclPlatform"
+	}
+
+	if {[file exists [file join [workingDirectory] core]]} {
+	    if {[preserveCore] > 1} {
+		puts "rename core file (> 1)"
+		puts [outputChannel] "produced core file! \
+			Moving file to: \
+			[file join [temporaryDirectory] core-$testFileName]"
+		catch {file rename -force -- \
+			[file join [workingDirectory] core] \
+			[file join [temporaryDirectory] core-$testFileName]
+		} msg
+		if {$msg ne {}} {
+		    PrintError "Problem renaming file: $msg"
+		}
+	    } else {
+		# Print a message if there is a core file and (1) there
+		# previously wasn't one or (2) the new one is different
+		# from the old one.
+
+		if {[info exists coreModTime]} {
+		    if {$coreModTime != [file mtime \
+			    [file join [workingDirectory] core]]} {
+			puts [outputChannel] "A core file was created!"
+		    }
+		} else {
+		    puts [outputChannel] "A core file was created!"
+		}
+	    }
+	}
+    }
+    flush [outputChannel]
+    flush [errorChannel]
+    return
+}
+
+#####################################################################
+
+# Procs that determine which tests/test files to run
+
+# tcltest::GetMatchingFiles
+#
+#       Looks at the patterns given to match and skip files and uses
+#	them to put together a list of the tests that will be run.
+#
+# Arguments:
+#       directory to search
+#
+# Results:
+#       The constructed list is returned to the user.  This will
+#	primarily be used in 'all.tcl' files.  It is used in
+#	runAllTests.
+#
+# Side Effects:
+#       None
+
+# a lower case version is needed for compatibility with tcltest 1.0
+proc tcltest::getMatchingFiles args {GetMatchingFiles {*}$args}
+
+proc tcltest::GetMatchingFiles { args } {
+    if {[llength $args]} {
+	set dirList $args
+    } else {
+	# Finding tests only in [testsDirectory] is normal operation.
+	# This procedure is written to accept multiple directory arguments
+	# only to satisfy version 1 compatibility.
+	set dirList [list [testsDirectory]]
+    }
+
+    set matchingFiles [list]
+    foreach directory $dirList {
+
+	# List files in $directory that match patterns to run.
+	set matchFileList [list]
+	foreach match [matchFiles] {
+	    set matchFileList [concat $matchFileList \
+		    [glob -directory $directory -types {b c f p s} \
+		    -nocomplain -- $match]]
+	}
+
+	# List files in $directory that match patterns to skip.
+	set skipFileList [list]
+	foreach skip [skipFiles] {
+	    set skipFileList [concat $skipFileList \
+		    [glob -directory $directory -types {b c f p s} \
+		    -nocomplain -- $skip]]
+	}
+
+	# Add to result list all files in match list and not in skip list
+	foreach file $matchFileList {
+	    if {$file ni $skipFileList} {
+		lappend matchingFiles $file
+	    }
+	}
+    }
+
+    if {[llength $matchingFiles] == 0} {
+	PrintError "No test files remain after applying your match and\
+		skip patterns!"
+    }
+    return $matchingFiles
+}
+
+# tcltest::GetMatchingDirectories --
+#
+#	Looks at the patterns given to match and skip directories and
+#	uses them to put together a list of the test directories that we
+#	should attempt to run.  (Only subdirectories containing an
+#	"all.tcl" file are put into the list.)
+#
+# Arguments:
+#	root directory from which to search
+#
+# Results:
+#	The constructed list is returned to the user.  This is used in
+#	the primary all.tcl file.
+#
+# Side Effects:
+#       None.
+
+proc tcltest::GetMatchingDirectories {rootdir} {
+
+    # Determine the skip list first, to avoid [glob]-ing over subdirectories
+    # we're going to throw away anyway.  Be sure we skip the $rootdir if it
+    # comes up to avoid infinite loops.
+    set skipDirs [list $rootdir]
+    foreach pattern [skipDirectories] {
+	set skipDirs [concat $skipDirs [glob -directory $rootdir -types d \
+		-nocomplain -- $pattern]]
+    }
+
+    # Now step through the matching directories, prune out the skipped ones
+    # as you go.
+    set matchDirs [list]
+    foreach pattern [matchDirectories] {
+	foreach path [glob -directory $rootdir -types d -nocomplain -- \
+		$pattern] {
+	    if {$path ni $skipDirs} {
+		set matchDirs [concat $matchDirs [GetMatchingDirectories $path]]
+		if {[file exists [file join $path all.tcl]]} {
+		    lappend matchDirs $path
+		}
+	    }
+	}
+    }
+
+    if {[llength $matchDirs] == 0} {
+	DebugPuts 1 "No test directories remain after applying match\
+		and skip patterns!"
+    }
+    return [lsort $matchDirs]
+}
+
+# tcltest::runAllTests --
+#
+#	prints output and sources test files according to the match and
+#	skip patterns provided.  after sourcing test files, it goes on
+#	to source all.tcl files in matching test subdirectories.
+#
+# Arguments:
+#	shell being tested
+#
+# Results:
+#	Whether there were any failures.
+#
+# Side effects:
+#	None.
+
+proc tcltest::runAllTests { {shell ""} } {
+    variable testSingleFile
+    variable numTestFiles
+    variable numTests
+    variable failFiles
+    variable DefaultValue
+    variable fullutf
+
+    FillFilesExisted
+    if {[llength [info level 0]] == 1} {
+	set shell [interpreter]
+    }
+
+    set testSingleFile false
+
+    puts [outputChannel] "Tests running in interp:  $shell"
+    puts [outputChannel] "Tests located in:  [testsDirectory]"
+    puts [outputChannel] "Tests running in:  [workingDirectory]"
+    puts [outputChannel] "Temporary files stored in\
+	    [temporaryDirectory]"
+
+    # [file system] first available in Tcl 8.4
+    if {![catch {file system [testsDirectory]} result]
+	    && ([lindex $result 0] ne "native")} {
+	# If we aren't running in the native filesystem, then we must
+	# run the tests in a single process (via 'source'), because
+	# trying to run then via a pipe will fail since the files don't
+	# really exist.
+	singleProcess 1
+    }
+
+    if {[singleProcess]} {
+	puts [outputChannel] \
+		"Test files sourced into current interpreter"
+    } else {
+	puts [outputChannel] \
+		"Test files run in separate interpreters"
+    }
+    if {[llength [skip]] > 0} {
+	puts [outputChannel] "Skipping tests that match:  [skip]"
+    }
+    puts [outputChannel] "Running tests that match:  [match]"
+
+    if {[llength [skipFiles]] > 0} {
+	puts [outputChannel] \
+		"Skipping test files that match:  [skipFiles]"
+    }
+    if {[llength [matchFiles]] > 0} {
+	puts [outputChannel] \
+		"Only running test files that match:  [matchFiles]"
+    }
+
+    set timeCmd {clock format [clock seconds]}
+    puts [outputChannel] "Tests began at [eval $timeCmd]"
+
+    # Run each of the specified tests
+    foreach file [lsort [GetMatchingFiles]] {
+	set tail [file tail $file]
+	puts [outputChannel] $tail
+	flush [outputChannel]
+
+	if {[singleProcess]} {
+	    if {[catch {
+		incr numTestFiles
+		uplevel 1 [list ::source -encoding utf-8 $file]
+	    } msg]} {
+		puts [outputChannel] "Test file error: $msg"
+		# append the name of the test to a list to be reported
+		# later
+		lappend testFileFailures $file
+	    }
+	    if {$numTests(Failed) > 0} {
+		set failFilesSet 1
+	    }
+	} else {
+	    # Pass along our configuration to the child processes.
+	    # EXCEPT for the -outfile, because the parent process
+	    # needs to read and process output of children.
+	    set childargv [list]
+	    foreach opt [Configure] {
+		if {$opt eq "-outfile"} {continue}
+		set value [Configure $opt]
+		# Don't bother passing default configuration options
+		if {$value eq $DefaultValue($opt)} {
+			continue
+		}
+		lappend childargv $opt $value
+	    }
+	    set cmd [linsert $childargv 0 | $shell $file]
+	    if {[catch {
+		incr numTestFiles
+		set pipeFd [open $cmd "r"]
+		if {$fullutf} {
+		    fconfigure $pipeFd -profile tcl8 -encoding utf-8
+		}
+		while {[gets $pipeFd line] >= 0} {
+		    if {[regexp [join {
+			    {^([^:]+):\t}
+			    {Total\t([0-9]+)\t}
+			    {Passed\t([0-9]+)\t}
+			    {Skipped\t([0-9]+)\t}
+			    {Failed\t([0-9]+)}
+			    } ""] $line null testFile \
+			    Total Passed Skipped Failed]} {
+			foreach index {Total Passed Skipped Failed} {
+			    incr numTests($index) [set $index]
+			}
+			if {$Failed > 0} {
+			    lappend failFiles $testFile
+			    set failFilesSet 1
+			}
+		    } elseif {[regexp [join {
+			    {^Number of tests skipped }
+			    {for each constraint:}
+			    {|^\t(\d+)\t(.+)$}
+			    } ""] $line match skipped constraint]} {
+			if {[string match \t* $match]} {
+			    AddToSkippedBecause $constraint $skipped
+			}
+		    } else {
+			puts [outputChannel] $line
+		    }
+		}
+		close $pipeFd
+	    } msg]} {
+		puts [outputChannel] "Test file error: $msg"
+		# append the name of the test to a list to be reported
+		# later
+		lappend testFileFailures $file
+	    }
+	}
+    }
+
+    # cleanup
+    puts [outputChannel] "\nTests ended at [eval $timeCmd]"
+    cleanupTests 1
+    if {[info exists testFileFailures]} {
+	puts [outputChannel] "\nTest files exiting with errors:  \n"
+	foreach file $testFileFailures {
+	    puts [outputChannel] "  [file tail $file]\n"
+	}
+    }
+
+    # Checking for subdirectories in which to run tests
+    foreach directory [GetMatchingDirectories [testsDirectory]] {
+	set dir [file tail $directory]
+	puts [outputChannel] [string repeat ~ 44]
+	puts [outputChannel] "$dir test began at [eval $timeCmd]\n"
+
+	uplevel 1 [list ::source -encoding utf-8 [file join $directory all.tcl]]
+
+	set endTime [eval $timeCmd]
+	puts [outputChannel] "\n$dir test ended at $endTime"
+	puts [outputChannel] ""
+	puts [outputChannel] [string repeat ~ 44]
+    }
+    return [expr {[info exists testFileFailures] || [info exists failFilesSet]}]
+}
+
+#####################################################################
+
+# Test utility procs - not used in tcltest, but may be useful for
+# testing.
+
+# tcltest::loadTestedCommands --
+#
+#     Uses the specified script to load the commands to test. Allowed to
+#     be empty, as the tested commands could have been compiled into the
+#     interpreter.
+#
+# Arguments
+#     none
+#
+# Results
+#     none
+#
+# Side Effects:
+#     none.
+
+proc tcltest::loadTestedCommands {} {
+    return [uplevel 1 [loadScript]]
+}
+
+# tcltest::saveState --
+#
+#	Save information regarding what procs and variables exist.
+#
+# Arguments:
+#	none
+#
+# Results:
+#	Modifies the variable saveState
+#
+# Side effects:
+#	None.
+
+proc tcltest::saveState {} {
+    variable saveState
+    uplevel 1 [list ::set [namespace which -variable saveState]] \
+	    {[::list [::info procs] [::info vars]]}
+    DebugPuts  2 "[lindex [info level 0] 0]: $saveState"
+    return
+}
+
+# tcltest::restoreState --
+#
+#	Remove procs and variables that didn't exist before the call to
+#       [saveState].
+#
+# Arguments:
+#	none
+#
+# Results:
+#	Removes procs and variables from your environment if they don't
+#	exist in the saveState variable.
+#
+# Side effects:
+#	None.
+
+proc tcltest::restoreState {} {
+    variable saveState
+    foreach p [uplevel 1 {::info procs}] {
+	if {($p ni [lindex $saveState 0]) && ("[namespace current]::$p" ne
+		[uplevel 1 [list ::namespace origin $p]])} {
+
+	    DebugPuts 2 "[lindex [info level 0] 0]: Removing proc $p"
+	    uplevel 1 [list ::catch [list ::rename $p {}]]
+	}
+    }
+    foreach p [uplevel 1 {::info vars}] {
+	if {$p ni [lindex $saveState 1]} {
+	    DebugPuts 2 "[lindex [info level 0] 0]:\
+		    Removing variable $p"
+	    uplevel 1 [list ::catch [list ::unset $p]]
+	}
+    }
+    return
+}
+
+# tcltest::normalizeMsg --
+#
+#	Removes "extra" newlines from a string.
+#
+# Arguments:
+#	msg        String to be modified
+#
+# Results:
+#	string with extra newlines removed
+#
+# Side effects:
+#	None.
+
+proc tcltest::normalizeMsg {msg} {
+    regsub "\n$" [string tolower $msg] "" msg
+    set msg [string map [list "\n\n" "\n"] $msg]
+    return [string map [list "\n\}" "\}"] $msg]
+}
+
+# tcltest::makeFile --
+#
+# Create a new file with the name <name>, and write <contents> to it.
+#
+# If this file hasn't been created via makeFile since the last time
+# cleanupTests was called, add it to the $filesMade list, so it will be
+# removed by the next call to cleanupTests.
+#
+# Arguments:
+#	contents        content of the new file
+#       name            name of the new file
+#       directory       directory name for new file
+#
+# Results:
+#	absolute path to the file created
+#
+# Side effects:
+#	None.
+
+proc tcltest::makeFile {contents name {directory ""}} {
+    variable filesMade
+    variable fullutf
+
+    FillFilesExisted
+
+    if {[llength [info level 0]] == 3} {
+	set directory [temporaryDirectory]
+    }
+
+    set fullName [file join $directory $name]
+
+    DebugPuts 3 "[lindex [info level 0] 0]:\
+	     putting ``$contents'' into $fullName"
+
+    set fd [open $fullName w]
+    fconfigure $fd -translation lf
+    if {$fullutf} {
+	fconfigure $fd -profile tcl8 -encoding utf-8
+    }
+    if {[string index $contents end] eq "\n"} {
+	puts -nonewline $fd $contents
+    } else {
+	puts $fd $contents
+    }
+    close $fd
+
+    if {$fullName ni $filesMade} {
+	lappend filesMade $fullName
+    }
+    return $fullName
+}
+
+# tcltest::removeFile --
+#
+#	Removes the named file from the filesystem
+#
+# Arguments:
+#	name          file to be removed
+#       directory     directory from which to remove file
+#
+# Results:
+#	return value from [file delete]
+#
+# Side effects:
+#	None.
+
+proc tcltest::removeFile {name {directory ""}} {
+    variable filesMade
+    FillFilesExisted
+    if {[llength [info level 0]] == 2} {
+	set directory [temporaryDirectory]
+    }
+    set fullName [file join $directory $name]
+    DebugPuts 3 "[lindex [info level 0] 0]: removing $fullName"
+    set idx [lsearch -exact $filesMade $fullName]
+    if {$idx < 0} {
+	DebugDo 1 {
+	    Warn "removeFile removing \"$fullName\":\n  not created by makeFile"
+	}
+    } else {
+	set filesMade [lreplace $filesMade $idx $idx]
+    }
+    if {![file isfile $fullName]} {
+	DebugDo 1 {
+	    Warn "removeFile removing \"$fullName\":\n  not a file"
+	}
+    }
+    if {[catch {file delete -- $fullName} msg ]} {
+	DebugDo 1 {
+	    Warn "removeFile removing \"$fullName\":\n  failed: $msg"
+	}
+    }
+    return
+}
+
+# tcltest::makeDirectory --
+#
+# Create a new dir with the name <name>.
+#
+# If this dir hasn't been created via makeDirectory since the last time
+# cleanupTests was called, add it to the $directoriesMade list, so it
+# will be removed by the next call to cleanupTests.
+#
+# Arguments:
+#       name            name of the new directory
+#       directory       directory in which to create new dir
+#
+# Results:
+#	absolute path to the directory created
+#
+# Side effects:
+#	None.
+
+proc tcltest::makeDirectory {name {directory ""}} {
+    variable filesMade
+    FillFilesExisted
+    if {[llength [info level 0]] == 2} {
+	set directory [temporaryDirectory]
+    }
+    set fullName [file join $directory $name]
+    DebugPuts 3 "[lindex [info level 0] 0]: creating $fullName"
+    file mkdir $fullName
+    if {$fullName ni $filesMade} {
+	lappend filesMade $fullName
+    }
+    return $fullName
+}
+
+# tcltest::removeDirectory --
+#
+#	Removes a named directory from the file system.
+#
+# Arguments:
+#	name          Name of the directory to remove
+#       directory     Directory from which to remove
+#
+# Results:
+#	return value from [file delete]
+#
+# Side effects:
+#	None
+
+proc tcltest::removeDirectory {name {directory ""}} {
+    variable filesMade
+    FillFilesExisted
+    if {[llength [info level 0]] == 2} {
+	set directory [temporaryDirectory]
+    }
+    set fullName [file join $directory $name]
+    DebugPuts 3 "[lindex [info level 0] 0]: deleting $fullName"
+    set idx [lsearch -exact $filesMade $fullName]
+    set filesMade [lreplace $filesMade $idx $idx]
+    if {$idx < 0} {
+	DebugDo 1 {
+	    Warn "removeDirectory removing \"$fullName\":\n  not created\
+		    by makeDirectory"
+	}
+    }
+    if {![file isdirectory $fullName]} {
+	DebugDo 1 {
+	    Warn "removeDirectory removing \"$fullName\":\n  not a directory"
+	}
+    }
+    return [file delete -force -- $fullName]
+}
+
+# tcltest::viewFile --
+#
+#	reads the content of a file and returns it
+#
+# Arguments:
+#	name of the file to read
+#       directory in which file is located
+#
+# Results:
+#	content of the named file
+#
+# Side effects:
+#	None.
+
+proc tcltest::viewFile {name {directory ""}} {
+    variable fullutf
+
+    FillFilesExisted
+    if {[llength [info level 0]] == 2} {
+	set directory [temporaryDirectory]
+    }
+    set fullName [file join $directory $name]
+    set f [open $fullName]
+    if {$fullutf} {
+	fconfigure $f -profile tcl8 -encoding utf-8
+    }
+    set data [read -nonewline $f]
+    close $f
+    return $data
+}
+
+# tcltest::bytestring --
+#
+# Construct a string that consists of the requested sequence of bytes,
+# as opposed to a string of properly formed UTF-8 characters.
+# This allows the tester to
+# 1. Create denormalized or improperly formed strings to pass to C
+#    procedures that are supposed to accept strings with embedded NULL
+#    bytes.
+# 2. Confirm that a string result has a certain pattern of bytes, for
+#    instance to confirm that "\xE0\0" in a Tcl script is stored
+#    internally in UTF-8 as the sequence of bytes "\xC3\xA0\xC0\x80".
+#
+# Generally, it's a bad idea to examine the bytes in a Tcl string or to
+# construct improperly formed strings in this manner, because it involves
+# exposing that Tcl uses UTF-8 internally.
+#
+# This function doesn't work any more in Tcl 8.7, since the 'identity'
+# is gone (TIP #345)
+#
+# Arguments:
+#	string being converted
+#
+# Results:
+#	result fom encoding
+#
+# Side effects:
+#	None
+
+if {!$::tcltest::fullutf} {
+    proc tcltest::bytestring {string} {
+	return [encoding convertfrom identity $string]
+    }
+}
+
+# tcltest::OpenFiles --
+#
+#	used in io tests, uses testchannel
+#
+# Arguments:
+#	None.
+#
+# Results:
+#	???
+#
+# Side effects:
+#	None.
+
+proc tcltest::OpenFiles {} {
+    if {[catch {testchannel open} result]} {
+	return {}
+    }
+    return $result
+}
+
+# tcltest::LeakFiles --
+#
+#	used in io tests, uses testchannel
+#
+# Arguments:
+#	None.
+#
+# Results:
+#	???
+#
+# Side effects:
+#	None.
+
+proc tcltest::LeakFiles {old} {
+    if {[catch {testchannel open} new]} {
+	return {}
+    }
+    set leak {}
+    foreach p $new {
+	if {$p ni $old} {
+	    lappend leak $p
+	}
+    }
+    return $leak
+}
+
+#
+# Internationalization / ISO support procs     -- dl
+#
+
+# tcltest::SetIso8859_1_Locale --
+#
+#	used in cmdIL.test, uses testlocale
+#
+# Arguments:
+#	None.
+#
+# Results:
+#	None.
+#
+# Side effects:
+#	None.
+
+proc tcltest::SetIso8859_1_Locale {} {
+    variable previousLocale
+    variable isoLocale
+    if {[info commands testlocale] != ""} {
+	set previousLocale [testlocale ctype]
+	testlocale ctype $isoLocale
+    }
+    return
+}
+
+# tcltest::RestoreLocale --
+#
+#	used in cmdIL.test, uses testlocale
+#
+# Arguments:
+#	None.
+#
+# Results:
+#	None.
+#
+# Side effects:
+#	None.
+
+proc tcltest::RestoreLocale {} {
+    variable previousLocale
+    if {[info commands testlocale] != ""} {
+	testlocale ctype $previousLocale
+    }
+    return
+}
+
+# tcltest::threadReap --
+#
+#	Kill all threads except for the main thread.
+#	Do nothing if testthread is not defined.
+#
+# Arguments:
+#	none.
+#
+# Results:
+#	Returns the number of existing threads.
+#
+# Side Effects:
+#       none.
+#
+
+proc tcltest::threadReap {} {
+    if {[info commands testthread] ne {}} {
+
+	# testthread built into tcltest
+
+	testthread errorproc ThreadNullError
+	while {[llength [testthread names]] > 1} {
+	    foreach tid [testthread names] {
+		if {$tid != [mainThread]} {
+		    catch {
+			testthread send -async $tid {testthread exit}
+		    }
+		}
+	    }
+	    ## Enter a bit a sleep to give the threads enough breathing
+	    ## room to kill themselves off, otherwise the end up with a
+	    ## massive queue of repeated events
+	    after 1
+	}
+	testthread errorproc ThreadError
+	return [llength [testthread names]]
+    } elseif {[info commands thread::id] ne {}} {
+
+	# Thread extension
+
+	thread::errorproc ThreadNullError
+	while {[llength [thread::names]] > 1} {
+	    foreach tid [thread::names] {
+		if {$tid != [mainThread]} {
+		    catch {thread::send -async $tid {thread::exit}}
+		}
+	    }
+	    ## Enter a bit a sleep to give the threads enough breathing
+	    ## room to kill themselves off, otherwise the end up with a
+	    ## massive queue of repeated events
+	    after 1
+	}
+	thread::errorproc ThreadError
+	return [llength [thread::names]]
+    } else {
+	return 1
+    }
+    return 0
+}
+
+# Initialize the constraints and set up command line arguments
+namespace eval tcltest {
+    # Define initializers for all the built-in constraint definitions
+    DefineConstraintInitializers
+
+    # Set up the constraints in the testConstraints array to be lazily
+    # initialized by a registered initializer, or by "false" if no
+    # initializer is registered.
+    trace add variable testConstraints read [namespace code SafeFetch]
+
+    # Only initialize constraints at package load time if an
+    # [initConstraintsHook] has been predefined.  This is only
+    # for compatibility support.  The modern way to add a custom
+    # test constraint is to just call the [testConstraint] command
+    # straight away, without all this "hook" nonsense.
+    if {[namespace current] eq
+	    [namespace qualifiers [namespace which initConstraintsHook]]} {
+	InitConstraints
+    } else {
+	proc initConstraintsHook {} {}
+    }
+
+    # Define the standard match commands
+    customMatch exact	[list string equal]
+    customMatch glob	[list string match]
+    customMatch regexp	[list regexp --]
+
+    # If the TCLTEST_OPTIONS environment variable exists, configure
+    # tcltest according to the option values it specifies.  This has
+    # the effect of resetting tcltest's default configuration.
+    proc ConfigureFromEnvironment {} {
+	upvar #0 env(TCLTEST_OPTIONS) options
+	if {[catch {llength $options} msg]} {
+	    Warn "invalid TCLTEST_OPTIONS \"$options\":\n  invalid\
+		    Tcl list: $msg"
+	    return
+	}
+	if {[llength $options] % 2} {
+	    Warn "invalid TCLTEST_OPTIONS: \"$options\":\n  should be\
+		    -option value ?-option value ...?"
+	    return
+	}
+	if {[catch {Configure {*}$options} msg]} {
+	    Warn "invalid TCLTEST_OPTIONS: \"$options\":\n  $msg"
+	    return
+	}
+    }
+    if {[info exists ::env(TCLTEST_OPTIONS)]} {
+	ConfigureFromEnvironment
+    }
+
+    proc LoadTimeCmdLineArgParsingRequired {} {
+	set required false
+	if {[info exists ::argv] && ("-help" in $::argv)} {
+	    # The command line asks for -help, so give it (and exit)
+	    # right now.  ([configure] does not process -help)
+	    set required true
+	}
+	foreach hook { PrintUsageInfoHook processCmdLineArgsHook
+			processCmdLineArgsAddFlagsHook } {
+	    if {[namespace current] eq
+		    [namespace qualifiers [namespace which $hook]]} {
+		set required true
+	    } else {
+		proc $hook args {}
+	    }
+	}
+	return $required
+    }
+
+    # Only initialize configurable options from the command line arguments
+    # at package load time if necessary for backward compatibility.  This
+    # lets the tcltest user call [configure] for themselves if they wish.
+    # Traces are established for auto-configuration from the command line
+    # if any configurable options are accessed before the user calls
+    # [configure].
+    if {[LoadTimeCmdLineArgParsingRequired]} {
+	ProcessCmdLineArgs
+    } else {
+	EstablishAutoConfigureTraces
+    }
+
+    package provide [namespace tail [namespace current]] $Version
+}
diff --git a/src/vendormodules/textutil/wcswidth-35.2.tm b/src/vendormodules/textutil/wcswidth-35.2.tm
new file mode 100644
index 0000000..a8afafe
--- /dev/null
+++ b/src/vendormodules/textutil/wcswidth-35.2.tm
@@ -0,0 +1,2252 @@
+###
+# 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>
+# Author: Andreas Kupries <andreas.kupries@gmail.com>
+###
+package require Tcl 8.5
+package provide textutil::wcswidth 35.2
+namespace eval ::textutil {}
+
+proc ::textutil::wcswidth_type c {
+  if {$c <= 9734} {
+    if {$c <= 8318} {
+      if {$c <= 465} {
+	if {$c <= 252} {
+	  if {$c <= 208} {
+	    if {$c <= 175} {
+	      if {$c <= 168} {
+		if {$c <= 164} {
+		  if {$c <= 163} {
+		    if {$c <= 161} {
+		      if {$c <= 160} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 166} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 172} {
+		  if {$c <= 170} {
+		    if {$c <= 169} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 174} { return A } else { return N }
+		}
+	      }
+	    } else {
+	      if {$c <= 191} {
+		if {$c <= 186} {
+		  if {$c <= 181} {
+		    if {$c <= 180} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 187} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 207} {
+		  if {$c <= 198} {
+		    if {$c <= 197} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 237} {
+	      if {$c <= 230} {
+		if {$c <= 225} {
+		  if {$c <= 221} {
+		    if {$c <= 216} {
+		      if {$c <= 214} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 229} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 235} {
+		  if {$c <= 234} {
+		    if {$c <= 231} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 246} {
+		if {$c <= 241} {
+		  if {$c <= 240} {
+		    if {$c <= 239} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 243} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 251} {
+		  if {$c <= 250} { return A } else { return N }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 318} {
+	    if {$c <= 283} {
+	      if {$c <= 273} {
+		if {$c <= 257} {
+		  if {$c <= 256} {
+		    if {$c <= 254} {
+		      if {$c <= 253} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 272} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 282} {
+		  if {$c <= 275} {
+		    if {$c <= 274} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 304} {
+		if {$c <= 298} {
+		  if {$c <= 295} {
+		    if {$c <= 293} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 299} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 312} {
+		  if {$c <= 311} {
+		    if {$c <= 307} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 357} {
+	      if {$c <= 332} {
+		if {$c <= 327} {
+		  if {$c <= 324} {
+		    if {$c <= 323} {
+		      if {$c <= 322} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 331} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 339} {
+		  if {$c <= 337} {
+		    if {$c <= 333} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 462} {
+		if {$c <= 363} {
+		  if {$c <= 362} {
+		    if {$c <= 359} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 461} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 464} {
+		  if {$c <= 463} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 944} {
+	  if {$c <= 712} {
+	    if {$c <= 476} {
+	      if {$c <= 471} {
+		if {$c <= 469} {
+		  if {$c <= 468} {
+		    if {$c <= 467} {
+		      if {$c <= 466} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 470} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 474} {
+		  if {$c <= 473} {
+		    if {$c <= 472} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 475} { return N } else { return A }
+		}
+	      }
+	    } else {
+	      if {$c <= 707} {
+		if {$c <= 608} {
+		  if {$c <= 593} {
+		    if {$c <= 592} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 609} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 711} {
+		  if {$c <= 710} {
+		    if {$c <= 708} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 734} {
+	      if {$c <= 727} {
+		if {$c <= 719} {
+		  if {$c <= 717} {
+		    if {$c <= 716} {
+		      if {$c <= 715} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 720} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 733} {
+		  if {$c <= 732} {
+		    if {$c <= 731} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 929} {
+		if {$c <= 879} {
+		  if {$c <= 767} {
+		    if {$c <= 735} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 912} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 937} {
+		  if {$c <= 930} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 8221} {
+	    if {$c <= 4351} {
+	      if {$c <= 1039} {
+		if {$c <= 1024} {
+		  if {$c <= 969} {
+		    if {$c <= 962} {
+		      if {$c <= 961} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 1025} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 1105} {
+		  if {$c <= 1104} {
+		    if {$c <= 1103} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8214} {
+		if {$c <= 8208} {
+		  if {$c <= 8207} {
+		    if {$c <= 4447} { return W } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8210} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8219} {
+		  if {$c <= 8217} {
+		    if {$c <= 8215} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 8244} {
+	      if {$c <= 8239} {
+		if {$c <= 8227} {
+		  if {$c <= 8226} {
+		    if {$c <= 8223} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8231} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8243} {
+		  if {$c <= 8241} {
+		    if {$c <= 8240} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8254} {
+		if {$c <= 8251} {
+		  if {$c <= 8250} {
+		    if {$c <= 8245} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8253} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8308} {
+		  if {$c <= 8307} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    } else {
+      if {$c <= 8775} {
+	if {$c <= 8657} {
+	  if {$c <= 8485} {
+	    if {$c <= 8453} {
+	      if {$c <= 8363} {
+		if {$c <= 8360} {
+		  if {$c <= 8324} {
+		    if {$c <= 8320} {
+		      if {$c <= 8319} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8361} { return H } else { return N }
+		}
+	      } else {
+		if {$c <= 8451} {
+		  if {$c <= 8450} {
+		    if {$c <= 8364} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8452} { return N } else { return A }
+		}
+	      }
+	    } else {
+	      if {$c <= 8469} {
+		if {$c <= 8466} {
+		  if {$c <= 8457} {
+		    if {$c <= 8456} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8467} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8482} {
+		  if {$c <= 8480} {
+		    if {$c <= 8470} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 8559} {
+	      if {$c <= 8538} {
+		if {$c <= 8530} {
+		  if {$c <= 8491} {
+		    if {$c <= 8490} {
+		      if {$c <= 8486} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8532} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8555} {
+		  if {$c <= 8543} {
+		    if {$c <= 8542} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8601} {
+		if {$c <= 8585} {
+		  if {$c <= 8584} {
+		    if {$c <= 8569} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8591} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8633} {
+		  if {$c <= 8631} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 8725} {
+	    if {$c <= 8710} {
+	      if {$c <= 8703} {
+		if {$c <= 8678} {
+		  if {$c <= 8660} {
+		    if {$c <= 8659} {
+		      if {$c <= 8658} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8679} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8707} {
+		  if {$c <= 8705} {
+		    if {$c <= 8704} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8719} {
+		if {$c <= 8715} {
+		  if {$c <= 8714} {
+		    if {$c <= 8712} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8718} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8724} {
+		  if {$c <= 8721} {
+		    if {$c <= 8720} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 8742} {
+	      if {$c <= 8738} {
+		if {$c <= 8732} {
+		  if {$c <= 8730} {
+		    if {$c <= 8729} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8736} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8741} {
+		  if {$c <= 8740} {
+		    if {$c <= 8739} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8759} {
+		if {$c <= 8750} {
+		  if {$c <= 8749} {
+		    if {$c <= 8748} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8755} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8765} {
+		  if {$c <= 8763} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 9203} {
+	  if {$c <= 8853} {
+	    if {$c <= 8809} {
+	      if {$c <= 8799} {
+		if {$c <= 8785} {
+		  if {$c <= 8780} {
+		    if {$c <= 8779} {
+		      if {$c <= 8776} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 8786} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 8807} {
+		  if {$c <= 8803} {
+		    if {$c <= 8801} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 8835} {
+		if {$c <= 8815} {
+		  if {$c <= 8813} {
+		    if {$c <= 8811} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8833} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8852} {
+		  if {$c <= 8839} {
+		    if {$c <= 8837} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 8987} {
+	      if {$c <= 8895} {
+		if {$c <= 8869} {
+		  if {$c <= 8868} {
+		    if {$c <= 8857} {
+		      if {$c <= 8856} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 8894} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 8985} {
+		  if {$c <= 8978} {
+		    if {$c <= 8977} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 9199} {
+		if {$c <= 9192} {
+		  if {$c <= 9002} {
+		    if {$c <= 9000} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9196} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 9202} {
+		  if {$c <= 9200} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 9659} {
+	    if {$c <= 9621} {
+	      if {$c <= 9587} {
+		if {$c <= 9547} {
+		  if {$c <= 9450} {
+		    if {$c <= 9449} {
+		      if {$c <= 9311} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9551} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 9617} {
+		  if {$c <= 9615} {
+		    if {$c <= 9599} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 9649} {
+		if {$c <= 9634} {
+		  if {$c <= 9633} {
+		    if {$c <= 9631} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9641} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 9655} {
+		  if {$c <= 9653} {
+		    if {$c <= 9651} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 9681} {
+	      if {$c <= 9672} {
+		if {$c <= 9665} {
+		  if {$c <= 9663} {
+		    if {$c <= 9661} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9669} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 9677} {
+		  if {$c <= 9675} {
+		    if {$c <= 9674} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 9724} {
+		if {$c <= 9710} {
+		  if {$c <= 9701} {
+		    if {$c <= 9697} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9711} { return A } else { return N }
+		}
+	      } else {
+		if {$c <= 9732} {
+		  if {$c <= 9726} { return W } else { return N }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    }
+  } else {
+    if {$c <= 65497} {
+      if {$c <= 10070} {
+	if {$c <= 9918} {
+	  if {$c <= 9829} {
+	    if {$c <= 9791} {
+	      if {$c <= 9749} {
+		if {$c <= 9743} {
+		  if {$c <= 9741} {
+		    if {$c <= 9737} {
+		      if {$c <= 9736} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9747} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 9757} {
+		  if {$c <= 9756} {
+		    if {$c <= 9755} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9758} { return A } else { return N }
+		}
+	      }
+	    } else {
+	      if {$c <= 9811} {
+		if {$c <= 9794} {
+		  if {$c <= 9793} {
+		    if {$c <= 9792} { return A } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9799} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 9826} {
+		  if {$c <= 9825} {
+		    if {$c <= 9823} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 9875} {
+	      if {$c <= 9839} {
+		if {$c <= 9837} {
+		  if {$c <= 9835} {
+		    if {$c <= 9834} {
+		      if {$c <= 9830} { return N } else { return A }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9838} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 9874} {
+		  if {$c <= 9855} {
+		    if {$c <= 9854} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 9897} {
+		if {$c <= 9888} {
+		  if {$c <= 9887} {
+		    if {$c <= 9885} { return N } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9889} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 9916} {
+		  if {$c <= 9899} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 9978} {
+	    if {$c <= 9955} {
+	      if {$c <= 9939} {
+		if {$c <= 9933} {
+		  if {$c <= 9925} {
+		    if {$c <= 9923} {
+		      if {$c <= 9919} { return A } else { return N }
+		    } else {
+		      return W
+		    }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 9934} { return W } else { return A }
+		}
+	      } else {
+		if {$c <= 9954} {
+		  if {$c <= 9953} {
+		    if {$c <= 9940} { return W } else { return A }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    } else {
+	      if {$c <= 9971} {
+		if {$c <= 9962} {
+		  if {$c <= 9961} {
+		    if {$c <= 9959} { return N } else { return A }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 9969} { return A } else { return W }
+		}
+	      } else {
+		if {$c <= 9977} {
+		  if {$c <= 9973} {
+		    if {$c <= 9972} { return A } else { return W }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 10044} {
+	      if {$c <= 9993} {
+		if {$c <= 9988} {
+		  if {$c <= 9983} {
+		    if {$c <= 9981} {
+		      if {$c <= 9980} { return A } else { return W }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 9989} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 10024} {
+		  if {$c <= 10023} {
+		    if {$c <= 9995} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 10062} {
+		if {$c <= 10060} {
+		  if {$c <= 10059} {
+		    if {$c <= 10045} { return A } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 10061} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 10069} {
+		  if {$c <= 10066} { return N } else { return W }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 12771} {
+	  if {$c <= 11930} {
+	    if {$c <= 11034} {
+	      if {$c <= 10159} {
+		if {$c <= 10132} {
+		  if {$c <= 10111} {
+		    if {$c <= 10101} {
+		      if {$c <= 10071} { return W } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 10135} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 10175} {
+		  if {$c <= 10174} {
+		    if {$c <= 10160} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 11093} {
+		if {$c <= 11088} {
+		  if {$c <= 11087} {
+		    if {$c <= 11036} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 11092} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 11929} {
+		  if {$c <= 11903} {
+		    if {$c <= 11097} { return A } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 12438} {
+	      if {$c <= 12287} {
+		if {$c <= 12271} {
+		  if {$c <= 12245} {
+		    if {$c <= 12031} {
+		      if {$c <= 12019} { return W } else { return N }
+		    } else {
+		      return W
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 12283} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 12352} {
+		  if {$c <= 12350} {
+		    if {$c <= 12288} { return F } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 12592} {
+		if {$c <= 12548} {
+		  if {$c <= 12543} {
+		    if {$c <= 12440} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 12591} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 12687} {
+		  if {$c <= 12686} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 65039} {
+	    if {$c <= 42182} {
+	      if {$c <= 19903} {
+		if {$c <= 12871} {
+		  if {$c <= 12831} {
+		    if {$c <= 12830} {
+		      if {$c <= 12783} { return N } else { return W }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 12879} { return A } else { return W }
+		}
+	      } else {
+		if {$c <= 42127} {
+		  if {$c <= 42124} {
+		    if {$c <= 19967} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 57343} {
+		if {$c <= 44031} {
+		  if {$c <= 43388} {
+		    if {$c <= 43359} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 55203} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 65023} {
+		  if {$c <= 64255} {
+		    if {$c <= 63743} { return A } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return A
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 65376} {
+	      if {$c <= 65126} {
+		if {$c <= 65106} {
+		  if {$c <= 65071} {
+		    if {$c <= 65049} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 65107} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 65280} {
+		  if {$c <= 65131} {
+		    if {$c <= 65127} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return F
+		}
+	      }
+	    } else {
+	      if {$c <= 65487} {
+		if {$c <= 65479} {
+		  if {$c <= 65473} {
+		    if {$c <= 65470} { return H } else { return N }
+		  } else {
+		    return H
+		  }
+		} else {
+		  if {$c <= 65481} { return N } else { return H }
+		}
+	      } else {
+		if {$c <= 65495} {
+		  if {$c <= 65489} { return N } else { return H }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    } else {
+      if {$c <= 127991} {
+	if {$c <= 127247} {
+	  if {$c <= 110580} {
+	    if {$c <= 94193} {
+	      if {$c <= 65532} {
+		if {$c <= 65511} {
+		  if {$c <= 65510} {
+		    if {$c <= 65503} {
+		      if {$c <= 65500} { return H } else { return N }
+		    } else {
+		      return F
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 65518} { return H } else { return N }
+		}
+	      } else {
+		if {$c <= 94180} {
+		  if {$c <= 94175} {
+		    if {$c <= 65533} { return A } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 94191} { return N } else { return W }
+		}
+	      }
+	    } else {
+	      if {$c <= 101631} {
+		if {$c <= 100351} {
+		  if {$c <= 100343} {
+		    if {$c <= 94207} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 101589} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 110579} {
+		  if {$c <= 110575} {
+		    if {$c <= 101640} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 110959} {
+	      if {$c <= 110927} {
+		if {$c <= 110591} {
+		  if {$c <= 110590} {
+		    if {$c <= 110588} {
+		      if {$c <= 110587} { return W } else { return N }
+		    } else {
+		      return W
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 110882} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 110951} {
+		  if {$c <= 110947} {
+		    if {$c <= 110930} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 127183} {
+		if {$c <= 126980} {
+		  if {$c <= 126979} {
+		    if {$c <= 111355} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 127182} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 127242} {
+		  if {$c <= 127231} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 127589} {
+	    if {$c <= 127487} {
+	      if {$c <= 127374} {
+		if {$c <= 127343} {
+		  if {$c <= 127337} {
+		    if {$c <= 127279} {
+		      if {$c <= 127277} { return A } else { return N }
+		    } else {
+		      return A
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 127373} { return A } else { return W }
+		}
+	      } else {
+		if {$c <= 127404} {
+		  if {$c <= 127386} {
+		    if {$c <= 127376} { return A } else { return W }
+		  } else {
+		    return A
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 127560} {
+		if {$c <= 127547} {
+		  if {$c <= 127503} {
+		    if {$c <= 127490} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 127551} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 127583} {
+		  if {$c <= 127569} {
+		    if {$c <= 127567} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 127903} {
+	      if {$c <= 127798} {
+		if {$c <= 127788} {
+		  if {$c <= 127776} {
+		    if {$c <= 127743} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 127797} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 127891} {
+		  if {$c <= 127869} {
+		    if {$c <= 127868} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 127984} {
+		if {$c <= 127955} {
+		  if {$c <= 127950} {
+		    if {$c <= 127946} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 127967} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 127988} {
+		  if {$c <= 127987} { return N } else { return W }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 129008} {
+	  if {$c <= 128591} {
+	    if {$c <= 128335} {
+	      if {$c <= 128254} {
+		if {$c <= 128065} {
+		  if {$c <= 128064} {
+		    if {$c <= 128063} {
+		      if {$c <= 128062} { return W } else { return N }
+		    } else {
+		      return W
+		    }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 128252} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 128334} {
+		  if {$c <= 128330} {
+		    if {$c <= 128317} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 128406} {
+		if {$c <= 128378} {
+		  if {$c <= 128377} {
+		    if {$c <= 128359} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 128404} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 128506} {
+		  if {$c <= 128420} {
+		    if {$c <= 128419} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 128735} {
+	      if {$c <= 128722} {
+		if {$c <= 128716} {
+		  if {$c <= 128715} {
+		    if {$c <= 128709} {
+		      if {$c <= 128639} { return N } else { return W }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 128719} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 128732} {
+		  if {$c <= 128727} {
+		    if {$c <= 128724} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 128991} {
+		if {$c <= 128755} {
+		  if {$c <= 128748} {
+		    if {$c <= 128746} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 128764} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 129007} {
+		  if {$c <= 129003} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 129733} {
+	    if {$c <= 129660} {
+	      if {$c <= 129535} {
+		if {$c <= 129349} {
+		  if {$c <= 129339} {
+		    if {$c <= 129338} {
+		      if {$c <= 129291} { return N } else { return W }
+		    } else {
+		      return N
+		    }
+		  } else {
+		    return W
+		  }
+		} else {
+		  if {$c <= 129350} { return N } else { return W }
+		}
+	      } else {
+		if {$c <= 129655} {
+		  if {$c <= 129652} {
+		    if {$c <= 129647} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  return W
+		}
+	      }
+	    } else {
+	      if {$c <= 129711} {
+		if {$c <= 129679} {
+		  if {$c <= 129670} {
+		    if {$c <= 129663} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 129708} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 129727} {
+		  if {$c <= 129722} { return W } else { return N }
+		} else {
+		  return W
+		}
+	      }
+	    }
+	  } else {
+	    if {$c <= 196607} {
+	      if {$c <= 129775} {
+		if {$c <= 129759} {
+		  if {$c <= 129753} {
+		    if {$c <= 129743} { return N } else { return W }
+		  } else {
+		    return N
+		  }
+		} else {
+		  if {$c <= 129767} { return W } else { return N }
+		}
+	      } else {
+		if {$c <= 196605} {
+		  if {$c <= 131071} {
+		    if {$c <= 129782} { return W } else { return N }
+		  } else {
+		    return W
+		  }
+		} else {
+		  return N
+		}
+	      }
+	    } else {
+	      if {$c <= 1048573} {
+		if {$c <= 917999} {
+		  if {$c <= 917759} {
+		    if {$c <= 262141} { return W } else { return N }
+		  } else {
+		    return A
+		  }
+		} else {
+		  if {$c <= 983039} { return N } else { return A }
+		}
+	      } else {
+		if {$c <= 1114109} {
+		  if {$c <= 1048575} { return N } else { return A }
+		} else {
+		  return N
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    }
+  }
+}
+
+proc ::textutil::wcswidth_char c {
+  if {$c <= 94193} {
+    if {$c <= 10160} {
+      if {$c <= 9934} {
+	if {$c <= 9799} {
+	  if {$c <= 9199} {
+	    if {$c <= 9000} {
+	      if {$c <= 8985} {
+		if {$c <= 4447} {
+		  if {$c <= 4351} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 8987} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 9196} {
+		if {$c <= 9192} {
+		  if {$c <= 9002} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 9726} {
+	      if {$c <= 9203} {
+		if {$c <= 9202} {
+		  if {$c <= 9200} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 9724} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 9749} {
+		if {$c <= 9747} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 9897} {
+	    if {$c <= 9875} {
+	      if {$c <= 9855} {
+		if {$c <= 9854} {
+		  if {$c <= 9811} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 9874} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 9889} {
+		if {$c <= 9888} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 9923} {
+	      if {$c <= 9918} {
+		if {$c <= 9916} {
+		  if {$c <= 9899} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 9933} {
+		if {$c <= 9925} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 9995} {
+	  if {$c <= 9977} {
+	    if {$c <= 9969} {
+	      if {$c <= 9961} {
+		if {$c <= 9940} {
+		  if {$c <= 9939} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 9962} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 9973} {
+		if {$c <= 9972} {
+		  if {$c <= 9971} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 9988} {
+	      if {$c <= 9981} {
+		if {$c <= 9980} {
+		  if {$c <= 9978} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 9993} {
+		if {$c <= 9989} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 10069} {
+	    if {$c <= 10061} {
+	      if {$c <= 10059} {
+		if {$c <= 10024} {
+		  if {$c <= 10023} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 10060} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 10066} {
+		if {$c <= 10062} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 10135} {
+	      if {$c <= 10132} {
+		if {$c <= 10071} {
+		  if {$c <= 10070} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 10159} { return 1 } else { return 2 }
+	    }
+	  }
+	}
+      }
+    } else {
+      if {$c <= 12831} {
+	if {$c <= 12283} {
+	  if {$c <= 11903} {
+	    if {$c <= 11087} {
+	      if {$c <= 11034} {
+		if {$c <= 10175} {
+		  if {$c <= 10174} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 11036} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 11093} {
+		if {$c <= 11092} {
+		  if {$c <= 11088} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 12031} {
+	      if {$c <= 12019} {
+		if {$c <= 11930} {
+		  if {$c <= 11929} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 12271} {
+		if {$c <= 12245} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 12591} {
+	    if {$c <= 12440} {
+	      if {$c <= 12352} {
+		if {$c <= 12350} {
+		  if {$c <= 12287} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 12438} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 12548} {
+		if {$c <= 12543} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 12771} {
+	      if {$c <= 12687} {
+		if {$c <= 12686} {
+		  if {$c <= 12592} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 12830} {
+		if {$c <= 12783} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 65049} {
+	  if {$c <= 43359} {
+	    if {$c <= 42124} {
+	      if {$c <= 19903} {
+		if {$c <= 12879} {
+		  if {$c <= 12871} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 19967} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 42182} {
+		if {$c <= 42127} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 63743} {
+	      if {$c <= 55203} {
+		if {$c <= 44031} {
+		  if {$c <= 43388} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 65039} {
+		if {$c <= 64255} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 65376} {
+	    if {$c <= 65127} {
+	      if {$c <= 65107} {
+		if {$c <= 65106} {
+		  if {$c <= 65071} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 65126} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 65280} {
+		if {$c <= 65131} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 94180} {
+	      if {$c <= 94175} {
+		if {$c <= 65510} {
+		  if {$c <= 65503} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 94191} { return 1 } else { return 2 }
+	    }
+	  }
+	}
+      }
+    }
+  } else {
+    if {$c <= 128254} {
+      if {$c <= 127503} {
+	if {$c <= 110930} {
+	  if {$c <= 110580} {
+	    if {$c <= 101631} {
+	      if {$c <= 100351} {
+		if {$c <= 100343} {
+		  if {$c <= 94207} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 101589} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 110579} {
+		if {$c <= 110575} {
+		  if {$c <= 101640} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 110591} {
+	      if {$c <= 110590} {
+		if {$c <= 110588} {
+		  if {$c <= 110587} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 110927} {
+		if {$c <= 110882} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 127183} {
+	    if {$c <= 126979} {
+	      if {$c <= 110959} {
+		if {$c <= 110951} {
+		  if {$c <= 110947} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 111355} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 127182} {
+		if {$c <= 126980} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 127386} {
+	      if {$c <= 127376} {
+		if {$c <= 127374} {
+		  if {$c <= 127373} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 127490} {
+		if {$c <= 127487} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 127903} {
+	  if {$c <= 127776} {
+	    if {$c <= 127569} {
+	      if {$c <= 127560} {
+		if {$c <= 127551} {
+		  if {$c <= 127547} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 127567} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 127743} {
+		if {$c <= 127589} {
+		  if {$c <= 127583} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 127868} {
+	      if {$c <= 127798} {
+		if {$c <= 127797} {
+		  if {$c <= 127788} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 127891} {
+		if {$c <= 127869} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 127991} {
+	    if {$c <= 127984} {
+	      if {$c <= 127955} {
+		if {$c <= 127950} {
+		  if {$c <= 127946} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 127967} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 127988} {
+		if {$c <= 127987} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 128065} {
+	      if {$c <= 128064} {
+		if {$c <= 128063} {
+		  if {$c <= 128062} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 128252} { return 2 } else { return 1 }
+	    }
+	  }
+	}
+      }
+    } else {
+      if {$c <= 129008} {
+	if {$c <= 128715} {
+	  if {$c <= 128406} {
+	    if {$c <= 128359} {
+	      if {$c <= 128334} {
+		if {$c <= 128330} {
+		  if {$c <= 128317} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 128335} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 128404} {
+		if {$c <= 128378} {
+		  if {$c <= 128377} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 128591} {
+	      if {$c <= 128506} {
+		if {$c <= 128420} {
+		  if {$c <= 128419} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 128709} {
+		if {$c <= 128639} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 128746} {
+	    if {$c <= 128727} {
+	      if {$c <= 128722} {
+		if {$c <= 128719} {
+		  if {$c <= 128716} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 128724} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 128735} {
+		if {$c <= 128732} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 128991} {
+	      if {$c <= 128764} {
+		if {$c <= 128755} {
+		  if {$c <= 128748} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 129007} {
+		if {$c <= 129003} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  }
+	}
+      } else {
+	if {$c <= 129711} {
+	  if {$c <= 129652} {
+	    if {$c <= 129350} {
+	      if {$c <= 129339} {
+		if {$c <= 129338} {
+		  if {$c <= 129291} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+		if {$c <= 129349} { return 2 } else { return 1 }
+	      }
+	    } else {
+	      if {$c <= 129647} {
+		if {$c <= 129535} { return 2 } else { return 1 }
+	      } else {
+	        return 2
+	      }
+	    }
+	  } else {
+	    if {$c <= 129670} {
+	      if {$c <= 129663} {
+		if {$c <= 129660} {
+		  if {$c <= 129655} { return 1 } else { return 2 }
+		} else {
+		  return 1
+		}
+	      } else {
+	        return 2
+	      }
+	    } else {
+	      if {$c <= 129708} {
+		if {$c <= 129679} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  }
+	} else {
+	  if {$c <= 129775} {
+	    if {$c <= 129753} {
+	      if {$c <= 129733} {
+		if {$c <= 129727} {
+		  if {$c <= 129722} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+		if {$c <= 129743} { return 1 } else { return 2 }
+	      }
+	    } else {
+	      if {$c <= 129767} {
+		if {$c <= 129759} { return 1 } else { return 2 }
+	      } else {
+	        return 1
+	      }
+	    }
+	  } else {
+	    if {$c <= 196607} {
+	      if {$c <= 196605} {
+		if {$c <= 131071} {
+		  if {$c <= 129782} { return 2 } else { return 1 }
+		} else {
+		  return 2
+		}
+	      } else {
+	        return 1
+	      }
+	    } else {
+	      if {$c <= 262141} { return 2 } else { 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
+}
+
+# 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
+return