diff --git a/src/bootsupport/modules/overtype-1.5.0.tm b/src/bootsupport/modules/overtype-1.5.0.tm
deleted file mode 100644
index f4e466f3..00000000
--- a/src/bootsupport/modules/overtype-1.5.0.tm
+++ /dev/null
@@ -1,1039 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) Julian Noble 2003-2023
-#
-# @@ Meta Begin
-# Application overtype 1.5.0
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-##e.g package require frobz
-package require textutil
-package require punk::ansi  ;#required to detect, split, strip and calculate lengths
-package require punk::char  ;#box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#Julian Noble <julian@precisium.com.au> - 2003 
-#Released under standard 'BSD license' conditions.
-#
-#todo - ellipsis truncation indicator for center,right
-
-#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
-# - need to extract and replace ansi codes?
-
-namespace eval overtype {
-	namespace export *
-    variable default_ellipsis_horizontal "..." ;#fallback 
-    variable default_ellipsis_vertical "..." 
-    namespace eval priv {
-        proc _init {} {
-            upvar ::overtype::default_ellipsis_horizontal e_h
-            upvar ::overtype::default_ellipsis_vertical e_v
-            set e_h [format %c 0x2026] ;#Unicode Horizontal Ellipsis
-            set e_v [format %c 0x22EE]
-            #The unicode ellipsis looks more natural than triple-dash which is centred vertically whereas ellipsis is at floorline of text
-            #Also - unicode ellipsis has semantic meaning that other processors can interpret
-            #unicode does also provide a midline horizontal ellipsis 0x22EF
-
-            #set e [format %c 0x2504] ;#punk::char::charshort boxd_ltdshhz  - Box Drawings Light Triple Dash Horizontal
-            #if {![catch {package require punk::char}]} {
-            #    set e [punk::char::charshort boxd_ltdshhz] 
-            #}
-        }
-    }
-    priv::_init
-}
-proc overtype::about {} {
-	return "Simple text formatting. Author JMN. BSD-License"
-}
-
-namespace eval overtype {
-    variable escape_terminals
-    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
-    dict set escape_terminals CSI [list @ \\ ^ _ ` | ~ a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z "\{" "\}"]
-    #dict set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
-    dict set escape_terminals OSC [list \007 \033\\] ;#note mix of 1 and 2-byte terminals 
-
-    #self-contained 2 byte ansi escape sequences - review more?
-    variable ansi_2byte_codes_dict
-    set  ansi_2byte_codes_dict [dict create\
-        "reset_terminal"            "\u001bc"\
-        "save_cursor_posn"          "\u001b7"\
-        "restore_cursor_posn"       "\u001b8"\
-        "cursor_up_one"             "\u001bM"\
-        "NEL - Next Line"           "\u001bE"\
-        "IND - Down one line"       "\u001bD"\
-        "HTS - Set Tab Stop"        "\u001bH"\
-        ]
-
-        #debatable whether strip should reveal the somethinghidden - some terminals don't hide it anyway.
-        #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
-}
-
-
-#candidate for zig/c implementation?
-proc overtype::stripansi {text} {
-    variable escape_terminals  ;#dict
-    variable ansi_2byte_codes_dict
-    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-        #\033 same as \x1b
-        return $text
-    }
-
-    set text [convert_g0 $text] 
-
-    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-    set inputlist [split $text ""]
-    set outputlist [list] 
-
-    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-
-    set in_escapesequence 0
-    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-    set i 0
-    foreach u $inputlist {
-        set v [lindex $inputlist $i+1]
-        set uv ${u}${v}
-        if {$in_escapesequence eq "2b"} {
-            #2nd byte - done.
-            set in_escapesequence 0
-        } elseif {$in_escapesequence != 0} {
-            set escseq [dict get $escape_terminals $in_escapesequence]
-            if {$u in $escseq} {
-                set in_escapesequence 0
-            } elseif {$uv in $escseq} {
-                set in_escapseequence 2b ;#flag next byte as last in sequence
-            }
-        } else {
-            #handle both 7-bit and 8-bit CSI and OSC
-            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-                set in_escapesequence CSI
-            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-                set in_escapesequence OSC
-            } elseif {$uv in $2bytecodes} {
-                #self-contained e.g terminal reset - don't pass through.
-                set in_escapesequence 2b
-            } else {
-                lappend outputlist $u
-            }
-        }
-        incr i
-    }
-    return [join $outputlist ""]
-}
-
-#review
-#todo - map other chars  to unicode equivs
-proc overtype::convert_g0 {text} {
-    #using not \033 inside to stop greediness - review how does it compare to ".*?"
-    set re {\033\(0[^\033]*\033\(B} 
-    set re2 {\033\(0(.*)\033\(B} ;#capturing
-    set parts [ta::_perlish_split $re $text]
-    set out ""
-    foreach {pt g} $parts {
-        append out $pt
-        if {$g ne ""} {
-            #puts --$g--
-            #box sample
-            #lqk
-            #x x
-            #mqj
-            #m = boxd_lur
-            #set map [list l \u250f k \u2513] ;#heavy
-            set map [list l \u250c q \u2500 k \u2510 x \u2502 m \u2514 j \u2518] ;#light
-
-            regexp $re2 $g _match contents
-            append out [string map $map $contents]
-        }
-    }
-    return $out
-}
-
-#todo - convert esc(0 graphics sequences to single char unicode equivalents e.g box drawing set
-# esc) ??
-proc overtype::stripansi_gx {text} {
-        #e.g "\033(0" - select VT100 graphics for character set G0
-        #e.g "\033(B" - reset 
-        #e.g "\033)0" - select VT100 graphics for character set G1
-        #e.g "\033)X" - where X is any char other than 0 to reset ??
-        return [convert_g0 $text]
-}
-
-
-#This shouldn't be called on text containing ansi codes!
-proc overtype::strip_nonprinting_ascii {str} {
-    #review - some single-byte 'control' chars have visual representations e.g ETX as heart
-    #It is currently used for screen display width calculations
-    #equivalent for various unicode combining chars etc?
-    set map [list\
-        \007 ""\
-        [format %c 0] ""\
-        [format %c 0x7f] ""\
-    ]
-    return [string map $map $str]
-}
-
-#length of text for printing characters only
-#review - unicode and other non-printing chars and combining sequences?
-#certain unicode chars are full-width (single char 2 columns wide) e.g see "Halfwdith and fullwidth forms" and ascii_fuillwidth blocks in punk::char::charset_names
-#review - is there an existing library or better method? print to a terminal and query cursor position?
-#Note this length calculation is only suitable for lines being appended to other strings if the line is pre-processed to account for backspace and carriage returns first
-#If the raw line is appended to another string without such processing - the backspaces & carriage returns can affect data prior to the start of the string. 
-proc overtype::printing_length {line} {
-    if {[string first \n $line] >= 0} {
-        error "line_print_length must not contain newline characters"
-    }
-
-    #review - 
-    set line [stripansi $line]
-
-    set line [strip_nonprinting_ascii $line] ;#only strip nonprinting after stripansi - some like BEL are part of ansi
-    #backspace 0x08 only erases* printing characters anyway - so presumably order of processing doesn't matter
-    #(* more correctly - moves cursor back)
-    #backspace will not move beyond a preceding newline - but we have disallowed newlines for this function already
-    #leading backspaces will eat into any string (even prompt in non-standard tclsh shell) that is prepended to the line
-    # - but for the purposes of overtype we wouldn't want that - so we strip it here in the length calculation and should strip leading backspaces in the actual data concatenation operations too.
-    #curiously - a backspace sequence at the end of a string also doesn't reduce the printing width - so we can also strip from RHS
-
-    #Note that backspace following a \t will only shorten the string by one (ie it doesn't move back the whole tab width like it does interactively in the terminal)
-    #for this reason - it would seem best to normalize the tabs to spaces prior to performing the backspace calculation - otherwise we won't account for the 'short' tabs it effectivley produces
-    #normalize tabs to an appropriate* width
-    #*todo - handle terminal/context where tabwidth != the default 8 spaces
-    set line [textutil::tabify::untabify2 $line]
-
-    set bs [format %c 0x08]
-    #set line [string map [list "\r${bs}" "\r"] $line] ;#backsp following a \r will have no effect
-    set line [string trim $line $bs]
-    set n 0
-
-    set chars [split $line ""] 
-    #build an output 
-    set idx 0
-    set outchars [list]
-    set outsizes [list]
-    foreach c $chars {
-        if {$c eq $bs} {
-            if {$idx > 0} {
-                incr idx -1
-            }
-        } elseif {$c eq "\r"} {
-            set idx 0
-        } else {
-            priv::printing_length_addchar $idx $c
-            incr idx
-        }
-    }
-    set line2 [join $outchars ""]
-    return [punk::char::string_width $line2]
-}
-
-proc overtype::string_columns {text} {
-    if {[punk::ansi::ta::detect $text]} {
-        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with overtype::stripansi. Alternatively try overtype::printing_length"
-    }
-    return [punk::char::string_width $text]
-}
-
-namespace eval overtype::priv {
-    proc printing_length_addchar {i c} {
-        upvar outchars outc 
-        upvar outsizes outs
-        set nxt [llength $outc] 
-        if {$i < $nxt} {
-            lset outc $i $c
-        } else {
-            lappend outc $c
-        }
-    }
-}
-
-#string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
-proc overtype::left {args} {
-	# @c overtype starting at left (overstrike) 
-	# @c can/should we use something like this?: 'format "%-*s" $len $overtext 
-    variable default_ellipsis_horizontal
-
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] underblock overblock
-    set defaults [dict create\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::left unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
-    set overlines  [split $overblock \n]
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set undertext_printlen [printing_length $undertext]
-        set overlen [printing_length $overtext]
-        set diff [expr {$overlen - $colwidth}]
-
-        #review
-        #append overtext "\033\[0m"
-
-        if {$diff > 0} {
-            #background line is narrower 
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {![dict get $opts -overflow]} {
-                #set overtext [string range $overtext 0 $colwidth-1] ;#string range won't be correct e.g if contains ansi codes or leading \r or \b etc
-                if {[dict get $opts -ellipsis]} {
-                    set rendered [overtype::right $rendered $opt_ellipsistext]
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #we know overtext is shorter or equal
-            lappend outputlines [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-
-}
-
-namespace eval overtype::piper {
-    proc overcentre {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-bias left|right? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::centre {*}$argsflags $under $over
-    }
-    proc overleft {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <column>? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::left {*}$argsflags $under $over
-    }
-}
-#todo - left-right ellipsis ?
-proc overtype::centre {args} {
-    variable default_ellipsis_horizontal
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-bias [left|right]?  ?-overflow [1|0]? undertext overtext}
-	}
-	
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    set defaults [dict create\
-        -bias       left\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
-    set overlines  [split $overblock \n]
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set olen [printing_length $overtext]
-        set ulen [printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        #review
-        append overtext "\033\[0m"
-
-        set diff [expr {$colwidth - $olen}]
-        if {$diff > 0} {
-            #background block is wider
-            set half [expr {round(int($diff / 2))}]
-            if {[string match right [dict get $opts -bias]]} {
-                if {[expr {2 * $half}] < $diff} {
-                    incr half
-                }
-            }
-            
-            set rhs [expr {$diff - $half - 1}]
-            set lhs [expr {$half - 1}]
-            set rhsoffset [expr {$rhs +1}]
-            if 0 {
-            set a [string range $undertext 0 $lhs]
-            set background [string range $undertext $lhs+1 end-$rhsoffset]
-            set b [renderline -transparent $opt_transparent $background $overtext]
-            set c [string range $undertext end-$rhs end]
-            lappend outputlines $a$b$c
-            }
-            lappend outputlines [renderline -start $lhs -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-
-        } else {
-            #overlay wider or equal
-            set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {$diff < 0} {
-                #overlay is wider - trim if overflow not specified in opts
-                if {![dict get $opts -overflow]} {
-                    #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
-                    #set overtext [string range $overtext 0 $colwidth-1 ]
-                    if {[dict get $opts -ellipsis]} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            } else {
-                #widths match
-            }
-            lappend outputlines $rendered
-            #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-}
-
-proc overtype::right {args} {
-    variable default_ellipsis_horizontal
-	# @d !todo - implement overflow, length checks etc
-
-	if {[llength $args] < 2} {
-		error {usage: ?-overflow [1|0]? undertext overtext}
-	}
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    set defaults [dict create\
-        -bias       left\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis         [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_overflow        [dict get $opts -overflow]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-    
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {printing_length $v}]]
-    set overlines  [split $overblock \n]
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set olen [printing_length $overtext]
-        set ulen [printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        #review
-        #append overtext "\033\[0m"
-
-        set overflowlength [expr {$olen - $colwidth}]
-        if {$overflowlength > 0} {	
-            #overtext wider than undertext column
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -start 0 $undertext $overtext]
-            if {!$opt_overflow} {
-                if {$opt_ellipsis} {
-                    set rendered [overtype::right $rendered $opt_ellipsistext]
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #lappend outputlines [string range $undertext 0 end-$olen]$overtext
-            lappend outputlines [renderline -transparent $opt_transparent -start [expr {$colwidth - $olen}] $undertext $overtext]
-        }
-    }
-
-    return [join $outputlines \n]
-}
-
-# -- --- --- --- --- --- --- --- --- --- ---
-proc overtype::transparentline {args} {
-    foreach {under over} [lrange $args end-1 end] break
-    set argsflags [lrange $args 0 end-2]
-    set defaults [dict create\
-        -transparent 1\
-        -exposed 1 " "\
-        -exposed 2 " "\
-    ]
-    set newargs [dict merge $defaults $argsflags]
-    tailcall overtype::renderline {*}$newargs $under $over
-}
-#renderline may not make sense as it is in the long run for blocks of text - but is handy in the single-line-handling form anyway.
-# We are trying to handle ansi codes in a block of text which is acting like a mini-terminal in some sense.
-#We can process standard cursor moves such as \b \r - but no way to respond to other cursor movements e.g moving to other lines.
-#
-namespace eval overtype::piper {
-    proc renderline {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        foreach {over under} [lrange $args end-1 end] break
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::renderline {*}$argsflags $under $over
-    }
-}
-interp alias "" piper_renderline "" overtype::piper::renderline 
-
-#-returnextra to enable returning of overflow and length
-# todo - use ta::detect to short-circuit processing and do simple string calcs as an optimisation?
-#review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
-#todo - review transparency issues with single/double width characters!
-proc overtype::renderline {args} {
-	if {[llength $args] < 2} {
-		error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] under over
-    if {[string first \n $under] >=0 || [string first \n $over] >= 0} {
-        error "overtype::renderline not allowed to contain newlines"
-    }
-    set defaults [dict create\
-        -overflow   0\
-        -transparent 0\
-        -start 0\
-        -returnextra 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    #exposed1 and exposed2 for first and second col of underying 2wide char which is truncated by transparency or overflow
-
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::renderline unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_overflow            [dict get $opts -overflow]
-    set opt_colstart            [dict get $opts -start]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_transparent         [dict get $opts -transparent]  
-    if {$opt_transparent eq "0"} {
-        set do_transparency 0
-    } else {
-        set do_transparency 1
-        if {$opt_transparent eq "1"} {
-            set opt_transparent {[\s]}
-        }
-    }
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_returnextra         [dict get $opts -returnextra]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_exposed1            [dict get $opts -exposed1]
-    set opt_exposed2            [dict get $opts -exposed2]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-
-    #-----
-    #
-    if {[string first \t $under] >= 0} {
-        #set under [textutil::tabify::untabify2 $under]
-        set under [textutil::tabify::untabifyLine $under 8] ;#8 is default for untabify2 - review
-    }
-    set overdata $over
-    if {[string first \t $over] >= 0} {
-        #set overdata [textutil::tabify::untabify2 $over]
-        set overdata [textutil::tabify::untabifyLine $over 8]
-    }
-    #-------
-
-    #ta_detect ansi and do simpler processing?
-
-
-    # -- --- --- --- --- --- --- ---
-    set undermap [punk::ansi::ta::split_codes_single $under]
-    set understacks [dict create]
-
-    set i_u -1
-    set i_o 0 
-    set out [list] 
-    set u_codestack [list]
-    set pt_underchars "" ;#for string_columns length calculation for overflow 0 truncation
-    set remainder [list] ;#for returnextra
-    foreach {pt code} $undermap {
-        #pt = plain text
-        append pt_underchars $pt
-        foreach ch [split $pt ""] {
-            set width [punk::char::string_width $ch]
-            incr i_u
-            dict set understacks $i_u $u_codestack 
-            lappend out $ch
-            if {$width > 1} {
-                #presumably there are no triple-column or wider unicode chars.. until the aliens arrive.(?)
-                incr i_u
-                dict set understacks $i_u $u_codestack 
-                lappend out ""
-            }
-        }
-        #underlay should already have been rendered and not have non-sgr codes - but let's check for and not stack them if other codes are here
-        if {[priv::is_sgr $code]} {
-            if {[priv::has_sgr_leadingreset $code]} {
-                set u_codestack [list $code]
-            } else {
-                lappend u_codestack $code
-            }
-        }
-        #consider also other codes that should be stacked..?
-    }
-    #trailing codes in effect for underlay
-    if {[llength $undermap]} {
-        dict set understacks [expr {$i_u + 1}] $u_codestack
-    }
-
-
-    # -- --- --- --- --- --- --- ---
-    ####
-    #if opt_colstart - we need to build a space (or any singlewidth char really) padding on the left of the right number of columns.
-    #this will be processed as transparent - and handle doublewidth underlay characters appropriately
-    set startpad [string repeat " " $opt_colstart]
-    append startpad $overdata ;#overdata with left padding spaces based on col-start under will show through for left-padding portion regardless of -transparency
-    set overmap  [punk::ansi::ta::split_codes_single $startpad]
-    ####
-
-
-
-    set overstacks [dict create]
-    set o_codestack [list]
-    set pt_overchars ""
-    foreach {pt code} $overmap {
-        append pt_overchars $pt
-        foreach ch [split $pt ""] {
-           dict set overstacks $i_o $o_codestack 
-           incr i_o 
-        }
-        if {[priv::is_sgr $code]} {
-            #only stack SGR (graphics rendition) codes - not title sets, cursor moves etc 
-            if {[priv::has_sgr_leadingreset $code]} {
-                #m code which has sgr reset at start - no need to replay prior sgr codes 
-                set o_codestack [list $code]
-            } else {
-                lappend o_codestack $code
-            }
-        }
-    }
-    # -- --- --- --- --- --- --- ---
-
-
-
-
-    set bs [format %c 0x08]
-    set idx 0 ;# line index  (cursor - 1)
-    set idx_over -1
-    foreach {pt code} $overmap {
-        set ptchars [split $pt ""] ;#for lookahead
-        #emit plaintext chars first using existing SGR codes from under/over stack as appropriate
-        #then check if the following code is a cursor movement within the line and adjust index if so
-        foreach ch $ptchars {
-            incr idx_over
-            if {$ch eq "\r"} {
-                set idx $opt_colstart
-            } elseif {$ch eq "\b"} {
-                #review - backspace effect on double-width chars
-                if {$idx > $opt_colstart} {
-                    incr idx -1
-                }
-            } elseif {($idx < $opt_colstart)} {
-                incr idx
-            } elseif {($do_transparency && [regexp $opt_transparent $ch])} {    
-                #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
-                set owidth [punk::char::string_width $ch]
-                if {$idx > [llength $out]-1} {
-                    lappend out " "
-                    dict set understacks $idx [list] ;#review - use idx-1 codestack?
-                    incr idx
-                } else {
-                    set uwidth [punk::char::string_width [lindex $out $idx]]
-                    if {[lindex $out $idx] eq ""} {
-                        #2nd col of 2-wide char in underlay 
-                        incr idx
-                    } elseif {$uwidth == 0} {
-                        #e.g combining diacritic
-                        incr idx
-                    } elseif {$uwidth == 1} {
-                        incr idx
-                        if {$owidth > 1} {
-                            incr idx
-                        } 
-                    } elseif {$uwidth > 1} {
-                        if {[punk::char::string_width $ch] == 1} {
-                            #normal singlewide transparency 
-                            set next_pt_overchar [string index $pt_overchars $idx_over+1] ;#lookahead of next plain-text char in overlay
-                            if {$next_pt_overchar eq ""} {
-                                #special-case trailing transparent - no next_pt_overchar
-                                incr idx
-                            } else {
-                                if {[regexp $opt_transparent $next_pt_overchar]} {
-                                    incr idx
-                                } else {
-                                    #next overlay char is not transparent.. first-half of underlying 2wide char is exposed 
-                                    priv::render_addchar $idx $opt_exposed1 [dict get $overstacks $idx_over]
-                                    incr idx
-                                }
-                            }
-                        } else {
-                            #2wide transparency over 2wide in underlay
-                            incr idx
-                        }
-                    }
-                }
-            } else {
-                #non-transparent char in overlay
-                set owidth [punk::char::string_width $ch]
-                set uwidth [punk::char::string_width [lindex $out $idx]]
-                if {[lindex $out $idx] eq ""} {
-                    #2nd col of 2wide char in underlay
-                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                    incr idx
-                } elseif {$uwidth == 0} {
-                    #e.g combining diacritic - increment before over char  REVIEW
-                    #arguably the previous overchar should have done this - ie lookahead for combiners?
-                    priv::render_addchar $idx "" [dict get $overstacks $idx_over]
-                    incr idx
-                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                    incr idx
-
-                } elseif {$uwidth == 1} {
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                    } else {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx ""  [dict get $overstacks $idx_over]
-                    }
-                } elseif {$uwidth > 1} {
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx $opt_exposed2 [dict get $overstacks $idx_over]
-                        #don't incr idx - we are just putting a broken-indication in the underlay - which may get overwritten by next overlay char
-                    } else {
-                        #2wide over 2wide
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx 
-                    }
-                }
-            }
-        } 
-        #check following code
-        if {![priv::is_sgr $code]} {
-
-        }
-    }
-
-    if {$opt_overflow == 0} {
-        #need to truncate to the width of the original undertext
-        #review - string_width vs printing_length here. undertext requirement to be already rendered therefore punk::char::string_width ok?
-        set num_under_columns [punk::char::string_width $pt_underchars] ;#plaintext underchars
-    }
-
-    #coalesce and replay codestacks for out char list
-    set outstring ""    
-    set remstring "" ;#remainder after overflow point reached
-    set i 0
-    set cstack [list]
-    set prevstack [list]
-    set out_rawchars ""; #for overflow counting 
-    set output_to "outstring" ;#var in effect depending on overflow
-    set in_overflow 0 ;#used to stop char-width scanning once in overflow
-    foreach ch $out {
-        append out_rawchars $ch
-        if {$opt_overflow == 0 && !$in_overflow} {
-            if {[set nextvisualwidth [punk::char::string_width $out_rawchars]] < $num_under_columns} {
-            } else {
-                #todo - check if we overflowed with a double-width char ? 
-                #store visualwidth which may be short
-                set in_overflow 1
-            }
-        }
-        set cstack [dict get $understacks $i]
-        if {$cstack ne $prevstack} {
-            if {[llength $prevstack]} {
-                append $output_to \033\[m
-            }
-            foreach code $cstack {
-                append $output_to $code
-            }
-        }
-        append $output_to $ch
-        set prevstack $cstack
-        incr i
-        if {$in_overflow} {
-            set output_to "remstring"
-        }
-    }
-    if {[dict size $understacks] > 0} {
-        append $output_to [join [dict get $understacks [expr {[dict size $understacks]-1}]] ""] ;#tail codes
-    }
-    if {[string length $remstring]} {
-        #puts stderr "remainder:$remstring"
-    }
-    #pdict $understacks
-    if {$opt_returnextra} {
-        return [list $outstring $visualwidth [string length $outstring] $remstring]
-    } else {
-        return $outstring
-    }
-    #return [join $out ""]
-}
-proc overtype::test_renderline {} {
-    set t \uFF5E ;#2-wide tilde
-    set u \uFF3F ;#2-wide underscore
-    set missing \uFFFD
-    return [list $t $u A${t}B]
-}
-namespace eval overtype::priv {
-    #todo - move to punk::ansi::codetype
-    proc is_sgr {code} {
-        #SGR (Select Graphic Rendition) - codes ending in 'm' - e.g colour/underline 
-        #we will accept and pass through the less common colon separator (ITU Open Document Architecture) 
-        #Terminals should generally ignore it if they don't use it
-        regexp {\033\[[0-9;:]*m$} $code
-    }
-    proc is_cursor_move_in_line {code} {
-        #review - what about CSI n : m H where row n happens to be current line?
-        regexp {\033\[[0-9]*(:?C|D|G)$}
-    }
-    #pure SGR reset
-    proc is_sgr_reset {code} {
-        #todo 8-bit csi
-        regexp {\033\[0*m$} $code
-    }
-    #whether this code has 0 (or equivalently empty) parameter (but may set others)
-    #if an SGR code as a reset in it - we don't need to carry forward any previous SGR codes
-    #it generally only makes sense for the reset to be the first entry - otherwise the code has ineffective portions
-    #However - detecting zero or empty parameter in other positions requires knowing all other codes that may allow zero or empty params.
-    #We will only look at initial parameter as this is the well-formed normal case.  
-    #Review - consider normalizing sgr codes to remove other redundancies such as setting fg or bg color twice in same code
-    proc has_sgr_leadingreset {code} {
-        set params ""
-        regexp {\033\[(.*)m} $code _match params
-        set plist [split $params ";"]
-        if {[string trim [lindex $plist 0] 0] eq ""} {
-            #e.g \033\[m  \033\[0\;...m  \033\[0000...m
-            return 1
-        } else {
-            return 0
-        }
-    }
-    #has_sgr_reset  - rather than support this - create an sgr normalize function that removes dead params and brings reset to front of param list
-    proc render_addchar {i c stack} {
-        upvar out o
-        upvar understacks ustacks
-        set nxt [llength $o] 
-        if {$i < $nxt} {
-            lset o $i $c
-        } else {
-            lappend o $c
-        }
-        dict set ustacks $i $stack
-    }
-
-}
-
-
-# -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype::ta {
-    namespace path ::overtype
-    #*based* on but not identical to:
-    #https://github.com/perlancar/perl-Text-ANSI-Util/blob/master/lib/Text/ANSI/BaseUtil.pm
-
-    #handle both 7-bit and 8-bit csi 
-    #review - does codepage affect this? e.g ebcdic has 8bit csi in different position
-
-    #CSI
-    #variable re_csi_open {(?:\033\[|\u009b)[0-9;]+} ;#too specific - doesn't detect \033\[m
-    variable re_csi_open {(?:\033\[|\u009b])}
-
-    #colour and style
-    variable re_csi_colour {(?:\033\[|\u009b)[0-9;]*m} ;#e.g \033\[31m  \033\[m  \033\[0m \033\[m0000m
-    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
-    variable re_csi_code  {(?:\033\[|\u009b])[0-9;]*[a-zA-Z\\@^_|~`]}
-
-    #OSC - termnate with BEL (\a \007) or ST (string terminator \033\\)
-    #variable re_esc_osc1 {(?:\033\]|\u009c).*\007}
-    #variable re_esc_osc2 {(?:\033\]|\u009c).*\033\\}
-
-    #test - non-greedy
-    variable re_esc_osc1 {(?:\033\]|\u009c).*?\007}
-    variable re_esc_osc2 {(?:\033\]|\u009c).*?\033\\}
-
-    variable re_ansi_detect "${re_csi_open}|${re_esc_osc1}|${re_esc_osc2}"
-
-    #detect any ansi escapes
-    #review - only detect 'complete' codes - or just use the opening escapes for performance?
-    proc detect {text} {
-        variable re_ansi_detect
-        #variable re_csi_open
-        #variable re_esc_osc1
-        #variable re_esc_osc2
-        #todo - other escape sequences
-        #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
-        expr {[regexp $re_ansi_detect $text]}
-    }
-    #not in perl ta
-    proc detect_csi {text} {
-        variable re_csi_colour
-        expr {[regexp $re_csi_colour $text]}
-    }
-    proc strip {text} {
-        tailcall stripansi $text
-    }
-    #note this is character length after stripping ansi codes - not the printing length
-    proc length {text} {
-        string length [overtype::stripansi $text]
-    }
-    #todo - handle newlines
-    #not in perl ta
-    proc printing_length {text} {
-
-    }
-
-    proc trunc {text width args} {
-
-    }
-
-    #not in perl ta
-    #returns just the plaintext portions in a list
-    proc split_at_codes {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        textutil::splitx $text "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-    }
-    
-    # -- --- --- --- --- --- 
-    #Split $text to a list containing alternating ANSI color codes and text.
-    #ANSI color codes are always on the second element, fourth, and so on.
-    #(ie plaintext on odd list-indices ansi on even indices)
-    # Example:
-    #ta_split_codes ""              # => ""
-    #ta_split_codes "a"             # => "a"
-    #ta_split_codes "a\e[31m"       # => {"a"   "\e[31m"}
-    #ta_split_codes "\e[31ma"       # => {""    "\e[31m"       "a"}
-    #ta_split_codes "\e[31ma\e[0m"  # => {""    "\e[31m"       "a"  "\e[0m"}
-    #ta_split_codes "\e[31ma\e[0mb" # => {""    "\e[31m"       "a"  "\e[0m", "b"}
-    #ta_split_codes "\e[31m\e[0mb"  # => {""    "\e[31m\e[0m"  "b"}
-    #
-    proc split_codes {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
-        return [_perlish_split $re $text]
-    }
-    #like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
-    proc split_codes_single {text} {
-        variable re_esc_osc1
-        variable re_esc_osc2
-        variable re_csi_code
-        set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-        return [_perlish_split $re $text]
-    }
-
-    #review - tcl greedy expressions may match multiple in one element
-    proc _perlish_split {re text} {
-        if {[string length $text] == 0} {
-            return {}
-        }
-        set list [list]
-        set start 0
-        while {[regexp -start $start -indices -- $re $text match]} {
-            lassign $match      matchStart matchEnd
-            lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
-            set start [expr {$matchEnd+1}]
-        }
-        lappend list [string range $text $start end]
-        return $list
-    }
-    proc _ws_split {text} {
-        regexp -all -inline {(?:\S+)|(?:\s+)} $text
-    }
-    # -- --- --- --- --- --- 
-
-}
-
-# -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype {
-	interp alias {} ::overtype::center {} ::overtype::centre
-}
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide overtype [namespace eval overtype {
-    variable version
-    set version 1.5.0 
-}]
-return
\ No newline at end of file
diff --git a/src/bootsupport/modules/overtype-1.5.1.tm b/src/bootsupport/modules/overtype-1.5.1.tm
deleted file mode 100644
index 92f2464a..00000000
--- a/src/bootsupport/modules/overtype-1.5.1.tm
+++ /dev/null
@@ -1,963 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) Julian Noble 2003-2023
-#
-# @@ Meta Begin
-# Application overtype 1.5.1
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin overtype_module_overtype 0 1.5.1]
-#[copyright "2024"]
-#[titledesc {overtype text layout - ansi aware}]  [comment {-- Name section and table of contents description --}]
-#[moddesc {overtype text layout}]             [comment {-- Description at end of page heading --}] 
-#[require overtype]
-#[keywords module text ansi]
-#[description]
-#[para] -
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section Overview]
-#[para] overview of overtype 
-#[subsection Concepts]
-#[para] -
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[subsection dependencies]
-#[para] packages used by overtype 
-#[list_begin itemized]
-
-package require Tcl 8.6
-package require textutil
-package require punk::ansi  ;#required to detect, split, strip and calculate lengths
-package require punk::char  ;#box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
-#*** !doctools
-#[item] [package {Tcl 8.6}]
-#[item] [package textutil]
-#[item] [package punk::ansi]
-#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
-#[item] [package punk::char]
-#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
-
-# #package require frobz
-# #*** !doctools
-# #[item] [package {frobz}]
-
-#*** !doctools
-#[list_end]
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[section API]
-
-
-#Julian Noble <julian@precisium.com.au> - 2003 
-#Released under standard 'BSD license' conditions.
-#
-#todo - ellipsis truncation indicator for center,right
-
-#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
-# - need to extract and replace ansi codes?
-
-namespace eval overtype {
-	namespace export *
-    variable default_ellipsis_horizontal "..." ;#fallback 
-    variable default_ellipsis_vertical "..." 
-    namespace eval priv {
-        proc _init {} {
-            upvar ::overtype::default_ellipsis_horizontal e_h
-            upvar ::overtype::default_ellipsis_vertical e_v
-            set e_h [format %c 0x2026] ;#Unicode Horizontal Ellipsis
-            set e_v [format %c 0x22EE]
-            #The unicode ellipsis looks more natural than triple-dash which is centred vertically whereas ellipsis is at floorline of text
-            #Also - unicode ellipsis has semantic meaning that other processors can interpret
-            #unicode does also provide a midline horizontal ellipsis 0x22EF
-
-            #set e [format %c 0x2504] ;#punk::char::charshort boxd_ltdshhz  - Box Drawings Light Triple Dash Horizontal
-            #if {![catch {package require punk::char}]} {
-            #    set e [punk::char::charshort boxd_ltdshhz] 
-            #}
-        }
-    }
-    priv::_init
-}
-proc overtype::about {} {
-	return "Simple text formatting. Author JMN. BSD-License"
-}
-
-namespace eval overtype {
-    variable escape_terminals
-    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
-    dict set escape_terminals CSI [list @ \\ ^ _ ` | ~ a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z "\{" "\}"]
-    #dict set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
-    dict set escape_terminals OSC [list \007 \033\\] ;#note mix of 1 and 2-byte terminals 
-
-    #self-contained 2 byte ansi escape sequences - review more?
-    variable ansi_2byte_codes_dict
-    set  ansi_2byte_codes_dict [dict create\
-        "reset_terminal"            "\u001bc"\
-        "save_cursor_posn"          "\u001b7"\
-        "restore_cursor_posn"       "\u001b8"\
-        "cursor_up_one"             "\u001bM"\
-        "NEL - Next Line"           "\u001bE"\
-        "IND - Down one line"       "\u001bD"\
-        "HTS - Set Tab Stop"        "\u001bH"\
-        ]
-
-        #debatable whether strip should reveal the somethinghidden - some terminals don't hide it anyway.
-        #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
-}
-
-
-#proc overtype::stripansi {text} {
-#    variable escape_terminals  ;#dict
-#    variable ansi_2byte_codes_dict
-#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-#        #\033 same as \x1b
-#        return $text
-#    }
-#
-#    set text [convert_g0 $text] 
-#
-#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-#    set inputlist [split $text ""]
-#    set outputlist [list] 
-#
-#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-#
-#    set in_escapesequence 0
-#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-#    set i 0
-#    foreach u $inputlist {
-#        set v [lindex $inputlist $i+1]
-#        set uv ${u}${v}
-#        if {$in_escapesequence eq "2b"} {
-#            #2nd byte - done.
-#            set in_escapesequence 0
-#        } elseif {$in_escapesequence != 0} {
-#            set escseq [dict get $escape_terminals $in_escapesequence]
-#            if {$u in $escseq} {
-#                set in_escapesequence 0
-#            } elseif {$uv in $escseq} {
-#                set in_escapseequence 2b ;#flag next byte as last in sequence
-#            }
-#        } else {
-#            #handle both 7-bit and 8-bit CSI and OSC
-#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-#                set in_escapesequence CSI
-#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-#                set in_escapesequence OSC
-#            } elseif {$uv in $2bytecodes} {
-#                #self-contained e.g terminal reset - don't pass through.
-#                set in_escapesequence 2b
-#            } else {
-#                lappend outputlist $u
-#            }
-#        }
-#        incr i
-#    }
-#    return [join $outputlist ""]
-#}
-
-
-
-
-
-proc overtype::string_columns {text} {
-    if {[punk::ansi::ta::detect $text]} {
-        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
-    }
-    return [punk::char::string_width $text]
-}
-
-
-#string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
-proc overtype::left {args} {
-	# @c overtype starting at left (overstrike) 
-	# @c can/should we use something like this?: 'format "%-*s" $len $overtext 
-    variable default_ellipsis_horizontal
-
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] underblock overblock
-    set defaults [dict create\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::left unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    set overlines  [split $overblock \n]
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set undertext_printlen [punk::ansi::printing_length $undertext]
-        set overlen [punk::ansi::printing_length $overtext]
-        set diff [expr {$overlen - $colwidth}]
-
-        #review
-        #append overtext "\033\[0m"
-
-        if {$diff > 0} {
-            #background line is narrower 
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {![dict get $opts -overflow]} {
-                #set overtext [string range $overtext 0 $colwidth-1] ;#string range won't be correct e.g if contains ansi codes or leading \r or \b etc
-                if {[dict get $opts -ellipsis]} {
-                    set rendered [overtype::right $rendered $opt_ellipsistext]
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #we know overtext is shorter or equal
-            lappend outputlines [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-
-}
-
-namespace eval overtype::piper {
-    proc overcentre {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-bias left|right? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::centre {*}$argsflags $under $over
-    }
-    proc overleft {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <column>? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::left {*}$argsflags $under $over
-    }
-}
-#todo - left-right ellipsis ?
-proc overtype::centre {args} {
-    variable default_ellipsis_horizontal
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-bias [left|right]?  ?-overflow [1|0]? undertext overtext}
-	}
-	
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    set defaults [dict create\
-        -bias       left\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    set overlines  [split $overblock \n]
-    set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        #set olen [punk::ansi::printing_length $overtext]
-        set ulen [punk::ansi::printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        #review
-        #append overtext "\033\[0m"
-
-        set under_exposed [expr {$colwidth - $overblock_width}]
-        if {$under_exposed > 0} {
-            #background block is wider
-            if {$under_exposed % 2 == 0} {
-                #even left/right exposure
-                set left_exposed [expr {$under_exposed / 2}]
-            } else {
-                set beforehalf [expr {$under_exposed / 2}] ;#1 less than half due to integer division
-                if {[string tolower [dict get $opts -bias]] eq "left"} {
-                    set left_exposed $beforehalf
-                } else {
-                    #bias to the right
-                    set left_exposed [expr {$beforehalf + 1}]
-                }
-            }
-            
-            if 0 {
-            set rhs [expr {$diff - $half - 1}]
-            set lhs [expr {$half - 1}]
-            set rhsoffset [expr {$rhs +1}]
-            set a [string range $undertext 0 $lhs]
-            set background [string range $undertext $lhs+1 end-$rhsoffset]
-            set b [renderline -transparent $opt_transparent $background $overtext]
-            set c [string range $undertext end-$rhs end]
-            lappend outputlines $a$b$c
-            }
-            lappend outputlines [renderline -start $left_exposed -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-
-        } else {
-            #overlay wider or equal
-            set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {$under_exposed < 0} {
-                #overlay is wider - trim if overflow not specified in opts
-                if {![dict get $opts -overflow]} {
-                    #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
-                    #set overtext [string range $overtext 0 $colwidth-1 ]
-                    if {[dict get $opts -ellipsis]} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            } else {
-                #zero under_exposed - widths match
-            }
-            lappend outputlines $rendered
-            #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-}
-
-proc overtype::right {args} {
-    variable default_ellipsis_horizontal
-	# @d !todo - implement overflow, length checks etc
-
-	if {[llength $args] < 2} {
-		error {usage: ?-overflow [1|0]? undertext overtext}
-	}
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    set defaults [dict create\
-        -bias       left\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis         [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_overflow        [dict get $opts -overflow]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-    
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    set overlines  [split $overblock \n]
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set olen [punk::ansi::printing_length $overtext]
-        set ulen [punk::ansi::printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        #review
-        #append overtext "\033\[0m"
-
-        set overflowlength [expr {$olen - $colwidth}]
-        if {$overflowlength > 0} {	
-            #overtext wider than undertext column
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -start 0 $undertext $overtext]
-            if {!$opt_overflow} {
-                if {$opt_ellipsis} {
-                    set rendered [overtype::right $rendered $opt_ellipsistext]
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #lappend outputlines [string range $undertext 0 end-$olen]$overtext
-            lappend outputlines [renderline -transparent $opt_transparent -start [expr {$colwidth - $olen}] $undertext $overtext]
-        }
-    }
-
-    return [join $outputlines \n]
-}
-
-# -- --- --- --- --- --- --- --- --- --- ---
-proc overtype::transparentline {args} {
-    foreach {under over} [lrange $args end-1 end] break
-    set argsflags [lrange $args 0 end-2]
-    set defaults [dict create\
-        -transparent 1\
-        -exposed 1 " "\
-        -exposed 2 " "\
-    ]
-    set newargs [dict merge $defaults $argsflags]
-    tailcall overtype::renderline {*}$newargs $under $over
-}
-#renderline may not make sense as it is in the long run for blocks of text - but is handy in the single-line-handling form anyway.
-# We are trying to handle ansi codes in a block of text which is acting like a mini-terminal in some sense.
-#We can process standard cursor moves such as \b \r - but no way to respond to other cursor movements e.g moving to other lines.
-#
-namespace eval overtype::piper {
-    proc renderline {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        foreach {over under} [lrange $args end-1 end] break
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::renderline {*}$argsflags $under $over
-    }
-}
-interp alias "" piper_renderline "" overtype::piper::renderline 
-
-#-returnextra to enable returning of overflow and length
-# todo - use punk::ansi::ta::detect to short-circuit processing and do simple string calcs as an optimisation?
-#review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
-#todo - review transparency issues with single/double width characters!
-proc overtype::renderline {args} {
-	if {[llength $args] < 2} {
-		error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] under over
-    if {[string first \n $under] >=0 || [string first \n $over] >= 0} {
-        error "overtype::renderline not allowed to contain newlines"
-    }
-    set defaults [dict create\
-        -overflow   0\
-        -transparent 0\
-        -start 0\
-        -returnextra 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    #exposed1 and exposed2 for first and second col of underying 2wide char which is truncated by transparency or overflow
-
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::renderline unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_overflow            [dict get $opts -overflow]
-    set opt_colstart            [dict get $opts -start]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_transparent         [dict get $opts -transparent]  
-    if {$opt_transparent eq "0"} {
-        set do_transparency 0
-    } else {
-        set do_transparency 1
-        if {$opt_transparent eq "1"} {
-            set opt_transparent {[\s]}
-        }
-    }
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_returnextra         [dict get $opts -returnextra]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_exposed1            [dict get $opts -exposed1]
-    set opt_exposed2            [dict get $opts -exposed2]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-
-    #-----
-    #
-    if {[string first \t $under] >= 0} {
-        #set under [textutil::tabify::untabify2 $under]
-        set under [textutil::tabify::untabifyLine $under 8] ;#8 is default for untabify2 - review
-    }
-    set overdata $over
-    if {[string first \t $over] >= 0} {
-        #set overdata [textutil::tabify::untabify2 $over]
-        set overdata [textutil::tabify::untabifyLine $over 8]
-    }
-    #-------
-
-    #ta_detect ansi and do simpler processing?
-
-
-    # -- --- --- --- --- --- --- ---
-    set undermap [punk::ansi::ta::split_codes_single $under]
-    set understacks [dict create]
-
-    set i_u -1
-    set i_o 0 
-    set out [list] 
-    set u_codestack [list]
-    set pt_underchars "" ;#for string_columns length calculation for overflow 0 truncation
-    set remainder [list] ;#for returnextra
-    foreach {pt code} $undermap {
-        #pt = plain text
-        append pt_underchars $pt
-        foreach ch [split $pt ""] {
-            set width [punk::char::string_width $ch]
-            incr i_u
-            dict set understacks $i_u $u_codestack 
-            lappend out $ch
-            if {$width > 1} {
-                #presumably there are no triple-column or wider unicode chars.. until the aliens arrive.(?)
-                incr i_u
-                dict set understacks $i_u $u_codestack 
-                lappend out ""
-            }
-        }
-        #underlay should already have been rendered and not have non-sgr codes - but let's check for and not stack them if other codes are here
-        if {[priv::is_sgr $code]} {
-            if {[priv::has_sgr_leadingreset $code]} {
-                set u_codestack [list $code]
-            } else {
-                lappend u_codestack $code
-            }
-        }
-        #consider also other codes that should be stacked..?
-    }
-    #trailing codes in effect for underlay
-    if {[llength $undermap]} {
-        dict set understacks [expr {$i_u + 1}] $u_codestack
-    }
-
-
-    # -- --- --- --- --- --- --- ---
-    ####
-    #if opt_colstart - we need to build a space (or any singlewidth char really) padding on the left of the right number of columns.
-    #this will be processed as transparent - and handle doublewidth underlay characters appropriately
-    set startpad [string repeat " " $opt_colstart]
-    append startpad $overdata ;#overdata with left padding spaces based on col-start under will show through for left-padding portion regardless of -transparency
-    set overmap  [punk::ansi::ta::split_codes_single $startpad]
-    ####
-
-
-
-    set overstacks [dict create]
-    set o_codestack [list]
-    set pt_overchars ""
-    foreach {pt code} $overmap {
-        append pt_overchars $pt
-        foreach ch [split $pt ""] {
-           dict set overstacks $i_o $o_codestack 
-           incr i_o 
-        }
-        if {[priv::is_sgr $code]} {
-            #only stack SGR (graphics rendition) codes - not title sets, cursor moves etc 
-            if {[priv::has_sgr_leadingreset $code]} {
-                #m code which has sgr reset at start - no need to replay prior sgr codes 
-                set o_codestack [list $code]
-            } else {
-                lappend o_codestack $code
-            }
-        }
-    }
-    # -- --- --- --- --- --- --- ---
-
-
-
-
-    set bs [format %c 0x08]
-    set idx 0 ;# line index  (cursor - 1)
-    set idx_over -1
-    foreach {pt code} $overmap {
-        set ptchars [split $pt ""] ;#for lookahead
-        #emit plaintext chars first using existing SGR codes from under/over stack as appropriate
-        #then check if the following code is a cursor movement within the line and adjust index if so
-        foreach ch $ptchars {
-            incr idx_over
-            if {$ch eq "\r"} {
-                set idx $opt_colstart
-            } elseif {$ch eq "\b"} {
-                #review - backspace effect on double-width chars
-                if {$idx > $opt_colstart} {
-                    incr idx -1
-                }
-            } elseif {($idx < $opt_colstart)} {
-                incr idx
-            } elseif {($do_transparency && [regexp $opt_transparent $ch])} {    
-                #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
-                set owidth [punk::char::string_width $ch]
-                if {$idx > [llength $out]-1} {
-                    lappend out " "
-                    dict set understacks $idx [list] ;#review - use idx-1 codestack?
-                    incr idx
-                } else {
-                    set uwidth [punk::char::string_width [lindex $out $idx]]
-                    if {[lindex $out $idx] eq ""} {
-                        #2nd col of 2-wide char in underlay 
-                        incr idx
-                    } elseif {$uwidth == 0} {
-                        #e.g combining diacritic
-                        incr idx
-                    } elseif {$uwidth == 1} {
-                        incr idx
-                        if {$owidth > 1} {
-                            incr idx
-                        } 
-                    } elseif {$uwidth > 1} {
-                        if {[punk::char::string_width $ch] == 1} {
-                            #normal singlewide transparency 
-                            set next_pt_overchar [string index $pt_overchars $idx_over+1] ;#lookahead of next plain-text char in overlay
-                            if {$next_pt_overchar eq ""} {
-                                #special-case trailing transparent - no next_pt_overchar
-                                incr idx
-                            } else {
-                                if {[regexp $opt_transparent $next_pt_overchar]} {
-                                    incr idx
-                                } else {
-                                    #next overlay char is not transparent.. first-half of underlying 2wide char is exposed 
-                                    priv::render_addchar $idx $opt_exposed1 [dict get $overstacks $idx_over]
-                                    incr idx
-                                }
-                            }
-                        } else {
-                            #2wide transparency over 2wide in underlay
-                            incr idx
-                        }
-                    }
-                }
-            } else {
-                #non-transparent char in overlay
-                set owidth [punk::char::string_width $ch]
-                set uwidth [punk::char::string_width [lindex $out $idx]]
-                if {[lindex $out $idx] eq ""} {
-                    #2nd col of 2wide char in underlay
-                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                    incr idx
-                } elseif {$uwidth == 0} {
-                    #e.g combining diacritic - increment before over char  REVIEW
-                    #arguably the previous overchar should have done this - ie lookahead for combiners?
-                    priv::render_addchar $idx "" [dict get $overstacks $idx_over]
-                    incr idx
-                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                    incr idx
-
-                } elseif {$uwidth == 1} {
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                    } else {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx ""  [dict get $overstacks $idx_over]
-                    }
-                } elseif {$uwidth > 1} {
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx $opt_exposed2 [dict get $overstacks $idx_over]
-                        #don't incr idx - we are just putting a broken-indication in the underlay - which may get overwritten by next overlay char
-                    } else {
-                        #2wide over 2wide
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx 
-                    }
-                }
-            }
-        } 
-        #check following code
-        if {![priv::is_sgr $code]} {
-
-        }
-    }
-
-    if {$opt_overflow == 0} {
-        #need to truncate to the width of the original undertext
-        #review - string_width vs printing_length here. undertext requirement to be already rendered therefore punk::char::string_width ok?
-        set num_under_columns [punk::char::string_width $pt_underchars] ;#plaintext underchars
-    }
-
-    #coalesce and replay codestacks for out char list
-    set outstring ""    
-    set remstring "" ;#remainder after overflow point reached
-    set i 0
-    set cstack [list]
-    set prevstack [list]
-    set out_rawchars ""; #for overflow counting 
-    set output_to "outstring" ;#var in effect depending on overflow
-    set in_overflow 0 ;#used to stop char-width scanning once in overflow
-    foreach ch $out {
-        append out_rawchars $ch
-        if {$opt_overflow == 0 && !$in_overflow} {
-            if {[set nextvisualwidth [punk::char::string_width $out_rawchars]] < $num_under_columns} {
-            } else {
-                #todo - check if we overflowed with a double-width char ? 
-                #store visualwidth which may be short
-                set in_overflow 1
-            }
-        }
-        set cstack [dict get $understacks $i]
-        if {$cstack ne $prevstack} {
-            if {[llength $prevstack]} {
-                append $output_to \033\[m
-            }
-            foreach code $cstack {
-                append $output_to $code
-            }
-        }
-        append $output_to $ch
-        set prevstack $cstack
-        incr i
-        if {$in_overflow} {
-            set output_to "remstring"
-        }
-    }
-    if {[dict size $understacks] > 0} {
-        append $output_to [join [dict get $understacks [expr {[dict size $understacks]-1}]] ""] ;#tail codes
-    }
-    if {[string length $remstring]} {
-        #puts stderr "remainder:$remstring"
-    }
-    #pdict $understacks
-    if {$opt_returnextra} {
-        return [list $outstring $visualwidth [string length $outstring] $remstring]
-    } else {
-        return $outstring
-    }
-    #return [join $out ""]
-}
-proc overtype::test_renderline {} {
-    set t \uFF5E ;#2-wide tilde
-    set u \uFF3F ;#2-wide underscore
-    set missing \uFFFD
-    return [list $t $u A${t}B]
-}
-namespace eval overtype::priv {
-    #todo - move to punk::ansi::codetype
-    proc is_sgr {code} {
-        #SGR (Select Graphic Rendition) - codes ending in 'm' - e.g colour/underline 
-        #we will accept and pass through the less common colon separator (ITU Open Document Architecture) 
-        #Terminals should generally ignore it if they don't use it
-        regexp {\033\[[0-9;:]*m$} $code
-    }
-    proc is_cursor_move_in_line {code} {
-        #review - what about CSI n : m H where row n happens to be current line?
-        regexp {\033\[[0-9]*(:?C|D|G)$}
-    }
-    #pure SGR reset
-    proc is_sgr_reset {code} {
-        #todo 8-bit csi
-        regexp {\033\[0*m$} $code
-    }
-    #whether this code has 0 (or equivalently empty) parameter (but may set others)
-    #if an SGR code as a reset in it - we don't need to carry forward any previous SGR codes
-    #it generally only makes sense for the reset to be the first entry - otherwise the code has ineffective portions
-    #However - detecting zero or empty parameter in other positions requires knowing all other codes that may allow zero or empty params.
-    #We will only look at initial parameter as this is the well-formed normal case.  
-    #Review - consider normalizing sgr codes to remove other redundancies such as setting fg or bg color twice in same code
-    proc has_sgr_leadingreset {code} {
-        set params ""
-        regexp {\033\[(.*)m} $code _match params
-        set plist [split $params ";"]
-        if {[string trim [lindex $plist 0] 0] eq ""} {
-            #e.g \033\[m  \033\[0\;...m  \033\[0000...m
-            return 1
-        } else {
-            return 0
-        }
-    }
-    #has_sgr_reset  - rather than support this - create an sgr normalize function that removes dead params and brings reset to front of param list
-    proc render_addchar {i c stack} {
-        upvar out o
-        upvar understacks ustacks
-        set nxt [llength $o] 
-        if {$i < $nxt} {
-            lset o $i $c
-        } else {
-            lappend o $c
-        }
-        dict set ustacks $i $stack
-    }
-
-}
-
-
-# -- --- --- --- --- --- --- --- --- --- ---
-if 0 {
-namespace eval overtype::ta {
-    namespace path ::overtype
-    # *based* on but not identical to:
-    #https://github.com/perlancar/perl-Text-ANSI-Util/blob/master/lib/Text/ANSI/BaseUtil.pm
-
-    #handle both 7-bit and 8-bit csi 
-    #review - does codepage affect this? e.g ebcdic has 8bit csi in different position
-
-    #CSI
-    #variable re_csi_open {(?:\033\[|\u009b)[0-9;]+} ;#too specific - doesn't detect \033\[m
-    variable re_csi_open {(?:\033\[|\u009b])}
-
-    #colour and style
-    variable re_csi_colour {(?:\033\[|\u009b)[0-9;]*m} ;#e.g \033\[31m  \033\[m  \033\[0m \033\[m0000m
-    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
-    variable re_csi_code  {(?:\033\[|\u009b])[0-9;]*[a-zA-Z\\@^_|~`]}
-
-    #OSC - termnate with BEL (\a \007) or ST (string terminator \033\\)
-    #variable re_esc_osc1 {(?:\033\]|\u009c).*\007}
-    #variable re_esc_osc2 {(?:\033\]|\u009c).*\033\\}
-
-    #test - non-greedy
-    variable re_esc_osc1 {(?:\033\]|\u009c).*?\007}
-    variable re_esc_osc2 {(?:\033\]|\u009c).*?\033\\}
-
-    variable re_ansi_detect "${re_csi_open}|${re_esc_osc1}|${re_esc_osc2}"
-
-    #detect any ansi escapes
-    #review - only detect 'complete' codes - or just use the opening escapes for performance?
-    #proc detect {text} {
-    #    variable re_ansi_detect
-    #    #variable re_csi_open
-    #    #variable re_esc_osc1
-    #    #variable re_esc_osc2
-    #    #todo - other escape sequences
-    #    #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
-    #    expr {[regexp $re_ansi_detect $text]}
-    #}
-    #not in perl ta
-    #proc detect_csi {text} {
-    #    variable re_csi_colour
-    #    expr {[regexp $re_csi_colour $text]}
-    #}
-    proc strip {text} {
-        tailcall punk::ansi::stripansi $text
-    }
-    #note this is character length after stripping ansi codes - not the printing length
-    proc length {text} {
-        string length [punk::ansi::stripansi $text]
-    }
-
-    
-    # -- --- --- --- --- --- 
-    #Split $text to a list containing alternating ANSI color codes and text.
-    #ANSI color codes are always on the second element, fourth, and so on.
-    #(ie plaintext on odd list-indices ansi on even indices)
-    # Example:
-    #ta_split_codes ""              # => ""
-    #ta_split_codes "a"             # => "a"
-    #ta_split_codes "a\e[31m"       # => {"a"   "\e[31m"}
-    #ta_split_codes "\e[31ma"       # => {""    "\e[31m"       "a"}
-    #ta_split_codes "\e[31ma\e[0m"  # => {""    "\e[31m"       "a"  "\e[0m"}
-    #ta_split_codes "\e[31ma\e[0mb" # => {""    "\e[31m"       "a"  "\e[0m", "b"}
-    #ta_split_codes "\e[31m\e[0mb"  # => {""    "\e[31m\e[0m"  "b"}
-    #
-    #proc split_codes {text} {
-    #    variable re_esc_osc1
-    #    variable re_esc_osc2
-    #    variable re_csi_code
-    #    set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
-    #    return [_perlish_split $re $text]
-    #}
-    ##like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
-    #proc split_codes_single {text} {
-    #    variable re_esc_osc1
-    #    variable re_esc_osc2
-    #    variable re_csi_code
-    #    set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-    #    return [_perlish_split $re $text]
-    #}
-
-    ##review - tcl greedy expressions may match multiple in one element
-    #proc _perlish_split {re text} {
-    #    if {[string length $text] == 0} {
-    #        return {}
-    #    }
-    #    set list [list]
-    #    set start 0
-    #    while {[regexp -start $start -indices -- $re $text match]} {
-    #        lassign $match      matchStart matchEnd
-    #        lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
-    #        set start [expr {$matchEnd+1}]
-    #    }
-    #    lappend list [string range $text $start end]
-    #    return $list
-    #}
-    ## -- --- --- --- --- --- 
-
-}
-} ;# end if 0
-
-# -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype {
-	interp alias {} ::overtype::center {} ::overtype::centre
-}
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide overtype [namespace eval overtype {
-    variable version
-    set version 1.5.1 
-}]
-return
-
-#*** !doctools
-#[manpage_end]
diff --git a/src/bootsupport/modules/overtype-1.5.3.tm b/src/bootsupport/modules/overtype-1.5.3.tm
deleted file mode 100644
index 6b54a4ac..00000000
--- a/src/bootsupport/modules/overtype-1.5.3.tm
+++ /dev/null
@@ -1,1037 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) Julian Noble 2003-2023
-#
-# @@ Meta Begin
-# Application overtype 1.5.3
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin overtype_module_overtype 0 1.5.3]
-#[copyright "2024"]
-#[titledesc {overtype text layout - ansi aware}]  [comment {-- Name section and table of contents description --}]
-#[moddesc {overtype text layout}]             [comment {-- Description at end of page heading --}] 
-#[require overtype]
-#[keywords module text ansi]
-#[description]
-#[para] -
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[section Overview]
-#[para] overview of overtype 
-#[subsection Concepts]
-#[para] -
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Requirements
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-
-#*** !doctools
-#[subsection dependencies]
-#[para] packages used by overtype 
-#[list_begin itemized]
-
-package require Tcl 8.6
-package require textutil
-package require punk::ansi  ;#required to detect, split, strip and calculate lengths
-package require punk::char  ;#box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
-#*** !doctools
-#[item] [package {Tcl 8.6}]
-#[item] [package textutil]
-#[item] [package punk::ansi]
-#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
-#[item] [package punk::char]
-#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
-
-# #package require frobz
-# #*** !doctools
-# #[item] [package {frobz}]
-
-#*** !doctools
-#[list_end]
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[section API]
-
-
-#Julian Noble <julian@precisium.com.au> - 2003 
-#Released under standard 'BSD license' conditions.
-#
-#todo - ellipsis truncation indicator for center,right
-
-#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
-# - need to extract and replace ansi codes?
-
-namespace eval overtype {
-	namespace export *
-    variable default_ellipsis_horizontal "..." ;#fallback 
-    variable default_ellipsis_vertical "..." 
-    namespace eval priv {
-        proc _init {} {
-            upvar ::overtype::default_ellipsis_horizontal e_h
-            upvar ::overtype::default_ellipsis_vertical e_v
-            set e_h [format %c 0x2026] ;#Unicode Horizontal Ellipsis
-            set e_v [format %c 0x22EE]
-            #The unicode ellipsis looks more natural than triple-dash which is centred vertically whereas ellipsis is at floorline of text
-            #Also - unicode ellipsis has semantic meaning that other processors can interpret
-            #unicode does also provide a midline horizontal ellipsis 0x22EF
-
-            #set e [format %c 0x2504] ;#punk::char::charshort boxd_ltdshhz  - Box Drawings Light Triple Dash Horizontal
-            #if {![catch {package require punk::char}]} {
-            #    set e [punk::char::charshort boxd_ltdshhz] 
-            #}
-        }
-    }
-    priv::_init
-}
-proc overtype::about {} {
-	return "Simple text formatting. Author JMN. BSD-License"
-}
-
-namespace eval overtype {
-    variable escape_terminals
-    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
-    dict set escape_terminals CSI [list @ \\ ^ _ ` | ~ a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z "\{" "\}"]
-    #dict set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
-    dict set escape_terminals OSC [list \007 \033\\] ;#note mix of 1 and 2-byte terminals 
-
-    #self-contained 2 byte ansi escape sequences - review more?
-    variable ansi_2byte_codes_dict
-    set  ansi_2byte_codes_dict [dict create\
-        "reset_terminal"            "\u001bc"\
-        "save_cursor_posn"          "\u001b7"\
-        "restore_cursor_posn"       "\u001b8"\
-        "cursor_up_one"             "\u001bM"\
-        "NEL - Next Line"           "\u001bE"\
-        "IND - Down one line"       "\u001bD"\
-        "HTS - Set Tab Stop"        "\u001bH"\
-        ]
-
-        #debatable whether strip should reveal the somethinghidden - some terminals don't hide it anyway.
-        #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
-}
-
-
-#proc overtype::stripansi {text} {
-#    variable escape_terminals  ;#dict
-#    variable ansi_2byte_codes_dict
-#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-#        #\033 same as \x1b
-#        return $text
-#    }
-#
-#    set text [convert_g0 $text] 
-#
-#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-#    set inputlist [split $text ""]
-#    set outputlist [list] 
-#
-#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-#
-#    set in_escapesequence 0
-#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-#    set i 0
-#    foreach u $inputlist {
-#        set v [lindex $inputlist $i+1]
-#        set uv ${u}${v}
-#        if {$in_escapesequence eq "2b"} {
-#            #2nd byte - done.
-#            set in_escapesequence 0
-#        } elseif {$in_escapesequence != 0} {
-#            set escseq [dict get $escape_terminals $in_escapesequence]
-#            if {$u in $escseq} {
-#                set in_escapesequence 0
-#            } elseif {$uv in $escseq} {
-#                set in_escapseequence 2b ;#flag next byte as last in sequence
-#            }
-#        } else {
-#            #handle both 7-bit and 8-bit CSI and OSC
-#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-#                set in_escapesequence CSI
-#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-#                set in_escapesequence OSC
-#            } elseif {$uv in $2bytecodes} {
-#                #self-contained e.g terminal reset - don't pass through.
-#                set in_escapesequence 2b
-#            } else {
-#                lappend outputlist $u
-#            }
-#        }
-#        incr i
-#    }
-#    return [join $outputlist ""]
-#}
-
-
-
-
-
-proc overtype::string_columns {text} {
-    if {[punk::ansi::ta::detect $text]} {
-        error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
-    }
-    return [punk::char::string_width $text]
-}
-
-
-#string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
-proc overtype::left {args} {
-	# @c overtype starting at left (overstrike) 
-	# @c can/should we use something like this?: 'format "%-*s" $len $overtext 
-    variable default_ellipsis_horizontal
-
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] underblock overblock
-    set defaults [dict create\
-        -bias       ignored\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::left unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_exposed1        [dict get $opts -exposed1] ;#widechar_exposed_left  - todo
-    set opt_exposed2        [dict get $opts -exposed2] ;#widechar_exposed_right - todo
-    # -- --- --- --- --- ---
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    set right_exposed $under_exposed_max 
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set undertext_printlen [punk::ansi::printing_length $undertext]
-        if {$undertext_printlen < $colwidth} {
-            set udiff [expr {$colwidth - $undertext_printlen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        set overtext_printlen [punk::ansi::printing_length $overtext]
-        set overflowlength [expr {$overtext_printlen - $colwidth}]
-
-        #review
-        #append overtext "\033\[0m"
-
-
-        if {$overflowlength > 0} {
-            #background line is narrower than data in line
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {![dict get $opts -overflow]} {
-                #set overtext [string range $overtext 0 $colwidth-1] ;#string range won't be correct e.g if contains ansi codes or leading \r or \b etc
-                if {[dict get $opts -ellipsis]} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #we know overtext data is shorter or equal (for this line)
-            lappend outputlines [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-
-}
-
-namespace eval overtype::piper {
-    proc overcentre {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-bias left|right? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::centre {*}$argsflags $under $over
-    }
-    proc overleft {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <column>? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::left {*}$argsflags $under $over
-    }
-}
-#todo - left-right ellipsis ?
-proc overtype::centre {args} {
-    variable default_ellipsis_horizontal
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-bias [left|right]?  ?-overflow [1|0]? undertext overtext}
-	}
-	
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    #todo - vertical vs horizontal overflow for blocks
-    set defaults [dict create\
-        -bias       left\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis        [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    if {$under_exposed_max > 0} {
-        #background block is wider
-        if {$under_exposed_max % 2 == 0} {
-            #even left/right exposure
-            set left_exposed [expr {$under_exposed_max / 2}]
-        } else {
-            set beforehalf [expr {$under_exposed_max / 2}] ;#1 less than half due to integer division
-            if {[string tolower [dict get $opts -bias]] eq "left"} {
-                set left_exposed $beforehalf
-            } else {
-                #bias to the right
-                set left_exposed [expr {$beforehalf + 1}]
-            }
-        }
-    } else {
-        set left_exposed 0
-    }
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set overtext_datalen [punk::ansi::printing_length $overtext]
-        set ulen [punk::ansi::printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-
-        set overflowlength [expr {$overtext_datalen - $colwidth}]
-        #review - right-to-left langs should elide on left! - extra option required
-
-        if {$overflowlength > 0} {
-            #overlay line wider or equal
-            set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-            #overlay line data is wider - trim if overflow not specified in opts - and overtype an ellipsis at right if it was specified
-            if {![dict get $opts -overflow]} {
-                #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
-                #set overtext [string range $overtext 0 $colwidth-1 ]
-                if {$opt_ellipsis} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-            #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
-        } else {
-            #background block is wider than or equal to data for this line
-            lappend outputlines [renderline -start $left_exposed -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-}
-
-proc overtype::right {args} {
-    #NOT the same as align-right - which should be done to the overblock first if required
-    variable default_ellipsis_horizontal
-	# @d !todo - implement overflow, length checks etc
-
-	if {[llength $args] < 2} {
-		error {usage: ?-overflow [1|0]? undertext overtext}
-	}
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    set defaults [dict create\
-        -bias       ignored\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis         [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_overflow        [dict get $opts -overflow]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-    
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    set left_exposed $under_exposed_max 
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set overtext_datalen [punk::ansi::printing_length $overtext]
-        set ulen [punk::ansi::printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            puts xxx
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        if {$overtext_datalen < $overblock_width} {
-            set odiff [expr {$overblock_width - $overtext_datalen}]
-            #padding always on right - if alignment is required it should be done to block beforehand - not here
-            set overtextpadding "$overtext[string repeat { } $odiff]"
-        }
-
-        set overflowlength [expr {$overtext_datalen - $colwidth}]
-        if {$overflowlength > 0} {	
-            #raw overtext wider than undertext column
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -start 0 $undertext $overtext]
-            if {!$opt_overflow} {
-                if {$opt_ellipsis} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #padded overtext 
-            lappend outputlines [renderline -transparent $opt_transparent -start $left_exposed $undertext $overtext]
-        }
-    }
-
-    return [join $outputlines \n]
-}
-
-# -- --- --- --- --- --- --- --- --- --- ---
-proc overtype::transparentline {args} {
-    foreach {under over} [lrange $args end-1 end] break
-    set argsflags [lrange $args 0 end-2]
-    set defaults [dict create\
-        -transparent 1\
-        -exposed 1 " "\
-        -exposed 2 " "\
-    ]
-    set newargs [dict merge $defaults $argsflags]
-    tailcall overtype::renderline {*}$newargs $under $over
-}
-#renderline may not make sense as it is in the long run for blocks of text - but is handy in the single-line-handling form anyway.
-# We are trying to handle ansi codes in a block of text which is acting like a mini-terminal in some sense.
-#We can process standard cursor moves such as \b \r - but no way to respond to other cursor movements e.g moving to other lines.
-#
-namespace eval overtype::piper {
-    proc renderline {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        foreach {over under} [lrange $args end-1 end] break
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::renderline {*}$argsflags $under $over
-    }
-}
-interp alias "" piper_renderline "" overtype::piper::renderline 
-
-#-returnextra to enable returning of overflow and length
-# todo - use punk::ansi::ta::detect to short-circuit processing and do simple string calcs as an optimisation?
-#review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
-#todo - review transparency issues with single/double width characters!
-proc overtype::renderline {args} {
-	if {[llength $args] < 2} {
-		error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] under over
-    if {[string first \n $under] >=0 || [string first \n $over] >= 0} {
-        error "overtype::renderline not allowed to contain newlines"
-    }
-    set defaults [dict create\
-        -overflow   0\
-        -transparent 0\
-        -start 0\
-        -returnextra 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    #exposed1 and exposed2 for first and second col of underying 2wide char which is truncated by transparency or overflow
-
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::renderline unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_overflow            [dict get $opts -overflow]
-    set opt_colstart            [dict get $opts -start]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_transparent         [dict get $opts -transparent]  
-    if {$opt_transparent eq "0"} {
-        set do_transparency 0
-    } else {
-        set do_transparency 1
-        if {$opt_transparent eq "1"} {
-            set opt_transparent {[\s]}
-        }
-    }
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_returnextra         [dict get $opts -returnextra]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_exposed1            [dict get $opts -exposed1]
-    set opt_exposed2            [dict get $opts -exposed2]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-
-    #-----
-    #
-    if {[string first \t $under] >= 0} {
-        #set under [textutil::tabify::untabify2 $under]
-        set under [textutil::tabify::untabifyLine $under 8] ;#8 is default for untabify2 - review
-    }
-    set overdata $over
-    if {[string first \t $over] >= 0} {
-        #set overdata [textutil::tabify::untabify2 $over]
-        set overdata [textutil::tabify::untabifyLine $over 8]
-    }
-    #-------
-
-    #ta_detect ansi and do simpler processing?
-
-
-    # -- --- --- --- --- --- --- ---
-    set undermap [punk::ansi::ta::split_codes_single $under]
-    set understacks [dict create]
-
-    set i_u -1
-    set i_o 0 
-    set out [list] 
-    set u_codestack [list]
-    set pt_underchars "" ;#for string_columns length calculation for overflow 0 truncation
-    set remainder [list] ;#for returnextra
-    foreach {pt code} $undermap {
-        #pt = plain text
-        append pt_underchars $pt
-        foreach ch [split $pt ""] {
-            set width [punk::char::string_width $ch]
-            incr i_u
-            dict set understacks $i_u $u_codestack 
-            lappend out $ch
-            if {$width > 1} {
-                #presumably there are no triple-column or wider unicode chars.. until the aliens arrive.(?)
-                incr i_u
-                dict set understacks $i_u $u_codestack 
-                lappend out ""
-            }
-        }
-        #underlay should already have been rendered and not have non-sgr codes - but let's check for and not stack them if other codes are here
-        if {[priv::is_sgr $code]} {
-            if {[priv::has_sgr_leadingreset $code]} {
-                set u_codestack [list $code]
-            } else {
-                lappend u_codestack $code
-            }
-        }
-        #consider also other codes that should be stacked..?
-    }
-    #trailing codes in effect for underlay
-    if {[llength $undermap]} {
-        dict set understacks [expr {$i_u + 1}] $u_codestack
-    }
-
-
-    # -- --- --- --- --- --- --- ---
-    ####
-    #if opt_colstart - we need to build a space (or any singlewidth char really) padding on the left of the right number of columns.
-    #this will be processed as transparent - and handle doublewidth underlay characters appropriately
-    set startpad [string repeat " " $opt_colstart]
-    append startpad $overdata ;#overdata with left padding spaces based on col-start under will show through for left-padding portion regardless of -transparency
-    set overmap  [punk::ansi::ta::split_codes_single $startpad]
-    ####
-
-
-
-    set overstacks [dict create]
-    set o_codestack [list]
-    set pt_overchars ""
-    foreach {pt code} $overmap {
-        append pt_overchars $pt
-        foreach ch [split $pt ""] {
-           dict set overstacks $i_o $o_codestack 
-           incr i_o 
-        }
-        if {[priv::is_sgr $code]} {
-            #only stack SGR (graphics rendition) codes - not title sets, cursor moves etc 
-            if {[priv::has_sgr_leadingreset $code]} {
-                #m code which has sgr reset at start - no need to replay prior sgr codes 
-                set o_codestack [list $code]
-            } else {
-                lappend o_codestack $code
-            }
-        }
-    }
-    # -- --- --- --- --- --- --- ---
-
-
-
-
-    set bs [format %c 0x08]
-    set idx 0 ;# line index  (cursor - 1)
-    set idx_over -1
-    foreach {pt code} $overmap {
-        set ptchars [split $pt ""] ;#for lookahead
-        #emit plaintext chars first using existing SGR codes from under/over stack as appropriate
-        #then check if the following code is a cursor movement within the line and adjust index if so
-        foreach ch $ptchars {
-            incr idx_over
-            if {$ch eq "\r"} {
-                set idx $opt_colstart
-            } elseif {$ch eq "\b"} {
-                #review - backspace effect on double-width chars
-                if {$idx > $opt_colstart} {
-                    incr idx -1
-                }
-            } elseif {($idx < $opt_colstart)} {
-                incr idx
-            } elseif {($do_transparency && [regexp $opt_transparent $ch])} {    
-                #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
-                set owidth [punk::char::string_width $ch]
-                if {$idx > [llength $out]-1} {
-                    lappend out " "
-                    dict set understacks $idx [list] ;#review - use idx-1 codestack?
-                    incr idx
-                } else {
-                    set uwidth [punk::char::string_width [lindex $out $idx]]
-                    if {[lindex $out $idx] eq ""} {
-                        #2nd col of 2-wide char in underlay 
-                        incr idx
-                    } elseif {$uwidth == 0} {
-                        #e.g combining diacritic
-                        incr idx
-                    } elseif {$uwidth == 1} {
-                        incr idx
-                        if {$owidth > 1} {
-                            incr idx
-                        } 
-                    } elseif {$uwidth > 1} {
-                        if {[punk::char::string_width $ch] == 1} {
-                            #normal singlewide transparency 
-                            set next_pt_overchar [string index $pt_overchars $idx_over+1] ;#lookahead of next plain-text char in overlay
-                            if {$next_pt_overchar eq ""} {
-                                #special-case trailing transparent - no next_pt_overchar
-                                incr idx
-                            } else {
-                                if {[regexp $opt_transparent $next_pt_overchar]} {
-                                    incr idx
-                                } else {
-                                    #next overlay char is not transparent.. first-half of underlying 2wide char is exposed 
-                                    priv::render_addchar $idx $opt_exposed1 [dict get $overstacks $idx_over]
-                                    incr idx
-                                }
-                            }
-                        } else {
-                            #2wide transparency over 2wide in underlay
-                            incr idx
-                        }
-                    }
-                }
-            } else {
-                #non-transparent char in overlay
-                set owidth [punk::char::string_width $ch]
-                set uwidth [punk::char::string_width [lindex $out $idx]]
-                if {[lindex $out $idx] eq ""} {
-                    #2nd col of 2wide char in underlay
-                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                    incr idx
-                } elseif {$uwidth == 0} {
-                    #e.g combining diacritic - increment before over char  REVIEW
-                    #arguably the previous overchar should have done this - ie lookahead for combiners?
-                    priv::render_addchar $idx "" [dict get $overstacks $idx_over]
-                    incr idx
-                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                    incr idx
-
-                } elseif {$uwidth == 1} {
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                    } else {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx ""  [dict get $overstacks $idx_over]
-                    }
-                } elseif {$uwidth > 1} {
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx $opt_exposed2 [dict get $overstacks $idx_over]
-                        #don't incr idx - we are just putting a broken-indication in the underlay - which may get overwritten by next overlay char
-                    } else {
-                        #2wide over 2wide
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx 
-                    }
-                }
-            }
-        } 
-        #check following code
-        if {![priv::is_sgr $code]} {
-
-        }
-    }
-
-    if {$opt_overflow == 0} {
-        #need to truncate to the width of the original undertext
-        #review - string_width vs printing_length here. undertext requirement to be already rendered therefore punk::char::string_width ok?
-        set num_under_columns [punk::char::string_width $pt_underchars] ;#plaintext underchars
-    }
-
-    #coalesce and replay codestacks for out char list
-    set outstring ""    
-    set remstring "" ;#remainder after overflow point reached
-    set i 0
-    set cstack [list]
-    set prevstack [list]
-    set out_rawchars ""; #for overflow counting 
-    set output_to "outstring" ;#var in effect depending on overflow
-    set in_overflow 0 ;#used to stop char-width scanning once in overflow
-    foreach ch $out {
-        append out_rawchars $ch
-        if {$opt_overflow == 0 && !$in_overflow} {
-            if {[set nextvisualwidth [punk::char::string_width $out_rawchars]] < $num_under_columns} {
-            } else {
-                #todo - check if we overflowed with a double-width char ? 
-                #store visualwidth which may be short
-                set in_overflow 1
-            }
-        }
-        set cstack [dict get $understacks $i]
-        if {$cstack ne $prevstack} {
-            if {[llength $prevstack]} {
-                append $output_to \033\[m
-            }
-            foreach code $cstack {
-                append $output_to $code
-            }
-        }
-        append $output_to $ch
-        set prevstack $cstack
-        incr i
-        if {$in_overflow} {
-            set output_to "remstring"
-        }
-    }
-    if {[dict size $understacks] > 0} {
-        append $output_to [join [dict get $understacks [expr {[dict size $understacks]-1}]] ""] ;#tail codes
-    }
-    if {[string length $remstring]} {
-        #puts stderr "remainder:$remstring"
-    }
-    #pdict $understacks
-    if {$opt_returnextra} {
-        return [list $outstring $visualwidth [string length $outstring] $remstring]
-    } else {
-        return $outstring
-    }
-    #return [join $out ""]
-}
-proc overtype::test_renderline {} {
-    set t \uFF5E ;#2-wide tilde
-    set u \uFF3F ;#2-wide underscore
-    set missing \uFFFD
-    return [list $t $u A${t}B]
-}
-
-#same as textblock::size - but we don't want that circular dependency
-proc overtype::blocksize {textblock} {
-    if {$textblock eq ""} {
-        return [dict create width 0 height 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
-    }
-    set textblock [textutil::tabify::untabify2 $textblock]
-    #stripansi on entire block in one go rather than line by line - result should be the same - review - make tests
-    set textblock [punk::ansi::stripansi $textblock]
-    if {[string first \n $textblock] >= 0} {
-        set width [tcl::mathfunc::max {*}[lmap v [lines_as_list -- $textblock] {::punk::char::string_width $v}]]
-    } else {
-        set width [punk::char::string_width $textblock] 
-    }
-    set num_le [expr {[string length $textblock]-[string length [string map [list \n {}] $textblock]]}] ;#faster than splitting into single-char list
-    #our concept of block-height is likely to be different to other line-counting mechanisms
-    set height [expr {$num_le + 1}] ;# one line if no le - 2 if there is one trailing le even if no data follows le
-
-    return [dict create width $width height $height] ;#maintain order in 'image processing' standard width then height - caller may use lassign [dict values [blocksize <data>]] width height
-}
-
-namespace eval overtype::priv {
-
-
-    #todo - move to punk::ansi::codetype
-    proc is_sgr {code} {
-        #SGR (Select Graphic Rendition) - codes ending in 'm' - e.g colour/underline 
-        #we will accept and pass through the less common colon separator (ITU Open Document Architecture) 
-        #Terminals should generally ignore it if they don't use it
-        regexp {\033\[[0-9;:]*m$} $code
-    }
-    proc is_cursor_move_in_line {code} {
-        #review - what about CSI n : m H where row n happens to be current line?
-        regexp {\033\[[0-9]*(:?C|D|G)$}
-    }
-    #pure SGR reset
-    proc is_sgr_reset {code} {
-        #todo 8-bit csi
-        regexp {\033\[0*m$} $code
-    }
-    #whether this code has 0 (or equivalently empty) parameter (but may set others)
-    #if an SGR code as a reset in it - we don't need to carry forward any previous SGR codes
-    #it generally only makes sense for the reset to be the first entry - otherwise the code has ineffective portions
-    #However - detecting zero or empty parameter in other positions requires knowing all other codes that may allow zero or empty params.
-    #We will only look at initial parameter as this is the well-formed normal case.  
-    #Review - consider normalizing sgr codes to remove other redundancies such as setting fg or bg color twice in same code
-    proc has_sgr_leadingreset {code} {
-        set params ""
-        regexp {\033\[(.*)m} $code _match params
-        set plist [split $params ";"]
-        if {[string trim [lindex $plist 0] 0] eq ""} {
-            #e.g \033\[m  \033\[0\;...m  \033\[0000...m
-            return 1
-        } else {
-            return 0
-        }
-    }
-    #has_sgr_reset  - rather than support this - create an sgr normalize function that removes dead params and brings reset to front of param list
-    proc render_addchar {i c stack} {
-        upvar out o
-        upvar understacks ustacks
-        set nxt [llength $o] 
-        if {$i < $nxt} {
-            lset o $i $c
-        } else {
-            lappend o $c
-        }
-        dict set ustacks $i $stack
-    }
-
-}
-
-
-# -- --- --- --- --- --- --- --- --- --- ---
-if 0 {
-namespace eval overtype::ta {
-    namespace path ::overtype
-    # *based* on but not identical to:
-    #https://github.com/perlancar/perl-Text-ANSI-Util/blob/master/lib/Text/ANSI/BaseUtil.pm
-
-    #handle both 7-bit and 8-bit csi 
-    #review - does codepage affect this? e.g ebcdic has 8bit csi in different position
-
-    #CSI
-    #variable re_csi_open {(?:\033\[|\u009b)[0-9;]+} ;#too specific - doesn't detect \033\[m
-    variable re_csi_open {(?:\033\[|\u009b])}
-
-    #colour and style
-    variable re_csi_colour {(?:\033\[|\u009b)[0-9;]*m} ;#e.g \033\[31m  \033\[m  \033\[0m \033\[m0000m
-    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
-    variable re_csi_code  {(?:\033\[|\u009b])[0-9;]*[a-zA-Z\\@^_|~`]}
-
-    #OSC - termnate with BEL (\a \007) or ST (string terminator \033\\)
-    #variable re_esc_osc1 {(?:\033\]|\u009c).*\007}
-    #variable re_esc_osc2 {(?:\033\]|\u009c).*\033\\}
-
-    #test - non-greedy
-    variable re_esc_osc1 {(?:\033\]|\u009c).*?\007}
-    variable re_esc_osc2 {(?:\033\]|\u009c).*?\033\\}
-
-    variable re_ansi_detect "${re_csi_open}|${re_esc_osc1}|${re_esc_osc2}"
-
-    #detect any ansi escapes
-    #review - only detect 'complete' codes - or just use the opening escapes for performance?
-    #proc detect {text} {
-    #    variable re_ansi_detect
-    #    #variable re_csi_open
-    #    #variable re_esc_osc1
-    #    #variable re_esc_osc2
-    #    #todo - other escape sequences
-    #    #expr {[regexp $re_csi_open $text] || [regexp $re_esc_osc1 $text] || [regexp $re_esc_osc2 $text]} 
-    #    expr {[regexp $re_ansi_detect $text]}
-    #}
-    #not in perl ta
-    #proc detect_csi {text} {
-    #    variable re_csi_colour
-    #    expr {[regexp $re_csi_colour $text]}
-    #}
-    proc strip {text} {
-        tailcall punk::ansi::stripansi $text
-    }
-    #note this is character length after stripping ansi codes - not the printing length
-    proc length {text} {
-        string length [punk::ansi::stripansi $text]
-    }
-
-    
-    # -- --- --- --- --- --- 
-    #Split $text to a list containing alternating ANSI color codes and text.
-    #ANSI color codes are always on the second element, fourth, and so on.
-    #(ie plaintext on odd list-indices ansi on even indices)
-    # Example:
-    #ta_split_codes ""              # => ""
-    #ta_split_codes "a"             # => "a"
-    #ta_split_codes "a\e[31m"       # => {"a"   "\e[31m"}
-    #ta_split_codes "\e[31ma"       # => {""    "\e[31m"       "a"}
-    #ta_split_codes "\e[31ma\e[0m"  # => {""    "\e[31m"       "a"  "\e[0m"}
-    #ta_split_codes "\e[31ma\e[0mb" # => {""    "\e[31m"       "a"  "\e[0m", "b"}
-    #ta_split_codes "\e[31m\e[0mb"  # => {""    "\e[31m\e[0m"  "b"}
-    #
-    #proc split_codes {text} {
-    #    variable re_esc_osc1
-    #    variable re_esc_osc2
-    #    variable re_csi_code
-    #    set re "(?:${re_csi_code}|${re_esc_osc1}|${re_esc_osc2})+"
-    #    return [_perlish_split $re $text]
-    #}
-    ##like split_codes - but each ansi-escape is split out separately (with empty string of plaintext between codes so odd/even plain ansi still holds)
-    #proc split_codes_single {text} {
-    #    variable re_esc_osc1
-    #    variable re_esc_osc2
-    #    variable re_csi_code
-    #    set re "${re_csi_code}|${re_esc_osc1}|${re_esc_osc2}"
-    #    return [_perlish_split $re $text]
-    #}
-
-    ##review - tcl greedy expressions may match multiple in one element
-    #proc _perlish_split {re text} {
-    #    if {[string length $text] == 0} {
-    #        return {}
-    #    }
-    #    set list [list]
-    #    set start 0
-    #    while {[regexp -start $start -indices -- $re $text match]} {
-    #        lassign $match      matchStart matchEnd
-    #        lappend list [string range $text $start $matchStart-1] [string range $text $matchStart $matchEnd] 
-    #        set start [expr {$matchEnd+1}]
-    #    }
-    #    lappend list [string range $text $start end]
-    #    return $list
-    #}
-    ## -- --- --- --- --- --- 
-
-}
-} ;# end if 0
-
-# -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype {
-	interp alias {} ::overtype::center {} ::overtype::centre
-}
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide overtype [namespace eval overtype {
-    variable version
-    set version 1.5.3 
-}]
-return
-
-#*** !doctools
-#[manpage_end]
diff --git a/src/bootsupport/modules/overtype-1.5.6.tm b/src/bootsupport/modules/overtype-1.5.6.tm
deleted file mode 100644
index 5c56838b..00000000
--- a/src/bootsupport/modules/overtype-1.5.6.tm
+++ /dev/null
@@ -1,928 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) Julian Noble 2003-2023
-#
-# @@ Meta Begin
-# Application overtype 1.5.6
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin overtype_module_overtype 0 1.5.6]
-#[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
-#*** !doctools
-#[item] [package {Tcl 8.6}]
-#[item] [package textutil]
-#[item] [package punk::ansi]
-#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
-#[item] [package punk::char]
-#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
-
-# #package require frobz
-# #*** !doctools
-# #[item] [package {frobz}]
-
-#*** !doctools
-#[list_end]
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[section API]
-
-
-#Julian Noble <julian@precisium.com.au> - 2003 
-#Released under standard 'BSD license' conditions.
-#
-#todo - ellipsis truncation indicator for center,right
-
-#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
-# - need to extract and replace ansi codes?
-
-namespace eval overtype {
-	namespace export *
-    variable default_ellipsis_horizontal "..." ;#fallback 
-    variable default_ellipsis_vertical "..." 
-    namespace eval priv {
-        proc _init {} {
-            upvar ::overtype::default_ellipsis_horizontal e_h
-            upvar ::overtype::default_ellipsis_vertical e_v
-            set e_h [format %c 0x2026] ;#Unicode Horizontal Ellipsis
-            set e_v [format %c 0x22EE]
-            #The unicode ellipsis looks more natural than triple-dash which is centred vertically whereas ellipsis is at floorline of text
-            #Also - unicode ellipsis has semantic meaning that other processors can interpret
-            #unicode does also provide a midline horizontal ellipsis 0x22EF
-
-            #set e [format %c 0x2504] ;#punk::char::charshort boxd_ltdshhz  - Box Drawings Light Triple Dash Horizontal
-            #if {![catch {package require punk::char}]} {
-            #    set e [punk::char::charshort boxd_ltdshhz] 
-            #}
-        }
-    }
-    priv::_init
-}
-proc overtype::about {} {
-	return "Simple text formatting. Author JMN. BSD-License"
-}
-
-namespace eval overtype {
-    variable escape_terminals
-    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
-    dict set escape_terminals CSI [list @ \\ ^ _ ` | ~ a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z "\{" "\}"]
-    #dict set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
-    dict set escape_terminals OSC [list \007 \033\\] ;#note mix of 1 and 2-byte terminals 
-
-    #self-contained 2 byte ansi escape sequences - review more?
-    variable ansi_2byte_codes_dict
-    set  ansi_2byte_codes_dict [dict create\
-        "reset_terminal"            "\u001bc"\
-        "save_cursor_posn"          "\u001b7"\
-        "restore_cursor_posn"       "\u001b8"\
-        "cursor_up_one"             "\u001bM"\
-        "NEL - Next Line"           "\u001bE"\
-        "IND - Down one line"       "\u001bD"\
-        "HTS - Set Tab Stop"        "\u001bH"\
-        ]
-
-        #debatable whether strip should reveal the somethinghidden - some terminals don't hide it anyway.
-        #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
-}
-
-
-#proc overtype::stripansi {text} {
-#    variable escape_terminals  ;#dict
-#    variable ansi_2byte_codes_dict
-#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-#        #\033 same as \x1b
-#        return $text
-#    }
-#
-#    set text [convert_g0 $text] 
-#
-#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-#    set inputlist [split $text ""]
-#    set outputlist [list] 
-#
-#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-#
-#    set in_escapesequence 0
-#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-#    set i 0
-#    foreach u $inputlist {
-#        set v [lindex $inputlist $i+1]
-#        set uv ${u}${v}
-#        if {$in_escapesequence eq "2b"} {
-#            #2nd byte - done.
-#            set in_escapesequence 0
-#        } elseif {$in_escapesequence != 0} {
-#            set escseq [dict get $escape_terminals $in_escapesequence]
-#            if {$u in $escseq} {
-#                set in_escapesequence 0
-#            } elseif {$uv in $escseq} {
-#                set in_escapseequence 2b ;#flag next byte as last in sequence
-#            }
-#        } else {
-#            #handle both 7-bit and 8-bit CSI and OSC
-#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-#                set in_escapesequence CSI
-#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-#                set in_escapesequence OSC
-#            } elseif {$uv in $2bytecodes} {
-#                #self-contained e.g terminal reset - don't pass through.
-#                set in_escapesequence 2b
-#            } else {
-#                lappend outputlist $u
-#            }
-#        }
-#        incr i
-#    }
-#    return [join $outputlist ""]
-#}
-
-
-
-
-
-proc overtype::string_columns {text} {
-    if {[punk::ansi::ta::detect $text]} {
-        #error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
-        set text [punk::ansi::stripansi $text]
-    }
-    return [punk::char::string_width $text]
-}
-
-
-#string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
-proc overtype::left {args} {
-	# @c overtype starting at left (overstrike) 
-	# @c can/should we use something like this?: 'format "%-*s" $len $overtext 
-    variable default_ellipsis_horizontal
-
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] underblock overblock
-    set defaults [dict create\
-        -bias       ignored\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::left unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_exposed1        [dict get $opts -exposed1] ;#widechar_exposed_left  - todo
-    set opt_exposed2        [dict get $opts -exposed2] ;#widechar_exposed_right - todo
-    # -- --- --- --- --- ---
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    set right_exposed $under_exposed_max 
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set undertext_printlen [punk::ansi::printing_length $undertext]
-        if {$undertext_printlen < $colwidth} {
-            set udiff [expr {$colwidth - $undertext_printlen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        set overtext_printlen [punk::ansi::printing_length $overtext]
-        set overflowlength [expr {$overtext_printlen - $colwidth}]
-
-        #review
-        #append overtext "\033\[0m"
-
-
-        if {$overflowlength > 0} {
-            #background line is narrower than data in line
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {![dict get $opts -overflow]} {
-                #set overtext [string range $overtext 0 $colwidth-1] ;#string range won't be correct e.g if contains ansi codes or leading \r or \b etc
-                if {[dict get $opts -ellipsis]} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #we know overtext data is shorter or equal (for this line)
-            lappend outputlines [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-
-}
-
-namespace eval overtype::piper {
-    proc overcentre {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-bias left|right? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::centre {*}$argsflags $under $over
-    }
-    proc overleft {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <column>? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::left {*}$argsflags $under $over
-    }
-}
-#todo - left-right ellipsis ?
-proc overtype::centre {args} {
-    variable default_ellipsis_horizontal
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-bias [left|right]?  ?-overflow [1|0]? undertext overtext}
-	}
-	
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    #todo - vertical vs horizontal overflow for blocks
-    set defaults [dict create\
-        -bias       left\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis        [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    if {$under_exposed_max > 0} {
-        #background block is wider
-        if {$under_exposed_max % 2 == 0} {
-            #even left/right exposure
-            set left_exposed [expr {$under_exposed_max / 2}]
-        } else {
-            set beforehalf [expr {$under_exposed_max / 2}] ;#1 less than half due to integer division
-            if {[string tolower [dict get $opts -bias]] eq "left"} {
-                set left_exposed $beforehalf
-            } else {
-                #bias to the right
-                set left_exposed [expr {$beforehalf + 1}]
-            }
-        }
-    } else {
-        set left_exposed 0
-    }
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set overtext_datalen [punk::ansi::printing_length $overtext]
-        set ulen [punk::ansi::printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-
-        set overflowlength [expr {$overtext_datalen - $colwidth}]
-        #review - right-to-left langs should elide on left! - extra option required
-
-        if {$overflowlength > 0} {
-            #overlay line wider or equal
-            set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-            #overlay line data is wider - trim if overflow not specified in opts - and overtype an ellipsis at right if it was specified
-            if {![dict get $opts -overflow]} {
-                #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
-                #set overtext [string range $overtext 0 $colwidth-1 ]
-                if {$opt_ellipsis} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-            #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
-        } else {
-            #background block is wider than or equal to data for this line
-            lappend outputlines [renderline -start $left_exposed -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-}
-
-proc overtype::right {args} {
-    #NOT the same as align-right - which should be done to the overblock first if required
-    variable default_ellipsis_horizontal
-	# @d !todo - implement overflow, length checks etc
-
-	if {[llength $args] < 2} {
-		error {usage: ?-overflow [1|0]? undertext overtext}
-	}
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    set defaults [dict create\
-        -bias       ignored\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis         [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_overflow        [dict get $opts -overflow]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-    
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    set left_exposed $under_exposed_max 
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set overtext_datalen [punk::ansi::printing_length $overtext]
-        set ulen [punk::ansi::printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            puts xxx
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        if {$overtext_datalen < $overblock_width} {
-            set odiff [expr {$overblock_width - $overtext_datalen}]
-            #padding always on right - if alignment is required it should be done to block beforehand - not here
-            set overtextpadding "$overtext[string repeat { } $odiff]"
-        }
-
-        set overflowlength [expr {$overtext_datalen - $colwidth}]
-        if {$overflowlength > 0} {	
-            #raw overtext wider than undertext column
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -start 0 $undertext $overtext]
-            if {!$opt_overflow} {
-                if {$opt_ellipsis} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #padded overtext 
-            lappend outputlines [renderline -transparent $opt_transparent -start $left_exposed $undertext $overtext]
-        }
-    }
-
-    return [join $outputlines \n]
-}
-
-# -- --- --- --- --- --- --- --- --- --- ---
-proc overtype::transparentline {args} {
-    foreach {under over} [lrange $args end-1 end] break
-    set argsflags [lrange $args 0 end-2]
-    set defaults [dict create\
-        -transparent 1\
-        -exposed 1 " "\
-        -exposed 2 " "\
-    ]
-    set newargs [dict merge $defaults $argsflags]
-    tailcall overtype::renderline {*}$newargs $under $over
-}
-#renderline may not make sense as it is in the long run for blocks of text - but is handy in the single-line-handling form anyway.
-# We are trying to handle ansi codes in a block of text which is acting like a mini-terminal in some sense.
-#We can process standard cursor moves such as \b \r - but no way to respond to other cursor movements e.g moving to other lines.
-#
-namespace eval overtype::piper {
-    proc renderline {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        foreach {over under} [lrange $args end-1 end] break
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::renderline {*}$argsflags $under $over
-    }
-}
-interp alias "" piper_renderline "" overtype::piper::renderline 
-
-#-returnextra to enable returning of overflow and length
-# todo - use punk::ansi::ta::detect to short-circuit processing and do simple string calcs as an optimisation?
-#review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
-#todo - review transparency issues with single/double width characters!
-proc overtype::renderline {args} {
-	if {[llength $args] < 2} {
-		error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] under over
-    #should also rule out \v
-    if {[string first \n $over] >=0 || [string first \n $under] >= 0} {
-        error "overtype::renderline not allowed to contain newlines"
-    }
-    set defaults [dict create\
-        -overflow   0\
-        -transparent 0\
-        -start 0\
-        -returnextra 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    #exposed1 and exposed2 for first and second col of underying 2wide char which is truncated by transparency or overflow
-
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::renderline unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_overflow            [dict get $opts -overflow]
-    set opt_colstart            [dict get $opts -start]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_transparent         [dict get $opts -transparent]  
-    if {$opt_transparent eq "0"} {
-        set do_transparency 0
-    } else {
-        set do_transparency 1
-        if {$opt_transparent eq "1"} {
-            set opt_transparent {[\s]}
-        }
-    }
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_returnextra         [dict get $opts -returnextra]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_exposed1            [dict get $opts -exposed1]
-    set opt_exposed2            [dict get $opts -exposed2]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-
-    #-----
-    #
-    if {[string first \t $under] >= 0} {
-        #set under [textutil::tabify::untabify2 $under]
-        set under [textutil::tabify::untabifyLine $under 8] ;#8 is default for untabify2 - review
-    }
-    set overdata $over
-    if {[string first \t $over] >= 0} {
-        #set overdata [textutil::tabify::untabify2 $over]
-        set overdata [textutil::tabify::untabifyLine $over 8]
-    }
-    #-------
-
-    #ta_detect ansi and do simpler processing?
-
-
-    # -- --- --- --- --- --- --- ---
-    set undermap [punk::ansi::ta::split_codes_single $under]
-    set understacks [dict create]
-
-    set i_u -1
-    set i_o 0 
-    set out [list] 
-    set u_codestack [list]
-    set pt_underchars "" ;#for string_columns length calculation for overflow 0 truncation
-    set remainder [list] ;#for returnextra
-    foreach {pt code} $undermap {
-        #pt = plain text
-        append pt_underchars $pt
-        foreach grapheme [punk::char::grapheme_split $pt] {
-            set width [punk::char::string_width $grapheme]
-            incr i_u
-            dict set understacks $i_u $u_codestack 
-            lappend out $grapheme
-            if {$width > 1} {
-                incr i_u
-                #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?
-                dict set understacks $i_u $u_codestack 
-                lappend out ""
-            }
-        }
-
-        #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 
-        #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 {[punk::ansi::codetype::is_sgr_reset $code]} {
-            set u_codestack [list]
-        } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
-            set u_codestack [list $code]
-        } elseif {[punk::ansi::codetype::is_sgr $code]} {
-            lappend u_codestack $code
-        }
-        #consider also if there are other codes that should be stacked..?
-    }
-    #trailing codes in effect for underlay
-    if {[llength $undermap]} {
-        dict set understacks [expr {$i_u + 1}] $u_codestack
-    }
-
-
-    # -- --- --- --- --- --- --- ---
-    ####
-    #if opt_colstart - we need to build a space (or any singlewidth char really) padding on the left of the right number of columns.
-    #this will be processed as transparent - and handle doublewidth underlay characters appropriately
-    set startpad [string repeat " " $opt_colstart]
-    append startpad $overdata ;#overdata with left padding spaces based on col-start under will show through for left-padding portion regardless of -transparency
-    set overmap  [punk::ansi::ta::split_codes_single $startpad]
-    ####
-
-    #set 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 [dict create]
-    set o_codestack [list]
-    set pt_overchars ""
-    foreach {pt code} $overmap {
-        append pt_overchars $pt
-        foreach grapheme [punk::char::grapheme_split $pt] {
-           dict set overstacks $i_o $o_codestack 
-           incr i_o 
-        }
-
-        if {[punk::ansi::codetype::is_sgr $code]} {
-            if {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
-                #m code which has sgr reset at start - no need to replay prior sgr codes 
-                set o_codestack [list $code]
-            } else {
-                lappend o_codestack $code
-            }
-        }
-
-        #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 {[punk::ansi::codetype::is_sgr_reset $code]} {
-            set o_codestack [list]
-        } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
-            set o_codestack [list $code]
-        } elseif {[punk::ansi::codetype::is_sgr $code]} {
-            lappend o_codestack $code
-        }
-
-    }
-    # -- --- --- --- --- --- --- ---
-
-
-    #potential problem - combinining diacritics directly following control chars like \r \b
-
-    set bs [format %c 0x08]
-    set idx 0 ;# line index  (cursor - 1)
-    set idx_over -1
-    foreach {pt code} $overmap {
-        #set ptchars [split $pt ""] ;#for lookahead
-        set graphemes [punk::char::grapheme_split $pt]
-        #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 $graphemes {
-            incr idx_over
-            if {$ch eq "\r"} {
-                set idx $opt_colstart
-            } elseif {$ch eq "\b"} {
-                #review - backspace effect on double-width chars
-                if {$idx > $opt_colstart} {
-                    incr idx -1
-                }
-            } elseif {($idx < $opt_colstart)} {
-                incr idx
-            } elseif {($do_transparency && [regexp $opt_transparent $ch])} {    
-                #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
-                set owidth [punk::char::string_width $ch]
-                if {$idx > [llength $out]-1} {
-                    lappend out " "
-                    dict set understacks $idx [list] ;#review - use idx-1 codestack?
-                    incr idx
-                } else {
-                    set uwidth [punk::char::string_width [lindex $out $idx]]
-                    if {[lindex $out $idx] eq ""} {
-                        #2nd col of 2-wide char in underlay 
-                        incr idx
-                    } elseif {$uwidth == 0} {
-                        #e.g control char  ? combining diacritic ?
-                        incr idx
-                    } elseif {$uwidth == 1} {
-                        incr idx
-                        if {$owidth > 1} {
-                            incr idx
-                        } 
-                    } elseif {$uwidth > 1} {
-                        if {[punk::char::string_width $ch] == 1} {
-                            #normal singlewide transparency 
-                            set next_pt_overchar [string index $pt_overchars $idx_over+1] ;#lookahead of next plain-text char in overlay
-                            if {$next_pt_overchar eq ""} {
-                                #special-case trailing transparent - no next_pt_overchar
-                                incr idx
-                            } else {
-                                if {[regexp $opt_transparent $next_pt_overchar]} {
-                                    incr idx
-                                } else {
-                                    #next overlay char is not transparent.. first-half of underlying 2wide char is exposed 
-                                    priv::render_addchar $idx $opt_exposed1 [dict get $overstacks $idx_over]
-                                    incr idx
-                                }
-                            }
-                        } else {
-                            #2wide transparency over 2wide in underlay
-                            incr idx
-                        }
-                    }
-                }
-            } else {
-                #non-transparent char in overlay
-                set owidth [punk::char::string_width $ch]
-                set uwidth [punk::char::string_width [lindex $out $idx]]
-                if {[lindex $out $idx] eq ""} {
-                    #2nd col of 2wide char in underlay
-                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                    incr idx
-                } elseif {$uwidth == 0} {
-                    #e.g combining diacritic - increment before over char  REVIEW
-                    #arguably the previous overchar should have done this - ie lookahead for combiners?
-                    priv::render_addchar $idx "" [dict get $overstacks $idx_over]
-                    incr idx
-                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                    incr idx
-
-                } elseif {$uwidth == 1} {
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                    } else {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx ""  [dict get $overstacks $idx_over]
-                    }
-                } elseif {$uwidth > 1} {
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx $opt_exposed2 [dict get $overstacks $idx_over]
-                        #don't incr idx - we are just putting a broken-indication in the underlay - which may get overwritten by next overlay char
-                    } else {
-                        #2wide over 2wide
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx 
-                    }
-                }
-            }
-        } 
-
-        #cursor movement?
-        #if {![punk::ansi::codetype::is_sgr $code]} {
-        #
-        #}
-    }
-
-    if {$opt_overflow == 0} {
-        #need to truncate to the width of the original undertext
-        #review - string_width vs printing_length here. undertext requirement to be already rendered therefore punk::char::string_width ok?
-        set num_under_columns [punk::char::string_width $pt_underchars] ;#plaintext underchars
-    }
-
-    #coalesce and replay codestacks for out char list
-    set outstring ""    
-    set remstring "" ;#remainder after overflow point reached
-    set i 0
-    set cstack [list]
-    set prevstack [list]
-    set out_rawchars ""; #for overflow counting 
-    set output_to "outstring" ;#var in effect depending on overflow
-    set in_overflow 0 ;#used to stop char-width scanning once in overflow
-    foreach ch $out {
-        append out_rawchars $ch
-        if {$opt_overflow == 0 && !$in_overflow} {
-            if {[set nextvisualwidth [punk::char::string_width $out_rawchars]] < $num_under_columns} {
-            } else {
-                #todo - check if we overflowed with a double-width char ? 
-                #store visualwidth which may be short
-                set in_overflow 1
-            }
-        }
-        set cstack [dict get $understacks $i]
-        if {$cstack ne $prevstack} {
-            if {[llength $prevstack]} {
-                append $output_to \033\[m
-            }
-            foreach code $cstack {
-                append $output_to $code
-            }
-        }
-        append $output_to $ch
-        set prevstack $cstack
-        incr i
-        if {$in_overflow} {
-            set output_to "remstring"
-        }
-    }
-    if {[dict size $understacks] > 0} {
-        append $output_to [join [dict get $understacks [expr {[dict size $understacks]-1}]] ""] ;#tail codes
-    }
-    if {[string length $remstring]} {
-        #puts stderr "remainder:$remstring"
-    }
-    #pdict $understacks
-    if {$opt_returnextra} {
-        return [list $outstring $visualwidth [string length $outstring] $remstring]
-    } else {
-        return $outstring
-    }
-    #return [join $out ""]
-}
-proc overtype::test_renderline {} {
-    set t \uFF5E ;#2-wide tilde
-    set u \uFF3F ;#2-wide underscore
-    set missing \uFFFD
-    return [list $t $u A${t}B]
-}
-
-#same as textblock::size - but we don't want that circular dependency
-proc overtype::blocksize {textblock} {
-    if {$textblock eq ""} {
-        return [dict create width 0 height 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
-    }
-    set textblock [textutil::tabify::untabify2 $textblock]
-    #stripansi on entire block in one go rather than line by line - result should be the same - review - make tests
-    set textblock [punk::ansi::stripansi $textblock]
-    if {[string first \n $textblock] >= 0} {
-        set width [tcl::mathfunc::max {*}[lmap v [punk::lib::lines_as_list -- $textblock] {::punk::char::string_width $v}]]
-    } else {
-        set width [punk::char::string_width $textblock] 
-    }
-    set num_le [expr {[string length $textblock]-[string length [string map [list \n {}] $textblock]]}] ;#faster than splitting into single-char list
-    #our concept of block-height is likely to be different to other line-counting mechanisms
-    set height [expr {$num_le + 1}] ;# one line if no le - 2 if there is one trailing le even if no data follows le
-
-    return [dict create width $width height $height] ;#maintain order in 'image processing' standard width then height - caller may use lassign [dict values [blocksize <data>]] width height
-}
-
-namespace eval overtype::priv {
-
-    #is actually addgrapheme?
-    proc render_addchar {i c stack} {
-        upvar out o
-        upvar understacks ustacks
-        set nxt [llength $o] 
-        if {$i < $nxt} {
-            lset o $i $c
-        } else {
-            lappend o $c
-        }
-        dict set ustacks $i $stack
-    }
-
-}
-
-
-
-# -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype {
-	interp alias {} ::overtype::center {} ::overtype::centre
-}
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide overtype [namespace eval overtype {
-    variable version
-    set version 1.5.6 
-}]
-return
-
-#*** !doctools
-#[manpage_end]
diff --git a/src/bootsupport/modules/overtype-1.5.7.tm b/src/bootsupport/modules/overtype-1.5.7.tm
deleted file mode 100644
index aefb0840..00000000
--- a/src/bootsupport/modules/overtype-1.5.7.tm
+++ /dev/null
@@ -1,998 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) Julian Noble 2003-2023
-#
-# @@ Meta Begin
-# Application overtype 1.5.7
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin overtype_module_overtype 0 1.5.7]
-#[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
-#*** !doctools
-#[item] [package {Tcl 8.6}]
-#[item] [package textutil]
-#[item] [package punk::ansi]
-#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
-#[item] [package punk::char]
-#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
-
-# #package require frobz
-# #*** !doctools
-# #[item] [package {frobz}]
-
-#*** !doctools
-#[list_end]
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[section API]
-
-
-#Julian Noble <julian@precisium.com.au> - 2003 
-#Released under standard 'BSD license' conditions.
-#
-#todo - ellipsis truncation indicator for center,right
-
-#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
-# - need to extract and replace ansi codes?
-
-namespace eval overtype {
-	namespace export *
-    variable default_ellipsis_horizontal "..." ;#fallback 
-    variable default_ellipsis_vertical "..." 
-    namespace eval priv {
-        proc _init {} {
-            upvar ::overtype::default_ellipsis_horizontal e_h
-            upvar ::overtype::default_ellipsis_vertical e_v
-            set e_h [format %c 0x2026] ;#Unicode Horizontal Ellipsis
-            set e_v [format %c 0x22EE]
-            #The unicode ellipsis looks more natural than triple-dash which is centred vertically whereas ellipsis is at floorline of text
-            #Also - unicode ellipsis has semantic meaning that other processors can interpret
-            #unicode does also provide a midline horizontal ellipsis 0x22EF
-
-            #set e [format %c 0x2504] ;#punk::char::charshort boxd_ltdshhz  - Box Drawings Light Triple Dash Horizontal
-            #if {![catch {package require punk::char}]} {
-            #    set e [punk::char::charshort boxd_ltdshhz] 
-            #}
-        }
-    }
-    priv::_init
-}
-proc overtype::about {} {
-	return "Simple text formatting. Author JMN. BSD-License"
-}
-
-namespace eval overtype {
-    variable escape_terminals
-    #single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).
-    dict set escape_terminals CSI [list @ \\ ^ _ ` | ~ a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z "\{" "\}"]
-    #dict set escape_terminals CSI [list J K m n A B C D E F G s u] ;#basic 
-    dict set escape_terminals OSC [list \007 \033\\] ;#note mix of 1 and 2-byte terminals 
-
-    #self-contained 2 byte ansi escape sequences - review more?
-    variable ansi_2byte_codes_dict
-    set  ansi_2byte_codes_dict [dict create\
-        "reset_terminal"            "\u001bc"\
-        "save_cursor_posn"          "\u001b7"\
-        "restore_cursor_posn"       "\u001b8"\
-        "cursor_up_one"             "\u001bM"\
-        "NEL - Next Line"           "\u001bE"\
-        "IND - Down one line"       "\u001bD"\
-        "HTS - Set Tab Stop"        "\u001bH"\
-        ]
-
-        #debatable whether strip should reveal the somethinghidden - some terminals don't hide it anyway.
-        #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
-}
-
-
-#proc overtype::stripansi {text} {
-#    variable escape_terminals  ;#dict
-#    variable ansi_2byte_codes_dict
-#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-#        #\033 same as \x1b
-#        return $text
-#    }
-#
-#    set text [convert_g0 $text] 
-#
-#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-#    set inputlist [split $text ""]
-#    set outputlist [list] 
-#
-#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-#
-#    set in_escapesequence 0
-#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-#    set i 0
-#    foreach u $inputlist {
-#        set v [lindex $inputlist $i+1]
-#        set uv ${u}${v}
-#        if {$in_escapesequence eq "2b"} {
-#            #2nd byte - done.
-#            set in_escapesequence 0
-#        } elseif {$in_escapesequence != 0} {
-#            set escseq [dict get $escape_terminals $in_escapesequence]
-#            if {$u in $escseq} {
-#                set in_escapesequence 0
-#            } elseif {$uv in $escseq} {
-#                set in_escapseequence 2b ;#flag next byte as last in sequence
-#            }
-#        } else {
-#            #handle both 7-bit and 8-bit CSI and OSC
-#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-#                set in_escapesequence CSI
-#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-#                set in_escapesequence OSC
-#            } elseif {$uv in $2bytecodes} {
-#                #self-contained e.g terminal reset - don't pass through.
-#                set in_escapesequence 2b
-#            } else {
-#                lappend outputlist $u
-#            }
-#        }
-#        incr i
-#    }
-#    return [join $outputlist ""]
-#}
-
-
-
-
-
-proc overtype::string_columns {text} {
-    if {[punk::ansi::ta::detect $text]} {
-        #error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
-        set text [punk::ansi::stripansi $text]
-    }
-    return [punk::char::string_width $text]
-}
-
-
-#string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
-proc overtype::left {args} {
-	# @c overtype starting at left (overstrike) 
-	# @c can/should we use something like this?: 'format "%-*s" $len $overtext 
-    variable default_ellipsis_horizontal
-
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] underblock overblock
-    set defaults [dict create\
-        -bias       ignored\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::left unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_exposed1        [dict get $opts -exposed1] ;#widechar_exposed_left  - todo
-    set opt_exposed2        [dict get $opts -exposed2] ;#widechar_exposed_right - todo
-    # -- --- --- --- --- ---
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    set right_exposed $under_exposed_max 
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set undertext_printlen [punk::ansi::printing_length $undertext]
-        if {$undertext_printlen < $colwidth} {
-            set udiff [expr {$colwidth - $undertext_printlen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        set overtext_printlen [punk::ansi::printing_length $overtext]
-        set overflowlength [expr {$overtext_printlen - $colwidth}]
-
-        #review
-        #append overtext "\033\[0m"
-
-
-        if {$overflowlength > 0} {
-            #background line is narrower than data in line
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow [dict get $opts -overflow] $undertext $overtext]
-            if {![dict get $opts -overflow]} {
-                #set overtext [string range $overtext 0 $colwidth-1] ;#string range won't be correct e.g if contains ansi codes or leading \r or \b etc
-                if {[dict get $opts -ellipsis]} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #we know overtext data is shorter or equal (for this line)
-            lappend outputlines [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-
-}
-
-namespace eval overtype::piper {
-    proc overcentre {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-bias left|right? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::centre {*}$argsflags $under $over
-    }
-    proc overleft {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-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
-    }
-}
-#todo - left-right ellipsis ?
-proc overtype::centre {args} {
-    variable default_ellipsis_horizontal
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-bias [left|right]?  ?-overflow [1|0]? undertext overtext}
-	}
-	
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    #todo - vertical vs horizontal overflow for blocks
-    set defaults [dict create\
-        -bias       left\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis        [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    if {$under_exposed_max > 0} {
-        #background block is wider
-        if {$under_exposed_max % 2 == 0} {
-            #even left/right exposure
-            set left_exposed [expr {$under_exposed_max / 2}]
-        } else {
-            set beforehalf [expr {$under_exposed_max / 2}] ;#1 less than half due to integer division
-            if {[string tolower [dict get $opts -bias]] eq "left"} {
-                set left_exposed $beforehalf
-            } else {
-                #bias to the right
-                set left_exposed [expr {$beforehalf + 1}]
-            }
-        }
-    } else {
-        set left_exposed 0
-    }
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set overtext_datalen [punk::ansi::printing_length $overtext]
-        set ulen [punk::ansi::printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-
-        set overflowlength [expr {$overtext_datalen - $colwidth}]
-        #review - right-to-left langs should elide on left! - extra option required
-
-        if {$overflowlength > 0} {
-            #overlay line wider or equal
-            set rendered [renderline -transparent $opt_transparent -overflow [dict get $opts -overflow] -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-            #overlay line data is wider - trim if overflow not specified in opts - and overtype an ellipsis at right if it was specified
-            if {![dict get $opts -overflow]} {
-                #lappend outputlines [string range $overtext 0 [expr {$colwidth - 1}]]
-                #set overtext [string range $overtext 0 $colwidth-1 ]
-                if {$opt_ellipsis} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-            #lappend outputlines [renderline -transparent $opt_transparent $undertext $overtext]
-        } else {
-            #background block is wider than or equal to data for this line
-            lappend outputlines [renderline -startcolumn [expr {$left_exposed + 1}] -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-        }
-    }
-    return [join $outputlines \n]
-}
-
-proc overtype::right {args} {
-    #NOT the same as align-right - which should be done to the overblock first if required
-    variable default_ellipsis_horizontal
-	# @d !todo - implement overflow, length checks etc
-
-	if {[llength $args] < 2} {
-		error {usage: ?-overflow [1|0]? undertext overtext}
-	}
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    set defaults [dict create\
-        -bias       ignored\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::centre unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis         [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_overflow        [dict get $opts -overflow]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-    
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    set left_exposed $under_exposed_max 
-
-    set outputlines [list]
-    foreach undertext $underlines overtext $overlines {    
-        set overtext_datalen [punk::ansi::printing_length $overtext]
-        set ulen [punk::ansi::printing_length $undertext]
-        if {$ulen < $colwidth} {
-            set udiff [expr {$colwidth - $ulen}]
-            puts xxx
-            set undertext "$undertext[string repeat { } $udiff]"
-        }
-        if {$overtext_datalen < $overblock_width} {
-            set odiff [expr {$overblock_width - $overtext_datalen}]
-            #padding always on right - if alignment is required it should be done to block beforehand - not here
-            set overtextpadding "$overtext[string repeat { } $odiff]"
-        }
-
-        set overflowlength [expr {$overtext_datalen - $colwidth}]
-        if {$overflowlength > 0} {	
-            #raw overtext wider than undertext column
-            set rendered [renderline -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow $opt_overflow -startcolumn 1 $undertext $overtext]
-            if {!$opt_overflow} {
-                if {$opt_ellipsis} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-        } else {
-            #padded overtext 
-            lappend outputlines [renderline -transparent $opt_transparent -startcolumn [expr {$left_exposed + 1}] $undertext $overtext]
-        }
-    }
-
-    return [join $outputlines \n]
-}
-
-# -- --- --- --- --- --- --- --- --- --- ---
-proc overtype::transparentline {args} {
-    foreach {under over} [lrange $args end-1 end] break
-    set argsflags [lrange $args 0 end-2]
-    set defaults [dict create\
-        -transparent 1\
-        -exposed 1 " "\
-        -exposed 2 " "\
-    ]
-    set newargs [dict merge $defaults $argsflags]
-    tailcall overtype::renderline {*}$newargs $under $over
-}
-#renderline may not make sense as it is in the long run for blocks of text - but is handy in the single-line-handling form anyway.
-# We are trying to handle ansi codes in a block of text which is acting like a mini-terminal in some sense.
-#We can process standard cursor moves such as \b \r - but no way to respond to other cursor movements e.g moving to other lines.
-#
-namespace eval overtype::piper {
-    proc renderline {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        foreach {over under} [lrange $args end-1 end] break
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::renderline {*}$argsflags $under $over
-    }
-}
-interp alias "" piper_renderline "" overtype::piper::renderline 
-
-#-returnextra to enable returning of overflow and length
-# todo - use punk::ansi::ta::detect to short-circuit processing and do simple string calcs as an optimisation?
-#review - DECSWL/DECDWL double width line codes - very difficult/impossible to align and compose with other elements
-#todo - review transparency issues with single/double width characters!
-#bidi - need a base direction and concept of directional runs for RTL vs LTR - may be best handled at another layer?
-proc overtype::renderline {args} {
-	if {[llength $args] < 2} {
-		error {usage: ?-info 0|1? ?-startcolumn <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] under over
-    #should also rule out \v
-    if {[string first \n $over] >=0 || [string first \n $under] >= 0} {
-        error "overtype::renderline not allowed to contain newlines"
-    }
-    set defaults [dict create\
-        -overflow   0\
-        -transparent 0\
-        -startcolumn 1\
-        -info 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    #exposed1 and exposed2 for first and second col of underying 2wide char which is truncated by transparency or overflow
-
-    set known_opts [dict keys $defaults]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        if {$k ni $known_opts} {
-            error "overtype::renderline unknown option '$k'. Known options: $known_opts"
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_overflow            [dict get $opts -overflow]
-    set opt_colstart            [dict get $opts -startcolumn] ;#start cursor column
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_transparent         [dict get $opts -transparent]  
-    if {$opt_transparent eq "0"} {
-        set do_transparency 0
-    } else {
-        set do_transparency 1
-        if {$opt_transparent eq "1"} {
-            set opt_transparent {[\s]}
-        }
-    }
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_returnextra         [dict get $opts -info]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_exposed1            [dict get $opts -exposed1]
-    set opt_exposed2            [dict get $opts -exposed2]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-
-    #-----
-    #
-    if {[string first \t $under] >= 0} {
-        #set under [textutil::tabify::untabify2 $under]
-        set under [textutil::tabify::untabifyLine $under 8] ;#8 is default for untabify2 - review
-    }
-    set overdata $over
-    if {[string first \t $over] >= 0} {
-        #set overdata [textutil::tabify::untabify2 $over]
-        set overdata [textutil::tabify::untabifyLine $over 8]
-    }
-    #-------
-
-    #ta_detect ansi and do simpler processing?
-
-
-    # -- --- --- --- --- --- --- ---
-    set undermap [punk::ansi::ta::split_codes_single $under]
-    set understacks [dict create]
-
-    set i_u -1
-    set i_o 0 
-    set outcols [list] 
-    set u_codestack [list]
-    set pt_underchars "" ;#for string_columns length calculation for overflow 0 truncation
-    set remainder [list] ;#for returnextra
-    foreach {pt code} $undermap {
-        #pt = plain text
-        append pt_underchars $pt
-        foreach grapheme [punk::char::grapheme_split $pt] {
-            set width [punk::char::string_width $grapheme]
-            incr i_u
-            dict set understacks $i_u $u_codestack 
-            lappend outcols $grapheme
-            if {$width > 1} {
-                incr i_u
-                #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?
-                dict set understacks $i_u $u_codestack 
-                lappend outcols ""
-            }
-        }
-
-        #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 
-        #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 {[punk::ansi::codetype::is_sgr_reset $code]} {
-            set u_codestack [list]
-        } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
-            set u_codestack [list $code]
-        } elseif {[punk::ansi::codetype::is_sgr $code]} {
-            lappend u_codestack $code
-        }
-        #consider also if there are other codes that should be stacked..?
-    }
-    #trailing codes in effect for underlay
-    if {[llength $undermap]} {
-        dict set understacks [expr {$i_u + 1}] $u_codestack
-    }
-
-
-    # -- --- --- --- --- --- --- ---
-    ####
-    #if opt_colstart - we need to build a space (or any singlewidth char really) padding on the left of the right number of columns.
-    #this will be processed as transparent - and handle doublewidth underlay characters appropriately
-    set startpad [string repeat " " [expr {$opt_colstart -1}]]
-    append startpad $overdata ;#overdata with left padding spaces based on col-start under will show through for left-padding portion regardless of -transparency
-    set overmap  [punk::ansi::ta::split_codes_single $startpad]
-    ####
-    set colcursor $opt_colstart
-
-    #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 [dict create]
-    set o_codestack [list]
-    set pt_overchars ""
-    foreach {pt code} $overmap {
-        append pt_overchars $pt
-        foreach grapheme [punk::char::grapheme_split $pt] {
-           dict set overstacks $i_o $o_codestack 
-           incr i_o 
-        }
-
-        if {[punk::ansi::codetype::is_sgr $code]} {
-            if {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
-                #m code which has sgr reset at start - no need to replay prior sgr codes 
-                set o_codestack [list $code]
-            } else {
-                lappend o_codestack $code
-            }
-        }
-
-        #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 {[punk::ansi::codetype::is_sgr_reset $code]} {
-            set o_codestack [list]
-        } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
-            set o_codestack [list $code]
-        } elseif {[punk::ansi::codetype::is_sgr $code]} {
-            lappend o_codestack $code
-        }
-
-    }
-    # -- --- --- --- --- --- --- ---
-
-
-    #potential problem - combinining diacritics directly following control chars like \r \b
-
-    set bs [format %c 0x08]
-    set idx 0 ;# line index  (cursor - 1)
-    set idx_over -1
-    foreach {pt code} $overmap {
-        #set ptchars [split $pt ""] ;#for lookahead
-        set overlay_graphemes [punk::char::grapheme_split $pt]
-        #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 {
-            set within_undercols [expr {$idx <= [llength $outcols]-1}]
-            incr idx_over
-            if {$ch eq "\r"} {
-                set idx [expr {$opt_colstart -1}]
-            } elseif {$ch eq "\b"} {
-                #review - backspace effect on double-width chars
-                if {$idx > ($opt_colstart -1)} {
-                    incr idx -1
-                }
-            } elseif {($idx < ($opt_colstart -1))} {
-                incr idx
-            } elseif {($do_transparency && [regexp $opt_transparent $ch])} {    
-                #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
-                if {$idx > [llength $outcols]-1} {
-                    lappend outcols " "
-                    dict set understacks $idx [list] ;#review - use idx-1 codestack?
-                    incr idx
-                } else {
-                    set uwidth [punk::char::string_width [lindex $outcols $idx]]
-                    if {[lindex $outcols $idx] eq ""} {
-                        #2nd col of 2-wide char in underlay 
-                        incr idx
-                    } elseif {$uwidth == 0} {
-                        #e.g control char  ? combining diacritic ?
-                        incr idx
-                    } elseif {$uwidth == 1} {
-                        set owidth [punk::char::string_width $ch]
-                        incr idx
-                        if {$owidth > 1} {
-                            incr idx
-                        } 
-                    } elseif {$uwidth > 1} {
-                        if {[punk::char::string_width $ch] == 1} {
-                            #normal singlewide transparency 
-                            set next_pt_overchar [string index $pt_overchars $idx_over+1] ;#lookahead of next plain-text char in overlay
-                            if {$next_pt_overchar eq ""} {
-                                #special-case trailing transparent - no next_pt_overchar
-                                incr idx
-                            } else {
-                                if {[regexp $opt_transparent $next_pt_overchar]} {
-                                    incr idx
-                                } else {
-                                    #next overlay char is not transparent.. first-half of underlying 2wide char is exposed 
-                                    priv::render_addchar $idx $opt_exposed1 [dict get $overstacks $idx_over]
-                                    incr idx
-                                }
-                            }
-                        } else {
-                            #2wide transparency over 2wide in underlay
-                            incr idx
-                        }
-                    }
-                }
-            } else {
-                #non-transparent char in overlay
-                set uwidth [punk::char::string_width [lindex $outcols $idx]]
-                    
-                if {$within_undercols && [lindex $outcols $idx] eq ""} {
-                    #2nd col of 2wide char in underlay
-                    priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                    #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 
-                        #reset previous to an exposed 1st-half - but leave understacks code as is
-                        priv::render_addchar [expr {$idx-1}] $opt_exposed1 [dict get $understacks [expr {$idx-1}]]
-                    }
-                    incr idx
-                    
-                } elseif {$uwidth == 0} {
-                    if {$within_undercols} {
-                        #e.g combining diacritic - increment before over char  REVIEW
-                        #arguably the previous overchar should have done this - ie lookahead for combiners?
-                        priv::render_addchar $idx "" [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                    } else {
-                        #overflow
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                    }
-                } elseif {$uwidth == 1} {
-                    set owidth [punk::char::string_width $ch]
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                    } else {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx ""  [dict get $overstacks $idx_over]
-                        #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] >= [expr {$idx +2}] && [lindex $outcols $idx+1] eq ""} {
-                            priv::render_addchar [expr {$idx+1}] $opt_exposed2 [dict get $understacks [expr {$idx+1}]]
-                        }
-                        incr idx
-                    }
-                } elseif {$uwidth > 1} {
-                    set owidth [punk::char::string_width $ch]
-                    if {$owidth == 1} {
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx
-                        priv::render_addchar $idx $opt_exposed2 [dict get $overstacks $idx_over]
-                        #don't incr idx - we are just putting a broken-indication in the underlay - which may get overwritten by next overlay char
-                    } else {
-                        #2wide over 2wide
-                        priv::render_addchar $idx $ch [dict get $overstacks $idx_over]
-                        incr idx 2 
-                    }
-                }
-            }
-        } 
-
-        #cursor movement?
-        #if {![punk::ansi::codetype::is_sgr $code]} {
-        #
-        #}
-        if {[punk::ansi::codetype::is_cursor_move_in_line $code]} {
-        }
-        set re_col_move {\x1b\[([0-9]*)(C|D|G)}
-        if {[regexp $re_col_move $code _match num type]} {
-            if {$type eq "C"} {
-                #left-arrow/move-back
-                if {$num eq ""} {set num 1}
-                incr idx -$num
-                if {$idx < $opt_colstart} {
-                    set idx $opt_colstart
-                }
-            } elseif {$type eq "D"} {
-                #right-arrow/move forward
-                if {$num eq ""} {set num 1}
-                if {!$opt_overflow || ($idx + $num) <= [llength $outcols]-1} {
-                    incr idx $num
-                    if {$idx > [llength $outcols]-1} {
-                        set idx [llength $outcols] -1
-                    }
-                } else {
-                    set idxstart $idx
-                    set idxend [expr {[llength $outcols]-1}]
-                    set moveend [expr {$idxend - $idxstart}] 
-                    incr idx $moveend
-                    set stackinfo [dict get $understacks $idx] ;#use understack at end - which may or may not have already been replaced by stack from overtext
-                    #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
-                        priv::render_addchar $idx " " $stackinfo
-                    }
-                }
-            } elseif {$type eq "G"} {
-                #move absolute column
-                #adjust to colstart - as column 1 is within overlay
-                #ie 
-                set num [expr {$num + $opt_colstart}]
-                error "renderline absolute col move ESC G unimplemented"
-            }
-
-        }
-    }
-
-    if {$opt_overflow == 0} {
-        #need to truncate to the width of the original undertext
-        #review - string_width vs printing_length here. undertext requirement to be already rendered therefore punk::char::string_width ok?
-        set num_under_columns [punk::char::string_width $pt_underchars] ;#plaintext underchars
-    }
-
-    #coalesce and replay codestacks for outcols grapheme list
-    set outstring ""    
-    set remstring "" ;#remainder after overflow point reached
-    set i 0
-    set cstack [list]
-    set prevstack [list]
-    set out_rawchars ""; #for overflow counting 
-    set output_to "outstring" ;#var in effect depending on overflow
-    set in_overflow 0 ;#used to stop char-width scanning once in overflow
-    foreach ch $outcols {
-        append out_rawchars $ch
-        if {$opt_overflow == 0 && !$in_overflow} {
-            if {[set nextvisualwidth [punk::char::string_width $out_rawchars]] > $num_under_columns} {
-                #todo - check if we overflowed with a double-width char ? 
-                #store visualwidth which may be short
-                set in_overflow 1
-            }
-        }
-        if {$in_overflow} {
-            set output_to "remstring"
-        }
-        set cstack [dict get $understacks $i]
-        if {$cstack ne $prevstack} {
-            if {[llength $prevstack]} {
-                append $output_to \033\[m
-            }
-            foreach code $cstack {
-                append $output_to $code
-            }
-        }
-        append $output_to $ch
-        set prevstack $cstack
-        incr i
-    }
-    if {[dict size $understacks] > 0} {
-        append $output_to [join [dict get $understacks [expr {[dict size $understacks]-1}]] ""] ;#tail codes
-    }
-    if {[string length $remstring]} {
-        #puts stderr "remainder:$remstring"
-    }
-    #pdict $understacks
-    if {$opt_returnextra} {
-        set cursorinfo ""
-        return [list result $outstring visualwidth - stringlen [string length $outstring] remainder $remstring cursor [expr {$idx + 1}]]
-    } else {
-        return $outstring
-    }
-    #return [join $out ""]
-}
-proc overtype::test_renderline {} {
-    set t \uFF5E ;#2-wide tilde
-    set u \uFF3F ;#2-wide underscore
-    set missing \uFFFD
-    return [list $t $u A${t}B]
-}
-
-#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 [dict create width 0 height 1] ;#no such thing as zero-height block - for consistency with non-empty strings having no line-endings
-    }
-    set textblock [textutil::tabify::untabify2 $textblock]
-    #stripansi on entire block in one go rather than line by line - result should be the same - review - make tests
-    set textblock [punk::ansi::stripansi $textblock]
-    if {[string first \n $textblock] >= 0} {
-        set width [tcl::mathfunc::max {*}[lmap v [punk::lib::lines_as_list -- $textblock] {::punk::char::string_width $v}]]
-    } else {
-        set width [punk::char::string_width $textblock] 
-    }
-    set num_le [expr {[string length $textblock]-[string length [string map [list \n {}] $textblock]]}] ;#faster than splitting into single-char list
-    #our concept of block-height is likely to be different to other line-counting mechanisms
-    set height [expr {$num_le + 1}] ;# one line if no le - 2 if there is one trailing le even if no data follows le
-
-    return [dict create width $width height $height] ;#maintain order in 'image processing' standard width then height - caller may use lassign [dict values [blocksize <data>]] width height
-}
-
-namespace eval overtype::priv {
-
-    #is actually addgrapheme?
-    proc render_addchar {i c stack} {
-        upvar outcols o
-        upvar understacks ustacks
-        set nxt [llength $o] 
-        if {$i < $nxt} {
-            lset o $i $c
-        } else {
-            lappend o $c
-        }
-        dict set ustacks $i $stack
-    }
-
-}
-
-
-
-# -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype {
-	interp alias {} ::overtype::center {} ::overtype::centre
-}
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide overtype [namespace eval overtype {
-    variable version
-    set version 1.5.7 
-}]
-return
-
-#*** !doctools
-#[manpage_end]
diff --git a/src/bootsupport/modules/overtype-1.5.9.tm b/src/bootsupport/modules/overtype-1.5.9.tm
deleted file mode 100644
index a635158a..00000000
--- a/src/bootsupport/modules/overtype-1.5.9.tm
+++ /dev/null
@@ -1,1756 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) Julian Noble 2003-2023
-#
-# @@ Meta Begin
-# Application overtype 1.5.9
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin overtype_module_overtype 0 1.5.9]
-#[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
-#*** !doctools
-#[item] [package {Tcl 8.6}]
-#[item] [package textutil]
-#[item] [package punk::ansi]
-#[para] - required to detect, split, strip and calculate lengths of text possibly containing ansi codes
-#[item] [package punk::char]
-#[para] - box drawing - and also unicode character width determination for proper layout of text with double-column-width chars
-
-# #package require frobz
-# #*** !doctools
-# #[item] [package {frobz}]
-
-#*** !doctools
-#[list_end]
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[section API]
-
-
-#Julian Noble <julian@precisium.com.au> - 2003 
-#Released under standard 'BSD license' conditions.
-#
-#todo - ellipsis truncation indicator for center,right
-
-#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
-# - need to extract and replace ansi codes?
-
-namespace eval overtype {
-	namespace export *
-    variable default_ellipsis_horizontal "..." ;#fallback 
-    variable default_ellipsis_vertical "..." 
-    namespace eval priv {
-        proc _init {} {
-            upvar ::overtype::default_ellipsis_horizontal e_h
-            upvar ::overtype::default_ellipsis_vertical e_v
-            set e_h [format %c 0x2026] ;#Unicode Horizontal Ellipsis
-            set e_v [format %c 0x22EE]
-            #The unicode ellipsis looks more natural than triple-dash which is centred vertically whereas ellipsis is at floorline of text
-            #Also - unicode ellipsis has semantic meaning that other processors can interpret
-            #unicode does also provide a midline horizontal ellipsis 0x22EF
-
-            #set e [format %c 0x2504] ;#punk::char::charshort boxd_ltdshhz  - Box Drawings Light Triple Dash Horizontal
-            #if {![catch {package require punk::char}]} {
-            #    set e [punk::char::charshort boxd_ltdshhz] 
-            #}
-        }
-    }
-    priv::_init
-}
-proc overtype::about {} {
-	return "Simple text formatting. Author JMN. BSD-License"
-}
-
-namespace eval overtype {
-    variable grapheme_widths [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 
-
-    #self-contained 2 byte ansi escape sequences - review more?
-    variable ansi_2byte_codes_dict
-    set  ansi_2byte_codes_dict [dict create\
-        "reset_terminal"            "\u001bc"\
-        "save_cursor_posn"          "\u001b7"\
-        "restore_cursor_posn"       "\u001b8"\
-        "cursor_up_one"             "\u001bM"\
-        "NEL - Next Line"           "\u001bE"\
-        "IND - Down one line"       "\u001bD"\
-        "HTS - Set Tab Stop"        "\u001bH"\
-        ]
-
-        #debatable whether strip should reveal the somethinghidden - some terminals don't hide it anyway.
-        #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
-}
-
-
-#proc overtype::stripansi {text} {
-#    variable escape_terminals  ;#dict
-#    variable ansi_2byte_codes_dict
-#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-#        #\033 same as \x1b
-#        return $text
-#    }
-#
-#    set text [convert_g0 $text] 
-#
-#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-#    set inputlist [split $text ""]
-#    set outputlist [list] 
-#
-#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-#
-#    set in_escapesequence 0
-#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-#    set i 0
-#    foreach u $inputlist {
-#        set v [lindex $inputlist $i+1]
-#        set uv ${u}${v}
-#        if {$in_escapesequence eq "2b"} {
-#            #2nd byte - done.
-#            set in_escapesequence 0
-#        } elseif {$in_escapesequence != 0} {
-#            set escseq [dict get $escape_terminals $in_escapesequence]
-#            if {$u in $escseq} {
-#                set in_escapesequence 0
-#            } elseif {$uv in $escseq} {
-#                set in_escapseequence 2b ;#flag next byte as last in sequence
-#            }
-#        } else {
-#            #handle both 7-bit and 8-bit CSI and OSC
-#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-#                set in_escapesequence CSI
-#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-#                set in_escapesequence OSC
-#            } elseif {$uv in $2bytecodes} {
-#                #self-contained e.g terminal reset - don't pass through.
-#                set in_escapesequence 2b
-#            } else {
-#                lappend outputlist $u
-#            }
-#        }
-#        incr i
-#    }
-#    return [join $outputlist ""]
-#}
-
-
-
-
-
-proc overtype::string_columns {text} {
-    if {[punk::ansi::ta::detect $text]} {
-        #error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
-        set text [punk::ansi::stripansi $text]
-    }
-    return [punk::char::ansifreestring_width $text]
-}
-
-
-#string range should generally be avoided for both undertext and overtext which contain ansi escapes and other cursor affecting chars such as \b and \r
-proc overtype::left {args} {
-	# @c overtype starting at left (overstrike) 
-	# @c can/should we use something like this?: 'format "%-*s" $len $overtext 
-    variable default_ellipsis_horizontal
-
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-overflow [1|0]? ?-ellipsis [1|0]? ?-ellipsistext ...? undertext overtext}
-	}
-    lassign [lrange $args end-1 end] underblock overblock
-    set defaults [dict create\
-        -bias       ignored\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        switch -- $k {
-            -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 {}
-            default {
-                set known_opts [dict keys $defaults]
-                error "overtype::left unknown option '$k'. Known options: $known_opts"
-            }
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_exposed1        [dict get $opts -exposed1] ;#widechar_exposed_left  - todo
-    set opt_exposed2        [dict get $opts -exposed2] ;#widechar_exposed_right - todo
-    # -- --- --- --- --- ---
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    set right_exposed $under_exposed_max 
-
-    set outputlines [list]
-    if {[punk::ansi::ta::detect_sgr [lindex $underlines 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 undertext_printlen [punk::ansi::printing_length $undertext]
-        if {$undertext_printlen < $colwidth} {
-            set udiff [expr {$colwidth - $undertext_printlen}]
-            append undertext [string repeat { } $udiff]
-        }
-        set overtext_printlen [punk::ansi::printing_length $overtext]
-        set overflowlength [expr {$overtext_printlen - $colwidth}]
-
-
-        set overtext [string cat $replay_codes_overlay $overtext]
-        set undertext [string cat $replay_codes_underlay $undertext]
-        set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 -overflow [dict get $opts -overflow] $undertext $overtext]
-        set rendered [dict get $rinfo result]
-        if {$overflowlength > 0} {
-            #background line is narrower than data in line
-
-            if {![dict get $opts -overflow]} {
-                #set overtext [string range $overtext 0 $colwidth-1] ;#string range won't be correct e.g if contains ansi codes or leading \r or \b etc
-                if {[dict get $opts -ellipsis]} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        #review - ansi codes in overlay's overflow?
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            #lappend outputlines $rendered
-        }
-            #we know overtext data is shorter or equal (for this line)
-            #lappend outputlines [renderline -insert_mode 0 -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-            #set rinfo [renderline -info 1 -insert_mode 0 -transparent $opt_transparent -exposed1 $opt_exposed1 -exposed2 $opt_exposed2 $undertext $overtext]
-            #lappend outputlines  [dict get $rinfo result] 
-        lappend outputlines $rendered
-        set replay_codes_underlay [dict get $rinfo replay_codes_underlay]
-        set replay_codes_overlay [dict get $rinfo replay_codes_overlay]
-    }
-    return [join $outputlines \n]
-
-}
-
-namespace eval overtype::piper {
-    proc overcentre {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-bias left|right? ?-transparent [0|1|<regexp>]? ?-exposed1 <char>? ?-exposed2 <char>?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        lassign [lrange $args end-1 end] over under
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::centre {*}$argsflags $under $over
-    }
-    proc overleft {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-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
-    }
-}
-#todo - left-right ellipsis ?
-proc overtype::centre {args} {
-    variable default_ellipsis_horizontal
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-bias [left|right]?  ?-overflow [1|0]? undertext overtext}
-	}
-	
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    #todo - vertical vs horizontal overflow for blocks
-    set defaults [dict create\
-        -bias       left\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        switch -- $k {
-            -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 {}
-            default {
-                set known_opts [dict keys $defaults]
-                error "overtype::centre unknown option '$k'. Known options: $known_opts"
-            }
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis        [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    if {$under_exposed_max > 0} {
-        #background block is wider
-        if {$under_exposed_max % 2 == 0} {
-            #even left/right exposure
-            set left_exposed [expr {$under_exposed_max / 2}]
-        } else {
-            set beforehalf [expr {$under_exposed_max / 2}] ;#1 less than half due to integer division
-            if {[string tolower [dict get $opts -bias]] eq "left"} {
-                set left_exposed $beforehalf
-            } else {
-                #bias to the right
-                set left_exposed [expr {$beforehalf + 1}]
-            }
-        }
-    } else {
-        set left_exposed 0
-    }
-
-    set outputlines [list]
-    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 [string cat $replay_codes_underlay $undertext]
-        set overtext  [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]
-            #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 {$opt_ellipsis} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-            #lappend outputlines [renderline -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  [dict get $rinfo result]
-        }
-        set replay_codes_underlay [dict get $rinfo replay_codes_underlay]
-        set replay_codes_overlay [dict get $rinfo replay_codes_overlay]
-    }
-    return [join $outputlines \n]
-}
-
-proc overtype::right {args} {
-    #NOT the same as align-right - which should be done to the overblock first if required
-    variable default_ellipsis_horizontal
-	# @d !todo - implement overflow, length checks etc
-
-	if {[llength $args] < 2} {
-		error {usage: ?-overflow [1|0]? ?-transparent 0|<char>? undertext overtext}
-	}
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    set defaults [dict create\
-        -bias       ignored\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-        -align  "left"\
-    ]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        switch -- $k {
-            -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -align {}
-            default {
-                set known_opts [dict keys $defaults]
-                error "overtype::centre unknown option '$k'. Known options: $known_opts"
-            }
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis         [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_overflow        [dict get $opts -overflow]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    set opt_align           [dict get $opts -align]
-    # -- --- --- --- --- ---
-    
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {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 [string cat $replay_codes_underlay $undertext]
-        set overtext [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]
-            if {!$opt_overflow} {
-                if {$opt_ellipsis} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set ellipsis [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  [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]
-    }
-
-    return [join $outputlines \n]
-}
-
-# -- --- --- --- --- --- --- --- --- --- ---
-proc overtype::transparentline {args} {
-    foreach {under over} [lrange $args end-1 end] break
-    set argsflags [lrange $args 0 end-2]
-    set defaults [dict create\
-        -transparent 1\
-        -exposed 1 " "\
-        -exposed 2 " "\
-    ]
-    set newargs [dict merge $defaults $argsflags]
-    tailcall overtype::renderline {*}$newargs $under $over
-}
-#renderline may not make sense as it is in the long run for blocks of text - but is handy in the single-line-handling form anyway.
-# We are trying to handle ansi codes in a block of text which is acting like a mini-terminal in some sense.
-#We can process standard cursor moves such as \b \r - but no way to respond to other cursor movements e.g moving to other lines.
-#
-namespace eval overtype::piper {
-    proc renderline {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        foreach {over under} [lrange $args end-1 end] break
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::renderline {*}$argsflags $under $over
-    }
-}
-interp alias "" piper_renderline "" overtype::piper::renderline 
-
-#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 {[dict exists $grapheme_widths $ch]} {
-        return [dict get $grapheme_widths $ch]
-    }
-    set width [punk::char::ansifreestring_width $ch]
-    dict set grapheme_widths $ch $width
-    return $width
-}
-
-#v2
-#-returnextra to enable 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
-#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 overtype::renderline {args} {
-	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"
-    #}
-
-    set defaults [dict create\
-        -overflow      0\
-        -transparent   0\
-        -startcolumn   1\
-        -cursor_column 1\
-        -cursor_row    ""\
-        -insert_mode   1\
-        -info          0\
-        -exposed1      \uFFFD\
-        -exposed2      \uFFFD\
-    ]
-    #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]
-    dict for {k v} $argsflags {
-        switch -- $k {
-            -overflow - -transparent - -startcolumn - -cursor_column - -cursor_row - -insert_mode - -info - -exposed1 - -exposed2 {}
-            default {
-                set known_opts [dict keys $defaults]
-                error "overtype::renderline unknown option '$k'. Known options: $known_opts"
-            }
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_overflow            [dict get $opts -overflow]
-    set opt_colstart            [dict get $opts -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]
-    if {[string length $opt_row_context]} {
-        if {![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'"
-        }
-    }
-    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)
-    #default is for overtype
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_transparent         [dict get $opts -transparent]  
-    if {$opt_transparent eq "0"} {
-        set do_transparency 0
-    } else {
-        set do_transparency 1
-        if {$opt_transparent eq "1"} {
-            set opt_transparent {[\s]}
-        }
-    }
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_returnextra         [dict get $opts -info]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_exposed1            [dict get $opts -exposed1]
-    set opt_exposed2            [dict get $opts -exposed2]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-
-    if {$opt_row_context eq ""} {
-        set cursor_row 0 ;#we aren't allowed to make assumptions about our context. zero represents cursor_row_change - not an absolute row (for which zero is invalid anyway)
-    } else {
-        set cursor_row "=$opt_row_context" ;#we are at this row number in the greater context - allow moves that explicitly refer to this row without returning prematurely
-    }
-
-
-    #-----
-    #
-    if {[string first \t $under] >= 0} {
-        #set under [textutil::tabify::untabify2 $under]
-        set under [textutil::tabify::untabifyLine $under 8] ;#8 is default for untabify2 - review
-    }
-    set overdata $over
-    if {[string first \t $over] >= 0} {
-        #set overdata [textutil::tabify::untabify2 $over]
-        set overdata [textutil::tabify::untabifyLine $over 8]
-    }
-    #-------
-
-    #ta_detect ansi and do simpler processing?
-
-    #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.
-
-    # -- --- --- --- --- --- --- ---
-    set undermap [punk::ansi::ta::split_codes_single $under]
-    set understacks [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 understacks_gx [dict create]
-    set understacks_gx [list]
-    set pt_underchars "" ;#for string_columns length calculation for overflow 0 truncation
-    set remainder [list] ;#for returnextra
-    foreach {pt code} $undermap {
-        #pt = plain text
-        append pt_underchars $pt
-        foreach 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 {
-                    set width [grapheme_width_cached $grapheme]
-                }
-            }
-            #set width [grapheme_width_cached $grapheme]
-            incr i_u
-            #dict set understacks $i_u $u_codestack 
-            lappend understacks $u_codestack
-            #dict set understacks_gx $i_u $u_gx_stack
-            lappend understacks_gx $u_gx_stack
-            
-            lappend undercols $grapheme
-            if {$width > 1} {
-                incr i_u
-                #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?
-                #dict set understacks $i_u $u_codestack 
-                lappend understacks $u_codestack
-                #dict set understacks_gx $i_u $u_gx_stack
-                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 
-        #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 ""} {
-            if {[punk::ansi::codetype::is_sgr_reset $code]} {
-                set u_codestack [list]
-            } elseif {[punk::ansi::codetype::has_sgr_leadingreset $code]} {
-                set u_codestack [list $code]
-            } elseif {[punk::ansi::codetype::is_sgr $code]} {
-                lappend u_codestack $code
-            } else {
-                #leave SGR stack as is 
-                if {[punk::ansi::codetype::is_gx_open $code]} {
-                    set u_gx_stack [list gx0_on] ;#we'd better use a placeholder - or debugging will probably get into a big mess
-                } elseif {[punk::ansi::codetype::is_gx_close $code]} {
-                    set u_gx_stack [list]
-                } 
-            } 
-        }
-
-        #consider also if there are other codes that should be stacked..?
-    }
-
-    #trailing codes in effect for underlay
-    #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 $undermap]} {
-        #dict set understacks [expr {$i_u + 1}] $u_codestack ;#This is one column higher than our input
-        lappend understacks $u_codestack
-        set replay_codes_underlay [join $u_codestack ""]
-
-        # For gx we need the column after the data too ?
-        #dict set understacks_gx [expr {$i_u +1}] $u_gx_stack
-        lappend understacks_gx $u_gx_stack
-    } else {
-        set replay_codes_underlay ""
-        #in case overlay onto emptystring as underlay 
-        #dict set understacks 0 [list]
-        lappend understacks [list]
-        #dict set understacks_gx 0 [list]
-        lappend understacks_gx [list]
-    }
-    #note - be careful.. understacks 1 bigger than input - for insertion at end (review)
-
-
-    # -- --- --- --- --- --- --- ---
-    ####
-    #if opt_colstart - we need to build a space (or any singlewidth char really) padding on the left of the right number of columns.
-    #this will be processed as transparent - and handle doublewidth underlay characters appropriately
-    set startpad_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]
-    ####
-
-    #???
-    set colcursor $opt_colstart
-
-    #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 [dict create]
-    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 
-    foreach {pt code} $overmap {
-        append pt_overchars $pt
-        #will get empty pt between adjacent codes
-        foreach grapheme [punk::char::grapheme_split $pt] {
-           #dict set overstacks $i_o $o_codestack 
-           lappend overstacks $o_codestack
-           #dict set overstacks_gx $i_o $o_gxstack
-           lappend overstacks_gx $o_gxstack
-           incr i_o 
-           lappend overlay_grapheme_control_list [list g $grapheme]
-        }
-
-        #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 ""} {
-            #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]
-                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]} {
-                lappend o_codestack $code
-                lappend overlay_grapheme_control_list [list sgr $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}]
-    #dict set overstacks $i_o $o_codestack
-    lappend overstacks $o_codestack
-    #dict set overstacks_gx $i_o $o_gxstack
-    lappend overstacks_gx $o_gxstack
-    set replay_codes_overlay [join $o_codestack ""]
-
-    #if {[dict exists $overstacks $max_overlay_grapheme_index]} {
-    #    set replay_codes_overlay [join [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 break and force in_overflow to 1 
-    if {$opt_overflow} {
-        set overflow_idx -1
-    } else {
-        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 insert_lines_above 0   ;#return key
-    set insert_lines_below 0
-
-    #set idx 0 ;# line index  (cursor - 1)
-    #set idx [expr {$opt_colstart + $opt_colcursor} -1]
-    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
-    set cursor_column $opt_colcursor
-    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 in_overflow 0
-    #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
-                if {$overflow_idx != -1 && $idx == $overflow_idx } {
-                    #review 2w overflow?
-                    set in_overflow 1 
-                    #first overstack codeset only
-                    #priv::render_addchar $idx $ch [dict get $overstacks $idx_over] [dict get $overstacks_gx $idx_over] $insert_mode
-                    priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
-                    incr idx
-                    set cursor_column [expr {$idx + 1}]
-                    continue 
-                }
-
-                set within_undercols [expr {$idx <= [llength $undercols]-1}] ;#within our original data width
-
-                if {$in_overflow} {
-                    #render any char - even \b\v\r into outcols - will become part of overflow
-                    #no stacks added from here on - raw codes go into overflow/remainder
-                    priv::render_addchar $idx $ch [list] [list] $insert_mode
-                    incr idx ;#width doesn't matter from here 
-                } else {
-                    if {($idx < ($opt_colstart -1))} {
-                        incr idx
-                    } elseif {($do_transparency && [regexp $opt_transparent $ch])} {    
-                        #pre opt_colstart is effectively transparent (we have applied padding of required number of columns to left of overlay)
-                        if {$idx > [llength $outcols]-1} {
-                            lappend outcols " "
-                            #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 [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 [dict get $overstacks $idx_over] [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 chtest [string map [list \n <lf> \b <bs> \r <cr> \v <vt>] $ch]
-                        switch -- $chtest {
-                            "<lf>" {
-                                switch -- [string index $cursor_row 0] {
-                                    0 {
-                                        incr cursor_row
-                                    }
-                                    = {
-                                        #deliberately keeping literals in switch statement rather than matching on =$opt_row_context directly (keep switch byte-compiled)
-                                        if {$cursor_row eq "=$opt_row_context"} {
-                                            set cursor_row "=[expr {$opt_row_context +1}]" ;#we can return an absolute next cursor row
-                                        } else {
-                                            error "overtype::renderline bad cursor_row $cursor_row encountered when lf encountered"
-                                        }
-                                    }
-                                    default {
-                                        #we should have already returned if cursor_row is not 1 or "=$opt_row_context"
-                                        error "overtype::renderline bad cursor_row $cursor_row encountered when lf encountered."
-                                    }
-                                }
-                                
-                                #override overflow_idx even if it was set to -1 due to opt_overflow = 1
-                                set overflow_idx $idx
-                                #set unapplied [join [lrange $overlay_grapheme_control_list $gci+1 end]]
-                                set unapplied ""
-                                append unapplied [join [lindex $overstacks $idx_over] ""]
-                                switch -- [lindex $overstacks_gx $idx_over] {
-                                    "gx0_on" {
-                                        append unapplied "\x1b(0"
-                                    }
-                                    "gx0_off" {
-                                        append unapplied "\x1b(B"
-                                    }
-                                }
-
-                                foreach gc [lrange $overlay_grapheme_control_list $gci+1 end] {
-                                    lassign $gc type item
-                                    if {$type eq "gx0"} {
-                                        if {$item eq "gx0_on"} {
-                                            append unapplied "\x1b(0"
-                                        } elseif {$item eq "gx0_off"} {
-                                            append unapplied "\x1b(B"
-                                        }
-                                    } else {
-                                        append unapplied $item
-                                    }
-                                    incr idx_over
-                                }
-                                if {$idx == 0} {
-                                    set insert_lines_above 1
-                                } else {
-                                    set insert_lines_below 1
-                                }
-                                break
-                                set cursor_column 1
-                            }
-                            "<cr>" {
-                                set idx [expr {$opt_colstart -1}]
-                                set cursor_column 1 ;#?
-                            }
-                            "<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
-                                }
-                            }
-                            "<vt>" {
-                                #end processing this overline. rest of line is remainder. cursor for column as is. 
-                                if {$cursor_row eq 0} {
-                                    incr cursor_row
-                                } elseif {$cursor_row eq "=$opt_row_context"} {
-                                    set cursor_row "=[expr {$opt_row_context +1}]" ;#we can return an absolute next cursor row
-                                } else {
-                                    #we should have already returned if cursor_row is not 1 or "=$opt_row_context"
-                                    error "overtype::renderline bad cursor_row $cursor_row encountered when \v encountered"
-                                }
-                                #override overflow_idx even if it was set to -1 due to opt_overflow = 1
-                                set overflow_idx [expr $idx]
-                                set in_overflow 1
-                                incr idx
-                                #keep cursor_column at same column
-                                #break
-                            }
-                            default {
-
-                                #non-transparent char in overlay
-                                set uwidth [grapheme_width_cached [lindex $outcols $idx]]
-                                    
-                                if {$within_undercols && [lindex $outcols $idx] 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 [expr {$idx-1}]] [lindex $understacks_gx [expr {$idx-1}]] 0 
-                                        }
-                                        incr idx
-                                        incr cursor_column
-                                    } 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 [expr {$idx-1}]] [lindex $understacks_gx [expr {$idx-1}]] 0  ;#replace not insert
-                                        } ;# else??
-                                        incr idx
-                                        incr cursor_column
-                                    }
-                                    
-                                } elseif {$uwidth == 0} {
-                                    if {$within_undercols} {
-                                        #e.g combining diacritic - increment before over char  REVIEW
-                                        #arguably the previous overchar should have done this - ie lookahead for combiners?
-                                        priv::render_addchar $idx "" [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
-                                    } else {
-                                        #overflow
-                                        priv::render_addchar $idx $ch [lindex $overstacks $idx_over] [lindex $overstacks_gx $idx_over] $insert_mode
-                                        incr idx
-                                        incr cursor_column
-                                    }
-                                } elseif {$uwidth == 1} {
-                                    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
-                                        incr cursor_column
-                                    } 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] >= [expr {$idx +2}] && [lindex $outcols $idx+1] eq ""} {
-                                            #priv::render_addchar [expr {$idx+1}] $opt_exposed2 [dict get $understacks [expr {$idx+1}]] [dict get $understacks_gx [expr {$idx+1}]] $insert_mode
-                                            priv::render_addchar [expr {$idx+1}] $opt_exposed2 [lindex $understacks [expr {$idx+1}]] [lindex $understacks_gx [expr {$idx+1}]] $insert_mode
-                                        }
-                                        incr idx
-                                        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
-                                    }
-                                }
-                            }
-                        } ;# end switch
-                    }
-                }
-            }
-            other {
-                set code $item
-                if {$in_overflow} {
-                    #render controls into overflow/remainder output 
-                    priv::render_addchar $idx $code [list] [list] $insert_mode
-                    incr idx ;#take up a column for each control sequence too
-                    continue
-                }
-
-                #cursor movement?
-                #if {![punk::ansi::codetype::is_sgr $code]} {
-                #
-                #}
-                #if {[punk::ansi::codetype::is_cursor_move_in_line $code]} {
-                #}
-                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$}
-                set re_vt_sequence {\x1b\[([0-9]*)(?:;){0,1}([0-9]*)~$}
-                set matchinfo [list]
-
-                switch -regexp -matchvar matchinfo -- $code\
-                $re_col_move {
-                    lassign $matchinfo _match num type
-                    switch -- $type {
-                        D {
-                            #left-arrow/move-back
-                            if {$num eq ""} {set num 1}
-                            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 {
-                            #right-arrow/move forward
-                            if {$num eq ""} {set num 1}
-                            
-                            #todo - retrict to moving 1 position past datalen? restrict to column width? 
-                            #should ideally wrap to next line 
-                            if {!$opt_overflow || ($idx + $num) <= [llength $outcols]} {
-                                incr idx $num
-                                incr cursor_column $num
-
-                                if {$idx > [llength $outcols]+1} {
-                                    #set idx [expr {[llength $outcols] -1}]
-                                    set idx [expr {[llength $outcols]+2}] 
-                                    set cursor_column [expr {[llength $outcols]+1}]
-                                }
-                            } else {
-                                if {!$insert_mode} {
-                                    #block editing style with arrow keys
-                                    #overtype mode
-                                    set idxstart $idx
-                                    set idxend [expr {[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 {[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
-                                    #} 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 [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 [expr {[llength $outcols]}];#allow one beyond - for adding character at end of line
-                                        set cursor_column [expr {[llength $outcols]+1}]
-                                    }
-                                }
-                            }
-                        }
-                        G {
-                            #move absolute column
-                            #adjust to colstart - as column 1 is within overlay
-                            #???
-                            set idx [expr {$num + $opt_colstart -1}] 
-                            set cursor_column $num
-                            error "renderline absolute col move ESC G unimplemented"
-                        }
-                    }
-                }\
-                $re_row_move {
-                    lassign $matchinfo _match num type
-                    switch -- $type {
-                        A {
-                            #move up
-                            if {$num eq ""} {set num 1}
-                            if {$cursor_row eq 0} {
-                                incr cursor_row -1 ;#relative change
-                            } elseif {$cursor_row eq "=$opt_row_context"} {
-                                set cursor_row "=[expr {$opt_row_context -1}]" ;#we can return an absolute next cursor row
-                            } else {
-                                #we should have already returned if cursor_row is not 1 or "=$opt_row_context"
-                                error "overtype::renderline bad cursor_row $cursor_row encountered when \v encountered"
-                            }
-                            #ensure rest of *overlay* is emitted to remainder
-                            incr idx
-                            #retain cursor_column
-                            break 
-                        }
-                        B {
-                            #move down
-                            if {$num eq ""} {set num 1}
-                            if {$cursor_row eq 0} {
-                                incr cursor_row 1 ;#relative change
-                            } elseif {$cursor_row eq "=$opt_row_context"} {
-                                set cursor_row "=[expr {$opt_row_context +1}]" ;#we can return an absolute next cursor row
-                            } else {
-                                #we should have already returned if cursor_row is not 1 or "=$opt_row_context"
-                                error "overtype::renderline bad cursor_row $cursor_row encountered when \v encountered"
-                            }
-                            #set overflow_idx $idx ;#ensure rest of line is emitted to remainder
-                            incr idx
-                            #retain cursor_column
-                            break 
-                        }
-                    }
-                }\
-                $re_both_move {
-                    lassign $matchinfo _match row col 
-                    if {$row eq ""} {set row 1}
-                    if {$col eq ""} {set col 1}
-                    set cursor_column $col
-                }\
-                $re_vt_sequence {
-                    lassign $matchinfo _match 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
-                        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
-                    }
-
-                }
-            }
-            sgr {
-                #prior to overflow - we have our sgr codes already in stacks
-                #post-overflow we need to keep them in order along with non sgr codes and graphemes
-                if {$in_overflow} {
-                    set code $item
-                    #render controls into output - will become overflow/remainder
-                    priv::render_addchar $idx $code [list] [list] $insert_mode
-                    incr idx ;#take up an overflow column for each control sequence too
-                }
-            }
-            gx0 {
-                if {$in_overflow} {
-                    set code $item
-                    if {$code eq "gx0_on"} {
-                        set actual "\x1b(0"
-                    } else {
-                        set actual "\x1b(B"
-                    }
-                    priv::render_addchar $idx $actual [list] [list] $insert_mode 
-                    incr idx
-                }
-
-            }
-        }
-    }
-
-    #--------------
-    #if {$in_overflow} {
-    #    #set cursor_column [expr {$overflow_idx -1}]
-    #    set cursor_column [expr {$overflow_idx +1}]
-    #} else {
-    #    set cursor_column [expr {$idx + 1}]
-    #}
-
-
-    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
-    foreach ch $outcols {
-        #puts "---- [ansistring VIEW $ch]"
-
-        if {$in_overflow} {
-            #ch could be a control-sequence or a grapheme once in overflow
-            if {$i == $overflow_idx} {
-                #only run when we exactly hit overflow_idx
-                if {$i < [llength $understacks_gx]} {
-                    #set g0 [dict get $understacks_gx $i]
-                    set g0 [lindex $understacks_gx $i]
-                    if {[llength $g0]} {
-                        append outstring "\x1b(B"
-                    }
-                }
-                #add first codestack only
-                if {$i < [llength $understacks]} {
-                    set cstack [lindex $understacks $i]
-                    append overflow_right [join $cstack ""]
-                }
-            }
-            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
-                }
-            }
-
-            if {$i < [llength $understacks_gx]} {
-                #set g0 [dict get $understacks_gx $i]
-                set g0 [lindex $understacks_gx $i]
-                if {$g0 ne $prev_g0} {
-                    if {$g0 eq [list "gx0_on"]} {
-                        append outstring "\x1b(0"
-                    } else {
-                        append outstring "\x1b(B"
-                    }
-                }
-                set prev_g0 $g0
-            } else {
-                set prev_g0 [list]
-            }
-            #code replay when not in overflow
-            if {$i < [llength $understacks]} {
-                #set cstack [dict get $understacks $i]
-                set cstack [lindex $understacks $i]
-                if {$cstack ne $prevstack} {
-                    if {[llength $prevstack]} {
-                        append outstring \033\[m
-                    }
-                    append outstring [join $cstack ""]
-                }
-                set prevstack $cstack
-            } else {
-                set prevstack [list]
-            }
-            append outstring $ch
-        }
-        incr i
-    }
-
-    set replay_codes ""
-    if {[llength $understacks] > 0} {
-        if {$overflow_idx == -1} {
-            #set tail_idx [dict size $understacks]
-            set tail_idx [llength $understacks]
-        } else {
-            set tail_idx [llength $undercols]
-        }
-        #if {[dict exists $understacks [expr {$tail_idx-1}]]} {
-        #    set replay_codes [join [dict get $understacks [expr {$tail_idx-1}]] ""] ;#tail replay codes
-        #}
-        if {$tail_idx-1 < [llength $understacks]} {
-            set replay_codes [join [lindex $understacks [expr {$tail_idx-1}]] ""] ;#tail replay codes
-        }
-        if {$tail_idx-1 < [llength $understacks_gx]} {
-            #set gx0 [dict get $understacks_gx [expr {$tail_idx-1}]]
-            set gx0 [lindex $understacks_gx [expr {$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]
-    }
-    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
-        #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
-        return [list\
-            result $outstring\
-            visualwidth [punk::ansi::printing_length $outstring]\
-            stringlen [string length $outstring]\
-            overflow_idx $overflow_idx\
-            overflow_right $overflow_right\
-            unapplied $unapplied\
-            insert_mode $insert_mode\
-            insert_lines_above $insert_lines_above\
-            insert_lines_below $insert_lines_below\
-            cursor_column $cursor_column\
-            cursor_row_change $cursor_row\
-            replay_codes $replay_codes\
-            replay_codes_underlay $replay_codes_underlay\
-            replay_codes_overlay $replay_codes_overlay\
-        ]
-    } else {
-        return $outstring
-    }
-    #return [join $out ""]
-}
-proc overtype::test_renderline {} {
-    set t \uFF5E ;#2-wide tilde
-    set u \uFF3F ;#2-wide underscore
-    set missing \uFFFD
-    return [list $t $u A${t}B]
-}
-
-#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 [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} {
-        set textblock [textutil::tabify::untabify2 $textblock]
-    }
-    #stripansi on entire block in one go rather than line by line - result should be the same - review - make tests
-    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
-        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 [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]
-
-    #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]
-        } 
-        set answer [punk::ansi::codetype::is_sgr $code]
-        dict set cache_is_sgr $code $answer
-        return $answer
-    }
-    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 {
-
-        }
-    }
-    #is actually addgrapheme?
-    proc render_addchar {i c sgrstack gx0stack {insert_mode 0}} {
-        upvar outcols o
-        upvar understacks ustacks
-        upvar understacks_gx gxstacks
-
-        set nxt [llength $o] 
-        if {!$insert_mode} {
-            if {$i < $nxt} {
-                lset o $i $c
-            } else {
-                lappend o $c
-            }
-            #dict set ustacks $i $sgrstack
-            if {$i < [llength $ustacks]} {
-                lset ustacks $i $sgrstack
-            } else {
-                lappend ustacks $sgrstack
-            }
-            #dict set gxstacks $i $gx0stack
-            if {$i < [llength $gxstacks]} {
-                lset gxstacks $i $gx0stack
-            } else {
-                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
-            }
-            #rewrite our whole understacks
-            #for inserts - the dict structure of the ansi stacks is less than ideal.  
-            #set new [dict create]
-            #dict for {k v} $ustacks {
-            #    if {$k < $i} {
-            #        dict set new $k $v
-            #    } elseif {$k == $i} {
-            #        dict set new $k $sgrstack
-            #        dict set new [expr {$k+1}] $v
-            #    } else {
-            #        dict set new [expr {$k+1}] $v
-            #    }
-            #}
-            #set ustacks $new
-            if {$i < [llength $ustacks]} {
-                set ustacks [linsert $ustacks $i $sgrstack]
-            } else {
-                lappend ustacks $sgrstack
-            }
-
-            if {$i < [llength $gxstacks]} {
-                set gxstacks [linsert $gxstacks $i $gx0stack]
-            } else {
-                lappend gxstacks $gx0stack
-            }
-        }
-    }
-
-}
-
-
-
-# -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype {
-	interp alias {} ::overtype::center {} ::overtype::centre
-}
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide overtype [namespace eval overtype {
-    variable version
-    set version 1.5.9 
-}]
-return
-
-#*** !doctools
-#[manpage_end]
diff --git a/src/bootsupport/modules/overtype-1.6.0.tm b/src/bootsupport/modules/overtype-1.6.0.tm
deleted file mode 100644
index f5bdf82b..00000000
--- a/src/bootsupport/modules/overtype-1.6.0.tm
+++ /dev/null
@@ -1,3292 +0,0 @@
-# -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
-#
-# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
-# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# (C) Julian Noble 2003-2023
-#
-# @@ Meta Begin
-# Application overtype 1.6.0
-# Meta platform     tcl
-# Meta license      BSD 
-# @@ Meta End
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-# doctools header
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[manpage_begin overtype_module_overtype 0 1.6.0]
-#[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]
-
-
-
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-#*** !doctools
-#[section API]
-
-
-#Julian Noble <julian@precisium.com.au> - 2003 
-#Released under standard 'BSD license' conditions.
-#
-#todo - ellipsis truncation indicator for center,right
-
-#v1.4 2023-07 - naive ansi color handling - todo - fix string range 
-# - need to extract and replace ansi codes?
-
-namespace eval overtype {
-    namespace import ::punk::assertion::assert
-    punk::assertion::active true 
-
-    namespace path ::punk::lib
-
-	namespace export *
-    variable default_ellipsis_horizontal "..." ;#fallback 
-    variable default_ellipsis_vertical "..." 
-    namespace eval priv {
-        proc _init {} {
-            upvar ::overtype::default_ellipsis_horizontal e_h
-            upvar ::overtype::default_ellipsis_vertical e_v
-            set e_h [format %c 0x2026] ;#Unicode Horizontal Ellipsis
-            set e_v [format %c 0x22EE]
-            #The unicode ellipsis looks more natural than triple-dash which is centred vertically whereas ellipsis is at floorline of text
-            #Also - unicode ellipsis has semantic meaning that other processors can interpret
-            #unicode does also provide a midline horizontal ellipsis 0x22EF
-
-            #set e [format %c 0x2504] ;#punk::char::charshort boxd_ltdshhz  - Box Drawings Light Triple Dash Horizontal
-            #if {![catch {package require punk::char}]} {
-            #    set e [punk::char::charshort boxd_ltdshhz] 
-            #}
-        }
-    }
-    priv::_init
-}
-proc overtype::about {} {
-	return "Simple text formatting. Author JMN. BSD-License"
-}
-
-namespace eval overtype {
-    variable grapheme_widths [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 
-
-    #self-contained 2 byte ansi escape sequences - review more?
-    variable ansi_2byte_codes_dict
-    set  ansi_2byte_codes_dict [dict create\
-        "reset_terminal"            "\u001bc"\
-        "save_cursor_posn"          "\u001b7"\
-        "restore_cursor_posn"       "\u001b8"\
-        "cursor_up_one"             "\u001bM"\
-        "NEL - Next Line"           "\u001bE"\
-        "IND - Down one line"       "\u001bD"\
-        "HTS - Set Tab Stop"        "\u001bH"\
-        ]
-
-        #debatable whether strip should reveal the somethinghidden - some terminals don't hide it anyway.
-        #  "PM - Privacy Message"      "\u001b^somethinghidden\033\\"\
-}
-
-
-#proc overtype::stripansi {text} {
-#    variable escape_terminals  ;#dict
-#    variable ansi_2byte_codes_dict
-#    #important that we don't spend too much time on this for plain text that doesn't contain any escapes anyway
-#    if {[string first \033 $text] <0 && [string first \009c $text] <0} {
-#        #\033 same as \x1b
-#        return $text
-#    }
-#
-#    set text [convert_g0 $text] 
-#
-#    #we process char by char - line-endings whether \r\n or \n should be processed as per any other character.
-#    #line endings can theoretically occur within an ansi escape sequence (review e.g title?)
-#    set inputlist [split $text ""]
-#    set outputlist [list] 
-#
-#    set 2bytecodes [dict values $ansi_2byte_codes_dict]
-#
-#    set in_escapesequence 0
-#    #assumption - undertext already 'rendered' - ie no backspaces or carriagereturns or other cursor movement controls
-#    set i 0
-#    foreach u $inputlist {
-#        set v [lindex $inputlist $i+1]
-#        set uv ${u}${v}
-#        if {$in_escapesequence eq "2b"} {
-#            #2nd byte - done.
-#            set in_escapesequence 0
-#        } elseif {$in_escapesequence != 0} {
-#            set escseq [dict get $escape_terminals $in_escapesequence]
-#            if {$u in $escseq} {
-#                set in_escapesequence 0
-#            } elseif {$uv in $escseq} {
-#                set in_escapseequence 2b ;#flag next byte as last in sequence
-#            }
-#        } else {
-#            #handle both 7-bit and 8-bit CSI and OSC
-#            if {[regexp {^(?:\033\[|\u009b)} $uv]} {
-#                set in_escapesequence CSI
-#            } elseif {[regexp {^(?:\033\]|\u009c)} $uv]} {
-#                set in_escapesequence OSC
-#            } elseif {$uv in $2bytecodes} {
-#                #self-contained e.g terminal reset - don't pass through.
-#                set in_escapesequence 2b
-#            } else {
-#                lappend outputlist $u
-#            }
-#        }
-#        incr i
-#    }
-#    return [join $outputlist ""]
-#}
-
-
-
-
-
-proc overtype::string_columns {text} {
-    if {[punk::ansi::ta::detect $text]} {
-        #error "error string_columns is for calculating character length of string - ansi codes must be stripped/rendered first e.g with punk::ansi::stripansi. Alternatively try punk::ansi::printing_length"
-        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)
-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
-            }
-        }
-    }
-}
-#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 overtype::left {args} {
-    #*** !doctools
-    #[call [fun overtype::left] [arg args] ]
-	#[para]	usage: ?-transparent [0|1]? ?-overflow [1|0]? ?-ellipsis [1|0]? ?-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 defaults [dict create\
-        -bias       ignored\
-        -width      \uFFEF\
-        -height     \uFFeF\
-        -wrap       0\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -appendlines  1\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-        -experimental  0\
-        -looplimit  100000\
-    ]
-    #-ellipsis args not used if -wrap is true
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        switch -- $k {
-            -looplimit - -width - -height - -bias - -wrap - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -appendlines - -transparent - -exposed1 - -exposed2 - -experimental {}
-            default {
-                set known_opts [dict keys $defaults]
-                error "overtype::left unknown option '$k'. Known options: $known_opts"
-            }
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_overflow        [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)
-    #####
-    #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
-    # -- --- --- --- --- ---
-
-    #a hack until we work out how to avoid infinite loops... 
-    #
-    set looplimit [dict get $opts -looplimit]
-
-    # ----------------------------
-    #  -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   [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
-            }
-        }
-    }
-    # ----------------------------
-
-    #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 norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-
-    #set underlines [split $underblock \n]
-
-    #underblock is a 'rendered' block - so width height make sense
-    if {$opt_width eq "\uFFEF"} {
-        lassign [blocksize $underblock] _w colwidth _h colheight
-    } else {
-        set colwidth $opt_width
-        set colheight $opt_height
-    }
-    if {$underblock eq ""} {
-        set blank "\x1b\[0m\x1b\[0m"
-        #set underlines [list "\x1b\[0m\x1b\[0m"]
-        set underlines [lrepeat $colheight $blank]
-    } else {
-        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
-
-    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 [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 [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 [dict create 1 ""] 
-    #lappend replay_codes_overlay ""
-    set replay_codes_overlay ""
-    set unapplied ""
-    set cursor_saved_position [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 1
-    }
-
-    set instruction_stats [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 {![string length $overtext]} {
-            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 [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]
-        }
-        #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         [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 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]
-
-
-
-        #-- todo - detect looping properly
-        if {$row > 1 && $overtext ne "" && $unapplied eq $overtext && $post_render_row == $row && $instruction eq ""} {
-            puts stderr "overtype::left loop?"
-            puts [ansistring VIEW $rinfo]
-            break
-        }
-        #--
-
-        if {[dict size $c_saved_pos] >= 1} {
-            set cursor_saved_position $c_saved_pos
-            set cursor_saved_attributes $c_saved_attributes
-        }
-
-            #background line is narrower than data in line
-
-        set overflow_handled 0
-        if {!$opt_overflow && !$autowrap_mode} {
-            #not allowed to overflow column or wrap therefore we get overflow data to truncate 
-            if {[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 {[string trim $lostdata] eq ""} {
-                        set show_ellipsis 0
-                    }
-                    #set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                    if {[string trim [ansistrip $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
-            }
-        }
-
-
-
-        set nextprefix ""
-
-
-            #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 
-            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 {[dict exists $cursor_saved_position row]} {
-                        set row [dict get $cursor_saved_position row]
-                        set col [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 $cursor_saved_attributes
-                        set cursor_saved_position [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"
-                    }
-                    #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 [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..
-                        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 1
-                    # ----------------------
-                }
-                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 1
-                            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 1
-                                if {$row > [llength $outputlines]} {
-                                    lappend outputlines {*}[lrepeat 1 ""]
-                                }
-                            } else {
-                                append rendered $overflow_right
-                                set overflow_right ""
-                                set row $post_render_row
-                                set col 1
-                                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 1
-
-                }
-                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 1
-                            } 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 1
-
-
-
-                            }
-                        }
-                    } 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 1
-                            } 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
-                    incr row
-                    set col 1 ;#whether wrap or not - next data is at column 1
-                    if {!$autowrap_mode} {
-                        set overflow_handled 1
-                        set unapplied ""
-                        #handled by dropping it 
-                    }
-                }
-                overflow_splitchar {
-                    #2nd half of grapheme would overflow - grapheme 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
-                    incr row
-                    if {$autowrap_mode} {
-                        set col 1
-                    } else {
-                        set overflow_handled 1
-                        #handled by dropping it 
-                    }
-                }
-                vt {
-
-                    #can vt add a line like a linefeed can?
-                    set row $post_render_row
-                    set col $post_render_col
-                }
-                default {
-                    puts stderr "overtype::left unhandled renderline instruction '$instruction'"
-                }
-
-            }
-
-        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::left looplimit reached"
-            lappend outputlines "[a+ red bold]<truncated> - looplimit $looplimit reached[a]"
-            break
-        }
-    }
-    
-    set result [join $outputlines \n]
-    if {$info_mode} {
-        append result \n$instruction_stats\n
-    }
-    return $result
-}
-
-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
-    }
-}
-#todo - left-right ellipsis ?
-proc overtype::centre {args} {
-    variable default_ellipsis_horizontal
-	if {[llength $args] < 2} {
-		error {usage: ?-transparent [0|1]? ?-bias [left|right]?  ?-overflow [1|0]? undertext overtext}
-	}
-	
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    #todo - vertical vs horizontal overflow for blocks
-    set defaults [dict create\
-        -bias       left\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-    ]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        switch -- $k {
-            -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 {}
-            default {
-                set known_opts [dict keys $defaults]
-                error "overtype::centre unknown option '$k'. Known options: $known_opts"
-            }
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis        [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    # -- --- --- --- --- ---
-
-
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {$colwidth - $overblock_width}]
-    if {$under_exposed_max > 0} {
-        #background block is wider
-        if {$under_exposed_max % 2 == 0} {
-            #even left/right exposure
-            set left_exposed [expr {$under_exposed_max / 2}]
-        } else {
-            set beforehalf [expr {$under_exposed_max / 2}] ;#1 less than half due to integer division
-            if {[string tolower [dict get $opts -bias]] eq "left"} {
-                set left_exposed $beforehalf
-            } else {
-                #bias to the right
-                set left_exposed [expr {$beforehalf + 1}]
-            }
-        }
-    } else {
-        set left_exposed 0
-    }
-
-    set outputlines [list]
-    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 [string cat $replay_codes_underlay $undertext]
-        set overtext  [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]
-            #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 {$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]
-                        set lostdata ""
-                        if {$overflow_right ne ""} {
-                            append lostdata $overflow_right
-                        }
-                        if {$unapplied ne ""} {
-                            append lostdata $unapplied
-                        }
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set rendered [overtype::right $rendered $opt_ellipsistext]
-                    }
-                }
-            }
-            lappend outputlines $rendered
-            #lappend outputlines [renderline -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  [dict get $rinfo result]
-        }
-        set replay_codes_underlay [dict get $rinfo replay_codes_underlay]
-        set replay_codes_overlay [dict get $rinfo replay_codes_overlay]
-    }
-    return [join $outputlines \n]
-}
-
-proc overtype::right {args} {
-    #NOT the same as align-right - which should be done to the overblock first if required
-    variable default_ellipsis_horizontal
-	# @d !todo - implement overflow, length checks etc
-
-	if {[llength $args] < 2} {
-		error {usage: ?-overflow [1|0]? ?-transparent 0|<char>? undertext overtext}
-	}
-    foreach {underblock overblock} [lrange $args end-1 end] break
-
-    set defaults [dict create\
-        -bias       ignored\
-        -ellipsis   0\
-        -ellipsistext   $default_ellipsis_horizontal\
-        -ellipsiswhitespace 0\
-        -overflow   0\
-        -transparent 0\
-        -exposed1 \uFFFD\
-        -exposed2 \uFFFD\
-        -align  "left"\
-    ]
-    set argsflags [lrange $args 0 end-2]
-    dict for {k v} $argsflags {
-        switch -- $k {
-            -bias - -ellipsis - -ellipsistext - -ellipsiswhitespace - -overflow - -transparent - -exposed1 - -exposed2 - -align {}
-            default {
-                set known_opts [dict keys $defaults]
-                error "overtype::centre unknown option '$k'. Known options: $known_opts"
-            }
-        }
-    }
-    set opts [dict merge $defaults $argsflags]
-    # -- --- --- --- --- ---
-    set opt_transparent     [dict get $opts -transparent]
-    set opt_ellipsis         [dict get $opts -ellipsis]
-    set opt_ellipsistext    [dict get $opts -ellipsistext]
-    set opt_ellipsiswhitespace [dict get $opts -ellipsiswhitespace]
-    set opt_overflow        [dict get $opts -overflow]
-    set opt_exposed1        [dict get $opts -exposed1]
-    set opt_exposed2        [dict get $opts -exposed2]
-    set opt_align           [dict get $opts -align]
-    # -- --- --- --- --- ---
-    
-    set norm [list \r\n \n]
-    set underblock [string map $norm $underblock]
-    set overblock  [string map $norm $overblock]
-
-    set underlines [split $underblock \n]
-    #set colwidth [tcl::mathfunc::max {*}[lmap v $underlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $underblock] _w colwidth _h colheight
-    set overlines  [split $overblock \n]
-    #set overblock_width [tcl::mathfunc::max {*}[lmap v $overlines {punk::ansi::printing_length $v}]]
-    lassign [blocksize $overblock] _w overblock_width _h overblock_height 
-    set under_exposed_max [expr {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 [string cat $replay_codes_underlay $undertext]
-        set overtext [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]
-            if {!$opt_overflow} {
-                if {$opt_ellipsis} {
-                    set show_ellipsis 1
-                    if {!$opt_ellipsiswhitespace} {
-                        #we don't want ellipsis if only whitespace was lost
-                        set lostdata [string range $overtext end-[expr {$overflowlength-1}] end]
-                        if {[string trim $lostdata] eq ""} {
-                            set show_ellipsis 0
-                        }
-                    }
-                    if {$show_ellipsis} {
-                        set ellipsis [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  [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]
-    }
-
-    return [join $outputlines \n]
-}
-
-# -- --- --- --- --- --- --- --- --- --- ---
-proc overtype::transparentline {args} {
-    foreach {under over} [lrange $args end-1 end] break
-    set argsflags [lrange $args 0 end-2]
-    set defaults [dict create\
-        -transparent 1\
-        -exposed 1 " "\
-        -exposed 2 " "\
-    ]
-    set newargs [dict merge $defaults $argsflags]
-    tailcall overtype::renderline {*}$newargs $under $over
-}
-#renderline may not make sense as it is in the long run for blocks of text - but is handy in the single-line-handling form anyway.
-# We are trying to handle ansi codes in a block of text which is acting like a mini-terminal in some sense.
-#We can process standard cursor moves such as \b \r - but no way to respond to other cursor movements e.g moving to other lines.
-#
-namespace eval overtype::piper {
-    proc renderline {args} {
-        if {[llength $args] < 2} {
-            error {usage: ?-start <int>? ?-transparent [0|1|<regexp>]?  ?-overflow [1|0]? overtext pipelinedata}
-        }
-        foreach {over under} [lrange $args end-1 end] break
-        set argsflags [lrange $args 0 end-2]
-        tailcall overtype::renderline {*}$argsflags $under $over
-    }
-}
-interp alias "" piper_renderline "" overtype::piper::renderline 
-
-#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 {[dict exists $grapheme_widths $ch]} {
-        return [dict get $grapheme_widths $ch]
-    }
-    set width [punk::char::ansifreestring_width $ch]
-    dict set grapheme_widths $ch $width
-    return $width
-}
-
-
-
-# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
-# 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 overtype::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"
-    #}
-
-    set defaults [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 ""\
-        -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]
-    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 {}
-            default {
-                set known_opts [dict keys $defaults]
-                error "overtype::renderline unknown option '$k'. Known options: $known_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]
-    if {[string length $opt_row_context]} {
-        if {![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)
-    #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 temp_cursor_saved       [dict get $opts -cursor_restore_attributes]
-
-    set test_mode 0
-    set cp437_glyphs 0
-    foreach e [dict get $opts -experimental] {
-        switch -- $e {
-            test_mode {
-                set test_mode 1
-                set cp437_glyphs 1
-            }
-        }
-    }
-    set cp437_map [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
-    }
-
-    set opt_transparent         [dict get $opts -transparent]  
-    if {$opt_transparent eq "0"} {
-        set do_transparency 0
-    } else {
-        set do_transparency 1
-        if {$opt_transparent eq "1"} {
-            set opt_transparent {[\s]}
-        }
-    }
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_returnextra         [dict get $opts -info]
-    # -- --- --- --- --- --- --- --- --- --- --- ---
-    set opt_exposed1            [dict get $opts -exposed1]
-    set opt_exposed2            [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
-        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 ""} {
-        set undermap [punk::ansi::ta::split_codes_single $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 [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 [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 
-
-            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 {$maybemouse ne "<" && [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 -- [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
-    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 {
-        if {$cp437_glyphs} {
-            set pt [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 {[dict exists $overstacks $max_overlay_grapheme_index]} {
-    #    set replay_codes_overlay [join [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 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
-
-
-    #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 [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 string to 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 " "
-                                #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 [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 [dict get $overstacks $idx_over] [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 {
-                set code $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 re_ST_open {(?:\033P|\u0090|\033X|\u0098|\033\^|\u009e|\033_|\u009f)} 
-                set leadernorm [string range [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 [string cat $leadernorm [string range $code 3 end]]
-                    }
-                    7CSI - 7OSC {
-                        set codenorm [string cat $leadernorm [string range $code 2 end]]
-                    }
-                    7ESC {
-                        set codenorm [string cat $leadernorm [string range $code 1 end]]
-                    }
-                    8CSI - 8OSC {
-                        set codenorm [string cat $leadernorm [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 -- [string index $codenorm end] {
-                            M {
-                                puts stderr "mousedown $codenorm"
-                            }
-                            m {
-                                puts stderr "mouseup $codenorm"
-                            }
-                        }
-
-                    }
-                    {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] {
-                            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 {[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
-                                            #} 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 [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 ""
-                                foreach gc [lrange $overlay_grapheme_control_list $gci+1 end] {
-                                    lassign $gc type item
-                                    if {$type eq "gx0"} {
-                                        if {$item eq "gx0_on"} {
-                                            append unapplied "\x1b(0"
-                                        } elseif {$item eq "gx0_off"} {
-                                            append unapplied "\x1b(B"
-                                        }
-                                    } else {
-                                        append unapplied $item
-                                    }
-                                    #incr idx_over
-                                }
-                                #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 {[string index $codenorm 4] eq "?"} {
-                                    set num [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 -- [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 [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 [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 [string map [list "\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 [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 replay_codes ""
-    if {[llength $understacks] > 0} {
-        if {$overflow_idx == -1} {
-            #set tail_idx [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]
-        #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 [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\
-            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. 
-                }
-            }
-            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 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]] 
-            return $result
-        }
-    } else {
-        return $outstring
-    }
-    #return [join $out ""]
-}
-proc overtype::test_renderline {} {
-    set t \uFF5E ;#2-wide tilde
-    set u \uFF3F ;#2-wide underscore
-    set missing \uFFFD
-    return [list $t $u A${t}B]
-}
-
-#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 [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]} {
-            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 {[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 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 [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]
-
-    #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]
-        } 
-        set answer [punk::ansi::codetype::is_sgr $code]
-        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 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 ""
-        #append unapplied [join [lindex $overstacks $idx_over] ""]
-        #append unapplied [punk::ansi::codetype::sgr_merge_list {*}[lindex $overstacks $idx_over]]
-        append unapplied  [punk::ansi::codetype::sgr_merge_list {*}[lindex $og_stacks $gci]]
-        switch -- [lindex $overstacks_gx $idx_over] {
-            "gx0_on" {
-                append unapplied "\x1b(0"
-            }
-            "gx0_off" {
-                append unapplied "\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"} {
-                    append unapplied "\x1b(0"
-                } elseif {$item eq "gx0_off"} {
-                    append unapplied "\x1b(B"
-                }
-            } else {
-                append unapplied $item
-            }
-        }
-    }
-
-    #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 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 ""
-        append unapplied  [punk::ansi::codetype::sgr_merge_list {*}[lindex $og_stacks $gci]]
-        switch -- [lindex $overstacks_gx $idx_over] {
-            "gx0_on" {
-                append unapplied "\x1b(0"
-            }
-            "gx0_off" {
-                append unapplied "\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"} {
-                    append unapplied "\x1b(0"
-                } elseif {$item eq "gx0_off"} {
-                    append unapplied "\x1b(B"
-                }
-            } else {
-                append unapplied $item
-            }
-        }
-    }
-    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 {![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
-            }
-        }
-    }
-
-}
-
-
-
-# -- --- --- --- --- --- --- --- --- --- ---
-namespace eval overtype {
-	interp alias {} ::overtype::center {} ::overtype::centre
-}
-
-# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-##  Ready   
-package provide overtype [namespace eval overtype {
-    variable version
-    set version 1.6.0 
-}]
-return
-
-#*** !doctools
-#[manpage_end]
diff --git a/src/modules/flagfilter-0.3.tm b/src/modules/flagfilter-0.3.tm
index 6497be7f..c6064ea5 100644
--- a/src/modules/flagfilter-0.3.tm
+++ b/src/modules/flagfilter-0.3.tm
@@ -2078,10 +2078,11 @@ namespace eval flagfilter {
         #todo - add flaggednew to required if all was specified?
         #check invalid flags if not indicated in -extras  , either explicitly or with 'extra'
         set flags_from_required [get_flagged_only $required {}]
-        set known_flags [lsort -unique -nocase [concat [dict keys $defaults] $flags_from_required $soloflags]]
+        #set known_flags [lsort -unique -nocase [concat [dict keys $defaults] $flags_from_required $soloflags]] ;#why -nocase? why should -l and -L collapse to the uppercase version?
+        set known_flags [punk::lib::lunique_unordered [concat [dict keys $defaults] $flags_from_required $soloflags ]]
         foreach spec $command_specs {
             lassign $spec parentname pinfo
-            if {[string match -* $parentname]} {
+            if {[string match -* $parentname] && $parentname ni $known_flags} {
                 lappend known_flags $parentname
             }
             if {[dict exists $pinfo sub]} {
diff --git a/src/modules/funcl-0.1.tm b/src/modules/funcl-0.1.tm
index 2ee1ef56..ccdc9d99 100644
--- a/src/modules/funcl-0.1.tm
+++ b/src/modules/funcl-0.1.tm
@@ -38,7 +38,7 @@ namespace eval funcl {
         
         set end [lindex $args end]
         if {[llength $end] == 1 && [arg_is_script_shaped $end]} {
-            set endfunc [string map [list <end> $end] {uplevel 1 [list if 1 <end> ]}]
+            set endfunc [string map "<end> $end" {uplevel 1 [list if 1 <end> ]}]
         } else {
             set endfunc $end
         }
@@ -232,7 +232,7 @@ namespace eval funcl {
         }
         set comp [list] ;#composition list
         set end [lindex $args end]
-        if {[lindex $end 0] in [list "_fn" "_call"]} {
+        if {[lindex $end 0] in {_fn _call}]} {
             #is_funcl
             set endfunc [lindex $args end]
         } else {
diff --git a/src/modules/natsort-0.1.1.6.tm b/src/modules/natsort-0.1.1.6.tm
index d15015e9..92bb7e74 100644
--- a/src/modules/natsort-0.1.1.6.tm
+++ b/src/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} {
diff --git a/src/modules/patternpunk-1.1.tm b/src/modules/patternpunk-1.1.tm
index c90d7ede..8c72e673 100644
--- a/src/modules/patternpunk-1.1.tm
+++ b/src/modules/patternpunk-1.1.tm
@@ -92,7 +92,7 @@ set ::punk::bannerTemplate [string trim {
    / \   
  _+   +_ 
 } \n]
->punk .. Property front_2003 [string trim [string map [list % \u2003] {
+>punk .. Property front_2003 [string trim [string map "% \u2003" {
    _|_   
   @%v%@  
    %~%   
@@ -119,7 +119,7 @@ set ::punk::bannerTemplate [string trim {
     / \  
   _+   +_
 } \n]
->punk .. Property rhs_2003 [string trim [string map [list % \u2003] {
+>punk .. Property rhs_2003 [string trim [string map "% \u2003" {
    \\\_  
    \@%%> 
     |%~  
@@ -143,7 +143,7 @@ set ::punk::bannerTemplate [string trim {
   / \    
 _+   +_  
 } \n]
->punk .. Property lhs_2003 [string trim [string map [list % \u2003] {
+>punk .. Property lhs_2003 [string trim [string map "% \u2003" {
   _///   
  <%%@/   
   ~%|    
diff --git a/src/modules/poshinfo-999999.0a1.0.tm b/src/modules/poshinfo-999999.0a1.0.tm
new file mode 100644
index 00000000..79e6b2c1
--- /dev/null
+++ b/src/modules/poshinfo-999999.0a1.0.tm
@@ -0,0 +1,276 @@
+# -*- tcl -*-
+# Maintenance Instruction: leave the 999999.xxx.x as is and use punkshell 'pmix make' or bin/punkmake  to update from <pkg>-buildversion.txt
+# module template: shellspy/src/decktemplates/vendor/punk/modules/template_module-0.0.3.tm
+#
+# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
+# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# (C) 2024
+#
+# @@ Meta Begin
+# Application poshinfo 999999.0a1.0
+# Meta platform     tcl
+# Meta license      <unspecified>
+# @@ Meta End
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# doctools header
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[manpage_begin shellspy_module_poshinfo 0 999999.0a1.0]
+#[copyright "2024"]
+#[titledesc {Module API}]  [comment {-- Name section and table of contents description --}]
+#[moddesc {-}]             [comment {-- Description at end of page heading --}] 
+#[require poshinfo]
+#[keywords module]
+#[description]
+#[para] -
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section Overview]
+#[para] overview of poshinfo
+#[subsection Concepts]
+#[para] -
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Requirements
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[subsection dependencies]
+#[para] packages used by poshinfo
+#[list_begin itemized]
+
+package require Tcl 8.6-
+package require punk::config
+package require json ;#tcllib
+#toml, yaml?
+
+#*** !doctools
+#[item] [package {Tcl 8.6}]
+#[item] [package {punk::config}]
+#[item] [package {json}]
+
+# #package require frobz
+# #*** !doctools
+# #[item] [package {frobz}]
+
+#*** !doctools
+#[list_end]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+#*** !doctools
+#[section API]
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# oo::class namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#tcl::namespace::eval poshinfo::class {
+    #*** !doctools
+    #[subsection {Namespace poshinfo::class}]
+    #[para] class definitions
+    #if {[tcl::info::commands [tcl::namespace::current]::interface_sample1] eq ""} {
+        #*** !doctools
+        #[list_begin enumerated]
+
+        # oo::class create interface_sample1 {
+        #     #*** !doctools
+        #     #[enum] CLASS [class interface_sample1]
+        #     #[list_begin definitions]
+
+        #     method test {arg1} {
+        #         #*** !doctools
+        #         #[call class::interface_sample1    [method test] [arg arg1]]
+        #         #[para] test method
+        #         puts "test: $arg1"
+        #     }
+
+        #     #*** !doctools
+        #     #[list_end] [comment {-- end definitions interface_sample1}]
+        # }
+
+        #*** !doctools
+        #[list_end] [comment {--- end class enumeration ---}]
+    #}
+#}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# Base namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+tcl::namespace::eval poshinfo {
+    tcl::namespace::export {[a-z]*}  ;# Convention: export all lowercase
+    #variable xyz
+
+    #*** !doctools
+    #[subsection {Namespace poshinfo}]
+    #[para] Core API functions for poshinfo 
+    #[list_begin definitions]
+
+
+
+    #proc sample1 {p1 n args} {
+    #    #*** !doctools
+    #    #[call [fun sample1] [arg p1] [arg n] [opt {option value...}]]
+    #    #[para]Description of sample1 
+    #    #[para] Arguments:
+    #    #   [list_begin arguments]
+    #    #   [arg_def tring p1]       A description of string argument p1.
+    #    #   [arg_def integer n]      A description of integer argument n.
+    #    #   [list_end]
+    #    return "ok" 
+    #}
+
+    proc info_from_filename {fname} {
+        #string based filename processing: we are deliberately avoiding test of file existence etc here
+        if {$fname eq ""} {
+            error "poshinfo::info_from_filename unable to determine name from empty string" 
+        }
+        if {[string first . $fname] < 0} {
+            #theoretically we could have a file without dots - but it's more likely an error in this context
+            error "poshinfo::info_from_filename supplied value '$fname' doesn't look like a filename. Cowardly refusing to guess a shortname." 
+        }
+        set ftail [file tail $fname]
+        set rootname [file rootname $ftail]
+        set format [string trimleft [file extension $ftail] .]
+        set parts [split $rootname .]
+        if {[lindex $parts end] eq "omp"} {
+            set type omp
+            set shortname [join [lrange $parts 0 end-1] .]
+        } else {
+            if {$rootname eq "schema"} {
+                set type schema 
+            } else {
+                set type unknown
+            }
+            set shortname $rootname
+        }
+        return [dict create shortname $shortname format $format type $type]
+    }
+
+    proc themes_dict {{globfor *}} {
+        set running_config [punk::config::get running-config]
+        set posh_themes_path [tcl::dict::get $running_config posh_themes_path]
+        #posh_themes_path_extra ??
+
+        set themes [tcl::dict::create]
+
+        if {[string length $posh_themes_path]} {
+            if {[file exists $posh_themes_path]} {
+                set files [glob -nocomplain -directory $posh_themes_path -tails $globfor]
+                foreach ftail $files {
+                    set themeinfo [info_from_filename $ftail]
+                    set shortname [dict get $themeinfo shortname]
+                    dict set themeinfo path [file join $posh_themes_path $ftail]
+                    if {![dict exists $themes $shortname]} {
+                        dict set themes $shortname [list $themeinfo]
+                    } else {
+                        dict lappend themes $shortname $themeinfo
+                    }
+                } 
+            }
+        }
+        return $themes
+    }
+    proc themes {{globfor *}} {
+        set themes [themes_dict $globfor]
+        set posh_theme [file normalize [punk::config::get_running_global posh_theme]]
+        set t [textblock::class::table new "Posh Themes"]
+        $t configure -show_header 1 -show_hseps 0
+        $t add_column -headers Shortname
+        $t add_column -headers Path
+        dict for {shortname themeinfolist} $themes {
+            #hack - support just one for now
+            set themeinfo [lindex $themeinfolist 0]
+
+            set path [dict get $themeinfo path]
+            $t add_row [list $shortname $path]
+            set fg ""
+            set bg ""
+            switch -- [dict get $themeinfo type] {
+                schema {
+                    set bg Web-orange
+                }
+                omp {}
+                unknown {
+                    set bg Web-red
+                } 
+                default {
+                    #we shouldn't be getting other values
+                    set bg Web-yellow
+                }
+            }
+            if {$posh_theme eq [file normalize $path]} {
+                set fg web-limegreen
+            } 
+            if {"$fg$bg" ne ""} {
+                $t configure_row [expr {[$t row_count]-1}] -ansibase [a+ {*}$fg {*}$bg]
+            }
+        }
+        set result [$t print] 
+        $t destroy
+        return $result
+    }
+
+
+    #*** !doctools
+    #[list_end] [comment {--- end definitions namespace poshinfo ---}]
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# Secondary API namespace
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+tcl::namespace::eval poshinfo::lib {
+    tcl::namespace::export {[a-z]*}  ;# Convention: export all lowercase
+    tcl::namespace::path [tcl::namespace::parent]
+    #*** !doctools
+    #[subsection {Namespace poshinfo::lib}]
+    #[para] Secondary functions that are part of the API 
+    #[list_begin definitions]
+
+    #proc utility1 {p1 args} {
+    #    #*** !doctools
+    #    #[call lib::[fun utility1] [arg p1] [opt {?option value...?}]]
+    #    #[para]Description of utility1 
+    #    return 1 
+    #}
+
+
+
+    #*** !doctools
+    #[list_end] [comment {--- end definitions namespace poshinfo::lib ---}]
+}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+#*** !doctools
+#[section Internal]
+#tcl::namespace::eval poshinfo::system {
+    #*** !doctools
+    #[subsection {Namespace poshinfo::system}]
+    #[para] Internal functions that are not part of the API 
+
+
+
+#}
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Ready   
+package provide poshinfo [tcl::namespace::eval poshinfo {
+    variable pkg poshinfo
+    variable version
+    set version 999999.0a1.0 
+}]
+return
+
+#*** !doctools
+#[manpage_end]
+
diff --git a/src/modules/poshinfo-buildversion.txt b/src/modules/poshinfo-buildversion.txt
new file mode 100644
index 00000000..f47d01c8
--- /dev/null
+++ b/src/modules/poshinfo-buildversion.txt
@@ -0,0 +1,3 @@
+0.1.0
+#First line must be a semantic version number
+#all other lines are ignored.
diff --git a/src/modules/punk-0.1.tm b/src/modules/punk-0.1.tm
index b2d70db9..fbadc295 100644
--- a/src/modules/punk-0.1.tm
+++ b/src/modules/punk-0.1.tm
@@ -1154,14 +1154,14 @@ namespace eval punk {
         set script "proc $cmdname {leveldata} {"
         append script \n [string map [list <selector> $selector] {set selector "<selector>"}] ;# script should only need for error msgs
         set subindices [split $selector /]
-        append script \n [string map [list <subindices> [list $subindices] ] {set subindices <subindices>}]
+        append script \n [string map [list <subindices> [list $subindices]] {set subindices <subindices>}]
         set action ?match ;#default assumption. Alternatively set to ?mismatch or ?mismatch-<somereason> and always break
         append script \n {set action ?match}
         #append script \n {set assigned ""} ;#review
         set active_key_type ""
         append script \n {# set activey_key_type ""}
         set lhs  $selector
-        append script \n [string map [list <selector> $selector ] {set lhs "<selector>"}]
+        append script \n [string map [list <selector> $selector] {set lhs "<selector>"}]
         set rhs ""
         append script \n {set rhs ""}
 
@@ -1816,7 +1816,7 @@ namespace eval punk {
                                         if {$end < 0} {
                                             error $listmsg "destructure $selector" [list pipesyntax destructure selector $selector end_lessthanzero_out_of_bounds_for_all_data_while_bounds_check_on]
                                         }
-                                        append script \n [string map [list <e> $end] {
+                                        append script \n [string map "<e> $end" {
                                             set end <e>
                                             if {$end+1 > $len} {
                                                 set action ?mismatch-list-index-out-of-range
@@ -1831,7 +1831,7 @@ namespace eval punk {
                                         if {$endoffset > 0} {
                                             error $listmsg "destructure $selector" [list pipesyntax destructure selector $selector end+x_out_of_bounds_for_all_data_while_bounds_check_on]
                                         }
-                                        append script \n [string map [list <e_offset> $endoffset] {
+                                        append script \n [string map "<e_offset> $endoffset" {
                                             set endoffset <e_offset>
                                             if {abs($endoffset) >= $len} {
                                                 set action ?mismatch-list-index-out-of-range
@@ -3426,11 +3426,11 @@ namespace eval punk {
 
     #exclude quoted whitespace
     proc arg_is_script_shaped {arg} {
-        if {[string first \n $arg] >= 0} {
+        if {[tcl::string::first \n $arg] >= 0} {
             return 1
-        } elseif {[string first ";" $arg] >= 0} {
+        } elseif {[tcl::string::first ";" $arg] >= 0} {
             return 1
-        } elseif {[string first " " $arg] >= 0 || [string first \t $arg] >= 0} {
+        } elseif {[tcl::string::first " " $arg] >= 0 || [tcl::string::first \t $arg] >= 0} {
             lassign [_rhs_tail_split $arg] _  part2 ;#will have part2 if unquoted whitespace found
             return [expr {$part2 ne ""}]
         } else {
@@ -3478,7 +3478,7 @@ namespace eval punk {
             }
             incr i
         }
-        set tail [string range $fullrhs $i end]
+        set tail [tcl::string::range $fullrhs $i end]
         return [list $equalsrhs $tail]
     }
 
@@ -4577,7 +4577,7 @@ namespace eval punk {
         #----------------
 
         #can't use know - because we don't want to return before original unknown body is called.
-        proc ::unknown {args} [string map [list] {
+        proc ::unknown {args} [string cat {
             package require base64
             #set ::punk::last_run_display [list]
             #set ::repl::last_unknown [lindex $args 0] ;#jn
@@ -5135,31 +5135,6 @@ namespace eval punk {
         return $fullpath
     }
 
-    #todo - something better - 'previous' rather than reverting to startup
-    proc channelcolors {{onoff {}}} {
-        upvar ::punk::config::running running_config
-        upvar ::punk::config::startup startup_config
-        
-        if {![string length $onoff]} {
-            return [list stdout [dict get $running_config color_stdout] stderr [dict get $running_config color_stderr]]
-        } else {
-            set lower_onoff [string tolower $onoff]
-            switch -- $lower_onoff {
-                true - on - 1 {
-                    dict set running_config color_stdout [dict get $startup_config color_stdout]
-                    dict set running_config color_stderr [dict get $startup_config color_stderr]
-                }
-                false - off - 0 {
-                    dict set running_config color_stdout ""
-                    dict set running_config color_stderr ""
-                }
-                default {
-                    error "channelcolors: invalid value $onoff - expected true|false|on|off|1|0"
-                }
-            }
-        }
-        return [list stdout [dict get $running_config color_stdout] stderr [dict get $running_config color_stderr]]
-    }
 
     #useful for aliases e.g treemore -> xmore tree
     proc xmore {args} {
@@ -5525,6 +5500,9 @@ namespace eval punk {
 
 
     #maint - punk::args has similar
+    #this is largely obsolete - uses dict for argspecs (defaults) instead of textblock as in punk::args
+    #textblock has more flexibility in some ways - but not as easy to manipulate especially with regards to substitutions
+    #todo - consider a simple wrapper for punk::args to allow calling with dict of just name and default? 
     #JMN
     #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.
@@ -5636,10 +5614,11 @@ namespace eval punk {
     #dirfiles assumes we don't have glob chars in the filenames or paths - dirfiles_dict can be called directly with explicit -tailglob in the rare case that assumption doesn't hold
     # dirfiles will test last segment (tail) of supplied searchspecs for fileness vs folderness (when no globchars present in tail) so that it can pass the appropriate flags downstream
     proc dirfiles {args} {
-        set defaults [list\
-            -stripbase 1\
-        ]
-        lassign [dict values [get_leading_opts_and_values $defaults $args]] opts searchspecs ;#implicit merge of opts over defaults
+        set argspecs {
+            -stripbase -default 1 -type boolean
+        }
+        set argd [punk::args::get_dict $argspecs $args]
+        lassign [dict values $argd] opts searchspecs
 
         set opt_stripbase    [dict get $opts -stripbase]
 
@@ -5716,13 +5695,18 @@ namespace eval punk {
     #if caller supplies a tailglob as empty string - presume the caller hasn't set location to parentdir - and that last element is the search pattern.
     # -searchbase is always passed through - and is only used to construct a location path if a relative searchspec was supplied
     proc dirfiles_dict {args} {
-        set defaults [dict create\
-            -searchbase ""\
-            -tailglob "\uFFFF"\
-            -with_sizes "\uFFFF"\
-            -with_times "\uFFFF"\
-        ]
-        lassign [dict values [get_leading_opts_and_values $defaults $args]] opts searchspecs
+        set argspecs {
+            *opts -any 0
+            -searchbase     -default ""
+            -tailglob       -default "\uFFFF"
+            #with_sizes & with_times must accept 0|1|f|d|l where f = files d = dirs l = links (punk::du)
+            -with_sizes     -default "\uFFFF" -type string 
+            -with_times     -default "\uFFFF" -type string
+            *values -min 0 -max -1 -type string
+        }
+        set argd [punk::args::get_dict $argspecs $args]
+        lassign [dict values $argd] opts vals
+        set searchspecs [dict values $vals]
 
         #puts stderr "searchspecs: $searchspecs [llength $searchspecs]"
         #puts stdout "arglist: $opts"
@@ -5798,13 +5782,13 @@ namespace eval punk {
             #leave up to listing-provider defaults
             set next_opt_with_sizes ""
         } else {
-            set next_opt_with_sizes "-with_sizes $opt_with_sizes"
+            set next_opt_with_sizes [list -with_sizes $opt_with_sizes]
         }
         if {$opt_with_times eq "\uFFFF"} {
             #leave up to listing-provider defaults
             set next_opt_with_times ""
         } else {
-            set next_opt_with_times "-with_times $opt_with_times"
+            set next_opt_with_times [list -with_times $opt_with_times]
         }
         if {$in_vfs} {
             set listing [punk::du::lib::du_dirlisting_tclvfs $location -glob $glob {*}$next_opt_with_sizes {*}$next_opt_with_times]
@@ -5855,10 +5839,13 @@ namespace eval punk {
         #we add dotfiles to flaggedhidden list in case there is some other mechanism that has flagged items as hidden
         if {$::tcl_platform(platform) ne "windows"} {
             lappend flaggedhidden {*}[lsearch -all -inline [concat $dirs $files] ".*"]
-            set flaggedhidden [lsort -unique $flaggedhidden]
+            #e.g we can have dupes in the case where there are vfs mounted files that appear as dirs
+            #as we will need to do a (nat)sort as a last step - it will be faster to not sort items prematurely
+            #set flaggedhidden [lsort -unique $flaggedhidden]
+            set flaggedhidden [punk::lib::lunique_unordered $flaggedhidden]
         }
 
-        set dirs [lsort $dirs] ;#todo - natsort
+        set dirs [lsort $dirs] ;#todo - natsort 
         
 
 
@@ -5908,10 +5895,15 @@ namespace eval punk {
     proc dirfiles_dict_as_lines {args} {
         package require overtype
 
-        set defaults [list\
-            -stripbase 0\
-        ]
-        lassign [dict values [get_leading_opts_and_values $defaults $args]] opts list_of_dicts ;#implicit merge of opts over defaults
+        set argspecs {
+            -stripbase -default 0 -type boolean
+            *values -min 1 -max -1 -type dict
+        }
+        set argd [punk::args::get_dict $argspecs $args]
+        lassign [dict values $argd] opts vals
+        set list_of_dicts [dict values $vals]
+
+
 
         # -- --- --- --- --- --- --- --- --- --- --- ---
         set opt_stripbase [dict get $opts -stripbase]
@@ -6176,7 +6168,7 @@ namespace eval punk {
 
     proc delimit_number {unformattednumber {delim ","} {GroupSize 3}} {
         set number [punk::objclone $unformattednumber]
-        set number [string map [list _ ""] $number]
+        set number [string map {_ ""} $number]
         #normalize using expr - e.g 2e4 -> 20000.0
         set number [expr {$number}]
         # First, extract right hand part of number, up to and including decimal point
@@ -6565,15 +6557,6 @@ namespace eval punk {
         return $result
     }
 
-    #proc list_as_lines {args} {
-    #    set defaults [dict create\
-    #        -joinchar "\n"\
-    #    ]
-    #    lassign [dict values [get_leading_opts_and_values $defaults $args -minvalues 1 -maxvalues 1]] opts values
-    #    set opt_joinchar [dict get $opts -joinchar]
-    #    set list [lindex $values 0]
-    #    join $list $opt_joinchar
-    #}
 
     #--------------------------------------------------
     #some haskell-like operations
@@ -6895,13 +6878,16 @@ namespace eval punk {
 
     #An implementation of a notoriously controversial metric.
     proc LOC {args} {
-        set defaults [dict create\
-            -dir "\uFFFF"\
-            -exclude_dupfiles 1\
-            -exclude_punctlines 1\
-            -punctchars [list \{ \} \" \\ - _  + = . > , < ' : \; ` ~ ! @ # \$ % ^ & * \[ \] ( ) | / ?]\
-        ] 
-        lassign [dict values [get_leading_opts_and_values $defaults $args]] opts searchspecs ;#implicit merge of opts over defaults
+        set argspecs [subst {
+            -dir                -default "\uFFFF"
+            -exclude_dupfiles   -default 1 -type boolean
+            -exclude_punctlines -default 1 -type boolean
+            -punctchars         -default { [list \{ \} \" \\ - _  + = . > , < ' : \; ` ~ ! @ # \$ % ^ & * \[ \] ( ) | / ?] }
+        }]
+        set argd [punk::args::get_dict $argspecs $args]
+        lassign [dict values $argd] opts vals
+        set searchspecs [dict values $vals]
+
         # -- --- --- --- --- --- 
         set opt_dir [dict get $opts -dir]
         if {$opt_dir eq "\uFFFF"} {
@@ -7299,16 +7285,26 @@ namespace eval punk {
             if {[punk::lib::system::has_script_var_bug]} {
                 append warningblock \n "minor warning: punk::lib::system::has_script_var_bug returned true! (string rep for list variable in script generated when script changed)"
             }
+            if {[punk::lib::system::has_safeinterp_compile_bug]} {
+                set indent "    "
+                append warningblock \n "[a+ web-red]warning: punk::lib::system::has_safeinterp_compile_bug returned true!" \n
+                append warningblock "${indent}(ensemble commands not compiled in safe interps - heavy performance impact in safe interps)" \n
+                append warningblock "${indent}see https://core.tcl-lang.org/tcl/tktview/1095bf7f75"
+                append warningblock [a]
+            }
         }
 
         set text ""
         if {$topic in [list env environment]} {
-            set known $::punk::config::known_punk_env_vars
+            #todo - move to punk::config?
+
+            set known_punk $::punk::config::known_punk_env_vars
+            set known_other $::punk::config::known_other_env_vars
             append text \n
             set usetable 1
             if {$usetable} {
                 set t [textblock::class::table new -show_hseps 0 -show_header 1 -ansiborder_header [a+ web-green]]
-                foreach v $known {
+                foreach v $known_punk {
                     if {[info exists ::env($v)]} {
                         set c2 [set ::env($v)] 
                     } else {
@@ -7319,8 +7315,24 @@ namespace eval punk {
                 $t configure_column 0 -headers [list "Punk environment vars"]
                 $t configure_column 0 -minwidth [expr {[$t column_datawidth 0]+4}] -blockalign left -textalign left -header_colspans {all}
 
-                append text [$t print]\n
+                set punktable [$t print]
+                $t destroy
+
+                set t [textblock::class::table new -show_hseps 0 -show_header 1 -ansiborder_header [a+ web-green]]
+                foreach v $known_other {
+                    if {[info exists ::env($v)]} {
+                        set c2 [set ::env($v)] 
+                    } else {
+                        set c2 "(NOT SET)"
+                    }
+                    $t add_row [list $v $c2]
+                }
+                $t configure_column 0 -headers [list "Other environment vars"]
+                $t configure_column 0 -minwidth [expr {[$t column_datawidth 0]+4}] -blockalign left -textalign left -header_colspans {all}
+
+                set othertable [$t print]
                 $t destroy
+                append text [textblock::join $punktable " " $othertable]\n
             } else {
 
                 append text $linesep\n
@@ -7328,7 +7340,7 @@ namespace eval punk {
                 append text $linesep\n
                 set col1 [string repeat " " 25] 
                 set col2 [string repeat " " 50]
-                foreach v $known {
+                foreach v $known_punk {
                     set c1 [overtype::left $col1 $v]
                     if {[info exists ::env($v)]} {
                         set c2 [overtype::left $col2 [set ::env($v)] 
@@ -7434,7 +7446,7 @@ namespace eval punk {
     #NOTE: an alias may match in a namespace - but not have a corresponding command that matches that name (alias renamed)
     proc aliases {{glob *}} {
         set ns [uplevel 1 {::namespace current}] ;#must use :: - we can find ourselves in a namespace with a different 'namespace' command
-        set ns_mapped [string map [list :: \uFFFF] $ns] 
+        set ns_mapped [string map {:: \uFFFF} $ns] 
         #puts stderr "aliases ns: $ns_mapped"
         set segments [split $ns_mapped \uFFFF] ;#include empty string before leading ::
         if {![string length [lindex $segments end]]} {
@@ -7454,7 +7466,7 @@ namespace eval punk {
                 set abs $a
             }
 
-            set asegs [split [string map [list :: \uFFFF] $abs] \uFFFF]
+            set asegs [split [string map {:: \uFFFF} $abs] \uFFFF]
             set acount [llength $asegs]
             #puts "alias $abs  acount:$acount asegs:$asegs segcount:$segcount segments: $segments"
             if {[expr {$acount - 1}] == $segcount} {
@@ -7570,7 +7582,8 @@ namespace eval punk {
     #file normalize {//host/share} -> //host/share
     #To get back to some consistent cross platform behaviour - we will treat //something as a root/volume i.e we can't backtrack above it with ..
     proc filepath_dotted_minimal {path} {
-        set path [string map [list \\ /] $path]
+        #set path [string map [list \\ /] $path]
+        set path [string map "\\\\ /" $path]
         set doubleslash1_posn [string first // $path] 
         if {[punk::winpath::is_dos_device_path $path]} {
             
@@ -7583,7 +7596,7 @@ namespace eval punk {
                 #e.g on freebsd:  ->  / sharehost share path etc
                 #however..also on windows: file split //sharehost  -> / sharehost
                 #normalize by dropping leading slash before split - and then treating first 2 segments as a root
-                set normtail [string map [list //]]
+                set normtail [string map {// ""} $path]
                 set parts [file split [string range $path 1 end]]
                 
 
diff --git a/src/modules/punk/ansi-999999.0a1.0.tm b/src/modules/punk/ansi-999999.0a1.0.tm
index 096c34d0..29a4fad7 100644
--- a/src/modules/punk/ansi-999999.0a1.0.tm
+++ b/src/modules/punk/ansi-999999.0a1.0.tm
@@ -2406,7 +2406,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 {
@@ -2759,7 +2761,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 {
diff --git a/src/modules/punk/args-999999.0a1.0.tm b/src/modules/punk/args-999999.0a1.0.tm
index fffd3cf2..589ab69f 100644
--- a/src/modules/punk/args-999999.0a1.0.tm
+++ b/src/modules/punk/args-999999.0a1.0.tm
@@ -191,9 +191,10 @@
 #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 chan clock dict encoding info namespace string
+#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]
@@ -304,6 +305,7 @@ tcl::namespace::eval punk::args {
         set opt_required [list]
         set val_required [list]
         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 [tcl::dict::create]
@@ -411,7 +413,29 @@ tcl::namespace::eval punk::args {
                                 -nominlen - -nomaxlen - -norange - -nochoices - -nochoicelabels {
                                     tcl::dict::unset optspec_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
+                                        }
+                                        any - ansistring {
+
+                                        }
+                                        default {
+                                            #todo - disallow unknown types unless prefixed with custom-
+                                        }
+                                    }
+                                    tcl::dict::set optspec_defaults $k $v
+                                }
                                 -optional -
                                 -allow_ansi -
                                 -validate_without_ansi -
@@ -444,7 +468,26 @@ tcl::namespace::eval punk::args {
                                 -nominlen - -nomaxlen - -norange - -nochoices - -nochoicelabels {
                                     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
+                                }
                                 -allow_ansi -
                                 -validate_without_ansi -
                                 -strip_ansi -
@@ -480,7 +523,11 @@ tcl::namespace::eval punk::args {
             }
             #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 {
@@ -488,31 +535,38 @@ tcl::namespace::eval punk::args {
                         #normalize here so we don't have to test during actual args parsing in main function
                         switch -- [tcl::string::tolower $specval] {
                             int - integer {
-                                tcl::dict::set merged -type int
+                                tcl::dict::set spec_merged -type int
                             }
                             bool - boolean {
-                                tcl::dict::set merged -type bool 
+                                tcl::dict::set spec_merged -type bool 
                             }
                             char - character {
-                                tcl::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} {
-                                    tcl::dict::set merged -type none
-                                    tcl::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 dict
+                            }
                             default {
-                                tcl::dict::set merged -type [tcl::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 {
-                        tcl::dict::set merged $spec $specval
+                        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]
@@ -520,12 +574,12 @@ tcl::namespace::eval punk::args {
                     }
                 }
             }
-            set argspecs $merged
-            #if {$is_opt} {
+            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 
-            #}
+            } 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
             if {![tcl::dict::get $argspecs -optional]} {
@@ -555,6 +609,10 @@ tcl::namespace::eval punk::args {
             set spec_id "autoid_[incr id_counter]"
         }
 
+
+        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\
@@ -565,13 +623,14 @@ tcl::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\
         ]
         tcl::dict::set argspec_cache $cache_key $result
@@ -760,6 +819,7 @@ tcl::namespace::eval punk::args {
                             set newval [lindex $rawargs $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
@@ -822,6 +882,7 @@ tcl::namespace::eval punk::args {
                 } else {
                     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
                 }
             }
@@ -856,13 +917,23 @@ tcl::namespace::eval punk::args {
         #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 save interp 9.4us
-        if {[llength [set missing [struct::set difference $opt_required $flagsreceived]]]} {
+        #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]]]} {
             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]]]} {
+        if {[llength [set missing [punk::lib::ldiff $val_required $valnames_received]]]} {
                error "Required value missing for [Get_caller]. missing values $missing marked with -optional false - so must be present" 
         }
+
+
+
         #todo - allow defaults outside of choices/ranges
 
         #check types,ranges,choices
@@ -1004,6 +1075,13 @@ tcl::namespace::eval punk::args {
                             }
                         }
                     }
+                    dict {
+                        foreach e_check $vlist_check {
+                            if {[llength $e_check] %2 != 0} {
+                                error "Option $argname for [Get_caller] requires type 'dict' - must be key value pairs. Received: '$e_check'"
+                            }
+                        }
+                    }
                     alnum -
                     alpha -
                     ascii -
diff --git a/src/modules/punk/cap-999999.0a1.0.tm b/src/modules/punk/cap-999999.0a1.0.tm
index 7a3cf2ac..c6c7a3b7 100644
--- a/src/modules/punk/cap-999999.0a1.0.tm
+++ b/src/modules/punk/cap-999999.0a1.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/modules/punk/cap/handlers/templates-999999.0a1.0.tm b/src/modules/punk/cap/handlers/templates-999999.0a1.0.tm
index 25ab3ed2..9ce510f0 100644
--- a/src/modules/punk/cap/handlers/templates-999999.0a1.0.tm
+++ b/src/modules/punk/cap/handlers/templates-999999.0a1.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]
 
@@ -226,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?
@@ -249,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} {
diff --git a/src/modules/punk/config-0.1.tm b/src/modules/punk/config-0.1.tm
index bb7b237e..44db9a73 100644
--- a/src/modules/punk/config-0.1.tm
+++ b/src/modules/punk/config-0.1.tm
@@ -4,106 +4,314 @@ tcl::namespace::eval punk::config {
     variable startup ;#include env overrides 
     variable running
     variable known_punk_env_vars
+    variable known_other_env_vars
+
+    variable vars
 
     #todo - XDG_DATA_HOME etc
     #https://specifications.freedesktop.org/basedir-spec/latest/
     # see also: http://hiphish.github.io/blog/2020/08/30/dotfiles-were-a-mistake/
 
-    variable vars
-    set vars [list \
-        apps \
-        config \
-        configset \
-        scriptlib \
-        color_stdout \
-        color_stderr \
-        logfile_stdout \
-        logfile_stderr \
-        syslog_stdout \
-        syslog_stderr \
-        syslog_active \
-        exec_unknown \
-    ]
-    #todo pkg punk::config
-
-    #defaults
-
-    tcl::dict::set startup configset .punkshell
-    tcl::dict::set startup exec_unknown true ;#whether to use exec instead of experimental shellfilter::run
-    #tcl::dict::set startup color_stdout [list cyan bold] ;#not a good idea to default
-    tcl::dict::set startup color_stdout [list]
-
-    #This wraps the stderr stream as it comes in with Ansi - probably best to default to empty.. but it's useful.
-    tcl::dict::set startup color_stderr [list red bold]
-
-    tcl::dict::set startup syslog_stdout "127.0.0.1:514"
-    tcl::dict::set startup syslog_stderr "127.0.0.1:514"
-    tcl::dict::set startup syslog_active 0
-    #default file logs to logs folder at same location as exe if writable, or empty string
-    tcl::dict::set startup logfile_stdout ""
-    tcl::dict::set startup logfile_stderr ""
-    set exename ""
-    catch {
-        #catch for safe interps
-        #safe base will return empty string, ordinary safe interp will raise error
-        set exename [tcl::info::nameofexecutable]
-    }
-    if {$exename ne ""} {
-        set exefolder [file dirname $exename]
-        set log_folder $exefolder/logs
-        tcl::dict::set startup scriptlib $exefolder/scriptlib
-        tcl::dict::set startup apps $exefolder/../../punkapps
-        if {[file exists $log_folder]} {
+    proc init {} {
+        variable defaults 
+        variable startup
+        variable running
+        variable known_punk_env_vars
+        variable known_other_env_vars
+
+        set exename ""
+        catch {
+            #catch for safe interps
+            #safe base will return empty string, ordinary safe interp will raise error
+            set exename [tcl::info::nameofexecutable]
+        }
+        if {$exename ne ""} {
+            set exefolder [file dirname $exename]
+            #default file logs to logs folder at same level as exe if writable, or empty string
+            set log_folder [file normalize $exefolder/../logs]
+            #tcl::dict::set startup scriptlib $exefolder/scriptlib
+            #tcl::dict::set startup apps $exefolder/../../punkapps
+
+            #todo - use punk main.tcl location instead - exefolder doesn't work if system tclsh used etc
+            set default_scriptlib $exefolder/scriptlib
+            set default_apps $exefolder/../../punkapps
             if {[file isdirectory $log_folder] && [file writable $log_folder]} {
-                tcl::dict::set startup logfile_stdout $log_folder/repl-exec-stdout.txt
-                tcl::dict::set startup logfile_stderr $log_folder/repl-exec-stderr.txt
+                #tcl::dict::set startup logfile_stdout $log_folder/repl-exec-stdout.txt
+                #tcl::dict::set startup logfile_stderr $log_folder/repl-exec-stderr.txt
+                set default_logfile_stdout $log_folder/repl-exec-stdout.txt
+                set default_logfile_stderr $log_folder/repl-exec-stderr.txt
+            } else {
+                set default_logfile_stdout ""
+                set default_logfile_stderr ""
             }
+        } else {
+            #probably a safe interp - which cannot access info nameofexecutable even if access given to the location via punk::island 
+            #review - todo?
+            #tcl::dict::set startup scriptlib ""
+            #tcl::dict::set startup apps ""
+            set default_scriptlib ""
+            set default_apps ""
+            set default_logfile_stdout ""
+            set default_logfile_stderr ""
         }
-    } else {
-        #probably a safe interp - which cannot access info nameofexecutable even if access given to the location via punk::island 
-        #review - todo?
-        tcl::dict::set startup scriptlib ""
-        tcl::dict::set startup apps ""
-    }
 
+        # exec_unknown ;#whether to use exec instead of experimental shellfilter::run
+        #startup color_stdout - parameters as suitable for punk::ansi::a+ (test with 'punk::ansi::a?') e.g "cyan bold" ;#not a good idea to default
+        set default_color_stdout ""
+        #This wraps the stderr stream as it comes in with Ansi - probably best to default to empty.. but it's useful.
+        set  default_color_stderr "red bold"
 
-    #todo - load/write config file
-
-    #env vars override the configuration
-
-    #todo - define which configvars are settable in env
-    set known_punk_env_vars [list \
-        PUNK_APPS \
-        PUNK_CONFIG \
-        PUNK_CONFIGSET \
-        PUNK_SCRIPTLIB \
-        PUNK_EXECUNKNOWN \
-        PUNK_COLOR_STDERR \
-        PUNK_COLOR_STDOUT \
-        PUNK_LOGFILE_STDOUT \
-        PUNK_LOGFILE_STDERR \
-        PUNK_SYSLOG_STDOUT \
-        PUNK_SYSLOG_STDERR \
-        PUNK_SYSLOG_ACTIVE \
+        set homedir ""
+        if {[catch {
+            #depending on which build of tcl - some safe interps prior to bugfix https://core.tcl-lang.org/tcl/info/3aa487993f will return a homedir value in an unmodified safe interp
+            #other 'safe' interps may have explicitly made this available - we shouldn't override that decision here using interp issafe so we can't compensate for versions which shouldn't really be returning this in the safe interp
+            set homedir [file home]
+        } errM]} {
+            #tcl 8.6 doesn't have file home.. try again
+            if {[info exists ::env(HOME)]} {
+                set homedir $::env(HOME)
+            }
+        }
+        
+
+        # per user xdg vars
+        # ---
+        set default_xdg_config_home "" ;#config data - portable
+        set default_xdg_data_home "" ;#data the user likely to want to be portable
+        set default_xdg_cache_home "" ;#local cache
+        set default_xdg_state_home "" ;#persistent user data such as logs, but not as important or as portable as those in xdg_data_home
+        # ---
+        set default_xdg_data_dirs "" ;#non-user specific
+        #xdg_config_dirs ?
+        #xdg_runtime_dir ?
+        
+
+        #review. we are assuming if we can't get a home dir - then all the xdg vars including xdg_data_dirs aren't likely to be useful (as presumably filesystem access is absent)
+        #(safe interp generally won't have access to ::env either)
+        #This coupling doesn't necessarily hold - its possible the relevant env vars were copied to a safe interp - although that would be a policy that would make disabling 'info home' inconsistent. 
+        if {$homedir ne ""} {
+            if {"windows" eq $::tcl_platform(platform)} {
+                #as much as I'd prefer to use ~/.local/share and ~/.config to keep them more consistent with unixlike platforms - the vast majority of apps put them where microsoft wants them.
+                #we have a choice of LOCALAPPDATA vs APPDATA  (local to machine vs potentially roaming/redirected in a corporate environment)
+                #using the roaming location should not impact users who aren't using a domain controller but is potentially much more convenient for those who do. 
+                if {[info exists ::env(APPDATA)]} {
+                    set default_xdg_config_home $::env(APPDATA) 
+                    set default_xdg_data_home $::env(APPDATA) 
+                }
+
+                #The xdg_cache_home should be kept local
+                if {[info exists ::env(LOCALAPPDATA)]} {
+                    set default_xdg_cache_home $::env(LOCALAPPDATA)
+                    set default_xdg_state_home $::env(LOCALAPPDATA)
+                }
+
+                if {[info exists ::env(PROGRAMDATA)]} {
+                    #- equiv env(ALLUSERSPROFILE) ?
+                    set default_xdg_data_dirs $::env(PROGRAMDATA) 
+                }
+
+            } else {
+                #follow defaults as specified on freedesktop.org e.g https://specifications.freedesktop.org/basedir-spec/latest/ar01s03.html
+                set default_xdg_config_home [file join $homedir .config]
+                set default_xdg_data_home   [file join $homedir .local share]
+                set default_xdg_cache_home  [file join $homedir .cache]
+                set default_xdg_state_home  [file join $homedir .local state]
+                set default_xdg_data_dirs   /usr/local/share
+            }
+        } 
+
+        set defaults [dict create\
+            apps                    $default_apps\
+            config                  ""\
+            configset               ".punkshell"\
+            scriptlib               $default_scriptlib\
+            color_stdout            $default_color_stdout\
+            color_stderr            $default_color_stderr\
+            logfile_stdout          $default_logfile_stdout\
+            logfile_stderr          $default_logfile_stderr\
+            logfile_active          0\
+            syslog_stdout           "127.0.0.1:514"\
+            syslog_stderr           "127.0.0.1:514"\
+            syslog_active           0\
+            exec_unknown            true\
+            xdg_config_home         $default_xdg_config_home\
+            xdg_data_home           $default_xdg_data_home\
+            xdg_cache_home          $default_xdg_cache_home\
+            xdg_state_home          $default_xdg_state_home\
+            xdg_data_dirs           $default_xdg_data_dirs\
+            theme_posh_override     ""\
+            posh_theme              ""\
+            posh_themes_path        ""\
         ]
 
-    #override with env vars if set
-    variable evar
-    foreach evar $known_punk_env_vars {
-        if {[info exists ::env($evar)]} {
-            set f [set ::env($evar)]
-            if {$f ne "default"} {
-                #e.g PUNK_SCRIPTLIB -> scriptlib
-                set varname [tcl::string::tolower [tcl::string::range $evar 5 end]]
-                tcl::dict::set startup $varname $f 
+        set startup $defaults
+        #load values from saved config file  - $xdg_config_home/punk/punk.config ?
+        #typically we want env vars to override the stored config - as env vars conventionally used on some commandlines.
+        #that's possibly ok for the PUNK_ vars
+        #however.. others like the xdg vars and NOCOLOR may apply to other apps.. and we may want to override them from the saved config? 
+        #making some env vars override saved config values and some not would be potentially confusing. may need one/more specific settings or env vars to determine which takes precedence? 
+        #simpler is probably just to let env vars take precedence - and warn when saving or viewing config that the saved values are being overridden
+        #- requiring user to manually unset any unwanted env vars when launching?
+        
+        #we are likely to want the saved configs for subshells/decks to override them however.
+
+        #todo - load/save config file
+
+        #todo - define which configvars are settable in env
+        set known_punk_env_vars [list \
+            PUNK_APPS\
+            PUNK_CONFIG\
+            PUNK_CONFIGSET\
+            PUNK_SCRIPTLIB\
+            PUNK_EXECUNKNOWN\
+            PUNK_COLOR_STDERR\
+            PUNK_COLOR_STDOUT\
+            PUNK_LOGFILE_STDOUT\
+            PUNK_LOGFILE_STDERR\
+            PUNK_LOGFILE_ACTIVE\
+            PUNK_SYSLOG_STDOUT\
+            PUNK_SYSLOG_STDERR\
+            PUNK_SYSLOG_ACTIVE\
+            PUNK_THEME_POSH_OVERRIDE\
+            ]
+
+        #override with env vars if set
+        foreach evar $known_punk_env_vars {
+            if {[info exists ::env($evar)]} {
+                set f [set ::env($evar)]
+                if {$f ne "default"} {
+                    #e.g PUNK_SCRIPTLIB -> scriptlib
+                    set varname [tcl::string::tolower [tcl::string::range $evar 5 end]]
+                    tcl::dict::set startup $varname $f 
+                }
+            }
+        }
+
+        # https://no-color.org
+        #if {[info exists ::env(NO_COLOR)]} {
+        #    if {$::env(NO_COLOR) ne ""} {
+        #        set colour_disabled 1
+        #    }
+        #}
+        set known_other_env_vars [list\
+            NO_COLOR\
+            XDG_CONFIG_HOME\
+            XDG_DATA_HOME\
+            XDG_CACHE_HOME\
+            XDG_STATE_HOME\
+            XDG_DATA_DIRS\
+            POSH_THEME\
+            POSH_THEMES_PATH\
+        ]
+        foreach evar $known_other_env_vars {
+            if {[info exists ::env($evar)]} {
+                set f [set ::env($evar)]
+                if {$f ne "default"} {
+                    set varname [tcl::string::tolower $evar]
+                    tcl::dict::set startup $varname $f 
+                }
+            }
+        }
+
+
+        #unset -nocomplain vars
+
+        set running [tcl::dict::create]
+        set running [tcl::dict::merge $running $startup]
+    }
+    init 
+
+    #todo - consider how to divide up settings, categories, 'devices', decks etc
+    proc get_running_global {varname} {
+        variable running
+        if {[dict exists $running $varname]} {
+            return [dict get $running $varname]
+        }
+        error "No such global configuration item '$varname' found in running config"
+    }
+    proc get_startup_global {varname} {
+        variable startup
+        if {[dict exists $startup $varname]} {
+            return [dict get $startup $varname]
+        }
+        error "No such global configuration item '$varname' found in startup config"
+    }
+
+    proc get {whichconfig} {
+        variable startup
+        variable running
+        switch -- $whichconfig {
+            config - startup - startup-config - startup-configuration {
+                #show *startup* config - different behaviour may be confusing to those used to router startup and running configs
+                return $startup
+            }
+            running - running-config - running-configuration {
+                return $running
+            }
+        }
+    }
+
+    proc show {whichconfig} {
+        #todo - tables for console
+        variable startup
+        variable running
+        switch -- $whichconfig {
+            config - startup - startup-config - startup-configuration {
+                #show *startup* config - different behaviour may be confusing to those used to router startup and running configs
+                return [punk::print_dict $startup]
             }
+            running - running-config - running-configuration {
+                return [punk::print_dict $running]
+            }
+        }
+
+    }
+
+    #e.g 
+    # copy running-config startup-config
+    # copy startup-config test-config.cfg
+    # copy backup-config.cfg running-config
+    #review - consider the merge vs overwrite feature of some routers.. where copy to running-config does a merge rather than an overwrite ?
+    proc copy {fromconfig toconfig} {
+        error "sorry - unimplemented"
+        switch -- $toconfig {
+
         }
     }
-    unset -nocomplain evar
-    unset -nocomplain vars
 
-    set running [tcl::dict::create]
-    set running [tcl::dict::merge $running $startup]
+
+
+
+
+}
+
+
+
+
+
+#todo - move to cli?
+::tcl::namespace::eval punk::config {
+    #todo - something better - 'previous' rather than reverting to startup
+    proc channelcolors {{onoff {}}} {
+        variable running
+        variable startup
+
+        if {![string length $onoff]} {
+            return [list stdout [dict get $running color_stdout] stderr [dict get $running color_stderr]]
+        } else {
+            if {![string is boolean $onoff]} {
+                error "channelcolors: invalid value $onoff - expected boolean: true|false|on|off|1|0|yes|no"
+            }
+            if {$onoff} {
+                dict set running color_stdout [dict get $startup color_stdout]
+                dict set running color_stderr [dict get $startup color_stderr]
+            } else {
+                dict set running color_stdout ""
+                dict set running color_stderr ""
+            }
+        }
+        return [list stdout [dict get $running color_stdout] stderr [dict get $running color_stderr]]
+    }
 }
 
 package provide punk::config [tcl::namespace::eval punk::config {
diff --git a/src/modules/punk/console-999999.0a1.0.tm b/src/modules/punk/console-999999.0a1.0.tm
index 7be0509f..29926f41 100644
--- a/src/modules/punk/console-999999.0a1.0.tm
+++ b/src/modules/punk/console-999999.0a1.0.tm
@@ -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 ""} {
diff --git a/src/modules/punk/du-999999.0a1.0.tm b/src/modules/punk/du-999999.0a1.0.tm
index 3470774f..fb958eb6 100644
--- a/src/modules/punk/du-999999.0a1.0.tm
+++ b/src/modules/punk/du-999999.0a1.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]]
 
 
             #----
diff --git a/src/modules/punk/fileline-999999.0a1.0.tm b/src/modules/punk/fileline-999999.0a1.0.tm
index 19cfed6c..3c5339e6 100644
--- a/src/modules/punk/fileline-999999.0a1.0.tm
+++ b/src/modules/punk/fileline-999999.0a1.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
 
     }
 
diff --git a/src/modules/punk/lib-999999.0a1.0.tm b/src/modules/punk/lib-999999.0a1.0.tm
index 7194ccc1..5472295f 100644
--- a/src/modules/punk/lib-999999.0a1.0.tm
+++ b/src/modules/punk/lib-999999.0a1.0.tm
@@ -356,7 +356,62 @@ 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::list has 2 differing implementations (tcl vs critcl) which return results with different ordering to each other.
+    proc ldiff {fromlist removeitems} {
+        set doomed [list]
+        foreach item $removeitems {
+            lappend doomed {*}[lsearch -all -exact $fromlist $item]
+        }
+        lremove $fromlist {*}$doomed
+    }
+    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!" 
+        proc lunique_unordered {list} {
+            tailcall lunique $list
+        }
+    }
+    #order-preserving
+    proc lunique {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
+    }
+    proc lunique1 {list} {
+        set doomed [list]
+        #expr 'in' probably faster than using a dict - for lists approx < 20,000 items. (wiki wisdom - url?)
+        set i 0
+        foreach item $list {
+            if {$i in $doomed} {
+                incr i
+                continue
+            }
+            lappend doomed {*}[lrange [lsearch -all -exact -start $i $list $item] 1 end]
+            incr i
+        }
+        puts --->doomed:$doomed
+        lremove $list {*}$doomed
+    }
+    proc lunique2 {list} {
+        set new {}
+        foreach item $list {
+            if {$item ni $new} {
+            lappend new $item
+            }
+        }
+        return $new
+    }
     #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]
@@ -447,8 +502,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} {
@@ -1647,6 +1709,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 ---}]
 }
@@ -1685,6 +1753,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
diff --git a/src/modules/punk/mix-0.2.tm b/src/modules/punk/mix-0.2.tm
index f24deb65..24ef156c 100644
--- a/src/modules/punk/mix-0.2.tm
+++ b/src/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/modules/punk/mix/base-0.1.tm b/src/modules/punk/mix/base-0.1.tm
index 0a13ad3a..a9795574 100644
--- a/src/modules/punk/mix/base-0.1.tm
+++ b/src/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} {
diff --git a/src/modules/punk/mix/cli-0.3.tm b/src/modules/punk/mix/cli-0.3.tm
index 3e941e43..2d47efe9 100644
--- a/src/modules/punk/mix/cli-0.3.tm
+++ b/src/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"
             }
@@ -372,7 +373,7 @@ namespace eval punk::mix::cli {
                     }  
 
                     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/modules/punk/mix/commandset/loadedlib-999999.0a1.0.tm b/src/modules/punk/mix/commandset/loadedlib-999999.0a1.0.tm
index 0a6150ff..3788dc16 100644
--- a/src/modules/punk/mix/commandset/loadedlib-999999.0a1.0.tm
+++ b/src/modules/punk/mix/commandset/loadedlib-999999.0a1.0.tm
@@ -251,7 +251,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 +316,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/modules/punk/mix/templates/layouts/project/src/make.tcl b/src/modules/punk/mix/templates/layouts/project/src/make.tcl
index f4eef65f..c53315e9 100644
--- a/src/modules/punk/mix/templates/layouts/project/src/make.tcl
+++ b/src/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/modules/punk/mix/templates/modules/template_anyname-0.0.2.tm b/src/modules/punk/mix/templates/modules/template_anyname-0.0.2.tm
index 4bca651b..0a070c15 100644
--- a/src/modules/punk/mix/templates/modules/template_anyname-0.0.2.tm
+++ b/src/modules/punk/mix/templates/modules/template_anyname-0.0.2.tm
@@ -24,7 +24,7 @@ apply {code { #auto determine package name and version from name and placement o
     }
     set ver [join [lassign [split [file rootname [file tail [info script] ]] -] pkgtail] -]
     set pkgns  ${nsprefix}${pkgtail}
-    namespace eval $pkgns  [string map [list <pkg> $pkgns <ver> $ver] $code]
+    tcl::namespace::eval $pkgns  [string map [list <pkg> $pkgns <ver> $ver] $code]
     package provide $pkgns $ver;# only provide package if code evaluated without error
 } ::}  {
     #--------------------------------------
@@ -40,7 +40,7 @@ apply {code { #auto determine package name and version from name and placement o
 
 
 
-    namespace eval [namespace current]::lib {
+    tcl::namespace::eval [tcl::namespace::current]::lib {
         #proc test {args} {puts "[namespace current]::test got args: $args"}
     }
 
diff --git a/src/modules/punk/ns-999999.0a1.0.tm b/src/modules/punk/ns-999999.0a1.0.tm
index 42f3f0a5..ef4a0eb0 100644
--- a/src/modules/punk/ns-999999.0a1.0.tm
+++ b/src/modules/punk/ns-999999.0a1.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]"
@@ -1084,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 {
@@ -1104,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]
                     }
@@ -1113,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]
@@ -1132,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 {
@@ -1375,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 
                 }
 
@@ -1386,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
@@ -1462,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}]
@@ -1627,7 +1628,7 @@ namespace eval punk::ns {
     }
 
 
-    namespace eval internal {
+    tcl::namespace::eval internal {
 
 
         #maintenance: similar in punk::winrun
@@ -1713,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 ""
@@ -1725,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} {
@@ -1736,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]
@@ -1811,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]
@@ -1823,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]
@@ -1837,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>
@@ -1902,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 999999.0a1.0 
 }]
diff --git a/src/modules/punk/path-999999.0a1.0.tm b/src/modules/punk/path-999999.0a1.0.tm
index 3996d1c6..f2f52f56 100644
--- a/src/modules/punk/path-999999.0a1.0.tm
+++ b/src/modules/punk/path-999999.0a1.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/modules/punk/repl-0.1.tm b/src/modules/punk/repl-0.1.tm
index ea77765d..75193c81 100644
--- a/src/modules/punk/repl-0.1.tm
+++ b/src/modules/punk/repl-0.1.tm
@@ -153,7 +153,7 @@ proc ::punk::repl::init_signal_handlers {} {
                                 #avoid spurious triggers after interrupting a command..
                                 #review - dodgy.. we just want to interrupt child processes but then still be able to interrupt repl
                                 set ::punk::repl::signal_control_c 0
-                                set preverr [string map [list "child killed" "child_killed"] $::errorInfo]
+                                set preverr [string map {"child killed" "child_killed"} $::errorInfo]
                                 catch {error $preverr}   ;#for errorInfo display 
                                 return 42
                             } else {
@@ -207,7 +207,7 @@ proc ::punk::repl::init_signal_handlers {} {
 
                         if {[lindex $::errorCode 0] eq "CHILDKILLED"} {
                             set signal_control_c 0
-                            set preverr [string map [list "child killed" "child_killed"] $::errorInfo]
+                            set preverr [string map {"child killed" "child_killed"} $::errorInfo]
                             catch {error $preverr}   ;#for errorInfo display 
                             return 42 
                         }
@@ -1635,12 +1635,12 @@ proc repl::repl_process_data {inputchan chunktype chunk stdinlines prompt_config
 
                 if {$chunklen == 1} {
                     #presume it's a keypress from terminal
-                    set chunk [string map [list \r \n] $chunk]
+                    set chunk [string map {\r \n} $chunk]
                 } else {
                     #maybe a paste? (or stdin to active shell loop - possibly with no terminal ? )
                     #we'd better check for crlf and/or plain lf. If found - presume any lone CR is to be left as is.
                     if {[string first \n $chunk] < 0} {
-                        set chunk [string map [list \r \n] $chunk]
+                        set chunk [string map {\r \n} $chunk]
                     }
                     #else - 
                     #has lf - but what if last char is cr?
@@ -2479,6 +2479,8 @@ namespace eval repl {
 
         thread::send $codethread [string map [list   %args% [list $opts]\
                                                      %argv0% [list $::argv0]\
+                                                     %argv%  [list $::argv]\
+                                                     %argc%  [list $::argc]\
                                                      %replthread% [thread::id]\
                                                      %replthread_cond% $codethread_cond\
                                                      %replthread_interp% [list $opt_callback_interp]\
@@ -2486,6 +2488,8 @@ namespace eval repl {
                                                      %autopath% [list $::auto_path]\
                                                      ] {
             set ::argv0 %argv0%
+            set ::argv %argv%
+            set ::argc %argc% 
             tcl::tm::remove {*}[tcl::tm::list]
             tcl::tm::add {*}%tmlist% 
             #this sets the auto_path in the thread but outside of the code interp that will be created.
@@ -2599,7 +2603,7 @@ namespace eval repl {
                     return $stack
                 }
             }
-            namespace eval ::repl::interphelpers::subrepl_ensemble {
+            namespace eval ::repl::interphelpers::subshell_ensemble {
                 namespace export {[a-z]*} 
                 namespace ensemble create
                 proc punk {} {
@@ -2645,6 +2649,8 @@ namespace eval repl {
                         punk::island::add code $p
                     }
                 }
+
+                #review argv0,argv,argc
                 interp eval code {
                     set ::argv0 %argv0%
                     set ::auto_path %autopath%
@@ -2679,6 +2685,8 @@ namespace eval repl {
                 }
                 interp eval code {
                     set ::argv0 %argv0%
+                    set ::argc 0
+                    set ::argv {}
                     set ::auto_path %autopath%
                     #puts stdout "safe interp"
                     #flush stdout
@@ -2727,6 +2735,8 @@ namespace eval repl {
                 interp create code
                 interp eval code {
                     set ::argv0 %argv0%
+                    set ::argv %argv%
+                    set ::argc %argc%
                     set ::auto_path %autopath%
                     tcl::tm::remove {*}[tcl::tm::list]
                     tcl::tm::add {*}%tmlist% 
@@ -2738,7 +2748,7 @@ namespace eval repl {
                 }
             }
             code alias repl         ::repl::interphelpers::repl_ensemble
-            code alias subrepl      ::repl::interphelpers::subrepl_ensemble
+            code alias subshell     ::repl::interphelpers::subshell_ensemble
             code alias quit         ::repl::interphelpers::quit
             code alias editbuf      ::repl::interphelpers::editbuf
             code alias colour       ::repl::interphelpers::colour
diff --git a/src/modules/punk/repl/codethread-999999.0a1.0.tm b/src/modules/punk/repl/codethread-999999.0a1.0.tm
index ebb78c00..1c73b3a4 100644
--- a/src/modules/punk/repl/codethread-999999.0a1.0.tm
+++ b/src/modules/punk/repl/codethread-999999.0a1.0.tm
@@ -65,11 +65,11 @@ package require punk::config
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # oo::class namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::repl::codethread::class {
+#tcl::namespace::eval punk::repl::codethread::class {
     #*** !doctools
     #[subsection {Namespace punk::repl::codethread::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]
 
@@ -91,8 +91,8 @@ namespace eval punk::repl::codethread::class {
 
         #*** !doctools
         #[list_end] [comment {--- end class enumeration ---}]
-    }
-}
+    #}
+#}
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 
 
@@ -101,8 +101,8 @@ namespace eval punk::repl::codethread::class {
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # Base namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::repl::codethread {
-    namespace export *
+tcl::namespace::eval punk::repl::codethread {
+    tcl::namespace::export *
     variable replthread
     variable replthread_cond
     variable running 0
@@ -157,8 +157,8 @@ namespace eval punk::repl::codethread {
         }
         lappend outstack [shellfilter::stack::add stdout tee_to_var -settings {-varname ::punk::repl::codethread::output_stdout}]
         if {[string length [dict get $running_config color_stderr]] && [punk::console::colour]} {
-            #lappend errstack [shellfilter::stack::add stderr ansiwrap -settings [list -colour [dict get $running_config color_stderr]]]
-            lappend errstack [shellfilter::stack::add stderr ansiwrap -settings [list -colour cyan]]
+            lappend errstack [shellfilter::stack::add stderr ansiwrap -settings [list -colour [dict get $running_config color_stderr]]]
+            #lappend errstack [shellfilter::stack::add stderr ansiwrap -settings [list -colour cyan]]
         }
         lappend errstack [shellfilter::stack::add stderr tee_to_var -settings {-varname ::punk::repl::codethread::output_stderr}]
 
@@ -168,7 +168,7 @@ namespace eval punk::repl::codethread {
 
         set scope [interp eval code [list set ::punk::ns::ns_current]]
         set status [catch {
-            interp eval code [list namespace inscope $scope $script]
+            interp eval code [list tcl::namespace::inscope $scope $script]
         } result]
 
 
@@ -206,9 +206,9 @@ namespace eval punk::repl::codethread {
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 # Secondary API namespace
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
-namespace eval punk::repl::codethread::lib {
-    namespace export *
-    namespace path [namespace parent]
+tcl::namespace::eval punk::repl::codethread::lib {
+    tcl::namespace::export *
+    tcl::namespace::path [tcl::namespace::parent]
     #*** !doctools
     #[subsection {Namespace punk::repl::codethread::lib}]
     #[para] Secondary functions that are part of the API 
@@ -233,7 +233,7 @@ namespace eval punk::repl::codethread::lib {
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 #*** !doctools
 #[section Internal]
-namespace eval punk::repl::codethread::system {
+tcl::namespace::eval punk::repl::codethread::system {
     #*** !doctools
     #[subsection {Namespace punk::repl::codethread::system}]
     #[para] Internal functions that are not part of the API 
@@ -243,7 +243,7 @@ namespace eval punk::repl::codethread::system {
 }
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Ready   
-package provide punk::repl::codethread [namespace eval punk::repl::codethread {
+package provide punk::repl::codethread [tcl::namespace::eval punk::repl::codethread {
     variable pkg punk::repl::codethread
     variable version
     set version 999999.0a1.0 
diff --git a/src/modules/punk/repo-999999.0a1.0.tm b/src/modules/punk/repo-999999.0a1.0.tm
index 0e7c0a26..dcd37719 100644
--- a/src/modules/punk/repo-999999.0a1.0.tm
+++ b/src/modules/punk/repo-999999.0a1.0.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/modules/punk/winpath-999999.0a1.0.tm b/src/modules/punk/winpath-999999.0a1.0.tm
index cd4c26e2..2b09d373 100644
--- a/src/modules/punk/winpath-999999.0a1.0.tm
+++ b/src/modules/punk/winpath-999999.0a1.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/modules/punkcheck-0.1.0.tm b/src/modules/punkcheck-0.1.0.tm
index fc2f9509..ccef0624 100644
--- a/src/modules/punkcheck-0.1.0.tm
+++ b/src/modules/punkcheck-0.1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use '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.
diff --git a/src/modules/shellfilter-0.1.9.tm b/src/modules/shellfilter-0.1.9.tm
index 13981aa2..7bd34f67 100644
--- a/src/modules/shellfilter-0.1.9.tm
+++ b/src/modules/shellfilter-0.1.9.tm
@@ -10,9 +10,9 @@
 #
 
 
-namespace eval shellfilter::log {
+tcl::namespace::eval shellfilter::log {
     variable allow_adhoc_tags 1
-    variable open_logs [dict create]
+    variable open_logs [tcl::dict::create]
 
     #'tag' is an identifier for the log source. 
     # each tag will use it's own thread to write to the configured log target
@@ -20,11 +20,11 @@ namespace eval shellfilter::log {
         upvar ::shellfilter::sources sourcelist
         package require shellthread
         if {![dict exists $settingsdict -tag]} {
-            dict set settingsdict -tag $tag
+            tcl::dict::set settingsdict -tag $tag
         } else {
             #review
-            if {$tag ne [dict get $settingsdict -tag]} {
-                error "shellfilter::log::open first argument tag: '$tag' does not match -tag '[dict get $settingsdict -tag]' omit -tag, or supply same value"
+            if {$tag ne [tcl::dict::get $settingsdict -tag]} {
+                error "shellfilter::log::open first argument tag: '$tag' does not match -tag '[tcl::dict::get $settingsdict -tag]' omit -tag, or supply same value"
             }
         }
         if {$tag ni $sourcelist} {
@@ -250,18 +250,18 @@ namespace eval shellfilter::chan {
         variable o_is_junction
         constructor {tf} {
             set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
+            set o_enc [tcl::dict::get $tf -encoding]
             set o_lastxlines [list]
             set o_postcountdown 0
-            set defaults [dict create -pre 1 -post 1]
-            set settingsdict [dict get $tf -settings]
-            set settings [dict merge $defaults $settingsdict]
-            set o_datavar [dict get $settings -varname]
-            set o_grepfor [dict get $settings -grep]
-            set o_prelines [dict get $settings -pre]
-            set o_postlines [dict get $settings -post]
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
+            set defaults [tcl::dict::create -pre 1 -post 1]
+            set settingsdict [tcl::dict::get $tf -settings]
+            set settings [tcl::dict::merge $defaults $settingsdict]
+            set o_datavar [tcl::dict::get $settings -varname]
+            set o_grepfor [tcl::dict::get $settings -grep]
+            set o_prelines [tcl::dict::get $settings -pre]
+            set o_postlines [tcl::dict::get $settings -post]
+            if {[tcl::dict::exists $tf -junction]} {
+                set o_is_junction [tcl::dict::get $tf -junction]
             } else {
                 set o_is_junction 0
             }
@@ -278,7 +278,7 @@ namespace eval shellfilter::chan {
         #  return ?
         #}
         method write {transform_handle bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
+            set logdata [tcl::encoding::convertfrom $o_enc $bytes] 
             set lastx $o_lastxlines 
             lappend o_lastxlines $logdata
 
@@ -318,12 +318,12 @@ namespace eval shellfilter::chan {
         variable o_is_junction
         constructor {tf} {
             set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            set varname [dict get $settingsdict -varname]
+            set o_enc [tcl::dict::get $tf -encoding]
+            set settingsdict [tcl::dict::get $tf -settings]
+            set varname [tcl::dict::get $settingsdict -varname]
             set o_datavars $varname
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
+            if {[tcl::dict::exists $tf -junction]} {
+                set o_is_junction [tcl::dict::get $tf -junction]
             } else {
                 set o_is_junction 0
             }
@@ -348,7 +348,7 @@ namespace eval shellfilter::chan {
             return ""
         }
         method write {ch bytes} {
-            set stringdata [encoding convertfrom $o_enc $bytes]
+            set stringdata [tcl::encoding::convertfrom $o_enc $bytes]
             foreach v $o_datavars {
                 append $v $stringdata
             }
@@ -366,15 +366,15 @@ namespace eval shellfilter::chan {
         variable o_is_junction
         constructor {tf} {
             set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
+            set o_enc [tcl::dict::get $tf -encoding]
+            set settingsdict [tcl::dict::get $tf -settings]
             if {![dict exists $settingsdict -tag]} {
                 error "tee_to_pipe constructor settingsdict missing -tag"
             }
-            set o_localchan [dict get $settingsdict -pipechan]
-            set o_logsource [dict get $settingsdict -tag]
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
+            set o_localchan [tcl::dict::get $settingsdict -pipechan]
+            set o_logsource [tcl::dict::get $settingsdict -tag]
+            if {[tcl::dict::exists $tf -junction]} {
+                set o_is_junction [tcl::dict::get $tf -junction]
             } else {
                 set o_is_junction 0
             }
@@ -397,7 +397,7 @@ namespace eval shellfilter::chan {
             return ""
         }
         method read {transform_handle bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
+            set logdata [tcl::encoding::convertfrom $o_enc $bytes] 
             #::shellfilter::log::write $o_logsource $logdata
             puts -nonewline $o_localchan $logdata
             return  $bytes
@@ -406,7 +406,7 @@ namespace eval shellfilter::chan {
             return ""
         }
         method write {transform_handle bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
+            set logdata [tcl::encoding::convertfrom $o_enc $bytes] 
             #::shellfilter::log::write $o_logsource $logdata
             puts -nonewline $o_localchan $logdata
             return $bytes
@@ -425,15 +425,15 @@ namespace eval shellfilter::chan {
         variable o_is_junction
         constructor {tf} {
             set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            if {![dict exists $settingsdict -tag]} {
+            set o_enc [tcl::dict::get $tf -encoding]
+            set settingsdict [tcl::dict::get $tf -settings]
+            if {![tcl::dict::exists $settingsdict -tag]} {
                 error "tee_to_log constructor settingsdict missing -tag"
             }
-            set o_logsource [dict get $settingsdict -tag]
+            set o_logsource [tcl::dict::get $settingsdict -tag]
             set o_tid [::shellfilter::log::open $o_logsource $settingsdict]
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
+            if {[tcl::dict::exists $tf -junction]} {
+                set o_is_junction [tcl::dict::get $tf -junction]
             } else {
                 set o_is_junction 0
             }
@@ -450,12 +450,12 @@ namespace eval shellfilter::chan {
             # post any events
         }
         method read {ch bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
+            set logdata [tcl::encoding::convertfrom $o_enc $bytes] 
             ::shellfilter::log::write $o_logsource $logdata
             return  $bytes
         }
         method write {ch bytes} {
-            set logdata [encoding convertfrom $o_enc $bytes] 
+            set logdata [tcl::encoding::convertfrom $o_enc $bytes] 
             ::shellfilter::log::write $o_logsource $logdata
             return $bytes
         }
@@ -620,10 +620,10 @@ namespace eval shellfilter::chan {
         constructor {tf} {
             package require punk::ansi
             set o_trecord $tf
-            set o_enc [dict get $tf -encoding]
-            set settingsdict [dict get $tf -settings]
-            if {[dict exists $settingsdict -colour]} {
-                set o_colour [dict get $settingsdict -colour]
+            set o_enc [tcl::dict::get $tf -encoding]
+            set settingsdict [tcl::dict::get $tf -settings]
+            if {[tcl::dict::exists $settingsdict -colour]} {
+                set o_colour [tcl::dict::get $settingsdict -colour]
                 set o_do_colour [punk::ansi::a+ {*}$o_colour]
                 set o_do_normal [punk::ansi::a]
             } else {
@@ -631,8 +631,8 @@ namespace eval shellfilter::chan {
                 set o_do_colour ""
                 set o_do_normal ""
             }
-            if {[dict exists $tf -junction]} {
-                set o_is_junction [dict get $tf -junction]
+            if {[tcl::dict::exists $tf -junction]} {
+                set o_is_junction [tcl::dict::get $tf -junction]
             } else {
                 set o_is_junction 0
             }
@@ -652,18 +652,18 @@ namespace eval shellfilter::chan {
             return ""
         }
         method write {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes]
+            set instring [tcl::encoding::convertfrom $o_enc $bytes]
             set outstring "$o_do_colour$instring$o_do_normal"
             #set outstring ">>>$instring"
-            return [encoding convertto $o_enc $outstring]
+            return [tcl::encoding::convertto $o_enc $outstring]
         }
         method drain {transform_handle} {
             return ""
         }
         method read {transform_handle bytes} {
-            set instring [encoding convertfrom $o_enc $bytes]
+            set instring [tcl::encoding::convertfrom $o_enc $bytes]
             set outstring "$o_do_colour$instring$o_do_normal"
-            return [encoding convertto $o_enc $outstring]
+            return [tcl::encoding::convertto $o_enc $outstring]
         }
         method meta_is_redirection {} {
             return $o_is_junction
@@ -749,7 +749,7 @@ namespace eval shellfilter::chan {
                 set instring "\r$instring"
             }
 
-            set outstring [string map [list \r\n \n] $instring]
+            set outstring [string map {\r\n \n} $instring]
             set lastchar [string range $outstring end end] 
             if {$lastchar eq "\r"} {
                 set o_last_char_was_cr 1
@@ -810,9 +810,9 @@ namespace eval shellfilter::chan {
                 set instring "\r$instring"
             }
 
-            set outstring [string map [list \r\n \uFFFF] $instring]
-            set outstring [string map [list \n \r\n] $outstring]
-            set outstring [string map [list \uFFFF \r\n] $outstring]
+            set outstring [string map {\r\n \uFFFF} $instring]
+            set outstring [string map {\n \r\n} $outstring]
+            set outstring [string map {\uFFFF \r\n} $outstring]
 
             set lastchar [string range $outstring end end] 
             if {$lastchar eq "\r"} {
@@ -2217,7 +2217,7 @@ namespace eval shellfilter {
         #'clock micros' good enough id for shellcommand calls unless one day they can somehow be called concurrently or sequentially within a microsecond and within the same interp.
         # a simple counter would probably work too
         #consider other options if an alternative to the single vwait in this function is used.
-        set call_id [clock micros] ;
+        set call_id [tcl::clock::microseconds] ;
         set ::shellfilter::shellcommandvars($call_id,exitcode) ""
         set waitvar ::shellfilter::shellcommandvars($call_id,waitvar)
         if {$debug} {
@@ -2585,7 +2585,7 @@ namespace eval shellfilter {
 
 
       if {[string length $teefile]} {
-        set logname "redir_[string map [list : _ ] $winfile]_[clock micros]"
+        set logname "redir_[string map {: _} $winfile]_[tcl::clock::microseconds]"
         set tid [::shellfilter::log::open $logname {-syslog 127.0.0.1:514}]
         if {$teefile eq "write"} {
           ::shellfilter::log::write $logname "opening '$winfile' for write" 
@@ -2598,7 +2598,7 @@ namespace eval shellfilter {
         chan configure $fd -translation $outtranslation
         chan configure $fd -encoding utf-8 
 
-        set tempvar_bytetotal [namespace current]::totalbytes[clock micros] 
+        set tempvar_bytetotal [namespace current]::totalbytes[tcl::clock::microseconds] 
         set $tempvar_bytetotal 0
         chan event $rdout readable [list apply {{chan other wrerr outchan errchan read_proc_out_buffering waitfor outprefix call_id debug debugname writefile writefilefd copytempfile bytevar logtag} {
             #review - if we write outprefix to normal stdout.. why not to redirected file?  
diff --git a/src/modules/shellthread-1.6.1.tm b/src/modules/shellthread-1.6.1.tm
index 2084d255..11cfb0fd 100644
--- a/src/modules/shellthread-1.6.1.tm
+++ b/src/modules/shellthread-1.6.1.tm
@@ -12,15 +12,15 @@ namespace eval shellthread {
 
   proc iso8601 {{tsmicros ""}} {
     if {$tsmicros eq ""} {
-        set tsmicros [clock micros]
+        set tsmicros [tcl::clock::microseconds]
     } else {
-        set microsnow [clock micros]
-        if {[string length $tsmicros] != [string length $microsnow]} {
+        set microsnow [tcl::clock::microseconds]
+        if {[tcl::string::length $tsmicros] != [tcl::string::length $microsnow]} {
             error "iso8601 requires 'clock micros' or empty string to create timestamp"
         }
     }
     set seconds [expr {$tsmicros / 1000000}]
-    return [clock format $seconds  -format "%Y-%m-%d_%H-%M-%S"]
+    return [tcl::clock::format $seconds  -format "%Y-%m-%d_%H-%M-%S"]
   }
 }
 
diff --git a/src/modules/tcl9test-999999.0a1.0.tm b/src/modules/tcl9test-999999.0a1.0.tm
index 02641fc2..92c32ca9 100644
--- a/src/modules/tcl9test-999999.0a1.0.tm
+++ b/src/modules/tcl9test-999999.0a1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use '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.
diff --git a/src/modules/textblock-999999.0a1.0.tm b/src/modules/textblock-999999.0a1.0.tm
index 0ed4fb1e..3ffa2ba1 100644
--- a/src/modules/textblock-999999.0a1.0.tm
+++ b/src/modules/textblock-999999.0a1.0.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]\
@@ -197,9 +197,9 @@ namespace eval textblock {
             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
         }
@@ -209,9 +209,9 @@ namespace eval textblock {
             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
         }
@@ -221,13 +221,13 @@ namespace eval textblock {
             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
@@ -238,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]
@@ -282,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
@@ -292,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 {}\
@@ -339,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 
@@ -360,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 
@@ -387,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 {
@@ -423,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
@@ -447,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]} {
@@ -458,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]
@@ -515,12 +515,12 @@ 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 *}"
@@ -583,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
@@ -599,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
@@ -617,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 {
@@ -625,17 +625,17 @@ 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
                             }
                         }
                     }
@@ -646,25 +646,25 @@ namespace eval textblock {
                     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
                 }
 
@@ -696,8 +696,8 @@ namespace eval textblock {
                     }  else {
                         set m [struct::matrix $cmd]
                     }
-                    $m add columns [dict size $o_columndata]
-                    $m add rows [dict size $o_rowdefs]
+                    $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 
                     }
@@ -709,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" 
@@ -749,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%"
@@ -793,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 {
@@ -815,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
@@ -839,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"
                                                 }
@@ -854,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
@@ -905,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]"
@@ -928,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"
                                     }
@@ -940,23 +940,23 @@ 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
@@ -968,7 +968,7 @@ namespace eval textblock {
                                 }
                             }
                             foreach zidx $zero_heights {
-                                dict unset o_headerstates $zidx
+                                tcl::dict::unset o_headerstates $zidx
                             }
                         }
                         if {$args_got_headers || $args_got_header_colspans} {
@@ -976,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
                     tcl::dict::for {k cdef} $o_columndefs {
-                        set num_headers [llength [dict get $cdef -headers]]
+                        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
@@ -1003,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]
                     }
                     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)}]
@@ -1024,10 +1024,10 @@ namespace eval textblock {
                 #
                 method header_colspans {} {
                     set num_headers [my header_count_calc]
-                    set colspans_by_header [dict create]
+                    set colspans_by_header [tcl::dict::create]
                     tcl::dict::for {cidx cdef} $o_columndefs {
-                        set headerlist [dict get $cdef -headers]
-                        set colspans_for_column   [dict get $cdef -header_colspans]
+                        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] 
@@ -1061,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
@@ -1073,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'."
                     }
@@ -1084,63 +1084,63 @@ 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]
                         tcl::dict::for {cidx cdef} $o_columndefs {
-                            set colheaders [dict get $cdef -headers]
+                            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]
                                     tcl::dict::for {cidx cdef} $o_columndefs {
-                                        set colheaders [dict get $cdef -headers]
+                                        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]"
                     }
                     foreach {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]"
+                        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]"
                         }
                     }
 
@@ -1173,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]} {
@@ -1192,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} {
@@ -1270,13 +1270,13 @@ namespace eval textblock {
                                 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 colheaders [tcl::dict::get $o_columndefs $c -headers]
                                     set missing [expr {($hidx +1) - [llength $colheaders]}]
                                     if {$missing > 0} {
                                         lappend colheaders {*}[lrepeat $missing ""]
                                     }
                                     lset colheaders $hidx $hval
-                                    dict set o_columndefs $c -headers $colheaders 
+                                    tcl::dict::set o_columndefs $c -headers $colheaders 
                                     #invalidate column width cache
                                     set o_calculated_column_widths [list]
                                     # -- -- -- -- -- --
@@ -1287,16 +1287,16 @@ namespace eval textblock {
                                     foreach hdr $colheaders {
                                         lassign [textblock::size $hdr] _w this_header_width _h this_header_height
                                         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
                                 }
@@ -1305,7 +1305,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"
@@ -1315,17 +1315,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
                                 }
                             }
@@ -1336,17 +1336,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 ""\
@@ -1355,7 +1355,7 @@ 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]"
                     }
                     #safe jumptable test
                     #dict for {k v} $args {}
@@ -1363,14 +1363,14 @@ namespace eval textblock {
                         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
@@ -1381,23 +1381,23 @@ namespace eval textblock {
                     } else {
                         if {![llength $valuelist]} {
                             tcl::dict::for {k coldef} $o_columndefs {
-                                lappend valuelist [dict get $coldef -defaultvalue]
+                                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" 
                     }
@@ -1406,71 +1406,71 @@ 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]"
                     }
                     foreach {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]"
+                        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]
@@ -1504,46 +1504,46 @@ 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]
+                    if {![tcl::string::is integer $opt_minh] || ($opt_maxh ne "" && ![tcl::string::is integer -strict $opt_maxh])} {
+                        error "[tcl::namespace::current]::table::add_row error -minheight '$opt_minh' and -maxheight '$opt_maxh' must be integers greater than or equal to 1"
                     }
                     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::add_row error -minheight '$opt_minh' and -maxheight '$opt_maxh' must both be 1 or greater"
                     }
                     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::add_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
                     tcl::dict::for {cidx records} $o_columndata {
-                        dict set o_columndata $cidx [list]
+                        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]
                 }
 
 
@@ -1554,11 +1554,11 @@ 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]} {}
                             }
                         }
                     }
@@ -1595,53 +1595,53 @@ namespace eval textblock {
                             set joins {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"\
                     ]
                     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: $valid_positions"
                         }
                     }
                     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 all_cols [tcl::dict::keys $o_columndefs]
                         foreach c $all_cols {
-                            set headerset [dict get $o_columndefs $c -headers]
+                            set headerset [tcl::dict::get $o_columndefs $c -headers]
                             foreach hdr $headerset {
                                 append allheaders $hdr 
                             }
@@ -1654,7 +1654,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 ""
@@ -1669,13 +1669,13 @@ 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 {
@@ -1713,63 +1713,63 @@ namespace eval textblock {
                         }
                     }
                     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 {
@@ -1780,16 +1780,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]
 
@@ -1800,7 +1800,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]
@@ -1833,21 +1833,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]
@@ -1864,7 +1864,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\
                                 #    ]
@@ -1876,7 +1876,7 @@ namespace eval textblock {
                                     #just write an empty vertical placeholder. The spanned value will be overtyped below
                                     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\
                                     ]
@@ -1886,7 +1886,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}]
@@ -1906,18 +1906,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 {
@@ -1932,12 +1932,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 
                                                 }
                                             }
 
@@ -1946,12 +1946,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\
                                                 ]
@@ -1973,9 +1973,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
@@ -1983,7 +1983,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]'"
@@ -2017,17 +2017,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
@@ -2050,23 +2050,23 @@ 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
@@ -2100,15 +2100,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
@@ -2117,10 +2117,10 @@ namespace eval textblock {
                         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]
+                        set row_ansibase [tcl::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 ""
@@ -2184,8 +2184,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
@@ -2194,11 +2194,11 @@ 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 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::width $rowframe]
                             append part_body $rowframe \n
                         } else {
@@ -2206,17 +2206,17 @@ namespace eval textblock {
                                 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
                     }
@@ -2237,13 +2237,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]
                         }
@@ -2251,8 +2251,8 @@ 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
@@ -2260,29 +2260,29 @@ namespace eval textblock {
                     if {$opt_return eq "string"} {
                         return $output 
                     } else {
-                        return [dict create column $output headerwidth $return_headerwidth headerheight $return_headerheight bodywidth $return_bodywidth bodyheight $return_bodyheight]
+                        return [tcl::dict::create column $output 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} 
@@ -2291,7 +2291,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
 
@@ -2300,56 +2300,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
@@ -2386,34 +2386,34 @@ 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\
                     ]
                     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"
@@ -2427,7 +2427,7 @@ namespace eval textblock {
                         set t [textblock::class::table new]
                         $t add_column -headers "Col"
                         tcl::dict::for {col coldef} $o_columndefs {
-                            foreach property [dict keys $coldef] {
+                            foreach property [tcl::dict::keys $coldef] {
                                 if {$property eq "-ansireset"} {
                                     continue
                                 }
@@ -2437,11 +2437,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
+                        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
@@ -2450,19 +2450,19 @@ 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 
                             }
@@ -2478,7 +2478,7 @@ namespace eval textblock {
                                 switch -- $property {
                                     -ansireset {continue}
                                     -headers {
-                                        set htable [dict get $col_header_tables $col]
+                                        set htable [tcl::dict::get $col_header_tables $col]
                                         tcl::dict::for {innercol maxw} $max_widths {
                                             $htable configure_column $innercol -minwidth $maxw  -blockalign left
                                         }
@@ -2503,9 +2503,9 @@ namespace eval textblock {
                     puts stdout "columnstates: $o_columnstates"
                     puts stdout "headerstates: $o_headerstates"
                     tcl::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] 
+                        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]} {
@@ -2521,8 +2521,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} {
@@ -2536,23 +2536,23 @@ namespace eval textblock {
                 }
                 #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
@@ -2582,13 +2582,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
@@ -2605,7 +2605,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
@@ -2613,22 +2613,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 ""} {
@@ -2654,21 +2654,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 {
+                    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]
+                        set thiscol_widest_header [tcl::dict::get $o_columnstates $cidx maxwidthheaderseen]
                         if {$spanc eq "1"} {
                             if {$thiscol_widest_header > $colwidth} {
                                 set test_width [expr {max($thiscol_widest_header,$colwidth)}]
@@ -2726,8 +2726,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
@@ -2745,7 +2745,7 @@ namespace eval textblock {
                 }
                 
                 method column_datawidth {index_expression args} {
-                    set opts [dict create\
+                    set opts [tcl::dict::create\
                         -headers 0\
                         -footers 0\
                         -colspan *\
@@ -2756,30 +2756,30 @@ namespace eval textblock {
                     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]
                                 tcl::dict::for {hrow cspans} $all_colspans_by_header {
@@ -2790,7 +2790,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 {
@@ -2798,28 +2798,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}]]
@@ -2831,12 +2831,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'"
@@ -2879,14 +2879,14 @@ namespace eval textblock {
                     }
                 }
                 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]
+                    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
@@ -2897,19 +2897,19 @@ 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
                             }
                         }
                     }
@@ -2918,21 +2918,21 @@ namespace eval textblock {
                     #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
+                                tcl::dict::set colwidths $col $hwidth
+                                tcl::dict::set colspace_added $col $space_to_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]} {
@@ -2947,7 +2947,7 @@ namespace eval textblock {
                                     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
@@ -2955,8 +2955,8 @@ namespace eval textblock {
                                                     break
                                                 }
                                             }
-                                            dict incr colwidths $colid
-                                            dict incr colspace_added $colid
+                                            tcl::dict::incr colwidths $colid
+                                            tcl::dict::incr colspace_added $colid
                                         }
                                     }
                                 }
@@ -2965,11 +2965,11 @@ namespace eval textblock {
                                     #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
@@ -2982,17 +2982,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
                         }
                         #
@@ -3001,18 +3001,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]
                         }
 
                     }
@@ -3022,11 +3022,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] 
@@ -3038,35 +3038,35 @@ 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
                     tcl::dict::for {hrow rawspans} $spans_by_header {
                         set thiscol_spanval [lindex $rawspans $cidx]
@@ -3098,22 +3098,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\
                     ]
                     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 {
@@ -3138,12 +3138,12 @@ 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 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 o_calculated_column_widths [tcl::dict::get $calcresult colwidths]
                         }
                         default {
                             error "calculate_column_widths unknown algorithm $opt_algorithm. Known algorithms: $known_algorithms"
@@ -3155,15 +3155,15 @@ namespace eval textblock {
                 }
                 method print {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'"
@@ -3200,15 +3200,15 @@ 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::dict::get $columninfo column]
+                        set bodywidth   [tcl::dict::get $columninfo bodywidth] 
 
                         if {$table eq ""} {
                             set table $nextcol 
@@ -3227,24 +3227,24 @@ 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 [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 ""
@@ -3258,7 +3258,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]
                             }
@@ -3286,13 +3286,13 @@ 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]
@@ -3335,7 +3335,7 @@ namespace eval textblock {
         #For an impressive interactive terminal app (javascript)
         # see: https://github.com/spirometaxas/periodic-table-cli
 
-        set opts [dict create\
+        set opts [tcl::dict::create\
             -return "string"\
             -compact 1\
             -forcecolour 0\
@@ -3343,15 +3343,15 @@ namespace eval textblock {
         foreach {k v} $args {
             switch -- $k {
                 -return - -compact - -forcecolour {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    "textblock::periodic unknown option '$k'. Known options: [dict keys $opts]"
+                    "textblock::periodic unknown option '$k'. Known options: [tcl::dict::keys $opts]"
                 }
             }
         }
-        set opt_return  [dict get $opts -return]
-        if {[dict get $opts -forcecolour]} {
+        set opt_return  [tcl::dict::get $opts -return]
+        if {[tcl::dict::get $opts -forcecolour]} {
             set fc forcecolour
         } else {
             set fc ""
@@ -3373,82 +3373,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
+            tcl::dict::set ecat $e $val
         }
 
         set elements1 [list]
         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
@@ -3471,7 +3471,7 @@ namespace eval textblock {
         for {set c 0} {$c < $ccount} {incr c} {
             $t configure_column $c -minwidth 3
         }
-        if {[dict get $opts -compact]} {
+        if {[tcl::dict::get $opts -compact]} {
             $t configure -show_hseps 0 -show_header 0 -show_edge 0
         } else {
             $t configure -show_header 1
@@ -3493,7 +3493,7 @@ namespace eval textblock {
     }
 
     proc list_as_table {table_or_colcount datalist args} {
-        set defaults [dict create\
+        set defaults [tcl::dict::create\
             -return string\
             -frametype \uFFEF\
             -show_edge \uFFEF\
@@ -3503,10 +3503,10 @@ namespace eval textblock {
         foreach {k v} $args {
             switch -- $k {
                 -return - -show_edge - -show_seps - -frametype {
-                    dict set opts $k $v
+                    tcl::dict::set opts $k $v
                 }
                 default {
-                    error "unrecognised option '$k'. Known options [dict keys $defaults]"
+                    error "unrecognised option '$k'. Known options [tcl::dict::keys $defaults]"
                 }
             }
         }
@@ -3514,33 +3514,33 @@ namespace eval textblock {
         set count [llength $datalist]
 
         set is_new_table 0
-        if {[string is integer -strict $table_or_colcount]} {
+        if {[tcl::string::is integer -strict $table_or_colcount]} {
             set cols $table_or_colcount
             set is_new_table 1
             #defaults for new table only
-            if {[dict get $opts -frametype] eq "\uFFEF"} {
-                dict set opts -frametype "light"
+            if {[tcl::dict::get $opts -frametype] eq "\uFFEF"} {
+                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 "\uFFEF"} {
+                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 "\uFFEF"} {
+                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]]
+            set t [textblock::class::table new -show_header 0 -show_edge [tcl::dict::get $opts -show_edge] -frametype [tcl::dict::get $opts -frametype] -show_seps [tcl::dict::get $opts -show_seps]]
             for {set c 0} {$c < $cols} {incr c} {
                 $t add_column -headers [list $c]
             }
         } else {
-            if {[namespace tail [info object class $table_or_colcount]] ne "table"} {
+            if {[tcl::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"
             }
             set t $table_or_colcount
-            if {[dict get $opts -frametype] ne "\uFFEF"} {
-                $t configure -frametype [dict get $opts -frametype]
+            if {[tcl::dict::get $opts -frametype] ne "\uFFEF"} {
+                $t configure -frametype [tcl::dict::get $opts -frametype]
             }
-            if {[dict get $opts -show_edge] ne "\uFFEF"} {
-                $t configure -show_edge [dict get $opts -show_edge] 
+            if {[tcl::dict::get $opts -show_edge] ne "\uFFEF"} {
+                $t configure -show_edge [tcl::dict::get $opts -show_edge] 
             }
             $t row_clear
             set cols [$t column_count]
@@ -3572,7 +3572,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 "string"} {
             set result [$t print]
             if {$is_new_table} {
                 $t destroy
@@ -3593,14 +3593,14 @@ 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]]
@@ -3608,7 +3608,7 @@ namespace eval textblock {
                     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]
@@ -3663,7 +3663,7 @@ 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]
@@ -3678,7 +3678,7 @@ namespace eval textblock {
             #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"
@@ -3688,13 +3688,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 ""} {
@@ -3712,8 +3712,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
@@ -3723,16 +3723,16 @@ namespace eval textblock {
         if {[punk::ansi::ta::detect $textblock]} {
             set textblock [punk::ansi::stripansi $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
         }
@@ -3741,12 +3741,12 @@ namespace eval textblock {
         }
         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
@@ -3755,17 +3755,17 @@ 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
@@ -3776,17 +3776,17 @@ namespace eval textblock {
         if {[punk::ansi::ta::detect $textblock]} {
             set textblock [punk::ansi::stripansi $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
@@ -3796,13 +3796,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}]} {
@@ -3810,17 +3810,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  ""\
@@ -3834,7 +3834,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"
@@ -3842,13 +3842,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 
@@ -3864,20 +3864,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 {
@@ -3895,7 +3895,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?
@@ -3906,7 +3906,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 {
@@ -3915,7 +3915,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)
@@ -3931,9 +3931,9 @@ namespace eval textblock {
         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]
@@ -3948,7 +3948,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
@@ -4005,7 +4005,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
@@ -4097,44 +4097,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
         }
 
@@ -4148,16 +4148,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?
         tcl::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] 
+            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 "" ""
         }
 
@@ -4165,12 +4165,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 [expr {1 + (2 * [tcl::dict::size $blockinfo])}] $rows -return object]
+        $t configure_column 0 -headers [list [tcl::dict::get $opts -description] "within_ansi"] -ansibase $column_ansi
         set col 1
         tcl::dict::for {b bdict} $blockinfo {
-            if {[dict exists $bheaders $b]} {
-                set hdr [dict get $bheaders $b]
+            if {[tcl::dict::exists $bheaders $b]} {
+                set hdr [tcl::dict::get $bheaders $b]
             } else {
                 set hdr "Block $b"
             }
@@ -4226,7 +4226,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
@@ -4235,7 +4235,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
@@ -4249,12 +4249,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
         }
@@ -4275,8 +4275,8 @@ namespace eval textblock {
         #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) 
 
@@ -4311,7 +4311,7 @@ namespace eval textblock {
         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 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.
@@ -4343,7 +4343,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
@@ -4352,19 +4352,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 {
@@ -4416,25 +4416,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]
@@ -4474,7 +4474,7 @@ namespace eval textblock {
     }
     proc frametype {f} {
         variable frametypes
-        set default_custom [dict create hl " " vl " " 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
@@ -4496,13 +4496,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.
@@ -4510,25 +4510,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
@@ -4541,11 +4541,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
         }
@@ -4755,7 +4755,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 
@@ -4992,7 +4992,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 
@@ -5227,7 +5227,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
@@ -5473,7 +5473,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 
@@ -5605,28 +5605,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
                 }
@@ -5638,15 +5638,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\
@@ -5655,13 +5655,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"
@@ -5669,7 +5669,7 @@ 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
         }
@@ -5680,7 +5680,7 @@ namespace eval textblock {
             #review - are cached frames uniform width lines? 
             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" 
@@ -5691,7 +5691,7 @@ namespace eval textblock {
             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
@@ -5715,7 +5715,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 {
@@ -5739,7 +5739,7 @@ namespace eval textblock {
         }
         #todo args -justify left|centre|right (center)
 
-        set opts [dict create\
+        set opts [tcl::dict::create\
             -etabs 0\
             -type light\
             -boxlimits [list hl vl tlc blc trc brc]\
@@ -5762,27 +5762,27 @@ namespace eval textblock {
         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"} {
@@ -5867,11 +5867,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
         }
@@ -5880,12 +5880,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 {
@@ -5894,7 +5894,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 {
@@ -5903,14 +5903,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
@@ -5919,7 +5919,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 {
@@ -5991,8 +5991,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
                 }
@@ -6013,11 +6013,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
 
         }
@@ -6025,8 +6025,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]
 
 
@@ -6034,7 +6034,7 @@ 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?
@@ -6082,48 +6082,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]
                     
                 }
             }
@@ -6170,10 +6170,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 ""} {
@@ -6194,38 +6194,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]
                     }
                 }
             }
@@ -6284,12 +6284,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]
@@ -6345,10 +6345,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}
@@ -6357,7 +6357,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] ""]
             }
@@ -6376,17 +6376,17 @@ namespace eval textblock {
             #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
@@ -6400,7 +6400,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
         }
@@ -6413,8 +6413,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 
@@ -6472,7 +6472,7 @@ 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
@@ -6498,12 +6498,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
     }
@@ -6514,7 +6514,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 999999.0a1.0 
 }]
diff --git a/src/modules/winlibreoffice-999999.0a1.0.tm b/src/modules/winlibreoffice-999999.0a1.0.tm
index 5afd6ffe..c31fb711 100644
--- a/src/modules/winlibreoffice-999999.0a1.0.tm
+++ b/src/modules/winlibreoffice-999999.0a1.0.tm
@@ -1,5 +1,5 @@
 # -*- tcl -*-
-# Maintenance Instruction: leave the 999999.xxx.x as is and use '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.