From 54e3cf4daf3c1a9f5853be55834f3510ed9dbcca Mon Sep 17 00:00:00 2001
From: Julian Noble <julian@precisium.com.au>
Date: Tue, 3 Oct 2023 22:53:32 +1100
Subject: [PATCH] refactor and move ns commands to punk::ns - namespace
 path-glob search improvements

---
 src/bootsupport/modules/punk/mix-0.2.tm       |    7 +-
 src/modules/punk-0.1.tm                       | 1394 +----------------
 .../mix/commandset/loadedlib-999999.0a1.0.tm  |    8 +-
 src/modules/punk/ns-999999.0a1.0.tm           | 1307 ++++++++++++++++
 src/modules/punk/ns-buildversion.txt          |    3 +
 src/modules/punk/repl-0.1.tm                  |   13 +-
 6 files changed, 1342 insertions(+), 1390 deletions(-)
 create mode 100644 src/modules/punk/ns-999999.0a1.0.tm
 create mode 100644 src/modules/punk/ns-buildversion.txt

diff --git a/src/bootsupport/modules/punk/mix-0.2.tm b/src/bootsupport/modules/punk/mix-0.2.tm
index 837f8690..10d9ca20 100644
--- a/src/bootsupport/modules/punk/mix-0.2.tm
+++ b/src/bootsupport/modules/punk/mix-0.2.tm
@@ -5,6 +5,7 @@ package provide punk::mix [namespace eval punk::mix {
 }]
 
 package require punk::repo
+package rqeuire punk::ns
 
 namespace eval punk::mix::cli {
     namespace ensemble create
@@ -509,14 +510,14 @@ namespace eval punk::mix::cli {
             return false
         }
 
-        set moduleprefix [punk::nsprefix $libfound]
+        set moduleprefix [punk::ns::nsprefix $libfound]
         if {[string length $moduleprefix]} {
-            set moduleprefix_parts [punk::nsparts $moduleprefix]
+            set moduleprefix_parts [punk::ns::nsparts $moduleprefix]
             set relative_path [file join {*}$moduleprefix_parts]
         } else {
             set relative_path ""
         }
-        set pkgtail [punk::nstail $libfound] 
+        set pkgtail [punk::ns::nstail $libfound] 
         set target_path [file join $modulefolder_path $relative_path ${pkgtail}-${ver}.tm]
 
         if {$opt_askme} {
diff --git a/src/modules/punk-0.1.tm b/src/modules/punk-0.1.tm
index 0d7cba23..425a30ca 100644
--- a/src/modules/punk-0.1.tm
+++ b/src/modules/punk-0.1.tm
@@ -73,6 +73,7 @@ namespace eval ::repl {
     variable running 0
 }
 package require punk::config
+package require punk::ns
 package require punk::winpath ;# for windows paths - but has functions that can be called on unix systems
 package require punk::repo
 package require punk::du
@@ -124,7 +125,6 @@ namespace eval punk {
 
     variable last_run_display [list]
     variable colour_disabled 0
-    variable ns_current "::"
     #variable re_headvar1 {([a-zA-Z:@.(),]+?)(?![^(]*\))(,.*)*$}
 
 
@@ -4686,6 +4686,7 @@ namespace eval punk {
         }
         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} {
         if {[llength $args]} {
@@ -5024,7 +5025,7 @@ namespace eval punk {
     }
     #-------------------------------------------------------------------
 
-    namespace export help aliases alias nsjoin nsprefix dirfiles dirfiles_dict exitcode % pipedata pipecase pipeline pipematch pipeswitch pipeswitchc pipecase linelist linesort inspect list_as_lines is_list_all_in_list is_list_all_ni_list val treemore
+    namespace export help aliases alias  dirfiles dirfiles_dict exitcode % pipedata pipecase pipeline pipematch pipeswitch pipeswitchc pipecase linelist linesort inspect list_as_lines is_list_all_in_list is_list_all_ni_list val treemore
 
     #namespace ensemble create
 
@@ -5034,185 +5035,6 @@ namespace eval punk {
     }
 
 
-    #todo - package up as navns
-    proc corp {path} {
-        #thanks to Richard Suchenwirth for the original - wiki.tcl-lang.org/page/corp 
-        #Note: modified here to support aliases and relative/absolute name (with respect to namespace .ie ::name vs name)
-        if {[info exists ::auto_index($path)]} {
-            set body "# $::auto_index($path)\n"
-        } else {
-            set body ""
-        }
-
-        if {[string match ::* $path]} {
-            set targetns [nsprefix $path]
-            set name [nstail $path]
-        } else {
-            set thispath [uplevel 1 [list ::nsthis $path]]
-            set targetns [nsprefix $thispath]
-            set name [nstail $thispath]
-        }
-        #puts stderr "corp upns:$upns"
-
-        #set name [string trim $name :]        
-        #set origin [namespace origin ${upns}::$name]
-        set origin [punk::nseval $targetns [list ::namespace origin $name]]
-
-        #An renamed alias may exist that is the same name as a proc that was created later.. so we must check for the proc before looking into aliases!
-        if {$origin ni [info procs $origin]} {
-
-            #It seems an interp alias of "::x""  behaves the same as "x" 
-            #But we can't create both at the same time - and they have to be queried by the exact name.
-            #So we query for alias with and without leading ::
-            set alias_qualified [interp alias {} [string trim $origin :]]
-            set alias_unqualified [interp alias {} $origin]
-            if {[string length $alias_qualified] && [string length $alias_unqualified]} {
-                #our assumptions are wrong.. change in tcl version?
-                puts stderr "corp: Found alias for unqualified name:'[string trim $origin :]' and qualified name: '$origin' - unexpected (assumed impossible as at Tcl 8.6)"
-                if {$alias_qualified ne $alias_unqalified} {
-
-                } else {
-                    set alias $alias_unqualified
-                }
-            } else {
-                set alias ${alias_qualified}${alias_unqualified} ;#concatenate - as at least one should be empty
-            }
-
-            if {[string length $alias]} {
-                #todo - consider following alias-chain to ultimate proc?
-                #it can always be manually done with:
-                #.= corp $name |/1> corp |/1> corp ..
-                #depending on number of aliases in the chain
-                return [list alias {*}$alias]
-            }
-        } 
-        if {[nsprefix $origin] ne [nsprefix [nsjoin ${targetns} $name]]} {
-            append body "# namespace origin $origin" \n
-        }
-
-        append body [info body $origin]
-        set argl {}
-        foreach a [info args $origin] {
-            if {[info default $origin $a def]} {
-                lappend a $def
-            }
-            lappend argl $a
-        }
-        list proc [nsjoin ${targetns} $name] $argl $body
-    }
-
-    proc nsjoin {prefix name} {
-        if {[string match ::* $name]} {
-            if {"$prefix" ne ""} {
-                error "nsjoin: won't join non-empty prefix to absolute namespace path '$name'"
-            }
-            return $name
-        }
-        if {"$prefix" eq "::"} {
-            return ::$name
-        }
-        #if {"$name" eq ""} {
-        #    return $prefix
-        #}
-        #nsjoin ::x::y ""  should return ::x::y::   - this is the correct fully qualified form used to call a command that is the empty string
-        return ${prefix}::$name
-    }
-    proc nsjoinall {prefix args} {
-        #if {![llength $args]} {
-        #    error "usage: nsjoinall prefix relativens \[relativens ...\]"
-        #}
-        set segments [list $prefix]
-        foreach sub $args {
-            if {[string match ::* $sub]} {
-                if {[string length [concat {*}$segments]]} {
-                    error "nsjoin: won't join non-empty namespace prefix to absolute namespace path '$sub'"
-                }
-            }
-            lappend segments $sub
-        }
-        set nonempty_segments [list]
-        foreach s $segments {
-            if {[string length $s]} {
-                lappend nonempty_segments $s
-            }
-        }
-        if {$prefix eq "::"} {
-            return ::[join [lrange $nonempty_segments 1 end] ::]
-        }
-        return [join $nonempty_segments ::]
-    }
-    proc nsprefix {{nspath ""}} {
-        #normalize the common case of ::::
-        set nspath [string map [list :::: ::] $nspath]
-        set rawprefix [string range $nspath 0 end-[string length [punk::nstail $nspath]]]
-        if {$rawprefix eq "::"} {
-            return $rawprefix
-        } else {
-            if {[string match *:: $rawprefix]} {
-                return  [string range $rawprefix 0 end-2]
-            } else {
-                return $rawprefix
-            }
-            #return [string trimright $rawprefix :]
-        }
-    }
-
-    #namespace tail which handles :::cmd  ::x:::y  ::x:::/y  etc
-    #todo - raise error for unexpected sequences such as ::::  or more than 2 colons together.
-    proc nstail {nspath args} {
-        #normalize the common case of ::::
-        set nspath [string map [list :::: ::] $nspath]
-        set mapped [string map [list :: \u0FFF] $nspath] 
-        set parts [split $mapped \u0FFF]
-
-        set defaults [list -strict 0]
-        set opts [dict merge $defaults $args]
-        set strict [dict get $opts -strict]
-
-        if {$strict} {
-            foreach p $parts {
-                if {[string match :* $p]} {
-                    error "nstail unpaired colon ':' in $nspath"
-                }
-            }
-        }
-
-        #e.g  ::x::y:::z  should return ":z"
-        return [lindex $parts end]
-    }
-
-    #return a list of namespace segments - always with leading empty string for fully qualified namespace (ie for ::x)
-    #'supports' to some extent unreasonable namespaces /commands such as x:  ::x:  ::x:::y
-    #Can be used to either support use of such namespaces/commands - or as part of validation to disallow them 
-    #as opposed to silent behaviour of Tcl namespace commands which don't handle them consistently (for tcl 8.x anyway  Review tcl 9)
-    #Note that for  ::x::   the trailing :: cannot represent a trailing namespace part being an empty string 
-    #This is because Tcl's 'namespace eval "" ""' reports 'only global namespace can have empty name'
-    #NOTE tcl allows creating ambiguous namespaces.  e.g ::punk:::etc:::blah 
-    # is this :: punk :etc :blah  or :: punk :etc: blah 
-    #clearly leading/trailing colons in namespaces and commands are just a bad idea. 
-    #nsparts will prefer leading colon (ie greedy on ::)
-    #This is important to support leading colon commands such as :/
-    # ie ::punk:::jjj:::etc -> :: punk :jjj :etc
-    proc nsparts {nspath} {
-        set nspath [string map [list :::: ::] $nspath]
-        set mapped [string map [list  :: \u0FFF] $nspath] 
-        set parts [split $mapped \u0FFF]
-        if {[lindex $parts end] eq ""} {
-
-        }
-        return $parts
-    }
-
-    #review ???
-    proc ns_relative_to_location {name} {
-        if {[string match ::* $name]} {
-            error "ns_relative_to_location accepts a relative namespace name only ie one without leading ::"
-        }
-
-    }
-    proc ns_absolute_to_location {name} {
-
-    }
 
     #tilde
     #These aliases work fine for interactive use - but the result is always a string int-rep
@@ -5232,964 +5054,6 @@ namespace eval punk {
     interp alias {} ~ {} punk::~
 
 
-
-    interp alias {} nsjoin {} punk::nsjoin
-    interp alias {} nsprefix {} punk::nsprefix
-    interp alias {} nstail {} punk::nstail
-    interp alias {} nsparts {} punk::nsparts
-    interp alias {} nstree  {} punk::nstree
-
-    #tcl 8.x has creative writing var weirdness.. tcl 9 is likely to differ
-    proc nsvars {{nsglob "*"}} {
-        set ns_absolute [uplevel 1 [list punk::nspath_here_absolute $nsglob]]
-        #set commandns [uplevel 1 [list namespace current]]
-
-        set searchns [nsprefix $ns_absolute] ;#the ns within which we want to searchns
-        set searchall [nsjoin $searchns *] ;#will correctly form ::*  or ::childns::*
-
-        set rawresult [info vars $searchall] ;#will not find vars in ::x:::y   etc.  - seems to be impossible in tcl 8.x
-        set matched_fullpath [list]
-        foreach r $rawresult {
-            lappend matched_fullpath [nstail $r]
-        }
-
-        set location [nsprefix $ns_absolute]
-        set tailmatch [nstail $ns_absolute]
-        set raw_matched_in_ns [punk::nseval $location [list ::info vars $tailmatch]]
-        #NOTE: tcl <9 will read vars from global namespace - so we are only checking the intersection here
-        #(this is due to info vars ::etc:::blah failing to handle additional colon)
-        set matched_in_ns [list]
-        set result [list]
-        foreach r $raw_matched_in_ns {
-            set m [nstail $r]
-            lappend matched_in_ns $m
-            if {$m in $matched_fullpath} {
-                lappend result $m
-            }
-        }
-
-
-        return [list_as_lines [lsort $result]]
-        #.= lsort $result |> list_as_lines
-    }
-    interp alias {} nsvars {} punk::nsvars
-    interp alias {} nsorigin {} apply {ns {namespace origin [uplevel 1 nsthis $ns]} ::}
-
-    #todo - walk up each ns - testing for possibly weirdly named namespaces
-    proc nsexists {nspath} {
-
-    }
-
-    #create possibly nested namespace structure - but only if not already existant
-    proc n/new {args} {
-        variable ns_current
-        if {![llength $args]} {
-            error "usage: :/new <ns> \[<ns> ...\]"
-        }
-        set a1 [lindex $args 0]
-        set is_absolute [string match ::* $a1]
-        if {$is_absolute} {
-            set nspath [nsjoinall {*}$args]
-        } else {
-            if {[string match :* $a1]} {
-                puts stderr "n/new WARNING namespace with leading colon '$a1' is likely to have unexpected results"
-            }
-            set nspath [nsjoinall $ns_current {*}$args]
-        }
-
-        set ns_exists [punk::nseval [punk::nsprefix $nspath] [list ::namespace exists [punk::nstail $nspath] ]]
-
-        if {$ns_exists} {
-            error "Namespace $nspath already exists"
-        }
-        #namespace eval [nsprefix $nspath] [list namespace eval [nstail $nspath] {}]
-        punk::nseval [nsprefix $nspath] [list ::namespace eval [nstail $nspath] {}]
-        n/ $nspath
-    }
-
-
-    #nn/ ::/ nsup/ - back up one namespace level
-    proc nsup/ {v args} {
-        variable ns_current
-        if {$ns_current eq "::"} {
-            puts stderr "Already at global namespace '::'"
-        } else {
-            set out ""
-            set nsq [nsprefix $ns_current]
-            if {$v eq "/"} {
-                set out [punk::get_nslist -match [nsjoin $nsq *] -types [list children]]
-            } else {
-                set out [punk::get_nslist -match [nsjoin $nsq *] -types [list all]]
-            }
-            #set out [punk::nslist [nsjoin $nsq *]] 
-            set ns_current $nsq
-            append out "\n$ns_current"
-            return $out
-        }
-    }
-
-
-
-    #experimental
-    #is there ever any difference to {namespace current}?
-    #interp alias {} nsthis     {} .= .= namespace code {namespace current} |> .=* <0/#|
-    #interp alias {} nsthis    {} namespace current
-    
-    interp alias {} nsthis    {} punk::nspath_here_absolute
-    proc nspath_here_absolute {{nspath "\uFFFF"}} {
-        set path_is_absolute [expr {[string match ::* $nspath]}]
-        if {$path_is_absolute} {
-            return $nspath
-        }
-        set ns_caller [uplevel 1 {::namespace current}] ;#must qualify. Needs to be called from arbitrary namespaces where 'namespace' command may exist (e.g tdom::schema)
-        if {$nspath eq "\uFFFF"} {
-            return $ns_caller
-        }
-        #nsjoin will join nscaller with empty nspath to form nscaller::  - which is correct way to represent command named with empty string
-        return [punk::nsjoin $ns_caller $nspath]
-    }
-
-    proc nspath_to_absolute {nspath base} {
-        set path_is_absolute [expr {[string match ::* $nspath]}]
-        if {$path_is_absolute} {
-            return $nspath
-        }
-        if {![string length $nspath]} {
-            return $base
-        }
-        return [punk::nsjoin $base $nspath]
-    }
-
-    #cli command - impure - relies on caller/ns_current
-    proc nslist_dict {{glob "*"}} {
-        set ns_absolute [uplevel 1 [list punk::nspath_here_absolute $glob]]
-        return [get_ns_dicts $ns_absolute]
-    }
-    proc nslist_dict1 {{glob "*"}} {
-        variable ns_current  ;#keep fully qualified ie :: or ::etc
-        set ns_caller [uplevel 1 {namespace current}]
-        puts "nslist_dict ns_caller: $ns_caller  (ns_current: $ns_current)"
-
-        set glob_is_absolute [expr {[string match ::* $glob]}]
-        set globquals [namespace qualifiers $glob]
-        if {[string length $globquals]} {
-            if {$glob_is_absolute} {
-                set fqpath $globquals
-            } else {
-               set fqpath ${ns_caller}::${globquals} 
-            }
-        } else {
-            if {$glob_is_absolute} {
-                set fqpath :: 
-            } else {
-                set fqpath $ns_caller
-            }
-        }
-        #puts stderr ">>fqpath $fqpath"
-        set globtail [nstail $glob]
-        if {[hasglobs $globtail]} {
-            set location $fqpath 
-            set glob $globtail
-        } else {
-
-            if {$fqpath eq "::"} {
-                set location ::${globtail}
-            } else {
-                if {[string length $globtail]} {
-                    set location ${fqpath}::${globtail}
-                } else {
-                    set location ${fqpath}
-                }
-            }
-            set glob *
-        }
-        return [get_nslist_dict ${location}::$glob]
-    }
-
-    #recursive nseval - for introspection of weird namespace trees
-    #approx 10x slower than normal namespace eval - but still only a few microseconds.. fine for repl introspection
-    proc nseval_script {location} {
-        set parts [nsparts $location]
-        if {[lindex $parts 0] eq ""} {
-            lset parts 0 ::
-        }
-        if {[lindex $parts end] eq ""} {
-            set parts [lrange $parts 0 end-1]
-        }
-
-        set body ""
-        set i 0
-        set tails [lrepeat [llength $parts] ""]
-        foreach ns $parts {
-            set cmdlist [list ::namespace eval $ns]
-            set t ""
-            if {$i > 0} {
-                append body " <lb>"
-            }
-            append body $cmdlist
-            if {$i == ([llength $parts] -1)} {
-                append body " <script>"
-            }
-            if {$i > 0} {
-                set t {<rb>}
-            }
-            lset tails $i $t
-            incr i
-        }
-        append body [join [lreverse $tails] " "]
-        #puts stdout "tails: $tails"
-        #puts stdout "i: $i"
-        set body [string map [list <lb> "\{" <rb> "\}"] $body]
-
-        set scr {[::list ::eval [::uplevel <i>  {::set script}]]}
-
-        set up [expr {$i - 1}]
-        set scr [string map [list <i> $up] $scr]
-
-        set body [string map [list <script> $scr] $body]
-        return $body
-    }
-    proc nseval {fqns script} {
-        if {![string match ::* $fqns]} {
-            error "nseval only accepts a fully qualified namespace"
-        }
-        set loc [string map [list :: "_sep_"] $fqns]
-        set cmd ::punk::pipecmds::nseval_$loc
-        if {$cmd ni [info commands $cmd]} {
-            set body ""
-            append body \n [punk::nseval_script $fqns]
-
-            proc $cmd {script} $body
-            debug.punk.pipe.compile {proc $cmd} 6
-        }
-        tailcall $cmd $script
-    }
-    proc nschildren {fqns} {
-        if {![string match ::* $fqns]} {
-            error "nschildren only accespts a fully qualified namespace"
-        }
-        set parent [nsprefix $fqns]
-        set tail [nstail $fqns]
-        #puts ">>> parent $parent tail $tail"
-        set nslist [punk::nseval $parent [list ::namespace children $tail]]
-        return [lsort $nslist]
-    }
-    
-
-
-    #non-contextual - but impure due to state-retrieval from the passed-in namespace part of the fq_glob
-    #returns a list of dicts even if only one ns matched
-    #glob chars at last segment match contents/children of namespaces
-    #glob chars in the path will result in multiple namespaces being matched
-    #e.g  ::tcl::*::d* will match commands beginning with d and child namespaces beginning with d in any namespaces 1 below ::tcl
-    proc get_ns_dicts {fq_glob} {
-        #puts stderr "get_ns_dicts $fq_glob"
-        set glob_is_absolute [expr {[string match ::* $fq_glob]}]
-        if {!$glob_is_absolute} {
-            error "get_ns_dicts requires fully-qualified namespace glob e.g ::*"
-        }
-
-        set location [nsprefix $fq_glob]
-        set glob [nstail $fq_glob]
-        set commands [list]
-        
-
-           # set location [nsprefix $fq_glob]
-           # set glob [nstail $fq_glob]
-           # set allchildren [nschildren $location] ; #only returns 1 level deeper
-           # set commands [.= nscommands [nsjoin ${location} $glob] |> linelist ]
-
-        set nsglob [nsprefix $fq_glob]
-        set glob [nstail $fq_glob]
-        if {[regexp {[*?]} $nsglob]} {
-            set matched_namespaces [punk::nstree_list $nsglob]
-        } else {
-            set matched_namespaces [list $nsglob]
-        }
-        set nsdict_list [list]
-        foreach ch $matched_namespaces {
-            #puts "get_ns_dicts>>> $ch  glob:'$glob'"
-            set allchildren [nschildren $ch] ; #only returns 1 level deeper
-            
-            #nscommands returns exactly one line per entry + a trailing newline. If there is an empty line other than at the end - that is because there is a command named as the empty string.
-            # By default 'linelist'  trims 1st and last empty line. Turn off all block trimming with -block {}
-            set  commands [.= nscommands -raw [nsjoin $ch $glob] |> .=>1 linelist -block {}]
-            #by convention - returning just \n represents a single result of the empty string whereas no results  
-            #after passing through linelist this becomes {} {} which appears as a list of two empty strings.
-            #this is because there isn't a way to represent unambiguously all 3 cases of: empty-list, list of single empty string, list of two empty strings just using \n separated lines 
-            #unless we always return a newline at the tail if there is a result
-            #For this reason nscommands returns a trailing newline - so the last entry should always be empty string - and is a bogus entry
-            #We double-check it here to avoid regressions/mistakes - as nscommands is also a user-level command so there exists the temptation to make it not return the extra newline. 
-            if {[lindex $commands end] eq ""} {
-                set commands [lrange $commands 0 end-1]
-            } else {
-                puts stderr "get_ns_dicts WARNING nscommands didn't return a trailing newline - unexpected"
-            }
-            
-            
-
-            set location $ch 
-            #set exportpatterns [namespace eval $location {::namespace export}]
-            set exportpatterns [punk::nseval $location {::namespace export}]
-            set allexported [list]
-            set matched [list]
-            foreach p $exportpatterns {
-                if {[hasglobs $p]} {
-                    lappend matched {*}[punk::nseval $location [list ::info commands [nsjoin ${location} $p]]]
-                    foreach m $matched {
-                        lappend allexported [punk::nstail $m]
-                    }
-                } else {
-                    lappend allexported $p
-                }
-            }
-            set allexported [lsort -unique $allexported]
-            #NOTE: info procs within namespace eval is different to 'info commands' within namespace eval (info procs doesn't look outside of namespace)
-            set allprocs    [punk::nseval $location {::info procs}]
-            set tails [lmap v $allchildren {nstail $v}]
-            set allaliases [list]
-            set allensembles [list]
-            set allooobjects [list]
-            set allooclasses [list]
-            set allimported [list]
-            set allundetermined [list]
-            set interp_aliases [interp aliases ""]
-            #use aliases glob - because aliases can be present with or without leading ::
-            #NOTE: alias may not have matching command in the relevant namespce (renamed alias) so we can't just start with commands and check if it's an alias if we want to show all aliases
-            set raw_aliases [punk::nseval $location [list ::aliases $glob]] ;#'aliases $glob' must be passed as list, not separate args to namespace eval. 
-            set aliases [list]
-            foreach a $raw_aliases {
-                if {[string match *:: $a]} {
-                    #exception for alias such as ::p::2::  so that it doesn't show up as empty string
-                    #lappend aliases ::
-                    #JMN - 2023 - better to dispaly an empty string somehow
-                    lappend aliases "" 
-                } else {
-                    lappend aliases [punk::nstail $a]
-                }
-            }
-
-            foreach cmd $commands {
-                #if {"${location}::$cmd" in $interp_aliases || [string trimleft "${location}::$cmd" ":"] in $interp_aliases} {
-                #    #NOTE: doesn't cater for renamed aliases - Tcl 8.x doesn't seem to have any introspection capabilities to match command to a renamed alias
-                #    #which_alias hack from wiki relies on trace and executing the command - which we don't want to do.
-                #    lappend allaliases $cmd
-                #}
-
-                if {![catch {namespace ensemble configure ${location}::$cmd} ensemble_info]} {
-                    lappend allensembles $cmd 
-                } elseif {[info object isa object ${location}::$cmd]} {
-                    lappend allooobjects $cmd
-                    if {[info object isa class ${location}::$cmd]} {
-                        lappend allooclasses $cmd
-                    }
-                }
-
-                if {[catch {
-                    if {$cmd eq ""} {
-                        #empty command was previously marked as "::" - too confusing - nslist updated to properly display empty string.
-                        set nsorigin [namespace origin ${location}::]
-                    } elseif {[string match :* $cmd]} {
-                        set nsorigin [punk::nseval $location "::namespace origin $cmd"] 
-                    } else {
-                        set nsorigin [namespace origin [punk::nsjoin $location $cmd]]
-                    }
-                } errM]} {
-                    puts stderr "get_ns_dicts failed to determine origin of command '$cmd' adding to 'undetermined'"
-                    puts stderr "error message: $errM"
-                    lappend allundetermined $cmd
-                } else {
-                    if {[punk::nsprefix $nsorigin] ne $location} {
-                        lappend allimported $cmd
-                    }
-                }
-            }
-            if {$glob ne "*"} {
-                set tailmatches [lsearch -all -inline $tails $glob]
-                set fqchildren [lmap v $tailmatches {lindex ${location}::$v}]  ;#lindex without indices is fast equivalent of 'val'
-                set exported [lsearch -all -inline $allexported $glob]
-                set procs [lsearch -all -inline $allprocs $glob]
-                #set aliases [lsearch -all -inline $allaliases $glob]
-                set ensembles [lsearch -all -inline $allensembles $glob]
-                set ooobjects [lsearch -all -inline $allooobjects $glob]
-                set ooclasses [lsearch -all -inline $allooclasses $glob]
-                set imported [lsearch -all -inline $allimported $glob]
-                set undetermined [lsearch -all -inline $allundetermined $glob]
-            } else {
-                set tailmatches $tails
-                set fqchildren $allchildren
-                set exported $allexported
-                set procs $allprocs
-                #set aliases $allaliases
-                set ensembles $allensembles
-                set ooobjects $allooobjects
-                set ooclasses $allooclasses
-                set imported $allimported
-                set undetermined $allundetermined
-            }
-            set itemcount 0
-            incr itemcount [llength $tailmatches]
-            incr itemcount [llength $commands]
-            incr itemcount [llength $procs]
-            incr itemcount [llength $exported]
-            incr itemcount [llength $imported]
-            incr itemcount [llength $aliases]
-            incr itemcount [llength $ensembles]
-            incr itemcount [llength $ooobjects]
-            incr itemcount [llength $ooclasses]
-            incr itemcount [llength $exportpatterns]
-            incr itemcount [llength $undetermined]
-
-            lappend nsdict_list [dict create\
-                children [lsort $tailmatches]\
-                commands $commands\
-                procs $procs\
-                exported $exported\
-                imported $imported\
-                aliases $aliases\
-                ensembles $ensembles\
-                ooobjects $ooobjects\
-                ooclasses $ooclasses\
-                namespacexport $exportpatterns\
-                undetermined $undetermined\
-                location $location\
-                glob $glob\
-                itemcount $itemcount\
-            ]
-        }
-        return $nsdict_list 
-        #return [list children [lsort $tailmatches] commands $commands procs $procs exported $exported imported $imported aliases $aliases ensembles $ensembles ooobjects $ooobjects ooclasses $ooclasses namespacexport $exportpatterns location $location glob $glob]
-
-    }
-
-    #non-contextual - but impure due to state-retrieval from the passed-in namespace part of the fq_glob
-    proc get_nslist_dict1 {fq_glob} {
-        #puts stderr "get_nslist_dict $fq_glob"
-        set glob_is_absolute [expr {[string match ::* $fq_glob]}]
-        if {!$glob_is_absolute} {
-            error "get_nslist_dict requires fully-qualified namespace glob e.g ::*"
-        }
-        
-        set location [nsprefix $fq_glob]
-        set glob [nstail $fq_glob]
-        set commands [list]
-        if {1} {
-            set location [nsprefix $fq_glob]
-            set glob [nstail $fq_glob]
-
-            set allchildren [nschildren $location] ; #only returns 1 level deeper
-            set commands [.= nscommands [nsjoin ${location} $glob] |> linelist ]
-        } else {
-           set allchildren [punk::nstree_list $fq_glob]
-           foreach ch $allchildren {
-                lappend commands [.= nscommands [nsjoin $ch *] |> linelist]
-           }
-        }
-        
-
-        #set exportpatterns [namespace eval $location {::namespace export}]
-        set exportpatterns [punk::nseval $location {::namespace export}]
-        set allexported [list]
-        set matched [list]
-        foreach p $exportpatterns {
-            if {[hasglobs $p]} {
-                lappend matched {*}[punk::nseval $location [list ::info commands [nsjoin ${location} $p]]]
-                foreach m $matched {
-                    lappend allexported [punk::nstail $m]
-                }
-            } else {
-                lappend allexported $p
-            }
-        }
-        set allexported [lsort -unique $allexported]
-        #NOTE: info procs within namespace eval is different to 'info commands' within namespace eval (info procs doesn't look outside of namespace)
-        set allprocs    [punk::nseval $location {::info procs}]
-        set tails [lmap v $allchildren {nstail $v}]
-        set allaliases [list]
-        set allensembles [list]
-        set allooobjects [list]
-        set allooclasses [list]
-        set allimported [list]
-        set interp_aliases [interp aliases ""]
-
-        #use aliases glob - because aliases can be present with or without leading ::
-        #NOTE: alias may not have matching command in the relevant namespce (renamed alias) so we can't just start with commands and check if it's an alias if we want to show all aliases
-        set raw_aliases [punk::nseval $location [list ::aliases $glob]] ;#'aliases $glob' must be passed as list, not separate args to namespace eval. 
-        set aliases [list]
-        foreach a $raw_aliases {
-            if {[string match *:: $a]} {
-                #exception for alias such as ::p::2::  so that it doesn't show up as empty string
-                lappend aliases ::
-            } else {
-                lappend aliases [punk::nstail $a]
-            }
-        }
-
-        foreach cmd $commands {
-            #if {"${location}::$cmd" in $interp_aliases || [string trimleft "${location}::$cmd" ":"] in $interp_aliases} {
-            #    #NOTE: doesn't cater for renamed aliases - Tcl 8.x doesn't seem to have any introspection capabilities to match command to a renamed alias
-            #    #which_alias hack from wiki relies on trace and executing the command - which we don't want to do.
-            #    lappend allaliases $cmd
-            #}
-
-            if {![catch {namespace ensemble configure ${location}::$cmd} ensemble_info]} {
-                lappend allensembles $cmd 
-            } elseif {[info object isa object ${location}::$cmd]} {
-                lappend allooobjects $cmd
-                if {[info object isa class ${location}::$cmd]} {
-                    lappend allooclasses $cmd
-                }
-            }
-
-            if {$cmd eq "::"} {
-                set nsorigin [namespace origin ${location}:: ]
-            } elseif {[string match :* $cmd]} {
-                set nsorigin [punk::nseval $location "::namespace origin $cmd"] 
-            } else {
-                set nsorigin [namespace origin [punk::nsjoin $location $cmd]]
-            }
-            if {[punk::nsprefix $nsorigin] ne $location} {
-                lappend allimported $cmd
-            }
-        }
-        if {$glob ne "*"} {
-            set tailmatches [lsearch -all -inline $tails $glob]
-            set fqchildren [lmap v $tailmatches {lindex ${location}::$v}]  ;#lindex without indices is fast equivalent of 'val'
-            set exported [lsearch -all -inline $allexported $glob]
-            set procs [lsearch -all -inline $allprocs $glob]
-            #set aliases [lsearch -all -inline $allaliases $glob]
-            set ensembles [lsearch -all -inline $allensembles $glob]
-            set ooobjects [lsearch -all -inline $allooobjects $glob]
-            set ooclasses [lsearch -all -inline $allooclasses $glob]
-            set imported [lsearch -all -inline $allimported $glob]
-        } else {
-            set tailmatches $tails
-            set fqchildren $allchildren
-            set exported $allexported
-            set procs $allprocs
-            #set aliases $allaliases
-            set ensembles $allensembles
-            set ooobjects $allooobjects
-            set ooclasses $allooclasses
-            set imported $allimported
-        }
-
-
-
-        return [list children [lsort $tailmatches] commands $commands procs $procs exported $exported imported $imported aliases $aliases ensembles $ensembles ooobjects $ooobjects ooclasses $ooclasses namespacexport $exportpatterns location $location glob $glob]
-
-    }
-
-    proc nsglob_as_re {glob} {
-        #any segment that is not just * must match exactly one segment in the path
-        set pats [list]
-        foreach seg [punk::nsparts $glob] {
-            if {$seg eq ""} {
-                set seg ""
-            }
-            if {$seg eq "*"} {
-                lappend pats {[^:]*}
-            } elseif {$seg eq "**"} {
-                lappend pats {.*}
-            } else {
-                set seg [string map [list  . {[.]}] $seg]
-                if {[regexp {[*?]} $seg]} {
-                    set pat [string map [list * {[^:]*} ? {[^:]}] $seg]
-                    lappend pats "$pat"
-                } else {
-                    lappend pats "$seg"
-                }
-            }
-        }
-        return  "^[join $pats ::]\$"
-    }
-    proc globmatchns {glob path} {
-        return [regexp [nsglob_as_re $glob] $path]
-    }
-
-    proc nstree {{location ""}} {
-        if {![string match ::* $location]} {
-            set nscaller [uplevel 1 {::namespace current}]
-             set location [punk::nsjoin $nscaller $location] 
-        }
-        list_as_lines [punk::nstree_list $location]
-    }
-
-    proc nsx {path} {
-        set parts [punk::nsparts $path]
-    }
-    proc nstree_list {location args} {
-        #puts "> nstree_list $location $args"
-        set defaults [dict create\
-            -call-depth-internal 0\
-            -subnslist {}\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- ---- --- --- --- ---
-        set CALLDEPTH   [dict get $opts -call-depth-internal]
-        set subnslist   [dict get $opts -subnslist]
-        # -- ---- --- --- --- ---
-    
-        set ns_absolute [uplevel 1 [list punk::nspath_here_absolute $location]]
-
-        set base ""    
-        set tailparts ""
-        if {$CALLDEPTH == 0} { 
-            set parts [punk::nsparts $ns_absolute]
-            lset parts 0 ::
-            set idx 0
-            foreach seg $parts {
-                if {![regexp {[*?]} $seg]} {
-                    set base [nsjoin $base $seg]
-                } else {
-                    set tailparts [lrange $parts $idx end]
-                    break
-                }
-                incr idx
-            }
-        } else {
-           set base $location 
-           set tailparts $subnslist
-        }
-        if {![namespace exists $base]} {
-           return "" 
-        } 
-        #set parent [nsprefix $ns_absolute]
-        #set tail [nstail $ns_absolute]
-
-        set allchildren [lsort [punk::nseval $base [list ::namespace children]]]
-
-        #puts "->base:$base tailparts:$tailparts allchildren: $allchildren"
-
-        set nextglob [lindex $tailparts 0]
-        if {$nextglob ne "**"} {
-            set nslist [list]
-            if {[llength $tailparts]} {
-                set nsmatches [lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]::*]
-                lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
-            } else {
-                set nsmatches $allchildren
-            }
-            #return
-
-            foreach ch $nsmatches {
-                lappend nslist $ch
-                lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}]] 
-            }
-        } else {
-           set nslist [nstree_list $base -subnslist {}] 
-        }
-
-        #foreach ns $nslist {
-        #    puts "== $ns"
-        #}
-        set nslist_filtered [list]
-        if {$CALLDEPTH == 0} {
-            #puts "--base: $base"
-            #puts "-- globmatchns [nsjoin ${ns_absolute} **]"
-            #puts "-- globmatchns ${ns_absolute}"
-            if {$base ni $nslist} {
-                #puts stderr "> adding $base to $nslist"
-                set nslist [list $base {*}$nslist]
-            } 
-            foreach ns $nslist {
-                if {[globmatchns ${ns_absolute} $ns] || [globmatchns [nsjoin ${ns_absolute} **] $ns]} {
-                    lappend nslist_filtered $ns
-                }
-            } 
-            return $nslist_filtered
-        }
-        return $nslist
-    }
-
-    proc nslist {{glob "*"} args} {
-        set ns_absolute [uplevel 1 [list punk::nspath_here_absolute $glob]]
-        if {[dict exists $args -match]} {
-           error "nslist requires positional argument 'glob' instead of -match option" 
-        }
-        set defaults [dict create\
-            -match $ns_absolute
-        ]
-        package require textblock
-        set opts [dict merge $defaults $args]
-        set ns_matches [get_ns_dicts $ns_absolute] 
-        set with_results [list]
-        foreach nsdict $ns_matches {
-            if {[dict get $nsdict itemcount]>0} {
-                lappend with_results $nsdict
-            }
-        }
-        set count_with_results [llength $with_results]
-        set output ""
-        foreach nsdict $with_results {
-            dict set opts -nsdict $nsdict
-            set block [get_nslist {*}$opts]
-            if {[string first \n $block] < 0} {
-                #single line
-                set width [textblock::width [list $block]]
-            } else {
-                set width [textblock::width $block]
-            }
-            if {$width > 0} {
-                append output \n [dict get $nsdict location] \n
-                append output $block
-                if {$count_with_results > 1} {
-                    append output \n [string repeat - $width] 
-                }
-            }
-        }
-        return $output
-    }
-
-    #REVIEW - ansi codes can be *very*  confusing to the user when trying to handle lists etc..
-    proc get_nslist {args} {
-   
-        set known_types [list children commands exported imported aliases procs ensembles ooclasses ooobjects]
-        set defaults [dict create\
-            -match ""\
-            -types $known_types\
-            -nsdict ""\
-        ]
-        set opts [dict merge $defaults $args]
-        # -- --- --- --- --- --- --- --- --- --- 
-        set fq_glob             [dict get $opts -match]
-        set requested_types     [dict get $opts -types]
-        set opt_nsdict          [dict get $opts -nsdict]
-
-        set types $requested_types
-        if {"all" in $requested_types} {
-            foreach t $known_types {
-                if {$t ni $types} {
-                    lappend types $t
-                }
-            }
-        }
-        if {"oo" in $requested_types} {
-            if {"ooclasses" ni $types} {
-                lappend types "ooclasses"
-            }
-            if {"ooobjects" ni $types} {
-                lappend types "ooobjects"
-            }
-        }
-        foreach t $types {
-            if {$t in [list "oo" "all"]} {
-                continue
-            }
-            if {$t ni $known_types} {
-                error "Unrecognised namespace member type: $t known types: $known_types"
-            }
-        }
-
-        set glob_is_absolute [expr {[string match ::* $fq_glob]}]
-        if {!$glob_is_absolute} {
-            error "get_nslist requires fully-qualified namespace glob e.g ::*"
-        }
-        #2 columns for namespaces 4 for commands/procs/aliases - todo make less duplicated - generalize to specified number of columns for each?
-        #NOTE aliases may not be commands in current namespace - but we want to show them (marked red and with R)
-        #
-
-        set children [list]
-        set commands [list]
-        set exported [list]
-        set imported [list]
-        set aliases  [list]
-        set procs    [list]
-        set ensembles [list]
-        set ooclasses [list]
-        set ooobjects [list]
-
-        if {$opt_nsdict eq ""} {
-            set nsmatches [get_ns_dicts $fq_glob] 
-            set itemcount 0
-            set matches_with_results [list]
-            foreach nsinfo $nsmatches {
-                set itemcount [dict get $nsinfo itemcount] 
-                if {$itemcount > 0} {
-                    lappend matches_with_results $nsinfo
-                } 
-            }
-            if {[llength $matches_with_results] == 1} {
-               set contents [lindex $matches_with_results 0]
-            } elseif {[llength $matches_with_results] > 1} {
-               puts stderr "get_nslist WARNING: more than one ([llength $matches_with_results]) namespace had results for the pattern '$fq_glob'. Displaying only first. Consider calling get_ns_dicts and passing results to get_nslist one at a time using -nsdict option" 
-               set contents [lindex $matches_with_results 0]
-            } else {
-                return "- no results -"
-            }
-        } else {
-            set contents $opt_nsdict
-            if {[dict get $opt_nsdict itemcount] == 0} {
-                return "- no results -"
-            }
-        }
-        set ns       [dict get $contents location] 
-
-        package require overtype
-        if {"children" in $types} {
-            set children [dict get $contents children]
-        }
-        if {"commands" in $types} {
-            set commands [dict get $contents commands]
-            if {"exported" in $types} {
-                set exported [dict get $contents exported]
-            }
-            if {"imported" in $types} {
-                set imported [dict get $contents imported]
-            }
-            if {"aliases" in $types} {
-                set aliases  [dict get $contents aliases]
-            }
-            if {"procs" in $types} {
-                set procs    [dict get $contents procs]
-            }
-            if {"ensembles" in $types} {
-                set ensembles [dict get $contents ensembles]
-            }
-            if {"ooclasses" in $types} {
-                set ooclasses [dict get $contents ooclasses]
-            }
-            if {"ooobjects" in $types} {
-               set ooobjects [dict get $contents ooobjects]
-            }
-        }
-
-        set numchildren [llength $children]
-        if {$numchildren} {
-           set mid [expr {int(ceil($numchildren/2.0))}]
-           set children1 [lrange $children 0 $mid-1]
-           set children2 [lrange $children $mid end]
-        } else {
-            set children1 [list]
-            set children2 [list]
-        }
-
-        #elements are commands and possibly renamed aliases which may or may not have been renamed into the current namespace
-        #a command could be an empty string or something else weird. 
-        #Primarily just to handle empty string command - we will wrap each command as a 2-part element here
-        #(our foreach loop needs to ignore missing commands - but not empty string)
-        set elements [lmap v $commands {list c $v}]
-
-        set seencmds [list]
-        set masked [list] ;# 
-        foreach a $aliases {
-            if {[list c $a] in $elements} {
-                #possibly an ordinary alias - or a renamed alias that is masked by a proc/ensemble/oo 
-                #we can detect masking by proc/ensemble/oo - but not by a binary extension loaded after the rename:  REVIEW
-                if {$a in [concat $procs $ensembles $ooclasses $ooobjects]} {
-                    #we have an alias that is also a known other command-type
-                    lappend elements [list c $a] ;#add in twice so we can display both.
-                    lappend  masked $a
-                }
-            } else {
-                #a renamed-alias
-                lappend elements [list c $a]
-            }
-        }
-        set elements [lsort -index 1 $elements]
-        
-        
-        set numelements [llength $elements]
-        if {$numelements} {
-            set split1 [expr {int(ceil($numelements/4.0))}]
-            set elements1 [lrange $elements 0 $split1-1]
-            set remaining3 [lrange $elements $split1 end]
-
-            set numremaining3 [llength $remaining3] 
-            set split2 [expr {int(ceil($numremaining3/3.0))}]
-            set elements2 [lrange $remaining3 0 $split2-1]
-            set remaining2 [lrange $remaining3 $split2 end]
-
-            set numremaining2 [llength $remaining2]
-            set mid [expr {int(ceil($numremaining2/2.0))}]
-            set elements3 [lrange $remaining2 0 $mid-1]
-            set elements4 [lrange $remaining2 $mid end]
-
-        } else {
-            set elements1 [list]
-            set elements2 [list]
-            set elements3 [list]
-            set elements4 [list]
-        }
-
-
-
-        set chwidest1 [pipedata [list {*}$children1 ""] {lmap v $data {string length $v}}  {tcl::mathfunc::max {*}$data}]
-        set chwidest2 [pipedata [list {*}$children2 ""] {lmap v $data {string length $v}}  {tcl::mathfunc::max {*}$data}]
-
-        #wrap the cmd in [list] (just for the width calc) to get a proper length for what will actually be displayed
-        set cmdwidest1 [pipedata [list {*}$elements1 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-        set cmdwidest2 [pipedata [list {*}$elements2 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-        set cmdwidest3 [pipedata [list {*}$elements3 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-        set cmdwidest4 [pipedata [list {*}$elements4 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
-
-        set displaylist [list]
-        set col1 [string repeat " " [expr {$chwidest1 + 8}]]
-        set col2 [string repeat " " [expr {$chwidest2 + 8}]]
-        set col3 [string repeat " " [expr {$cmdwidest1 + 8}]]
-        set col4 [string repeat " " [expr {$cmdwidest2 + 8}]]
-        set col5 [string repeat " " [expr {$cmdwidest3 + 8}]]
-        set a [a+ purple bold]
-        set e [a+ yellow bold]
-        set o [a+ cyan bold]
-        set p [a+ white bold]
-        foreach ch1 $children1 ch2 $children2 cmd1 $elements1 cmd2 $elements2 cmd3 $elements3 cmd4 $elements4 {
-            set a1 [a+ cyan]
-            set c1 [a+ white]
-            set c2 [a+ white]
-            set c3 [a+ white]
-            set c4 [a+ white]
-
-            for {set i 1} {$i <= 4} {incr i} {
-                if {[llength [set cmd$i]]} {
-                    set c [a+ white]
-                    set prefix "     "
-                    set element [set cmd$i]
-                    set cmd [lindex $element 1]
-                    set cmd_display [list $cmd] ;#wrap in list so empty command is visible (and distinguishable from for example a double-curly command)
-                    if {$cmd ni $commands && $cmd in $aliases } {
-                        #ordinary un-masked commandless-alias
-                        set c [a+ red bold]
-                        set prefix "${a}als  "
-                        set prefix [overtype::right $prefix "-R"]
-                    } else {
-                        if {$cmd in $exported} {
-                            set c [a+ green bold]
-                        }
-                        if {$cmd in $aliases && $cmd in $seencmds} {
-                            #masked commandless-alias
-                            #assert member of masked - but we use seencmds instead to detect.
-                            set c [a+ yellow bold]
-                            set prefix "${a}als  "
-                            set prefix [overtype::right $prefix "-R"]
-                        } elseif {$cmd in $procs} {
-                            set prefix "${p}prc  "
-                        } elseif {$cmd in $ensembles} {
-                            set prefix "${e}ens  "
-                        } elseif {$cmd in $ooclasses} {
-                            set prefix "${o}ooc  "
-                        } elseif {$cmd in $ooobjects} {
-                            set prefix "${o}ooo  "
-                        } elseif {$cmd in $aliases} {
-                            set prefix "${a}als  "
-                        } else {
-                        }
-                        if {$cmd in $imported} {
-                            set prefix [overtype::right $prefix "-[a+ yellow bold]I[a+]"]
-                        }
-                    }
-                    set cmd$i "${prefix} $c$cmd_display"
-                    set c$i $c 
-                    lappend seencmds $cmd
-                }
-            }
-
-            lappend displaylist $a1[overtype::left $col1 $ch1][a+]$a1[overtype::left $col2 $ch2][a+]$c1[overtype::left $col3 $cmd1][a+]$c2[overtype::left $col4 $cmd2][a+]$c3[overtype::left $col5 $cmd3][a+]$c4$cmd4[a+]
-        }
-    
-        return [list_as_lines $displaylist]
-    }
-
     #todo - package as punk::navdir 
     #todo - in thread
     #todo - streaming version
@@ -6446,94 +5310,8 @@ namespace eval punk {
     }
 
 
-    #extra slash implies more verbosity (ie display commands instead of just nschildren)
-    interp alias {} :/ {} punk::ns/ /
-    interp alias {} :// {} punk::ns/ //
-    interp alias {} n/ {} punk::ns/ /
-    interp alias {} n// {} punk::ns/ //
-    interp alias {} ::/ {} punk::nsup/ /
-    interp alias {} ::// {} punk::nsup/ //
-    interp alias {} nn/ {} punk::nsup/ /
-    interp alias {} nn// {} punk::nsup/ //
-    interp alias {} :/new {} punk::n/new
-    interp alias {} n/new {} punk::n/new
-
-    #experimental... leading colon makes it hard (impossible?) to call directly if not within the namespace 
-    #todo - change semantics of args - it's not particularly useful to pass namespaces as separated items - would be better to accept options (e.g nslist option -types)
-    proc ns/ {v args}  {
-        variable ns_current ;#change active ns of repl by setting ns_current
-
-        set ns_caller [uplevel 1 {::namespace current}]
-        #puts stderr "ns_cur:$ns_current ns_call:$ns_caller"
-
-        if {![llength $args]} {
-            #set out [punk::get_nslist $ns_current]
-            if {$v eq "/"} {
-                #set out [punk::get_nslist -match [nsjoin $ns_current *] -types [list children]]
-                set out [punk::nslist [nsjoin $ns_current *] -types [list children]]
-            } else {
-                #set out [punk::get_nslist -match [nsjoin $ns_current *] -types [list all]]
-                set out [punk::nslist [nsjoin $ns_current *] -types [list all]]
-            }
-            #todo - cooperate with repl
-           
-            set ns_display "\n$ns_current"
-            if {$ns_current in [info commands $ns_current] } {
-                if {![catch [list namespace ensemble configure $ns_current] ensemble_info]} {
-                    if {[llength $ensemble_info] > 0} {
-                        #this namespace happens to match ensemble command. 
-                        #todo - keep cache of encountered ensembles from commands.. and examine namespace in the configure info.
-                        set ns_display  "\n[a+ yellow bold]$ns_current[a+]"
-                    }
-                }
-            }
-            append out $ns_display
-            return $out
-        } else {
-            set atail [lassign $args a1]
-            if {$a1 in [list :: ""]} {
-                set ns_current ::
-                tailcall punk::ns/ $v {*}$atail
-            }
-            set is_absolute [string match ::* $a1]
-            if {$is_absolute} {
-                if {![llength $atail] && [regexp {[*?]} $a1]} {
-                    #set out [punk::get_nslist -match $a1]
-                    set out [punk::nslist $a1]
-                    append out "\n$a1"
-                    return $out
-                }
-                set nsparent [nsprefix $a1]
-                set nstail [punk::nstail $a1]
-                if {[punk::nseval $nsparent [list ::namespace exists $nstail]]} {
-                    set ns_current $a1
-                    tailcall punk::ns/ $v {*}$atail
-                }
-                error "cannot change to namespace $a1"
-            } else {
-                set nsnext [nsjoin $ns_current $a1]
-                if {![llength $atail] && [regexp {[*?]} $a1]} {
-                    #set out [punk::get_nslist -match $nsnext]
-                    set out [punk::nslist $nsnext]
-                    append out "\n$nsnext"
-                    return $out
-                }
-
-                if {[punk::nseval $ns_current [list ::namespace exists $a1]]} {
-                    set ns_current $nsnext
-                    tailcall punk::ns/ $v {*}$atail
-                } else {
-                    error "cannot change to namespace $nsnext"
-                }
-            }
-        }
-    }
-
-    #
-
 
     proc d/new {args} {
-        variable ns_current
         if {![llength $args]} {
             error "usage: d/new <dir> \[<dir> ...\]"
         }
@@ -7161,8 +5939,8 @@ namespace eval punk {
     proc linelistraw {args} {
         set linelist [list]
         foreach {a} $args {
-            set nsplit [split $a \n]
-            lappend linelist {*}$nsplit
+            set nlsplit [split $a \n]
+            lappend linelist {*}$nlsplit
         }
         #return [split $text \n]
         return $linelist
@@ -7170,17 +5948,17 @@ namespace eval punk {
     proc linelist1 {args} {
         set linelist [list]
         foreach {a} $args {
-            set nsplit [split $a \n]
+            set nlsplit [split $a \n]
             set start 0
             set end "end"
 
-            if {[lindex $nsplit 0] eq ""} {
+            if {[lindex $nlsplit 0] eq ""} {
                 set start 1
             }
-            if {[lindex $nsplit end] eq ""} {
+            if {[lindex $nlsplit end] eq ""} {
                 set end "end-1"
             }
-            set alist [lrange $nsplit $start $end]
+            set alist [lrange $nlsplit $start $end]
             lappend linelist {*}$alist
         }
         return $linelist
@@ -7242,12 +6020,12 @@ namespace eval punk {
         if {[string first \n $text] < 0} {
             return $text
         }
-        set nsplit [split $text \n]
+        set nlsplit [split $text \n]
         if {![llength $opt_line]} {
-            set linelist $nsplit
-            #lappend linelist {*}$nsplit
+            set linelist $nlsplit
+            #lappend linelist {*}$nlsplit
         } else {
-            foreach ln $nsplit {
+            foreach ln $nlsplit {
                 #already normalized trimleft+trimright to trimline
                 if {"trimline" in $opt_line} {
                     lappend linelist [string trim $ln]  
@@ -7317,7 +6095,7 @@ namespace eval punk {
     proc linedict {args} {
         set data [lindex $args 0]
         set opts [lrange $args 1 end] ;#todo 
-        set nsplit [split $data \n]
+        set nlsplit [split $data \n]
         set rootindent -1
         set stepindent -1
 
@@ -7327,7 +6105,7 @@ namespace eval punk {
         set i 1
         set firstkeyline "N/A"
         set firststepline "N/A"
-        foreach ln $nsplit {
+        foreach ln $nlsplit {
             if {![string length [string trim $ln]]} {
                 incr i
                 continue
@@ -7592,7 +6370,7 @@ namespace eval punk {
     proc aliases {{glob *}} {
         set ns [uplevel 1 {::namespace current}] ;#must use :: - we can find ourselves in a namespace with a differen 'namespace' command
         set ns_mapped [string map [list :: \uFFFF] $ns] 
-        #puts stderr "ns: $ns_mapped"
+        #puts stderr "aliases ns: $ns_mapped"
         set segments [split $ns_mapped \uFFFF] ;#include empty string before leading ::
         if {![string length [lindex $segments end]]} {
             #special case for ::  only include leading segment rather thatn {} {}
@@ -7699,7 +6477,6 @@ namespace eval punk {
     #interp alias {} c {} clear   ;#external executable 'clear' may not always be available
     interp alias {} clear {} repl::term::reset
     interp alias {} c {} repl::term::reset
-    
 
     interp alias {} help {} punk::help
     interp alias {} aliases {} punk::aliases
@@ -7718,7 +6495,7 @@ namespace eval punk {
     #NOTE: anomalies in standard tcl processing on windows:
     #e.g file normalize {//host} -> c:/host
     #file normalize {//host/share} -> //host/share
-    #To get back to some consistent cross platform behaviour - we will define //something as a root/volume i.e we can't backtrack above it with ..
+    #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 doubleslash1_posn [string first // $path] 
@@ -7761,7 +6538,6 @@ namespace eval punk {
     interp alias {} list_filter_cond {} punk::list_filter_cond
     interp alias {} is_list_all_in_list {} punk::is_list_all_in_list
     interp alias {} is_list_all_ni_list {} punk::is_list_all_ni_list
-    interp alias {} corp       {} punk::corp
     interp alias {} inspect       {} punk::inspect
     interp alias {} ooinspect       {} punk::ooinspect
     interp alias {} pdict         {} punk::pdict
@@ -7785,139 +6561,6 @@ namespace eval punk {
 
 
 
-    interp alias {} nscommands1 {} .= ,'ok'@0.= {
-            set commandns [namespace current]
-            #upvar caseresult caseresult
-            inspect -label namespace_current [namespace current]
-            inspect -label nsthis [nsthis]
-            inspect -label nsthis2 [nsthis2]
-            inspect -label commandns $commandns
-            inspect -label info_procs [info procs]
-            #by using pipeswitch instead of pipeswitchc - we give the ability* for the switch script block to affect vars in the calling scope
-            # (*not a desirable feature from a functional point of view - but useful for debugging, and also potentially faster )
-            pipeswitch {
-                #no glob chars present
-                if {![llength $ns]} {
-                    set ns $commandns
-                } else {
-                    if {![string match ::* $ns]} {
-                        if {$commandns eq "::"} {set commandns ""}
-                        set ns ${commandns}::$ns
-                    }
-                }
-                inspect '$ns'
-                pipecase \
-                    caseresult= $ns |input> \
-                    1.= {expr {[string length [string map [list * "" ? ""] $data]] == [string length $data]}} |>  {
-                        #uplevel 1 [list info commands ${input}::*]
-                        info commands ${input}::*
-                    }
-
-                #pipecase1 ns has one or more of glob chars * or ?
-                pipecase \
-                    caseresult= $ns |input>  {
-                        #uplevel 1 [list info commands ${input}]
-                        info commands ${input}
-                    }
-            }
-        } |data@@ok/result>  {lmap v $data {punk::nstail $v}} |> lsort |> {join $data \n} <ns/0| 
-
-    #Must be no ansi when only single arg used.
-    #review - ansi codes will be very confusing in some scenarios! 
-    #todo - only output color when requested (how?) or via repltelemetry ?
-    interp alias {} nscommands {} .= ,'ok'@0.= {
-
-            #Note: namespace argument to apply doesn't accept namespace segments with leading colon - so pipelines won't work fully in dodgily-named namespaces such as :::x
-            #inspect -label namespace_current [namespace current]
-            #inspect -label info_procs [info procs]
-
-            ::set commandns [::namespace current]
-            ::set commandlist [::list]
-            #color code multiple args? - not very practical if many ns args supplied, but then... common case will only be 1 or 2 anyway
-            #colors can be stripped by caller with ansistrip - but we'll make the default case easier by using no ansi codes if a single arg is passed 
-            ::set colors [::list none cyan yellow green]
-            ::set ci 0 ;#colourindex
-            ::set do_raw 0
-            ::if {[::set posn [::lsearch $searchlist -raw]] >= 0} {
-                ::set searchlist [::lreplace $searchlist $posn $posn]
-                ::set do_raw 1 
-            }
-            ::if {![::llength $searchlist]} {
-                ::lappend searchlist *
-            }
-            ::foreach search $searchlist {
-                ::if {$ci > [::llength $colors]-1} {
-                    ::set ci 0
-                }
-                #by using pipeswitch instead of pipeswitchc - we give the ability* for the switch script block to affect vars in the calling scope
-                # (*not a desirable feature from a functional point of view - but useful for debugging, and also potentially faster )
-                ::if {$ci == 0 || $do_raw} {
-                    ::set col ""
-                    ::set rst ""
-                } else {
-                    ::set col [a+ [::lindex $colors $ci] bold]
-                    ::set rst [a+]
-                }
-                ::incr ci ;#colourindex
-                #inspect -label search $search
-                
-                ::if {![::llength $search]} {
-                    ::set base $commandns
-                    ::set what "*"
-                } else {
-                    ::if {[::string match ::* $search]} {
-                        ::set base [nsprefix $search]
-                        ::set what [nstail $search]
-                    } else {
-                        ::set base $commandns
-                        ::set what $search
-                    }
-                }
-
-                ::set all_ns_commands [::info commands [punk::nsjoin $base $what]]
-                #important not to call namespace eval (or punk::nseval) on non-existant base - or it will be created
-                ::if {![::namespace exists $base]} {
-                   ::continue 
-                }
-
-                #NOTE - matched commands will return commands from global ns due to 'namespace eval'
-                #We don't simply do info commands ${base}::$what  because it misses some oddly named things (JMN 2023 - like what?)
-                ::set matchedcommands [::pipeswitch {
-                    #inspect '$ns'
-                    #pipecase \
-                    #    caseresult= $ns |input> \
-                    #    1.= {expr {[string length [string map [list * "" ? ""] $data]] == [string length $data]}} |>  { info commands ${input}::* }
-
-                    #pipecase \
-                    #    caseresult= $ns |input>  { info commands ${input} }
-
-                    ::pipecase \
-                        caseresult.= ::list $base $what |,basens/0,g/1>  {punk::nseval $basens [::list ::info commands $g]}
-
-                }]
-                #lappend commandlist {*}[@@ok/result= $matchedcommands]
-
-                #need to pull result from matchedcommands dict
-                #set cmd_tails [@@ok/result= $matchedcommands |> {::lmap v $data {punk::nstail $v}}]
-                
-                ::set cmd_tails [::lmap v [::dict get $matchedcommands ok result] {punk::nstail $v}]
-
-                ::set all_ns_tails [::lmap v $all_ns_commands {punk::nstail $v}]
-
-                ::foreach c $cmd_tails {
-                    ::if {$c in $all_ns_tails} {
-                        ::if {$do_raw} {
-                            ::lappend commandlist [::list $c $c]
-                        } else {
-                            ::lappend commandlist [::list $c $col[::list $c]$rst]
-                        }
-                    }
-                }
-            }
-            ::list ok [::list result $commandlist]
-            #unless we always return trailing \n - it's impossible to represent a list containing only the empty string using \n (cannot disambiguate between empty list and/or list of 2 empty strings)
-            #we use the convention that a result of just \n represents a list of just the empty string - as we don't require duplicates anyway - so it shouldn't mean two empty strings.
-        }  |data@@ok/result> ::lsort -index 0  |> {::lmap v $data {::lindex $v 1}} |> {::if {![::llength $data]} {::return {}} else {::return [::join $data \n]\n}} <searchlist|  
 
     #interp alias {} = {} ::punk::pipeline = "" ""
     #interp alias {} = {} ::punk::match_assign "" ""
@@ -7951,9 +6594,6 @@ namespace eval punk {
     interp alias {} dirfiles {} punk::dirfiles
     interp alias {} dirfiles_dict {} punk::dirfiles_dict
     
-    #namespace/command/proc query
-    interp alias {} nslist {} punk::nslist
-    interp alias {} nslist_dict {} punk::nslist_dict
 
     if {$::tcl_platform(platform) eq "windows"} {
         set has_powershell 1
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 e93980e6..4a6d1100 100644
--- a/src/modules/punk/mix/commandset/loadedlib-999999.0a1.0.tm
+++ b/src/modules/punk/mix/commandset/loadedlib-999999.0a1.0.tm
@@ -17,7 +17,7 @@
 # ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
 ##  Requirements
 ##e.g package require frobz
-
+package require punk::ns
 
 
 
@@ -442,14 +442,14 @@ namespace eval punk::mix::commandset::loadedlib {
         }
         # -- ---------------------------------------
 
-        set moduleprefix [punk::nsprefix $libfound]
+        set moduleprefix [punk::ns::nsprefix $libfound]
         if {[string length $moduleprefix]} {
-            set moduleprefix_parts [punk::nsparts $moduleprefix]
+            set moduleprefix_parts [punk::ns::nsparts $moduleprefix]
             set relative_path [file join {*}$moduleprefix_parts]
         } else {
             set relative_path ""
         }
-        set pkgtail [punk::nstail $libfound] 
+        set pkgtail [punk::ns::nstail $libfound] 
         set target_path [file join $modulefolder_path $relative_path ${pkgtail}-${ver}.tm]
 
         if {$opt_askme} {
diff --git a/src/modules/punk/ns-999999.0a1.0.tm b/src/modules/punk/ns-999999.0a1.0.tm
new file mode 100644
index 00000000..b81632de
--- /dev/null
+++ b/src/modules/punk/ns-999999.0a1.0.tm
@@ -0,0 +1,1307 @@
+# -*- tcl -*-
+# Maintenance Instruction: leave the 999999.xxx.x as is and use 'pmix make' or src/make.tcl to update from <pkg>-buildversion.txt
+#
+# Please consider using a BSD or MIT style license for greatest compatibility with the Tcl ecosystem.
+# Code using preferred Tcl licenses can be eligible for inclusion in Tcllib, Tklib and the punk package repository.
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+# (C) 2023
+#
+# @@ Meta Begin
+# Application punk::ns 999999.0a1.0
+# Meta platform     tcl
+# Meta license      <unspecified>
+# @@ Meta End
+
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Requirements
+##e.g package require frobz
+
+
+namespace eval ::punk_dynamic::ns {
+
+}
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+namespace eval punk::ns {
+    variable ns_current "::"
+    namespace export nsjoin nsprefix nstail nsparts nseval
+
+    #leading colon makes it hard (impossible?) to call directly if not within the namespace 
+    #todo - change semantics of args - it's not particularly useful to pass namespaces as separated items - would be better to accept options (e.g nslist option -types)
+    proc ns/ {v args}  {
+        variable ns_current ;#change active ns of repl by setting ns_current
+
+        set ns_caller [uplevel 1 {::namespace current}]
+        #puts stderr "ns_cur:$ns_current ns_call:$ns_caller"
+
+        if {![llength $args]} {
+            #set out [get_nslist $ns_current]
+            if {$v eq "/"} {
+                set out [nslist [nsjoin $ns_current *] -types [list children]]
+            } else {
+                set out [nslist [nsjoin $ns_current *] -types [list all]]
+            }
+            #todo - cooperate with repl
+           
+            set ns_display "\n$ns_current"
+            if {$ns_current in [info commands $ns_current] } {
+                if {![catch [list namespace ensemble configure $ns_current] ensemble_info]} {
+                    if {[llength $ensemble_info] > 0} {
+                        #this namespace happens to match ensemble command. 
+                        #todo - keep cache of encountered ensembles from commands.. and examine namespace in the configure info.
+                        set ns_display  "\n[a+ yellow bold]$ns_current[a+]"
+                    }
+                }
+            }
+            append out $ns_display
+            return $out
+        } else {
+            set atail [lassign $args a1]
+            if {$a1 in [list :: ""]} {
+                set ns_current ::
+                tailcall ns/ $v {*}$atail
+            }
+            set is_absolute [string match ::* $a1]
+            if {$is_absolute} {
+                if {![llength $atail] && [regexp {[*?]} $a1]} {
+                    #set out [get_nslist -match $a1]
+                    set out [nslist $a1]
+                    append out "\n$a1"
+                    return $out
+                }
+                set nsparent [nsprefix $a1]
+                set nstail [nstail $a1]
+                if {[nseval $nsparent [list ::namespace exists $nstail]]} {
+                    set ns_current $a1
+                    tailcall ns/ $v {*}$atail
+                }
+                error "cannot change to namespace $a1"
+            } else {
+                set nsnext [nsjoin $ns_current $a1]
+                if {![llength $atail] && [regexp {[*?]} $a1]} {
+                    #set out [get_nslist -match $nsnext]
+                    set out [nslist $nsnext]
+                    append out "\n$nsnext"
+                    return $out
+                }
+
+                if {[nseval $ns_current [list ::namespace exists $a1]]} {
+                    set ns_current $nsnext
+                    tailcall ns/ $v {*}$atail
+                } else {
+                    error "cannot change to namespace $nsnext"
+                }
+            }
+        }
+    }
+
+
+    #create possibly nested namespace structure - but only if not already existant
+    proc n/new {args} {
+        variable ns_current
+        if {![llength $args]} {
+            error "usage: :/new <ns> \[<ns> ...\]"
+        }
+        set a1 [lindex $args 0]
+        set is_absolute [string match ::* $a1]
+        if {$is_absolute} {
+            set nspath [nsjoinall {*}$args]
+        } else {
+            if {[string match :* $a1]} {
+                puts stderr "n/new WARNING namespace with leading colon '$a1' is likely to have unexpected results"
+            }
+            set nspath [nsjoinall $ns_current {*}$args]
+        }
+
+        set ns_exists [nseval [nsprefix $nspath] [list ::namespace exists [nstail $nspath] ]]
+
+        if {$ns_exists} {
+            error "Namespace $nspath already exists"
+        }
+        #namespace eval [nsprefix $nspath] [list namespace eval [nstail $nspath] {}]
+        nseval [nsprefix $nspath] [list ::namespace eval [nstail $nspath] {}]
+        n/ $nspath
+    }
+
+
+    #nn/ ::/ nsup/ - back up one namespace level
+    proc nsup/ {v args} {
+        variable ns_current
+        if {$ns_current eq "::"} {
+            puts stderr "Already at global namespace '::'"
+        } else {
+            set out ""
+            set nsq [nsprefix $ns_current]
+            if {$v eq "/"} {
+                set out [get_nslist -match [nsjoin $nsq *] -types [list children]]
+            } else {
+                set out [get_nslist -match [nsjoin $nsq *] -types [list all]]
+            }
+            #set out [nslist [nsjoin $nsq *]] 
+            set ns_current $nsq
+            append out "\n$ns_current"
+            return $out
+        }
+    }
+
+    #todo - walk up each ns - testing for possibly weirdly named namespaces
+    #review - do we even need it.
+    proc nsexists {nspath} {
+        error "unimplemented"
+    }
+
+    #recursive nseval - for introspection of weird namespace trees
+    #approx 10x slower than normal namespace eval - but still only a few microseconds.. fine for repl introspection
+    proc nseval_script {location} {
+        set parts [nsparts $location]
+        if {[lindex $parts 0] eq ""} {
+            lset parts 0 ::
+        }
+        if {[lindex $parts end] eq ""} {
+            set parts [lrange $parts 0 end-1]
+        }
+
+        set body ""
+        set i 0
+        set tails [lrepeat [llength $parts] ""]
+        foreach ns $parts {
+            set cmdlist [list ::namespace eval $ns]
+            set t ""
+            if {$i > 0} {
+                append body " <lb>"
+            }
+            append body $cmdlist
+            if {$i == ([llength $parts] -1)} {
+                append body " <script>"
+            }
+            if {$i > 0} {
+                set t {<rb>}
+            }
+            lset tails $i $t
+            incr i
+        }
+        append body [join [lreverse $tails] " "]
+        #puts stdout "tails: $tails"
+        #puts stdout "i: $i"
+        set body [string map [list <lb> "\{" <rb> "\}"] $body]
+
+        set scr {[::list ::eval [::uplevel <i>  {::set script}]]}
+
+        set up [expr {$i - 1}]
+        set scr [string map [list <i> $up] $scr]
+
+        set body [string map [list <script> $scr] $body]
+        return $body
+    }
+    proc nseval {fqns script} {
+        if {![string match ::* $fqns]} {
+            error "nseval only accepts a fully qualified namespace"
+        }
+        set loc [string map [list :: "_sep_"] $fqns]
+        #set cmd ::punk::pipecmds::nseval_$loc
+        set cmd ::punk_dynamic::ns::eval-$loc
+        if {$cmd ni [info commands $cmd]} {
+            append body \n [nseval_script $fqns]
+            proc $cmd {script} $body
+            debug.punk.pipe.compile {proc $cmd} 6
+        }
+        tailcall $cmd $script
+    }
+    proc nschildren {fqns} {
+        if {![string match ::* $fqns]} {
+            error "nschildren only accespts a fully qualified namespace"
+        }
+        set parent [nsprefix $fqns]
+        set tail [nstail $fqns]
+        #puts ">>> parent $parent tail $tail"
+        set nslist [nseval $parent [list ::namespace children $tail]]
+        return [lsort $nslist]
+    }
+
+    proc nsjoin {prefix name} {
+        if {[string match ::* $name]} {
+            if {"$prefix" ne ""} {
+                error "nsjoin: won't join non-empty prefix to absolute namespace path '$name'"
+            }
+            return $name
+        }
+        if {"$prefix" eq "::"} {
+            return ::$name
+        }
+        #if {"$name" eq ""} {
+        #    return $prefix
+        #}
+        #nsjoin ::x::y ""  should return ::x::y::   - this is the correct fully qualified form used to call a command that is the empty string
+        return ${prefix}::$name
+    }
+    proc nsjoinall {prefix args} {
+        #if {![llength $args]} {
+        #    error "usage: nsjoinall prefix relativens \[relativens ...\]"
+        #}
+        set segments [list $prefix]
+        foreach sub $args {
+            if {[string match ::* $sub]} {
+                if {[string length [concat {*}$segments]]} {
+                    error "nsjoin: won't join non-empty namespace prefix to absolute namespace path '$sub'"
+                }
+            }
+            lappend segments $sub
+        }
+        set nonempty_segments [list]
+        foreach s $segments {
+            if {[string length $s]} {
+                lappend nonempty_segments $s
+            }
+        }
+        if {$prefix eq "::"} {
+            return ::[join [lrange $nonempty_segments 1 end] ::]
+        }
+        return [join $nonempty_segments ::]
+    }
+    proc nsprefix {{nspath ""}} {
+        #normalize the common case of ::::
+        set nspath [string map [list :::: ::] $nspath]
+        set rawprefix [string range $nspath 0 end-[string length [nstail $nspath]]]
+        if {$rawprefix eq "::"} {
+            return $rawprefix
+        } else {
+            if {[string match *:: $rawprefix]} {
+                return  [string range $rawprefix 0 end-2]
+            } else {
+                return $rawprefix
+            }
+            #return [string trimright $rawprefix :]
+        }
+    }
+
+    #namespace tail which handles :::cmd  ::x:::y  ::x:::/y  etc
+    #todo - raise error for unexpected sequences such as ::::  or more than 2 colons together.
+    proc nstail {nspath args} {
+        #normalize the common case of ::::
+        set nspath [string map [list :::: ::] $nspath]
+        set mapped [string map [list :: \u0FFF] $nspath] 
+        set parts [split $mapped \u0FFF]
+
+        set defaults [list -strict 0]
+        set opts [dict merge $defaults $args]
+        set strict [dict get $opts -strict]
+
+        if {$strict} {
+            foreach p $parts {
+                if {[string match :* $p]} {
+                    error "nstail unpaired colon ':' in $nspath"
+                }
+            }
+        }
+
+        #e.g  ::x::y:::z  should return ":z"
+        return [lindex $parts end]
+    }
+
+    #return a list of namespace segments - always with leading empty string for fully qualified namespace (ie for ::x)
+    #'supports' to some extent unreasonable namespaces /commands such as x:  ::x:  ::x:::y
+    #Can be used to either support use of such namespaces/commands - or as part of validation to disallow them 
+    #as opposed to silent behaviour of Tcl namespace commands which don't handle them consistently (for tcl 8.x anyway  Review tcl 9)
+    #Note that for  ::x::   the trailing :: cannot represent a trailing namespace part being an empty string 
+    #This is because Tcl's 'namespace eval "" ""' reports 'only global namespace can have empty name'
+    #NOTE tcl allows creating ambiguous namespaces.  e.g ::punk:::etc:::blah 
+    # is this :: punk :etc :blah  or :: punk :etc: blah 
+    #clearly leading/trailing colons in namespaces and commands are just a bad idea. 
+    #nsparts will prefer leading colon (ie greedy on ::)
+    #This is important to support leading colon commands such as :/
+    # ie ::punk:::jjj:::etc -> :: punk :jjj :etc
+    proc nsparts {nspath} {
+        set nspath [string map [list :::: ::] $nspath]
+        set mapped [string map [list  :: \u0FFF] $nspath] 
+        set parts [split $mapped \u0FFF]
+        if {[lindex $parts end] eq ""} {
+
+        }
+        return $parts
+    }
+
+    #tcl 8.x has creative writing var weirdness.. tcl 9 is likely to differ
+    proc nsvars {{nsglob "*"}} {
+        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $nsglob]]
+        #set commandns [uplevel 1 [list namespace current]]
+
+        set searchns [nsprefix $ns_absolute] ;#the ns within which we want to searchns
+        set searchall [nsjoin $searchns *] ;#will correctly form ::*  or ::childns::*
+
+        set rawresult [info vars $searchall] ;#will not find vars in ::x:::y   etc.  - seems to be impossible in tcl 8.x
+        set matched_fullpath [list]
+        foreach r $rawresult {
+            lappend matched_fullpath [nstail $r]
+        }
+
+        set location [nsprefix $ns_absolute]
+        set tailmatch [nstail $ns_absolute]
+        set raw_matched_in_ns [nseval $location [list ::info vars $tailmatch]]
+        #NOTE: tcl <9 will read vars from global namespace - so we are only checking the intersection here
+        #(this is due to info vars ::etc:::blah failing to handle additional colon)
+        set matched_in_ns [list]
+        set result [list]
+        foreach r $raw_matched_in_ns {
+            set m [nstail $r]
+            lappend matched_in_ns $m
+            if {$m in $matched_fullpath} {
+                lappend result $m
+            }
+        }
+
+
+        return [list_as_lines [lsort $result]]
+        #.= lsort $result |> list_as_lines
+    }
+
+    proc nsglob_as_re {glob} {
+        #any segment that is not just * must match exactly one segment in the path
+        set pats [list]
+        foreach seg [nsparts $glob] {
+            if {$seg eq ""} {
+                set seg ""
+            }
+            if {$seg eq "*"} {
+                lappend pats {[^:]*}
+            } elseif {$seg eq "**"} {
+                lappend pats {.*}
+            } else {
+                set seg [string map [list  . {[.]}] $seg]
+                if {[regexp {[*?]} $seg]} {
+                    set pat [string map [list ** {.*} * {[^:]*} ? {[^:]}] $seg]
+                    lappend pats "$pat"
+                } else {
+                    lappend pats "$seg"
+                }
+            }
+        }
+        return  "^[join $pats ::]\$"
+    }
+    proc globmatchns {glob path} {
+        return [regexp [nsglob_as_re $glob] $path]
+    }
+
+    proc nstree {{location ""}} {
+        if {![string match ::* $location]} {
+            set nscaller [uplevel 1 {::namespace current}]
+             set location [nsjoin $nscaller $location] 
+        }
+        list_as_lines [nstree_list $location]
+    }
+
+    proc nstree_list {location args} {
+        package require struct::list
+        #puts "> nstree_list $location $args"
+        set defaults [dict create\
+            -call-depth-internal 0\
+            -subnslist {}\
+            -allbelow 1\
+        ]
+        set opts [dict merge $defaults $args]
+        # -- ---- --- --- --- ---
+        set CALLDEPTH   [dict get $opts -call-depth-internal]
+        set subnslist   [dict get $opts -subnslist]
+        set allbelow    [dict get $opts -allbelow] ;#whether to return matches longer than the matched glob-path
+        # -- ---- --- --- --- ---
+    
+        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $location]]
+
+        set base ""    
+        set tailparts ""
+        if {$CALLDEPTH == 0} { 
+            set parts [nsparts $ns_absolute]
+            lset parts 0 ::
+            set idx 0
+            foreach seg $parts {
+                if {![regexp {[*?]} $seg]} {
+                    set base [nsjoin $base $seg]
+                } else {
+                    set tailparts [lrange $parts $idx end]
+                    break
+                }
+                incr idx
+            }
+        } else {
+           set base $location 
+           set tailparts $subnslist
+        }
+        if {![namespace exists $base]} {
+           return "" 
+        } 
+        #set parent [nsprefix $ns_absolute]
+        #set tail [nstail $ns_absolute]
+
+        set allchildren [lsort [nseval $base [list ::namespace children]]]
+
+        #puts "->base:$base tailparts:$tailparts allchildren: $allchildren"
+        #puts "->base:$base tailparts:$tailparts childcount: [llength $allchildren]"
+
+        #** only significant when it is the trailing part of a segment eg ::**::xxx  ::a**::xxx  
+        if {[llength $tailparts]} {
+            set nextglob [lindex $tailparts 0]
+            if {$nextglob eq "**"} {
+                set nslist [nstree_list $base -subnslist {} -allbelow 1] 
+            } elseif {[regexp {[*]{2}$} $nextglob]} {
+                set nslist [list]
+                #JMN
+                lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
+                foreach ch $nsmatches {
+                    lappend nslist $ch
+                    #lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow 1] 
+                    lappend nslist {*}[nstree_list $ch -subnslist [list "**" {*}[lrange $tailparts 1 end]] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow 0] 
+                }                
+            } else {
+                set nslist [list]
+                lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
+                foreach ch $nsmatches {
+                    lappend nslist $ch
+                    lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow $allbelow] 
+                }
+            }
+        } else {
+            #puts "nstree_list: no tailparts base:$base"
+            if {$allbelow} {
+                set nsmatches $allchildren
+                set nslist [list]
+                foreach ch $nsmatches {
+                    lappend nslist $ch
+                    lappend nslist {*}[nstree_list $ch -subnslist {} -call-depth-internal 0 -allbelow 1] 
+                }
+            } else {
+                set nslist $allchildren
+            }
+           #set nsmatches $allchildren
+           #set nslist [nstree_list $base -subnslist {} -allbelow 0] 
+        }
+        set nslist [lsort -unique $nslist]
+
+
+        if 0 {
+        set nextglob [lindex $tailparts 0]
+        if {$nextglob ne "**"} {
+            set nslist [list]
+            if {[llength $tailparts]} {
+                set nsmatches [list]
+                #lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]::*]
+                lappend nsmatches {*}[lsearch -all -inline -glob $allchildren [nsjoin ${base} $nextglob]]
+            } else {
+                set nsmatches $allchildren
+            }
+            #return
+
+            foreach ch $nsmatches {
+                lappend nslist $ch
+                lappend nslist {*}[nstree_list $ch -subnslist [lrange $tailparts 1 end] -call-depth-internal [expr {$CALLDEPTH + 1}] -allbelow $allbelow] 
+            }
+        } else {
+           set nslist [nstree_list $base -subnslist {} -allbelow 1] 
+        }
+        }
+
+        #foreach ns $nslist {
+        #    puts "== $ns"
+        #}
+        set nslist_filtered [list]
+        if {$CALLDEPTH == 0} {
+            #puts "--base: $base"
+            #puts "-- globmatchns [nsjoin ${ns_absolute} **]"
+            #puts "-- globmatchns ${ns_absolute}"
+            if {$base ni $nslist} {
+                #puts stderr "> adding $base to $nslist"
+                set nslist [list $base {*}$nslist]
+            } 
+
+            if {$allbelow} {
+                foreach ns $nslist {
+                    if {[globmatchns ${ns_absolute} $ns] || [globmatchns [nsjoin ${ns_absolute} **] $ns]} {
+                        lappend nslist_filtered $ns                    
+                    }
+                } 
+            } else {
+                set nslist_filtered [struct::list::Lfilter $nslist [list globmatchns ${ns_absolute}]]
+            }
+            return $nslist_filtered
+        }
+        return $nslist
+    }
+
+
+    #REVIEW - ansi codes can be *very*  confusing to the user when trying to handle lists etc..
+    proc get_nslist {args} {
+   
+        set known_types [list children commands exported imported aliases procs ensembles ooclasses ooobjects]
+        set defaults [dict create\
+            -match ""\
+            -types $known_types\
+            -nsdict ""\
+        ]
+        set opts [dict merge $defaults $args]
+        # -- --- --- --- --- --- --- --- --- --- 
+        set fq_glob             [dict get $opts -match]
+        set requested_types     [dict get $opts -types]
+        set opt_nsdict          [dict get $opts -nsdict]
+
+        set types $requested_types
+        if {"all" in $requested_types} {
+            foreach t $known_types {
+                if {$t ni $types} {
+                    lappend types $t
+                }
+            }
+        }
+        if {"oo" in $requested_types} {
+            if {"ooclasses" ni $types} {
+                lappend types "ooclasses"
+            }
+            if {"ooobjects" ni $types} {
+                lappend types "ooobjects"
+            }
+        }
+        foreach t $types {
+            if {$t in [list "oo" "all"]} {
+                continue
+            }
+            if {$t ni $known_types} {
+                error "Unrecognised namespace member type: $t known types: $known_types"
+            }
+        }
+
+        set glob_is_absolute [expr {[string match ::* $fq_glob]}]
+        if {!$glob_is_absolute} {
+            error "get_nslist requires fully-qualified namespace glob e.g ::*"
+        }
+        #2 columns for namespaces 4 for commands/procs/aliases - todo make less duplicated - generalize to specified number of columns for each?
+        #NOTE aliases may not be commands in current namespace - but we want to show them (marked red and with R)
+        #
+
+        set children [list]
+        set commands [list]
+        set exported [list]
+        set imported [list]
+        set aliases  [list]
+        set procs    [list]
+        set ensembles [list]
+        set ooclasses [list]
+        set ooobjects [list]
+
+        if {$opt_nsdict eq ""} {
+            set nsmatches [get_ns_dicts $fq_glob -allbelow 0] 
+            set itemcount 0
+            set matches_with_results [list]
+            foreach nsinfo $nsmatches {
+                set itemcount [dict get $nsinfo itemcount] 
+                if {$itemcount > 0} {
+                    lappend matches_with_results $nsinfo
+                } 
+            }
+            if {[llength $matches_with_results] == 1} {
+               set contents [lindex $matches_with_results 0]
+            } elseif {[llength $matches_with_results] > 1} {
+               puts stderr "get_nslist WARNING: more than one ([llength $matches_with_results]) namespace had results for the pattern '$fq_glob'. Displaying only first. Consider calling get_ns_dicts and passing results to get_nslist one at a time using -nsdict option" 
+               set contents [lindex $matches_with_results 0]
+            } else {
+                return "- no results -"
+            }
+        } else {
+            set contents $opt_nsdict
+            if {[dict get $opt_nsdict itemcount] == 0} {
+                return "- no results -"
+            }
+        }
+        set ns       [dict get $contents location] 
+
+        package require overtype
+        if {"children" in $types} {
+            set children [dict get $contents children]
+        }
+        if {"commands" in $types} {
+            set commands [dict get $contents commands]
+            if {"exported" in $types} {
+                set exported [dict get $contents exported]
+            }
+            if {"imported" in $types} {
+                set imported [dict get $contents imported]
+            }
+            if {"aliases" in $types} {
+                set aliases  [dict get $contents aliases]
+            }
+            if {"procs" in $types} {
+                set procs    [dict get $contents procs]
+            }
+            if {"ensembles" in $types} {
+                set ensembles [dict get $contents ensembles]
+            }
+            if {"ooclasses" in $types} {
+                set ooclasses [dict get $contents ooclasses]
+            }
+            if {"ooobjects" in $types} {
+               set ooobjects [dict get $contents ooobjects]
+            }
+        }
+
+        set numchildren [llength $children]
+        if {$numchildren} {
+           set mid [expr {int(ceil($numchildren/2.0))}]
+           set children1 [lrange $children 0 $mid-1]
+           set children2 [lrange $children $mid end]
+        } else {
+            set children1 [list]
+            set children2 [list]
+        }
+
+        #elements are commands and possibly renamed aliases which may or may not have been renamed into the current namespace
+        #a command could be an empty string or something else weird. 
+        #Primarily just to handle empty string command - we will wrap each command as a 2-part element here
+        #(our foreach loop needs to ignore missing commands - but not empty string)
+        set elements [lmap v $commands {list c $v}]
+
+        set seencmds [list]
+        set masked [list] ;# 
+        foreach a $aliases {
+            if {[list c $a] in $elements} {
+                #possibly an ordinary alias - or a renamed alias that is masked by a proc/ensemble/oo 
+                #we can detect masking by proc/ensemble/oo - but not by a binary extension loaded after the rename:  REVIEW
+                if {$a in [concat $procs $ensembles $ooclasses $ooobjects]} {
+                    #we have an alias that is also a known other command-type
+                    lappend elements [list c $a] ;#add in twice so we can display both.
+                    lappend  masked $a
+                }
+            } else {
+                #a renamed-alias
+                lappend elements [list c $a]
+            }
+        }
+        set elements [lsort -index 1 $elements]
+        
+        
+        set numelements [llength $elements]
+        if {$numelements} {
+            set split1 [expr {int(ceil($numelements/4.0))}]
+            set elements1 [lrange $elements 0 $split1-1]
+            set remaining3 [lrange $elements $split1 end]
+
+            set numremaining3 [llength $remaining3] 
+            set split2 [expr {int(ceil($numremaining3/3.0))}]
+            set elements2 [lrange $remaining3 0 $split2-1]
+            set remaining2 [lrange $remaining3 $split2 end]
+
+            set numremaining2 [llength $remaining2]
+            set mid [expr {int(ceil($numremaining2/2.0))}]
+            set elements3 [lrange $remaining2 0 $mid-1]
+            set elements4 [lrange $remaining2 $mid end]
+
+        } else {
+            set elements1 [list]
+            set elements2 [list]
+            set elements3 [list]
+            set elements4 [list]
+        }
+
+
+
+        set chwidest1 [pipedata [list {*}$children1 ""] {lmap v $data {string length $v}}  {tcl::mathfunc::max {*}$data}]
+        set chwidest2 [pipedata [list {*}$children2 ""] {lmap v $data {string length $v}}  {tcl::mathfunc::max {*}$data}]
+
+        #wrap the cmd in [list] (just for the width calc) to get a proper length for what will actually be displayed
+        set cmdwidest1 [pipedata [list {*}$elements1 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
+        set cmdwidest2 [pipedata [list {*}$elements2 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
+        set cmdwidest3 [pipedata [list {*}$elements3 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
+        set cmdwidest4 [pipedata [list {*}$elements4 ""] {lmap v $data {string length [list [lindex $v 1]]}}  {tcl::mathfunc::max {*}$data}]
+
+        set displaylist [list]
+        set col1 [string repeat " " [expr {$chwidest1 + 8}]]
+        set col2 [string repeat " " [expr {$chwidest2 + 8}]]
+        set col3 [string repeat " " [expr {$cmdwidest1 + 8}]]
+        set col4 [string repeat " " [expr {$cmdwidest2 + 8}]]
+        set col5 [string repeat " " [expr {$cmdwidest3 + 8}]]
+        set a [a+ purple bold]
+        set e [a+ yellow bold]
+        set o [a+ cyan bold]
+        set p [a+ white bold]
+        foreach ch1 $children1 ch2 $children2 cmd1 $elements1 cmd2 $elements2 cmd3 $elements3 cmd4 $elements4 {
+            set a1 [a+ cyan]
+            set c1 [a+ white]
+            set c2 [a+ white]
+            set c3 [a+ white]
+            set c4 [a+ white]
+
+            for {set i 1} {$i <= 4} {incr i} {
+                if {[llength [set cmd$i]]} {
+                    set c [a+ white]
+                    set prefix "     "
+                    set element [set cmd$i]
+                    set cmd [lindex $element 1]
+                    set cmd_display [list $cmd] ;#wrap in list so empty command is visible (and distinguishable from for example a double-curly command)
+                    if {$cmd ni $commands && $cmd in $aliases } {
+                        #ordinary un-masked commandless-alias
+                        set c [a+ red bold]
+                        set prefix "${a}als  "
+                        set prefix [overtype::right $prefix "-R"]
+                    } else {
+                        if {$cmd in $exported} {
+                            set c [a+ green bold]
+                        }
+                        if {$cmd in $aliases && $cmd in $seencmds} {
+                            #masked commandless-alias
+                            #assert member of masked - but we use seencmds instead to detect.
+                            set c [a+ yellow bold]
+                            set prefix "${a}als  "
+                            set prefix [overtype::right $prefix "-R"]
+                        } elseif {$cmd in $procs} {
+                            set prefix "${p}prc  "
+                        } elseif {$cmd in $ensembles} {
+                            set prefix "${e}ens  "
+                        } elseif {$cmd in $ooclasses} {
+                            set prefix "${o}ooc  "
+                        } elseif {$cmd in $ooobjects} {
+                            set prefix "${o}ooo  "
+                        } elseif {$cmd in $aliases} {
+                            set prefix "${a}als  "
+                        } else {
+                        }
+                        if {$cmd in $imported} {
+                            set prefix [overtype::right $prefix "-[a+ yellow bold]I[a+]"]
+                        }
+                    }
+                    set cmd$i "${prefix} $c$cmd_display"
+                    set c$i $c 
+                    lappend seencmds $cmd
+                }
+            }
+
+            lappend displaylist $a1[overtype::left $col1 $ch1][a+]$a1[overtype::left $col2 $ch2][a+]$c1[overtype::left $col3 $cmd1][a+]$c2[overtype::left $col4 $cmd2][a+]$c3[overtype::left $col5 $cmd3][a+]$c4$cmd4[a+]
+        }
+    
+        return [list_as_lines $displaylist]
+    }
+    proc nspath_here_absolute {{nspath "\uFFFF"}} {
+        set path_is_absolute [expr {[string match ::* $nspath]}]
+        if {$path_is_absolute} {
+            return $nspath
+        }
+        set ns_caller [uplevel 1 {::namespace current}] ;#must qualify. Needs to be called from arbitrary namespaces where 'namespace' command may exist (e.g tdom::schema)
+        if {$nspath eq "\uFFFF"} {
+            return $ns_caller
+        }
+        #nsjoin will join nscaller with empty nspath to form nscaller::  - which is correct way to represent command named with empty string
+        return [nsjoin $ns_caller $nspath]
+    }
+
+    proc nspath_to_absolute {nspath base} {
+        set path_is_absolute [expr {[string match ::* $nspath]}]
+        if {$path_is_absolute} {
+            return $nspath
+        }
+        if {![string length $nspath]} {
+            return $base
+        }
+        return [nsjoin $base $nspath]
+    }
+
+    proc nslist {{glob "*"} args} {
+        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $glob]]
+        if {[dict exists $args -match]} {
+           error "nslist requires positional argument 'glob' instead of -match option" 
+        }
+        set defaults [dict create\
+            -match $ns_absolute
+        ]
+        package require textblock
+        set opts [dict merge $defaults $args]
+        set ns_matches [get_ns_dicts $ns_absolute] 
+        set with_results [list]
+        foreach nsdict $ns_matches {
+            if {[dict get $nsdict itemcount]>0} {
+                lappend with_results $nsdict
+            }
+        }
+        set count_with_results [llength $with_results]
+        set output ""
+        foreach nsdict $with_results {
+            dict set opts -nsdict $nsdict
+            set block [get_nslist {*}$opts]
+            if {[string first \n $block] < 0} {
+                #single line
+                set width [textblock::width [list $block]]
+            } else {
+                set width [textblock::width $block]
+            }
+            if {$width > 0} {
+                append output \n [dict get $nsdict location] \n
+                append output $block
+                if {$count_with_results > 1} {
+                    append output \n [string repeat - $width] 
+                }
+            }
+        }
+        return $output
+    }
+    #cli command - impure - relies on caller/ns_current
+    proc nslist_dict {{glob "*"} args} {
+        set ns_absolute [uplevel 1 [list ::punk::ns::nspath_here_absolute $glob]]
+        return [get_ns_dicts $ns_absolute {*}$args]
+    }
+
+    #non-contextual - but impure due to state-retrieval from the passed-in namespace part of the fq_glob
+    #returns a list of dicts even if only one ns matched
+    #glob chars at last segment match contents/children of namespaces
+    #glob chars in the path will result in multiple namespaces being matched
+    #e.g  ::tcl::*::d* will match commands beginning with d and child namespaces beginning with d in any namespaces 1 below ::tcl
+    proc get_ns_dicts {fq_glob args} {
+        #puts stderr "get_ns_dicts $fq_glob"
+        set glob_is_absolute [expr {[string match ::* $fq_glob]}]
+        if {!$glob_is_absolute} {
+            error "get_ns_dicts requires fully-qualified namespace glob e.g ::*"
+        }
+        set defaults [dict create\
+            -allbelow 0\
+        ]
+        set opts [dict merge $defaults $args]
+        # -- --- --- --- --- --- --- --- --- --- --- ---
+        set allbelow            [dict get $opts -allbelow]
+        # -- --- --- --- --- --- --- --- --- --- --- ---
+
+        set location [nsprefix $fq_glob]
+        set glob [nstail $fq_glob]
+        set commands [list]
+        
+
+           # set location [nsprefix $fq_glob]
+           # set glob [nstail $fq_glob]
+           # set allchildren [nschildren $location] ; #only returns 1 level deeper
+           # set commands [.= nscommands [nsjoin ${location} $glob] |> linelist ]
+
+        set nsglob [nsprefix $fq_glob]
+        set glob [nstail $fq_glob]
+        set matched_namespaces [nstree_list $nsglob -allbelow $allbelow]
+
+        set report_namespaces [list] 
+        #special case trailing ** in last segment
+        if {[regexp {[*]{2}$} $glob]} {
+            lappend report_namespaces {*}$matched_namespaces 
+            foreach ns $matched_namespaces {
+                lappend report_namespaces {*}[nstree_list [nsjoin $ns $glob]]
+            }
+        } else {
+           set report_namespaces $matched_namespaces 
+        }
+
+        set nsdict_list [list]
+        foreach ch $report_namespaces {
+            #puts "get_ns_dicts>>> $ch  glob:'$glob'"
+            set allchildren [nschildren $ch] ; #only returns 1 level deeper
+            
+            #nscommands returns exactly one line per entry + a trailing newline. If there is an empty line other than at the end - that is because there is a command named as the empty string.
+            # By default 'linelist'  trims 1st and last empty line. Turn off all block trimming with -block {}
+            set  commands [.= nscommands -raw [nsjoin $ch $glob] |> .=>1 linelist -block {}]
+            #by convention - returning just \n represents a single result of the empty string whereas no results  
+            #after passing through linelist this becomes {} {} which appears as a list of two empty strings.
+            #this is because there isn't a way to represent unambiguously all 3 cases of: empty-list, list of single empty string, list of two empty strings just using \n separated lines 
+            #unless we always return a newline at the tail if there is a result
+            #For this reason nscommands returns a trailing newline - so the last entry should always be empty string - and is a bogus entry
+            #We double-check it here to avoid regressions/mistakes - as nscommands is also a user-level command so there exists the temptation to make it not return the extra newline. 
+            if {[lindex $commands end] eq ""} {
+                set commands [lrange $commands 0 end-1]
+            } else {
+                puts stderr "get_ns_dicts WARNING nscommands didn't return a trailing newline - unexpected"
+            }
+            
+            
+
+            set location $ch 
+            #set exportpatterns [namespace eval $location {::namespace export}]
+            set exportpatterns [nseval $location {::namespace export}]
+            set allexported [list]
+            set matched [list]
+            foreach p $exportpatterns {
+                if {[regexp {[*?]} $p]} {
+                    lappend matched {*}[nseval $location [list ::info commands [nsjoin ${location} $p]]]
+                    foreach m $matched {
+                        lappend allexported [nstail $m]
+                    }
+                } else {
+                    lappend allexported $p
+                }
+            }
+            set allexported [lsort -unique $allexported]
+            #NOTE: info procs within namespace eval is different to 'info commands' within namespace eval (info procs doesn't look outside of namespace)
+            set allprocs    [nseval $location {::info procs}]
+            set tails [lmap v $allchildren {nstail $v}]
+            set allaliases [list]
+            set allensembles [list]
+            set allooobjects [list]
+            set allooclasses [list]
+            set allimported [list]
+            set allundetermined [list]
+            set interp_aliases [interp aliases ""]
+            #use aliases glob - because aliases can be present with or without leading ::
+            #NOTE: alias may not have matching command in the relevant namespce (renamed alias) so we can't just start with commands and check if it's an alias if we want to show all aliases
+            set raw_aliases [nseval $location [list ::aliases $glob]] ;#'aliases $glob' must be passed as list, not separate args to namespace eval. 
+            set aliases [list]
+            foreach a $raw_aliases {
+                if {[string match *:: $a]} {
+                    #exception for alias such as ::p::2::  so that it doesn't show up as empty string
+                    #lappend aliases ::
+                    #JMN - 2023 - better to dispaly an empty string somehow
+                    lappend aliases "" 
+                } else {
+                    lappend aliases [nstail $a]
+                }
+            }
+
+            foreach cmd $commands {
+                #if {"${location}::$cmd" in $interp_aliases || [string trimleft "${location}::$cmd" ":"] in $interp_aliases} {
+                #    #NOTE: doesn't cater for renamed aliases - Tcl 8.x doesn't seem to have any introspection capabilities to match command to a renamed alias
+                #    #which_alias hack from wiki relies on trace and executing the command - which we don't want to do.
+                #    lappend allaliases $cmd
+                #}
+
+                if {![catch {namespace ensemble configure ${location}::$cmd} ensemble_info]} {
+                    lappend allensembles $cmd 
+                } elseif {[info object isa object ${location}::$cmd]} {
+                    lappend allooobjects $cmd
+                    if {[info object isa class ${location}::$cmd]} {
+                        lappend allooclasses $cmd
+                    }
+                }
+
+                if {[catch {
+                    if {$cmd eq ""} {
+                        #empty command was previously marked as "::" - too confusing - nslist updated to properly display empty string.
+                        set nsorigin [namespace origin ${location}::]
+                    } elseif {[string match :* $cmd]} {
+                        set nsorigin [nseval $location "::namespace origin $cmd"] 
+                    } else {
+                        set nsorigin [namespace origin [nsjoin $location $cmd]]
+                    }
+                } errM]} {
+                    puts stderr "get_ns_dicts failed to determine origin of command '$cmd' adding to 'undetermined'"
+                    puts stderr "error message: $errM"
+                    lappend allundetermined $cmd
+                } else {
+                    if {[nsprefix $nsorigin] ne $location} {
+                        lappend allimported $cmd
+                    }
+                }
+            }
+            if {$glob ne "*"} {
+                set tailmatches [lsearch -all -inline $tails $glob]
+                set fqchildren [lmap v $tailmatches {lindex ${location}::$v}]  ;#lindex without indices is fast equivalent of 'val'
+                set exported [lsearch -all -inline $allexported $glob]
+                set procs [lsearch -all -inline $allprocs $glob]
+                #set aliases [lsearch -all -inline $allaliases $glob]
+                set ensembles [lsearch -all -inline $allensembles $glob]
+                set ooobjects [lsearch -all -inline $allooobjects $glob]
+                set ooclasses [lsearch -all -inline $allooclasses $glob]
+                set imported [lsearch -all -inline $allimported $glob]
+                set undetermined [lsearch -all -inline $allundetermined $glob]
+            } else {
+                set tailmatches $tails
+                set fqchildren $allchildren
+                set exported $allexported
+                set procs $allprocs
+                #set aliases $allaliases
+                set ensembles $allensembles
+                set ooobjects $allooobjects
+                set ooclasses $allooclasses
+                set imported $allimported
+                set undetermined $allundetermined
+            }
+            set itemcount 0
+            incr itemcount [llength $tailmatches]
+            incr itemcount [llength $commands]
+            incr itemcount [llength $procs]
+            incr itemcount [llength $exported]
+            incr itemcount [llength $imported]
+            incr itemcount [llength $aliases]
+            incr itemcount [llength $ensembles]
+            incr itemcount [llength $ooobjects]
+            incr itemcount [llength $ooclasses]
+            incr itemcount [llength $exportpatterns]
+            incr itemcount [llength $undetermined]
+
+            lappend nsdict_list [dict create\
+                children [lsort $tailmatches]\
+                commands $commands\
+                procs $procs\
+                exported $exported\
+                imported $imported\
+                aliases $aliases\
+                ensembles $ensembles\
+                ooobjects $ooobjects\
+                ooclasses $ooclasses\
+                namespacexport $exportpatterns\
+                undetermined $undetermined\
+                location $location\
+                glob $glob\
+                itemcount $itemcount\
+            ]
+        }
+        return $nsdict_list 
+        #return [list children [lsort $tailmatches] commands $commands procs $procs exported $exported imported $imported aliases $aliases ensembles $ensembles ooobjects $ooobjects ooclasses $ooclasses namespacexport $exportpatterns location $location glob $glob]
+
+    }
+    #Must be no ansi when only single arg used.
+    #review - ansi codes will be very confusing in some scenarios! 
+    #todo - only output color when requested (how?) or via repltelemetry ?
+    interp alias {} nscommands {} .= ,'ok'@0.= {
+
+            #Note: namespace argument to apply doesn't accept namespace segments with leading colon - so pipelines won't work fully in dodgily-named namespaces such as :::x
+            #inspect -label namespace_current [namespace current]
+            #inspect -label info_procs [info procs]
+
+            ::set commandns [::namespace current]
+            ::set commandlist [::list]
+            #color code multiple args? - not very practical if many ns args supplied, but then... common case will only be 1 or 2 anyway
+            #colors can be stripped by caller with ansistrip - but we'll make the default case easier by using no ansi codes if a single arg is passed 
+            ::set colors [::list none cyan yellow green]
+            ::set ci 0 ;#colourindex
+            ::set do_raw 0
+            ::if {[::set posn [::lsearch $searchlist -raw]] >= 0} {
+                ::set searchlist [::lreplace $searchlist $posn $posn]
+                ::set do_raw 1 
+            }
+            ::if {![::llength $searchlist]} {
+                ::lappend searchlist *
+            }
+            ::foreach search $searchlist {
+                ::if {$ci > [::llength $colors]-1} {
+                    ::set ci 0
+                }
+                #by using pipeswitch instead of pipeswitchc - we give the ability* for the switch script block to affect vars in the calling scope
+                # (*not a desirable feature from a functional point of view - but useful for debugging, and also potentially faster )
+                ::if {$ci == 0 || $do_raw} {
+                    ::set col ""
+                    ::set rst ""
+                } else {
+                    ::set col [a+ [::lindex $colors $ci] bold]
+                    ::set rst [a+]
+                }
+                ::incr ci ;#colourindex
+                #inspect -label search $search
+                
+                ::if {![::llength $search]} {
+                    ::set base $commandns
+                    ::set what "*"
+                } else {
+                    ::if {[::string match ::* $search]} {
+                        ::set base [::punk::ns::nsprefix $search]
+                        ::set what [::punk::ns::nstail $search]
+                    } else {
+                        ::set base $commandns
+                        ::set what $search
+                    }
+                }
+
+                ::set all_ns_commands [::info commands [::punk::ns::nsjoin $base $what]]
+                #important not to call namespace eval (or punk::ns::nseval) on non-existant base - or it will be created
+                ::if {![::namespace exists $base]} {
+                   ::continue 
+                }
+
+                #NOTE - matched commands will return commands from global ns due to 'namespace eval'
+                #We don't simply do info commands ${base}::$what  because it misses some oddly named things (JMN 2023 - like what?)
+                ::set matchedcommands [::pipeswitch {
+                    #inspect '$ns'
+                    #pipecase \
+                    #    caseresult= $ns |input> \
+                    #    1.= {expr {[string length [string map [list * "" ? ""] $data]] == [string length $data]}} |>  { info commands ${input}::* }
+
+                    #pipecase \
+                    #    caseresult= $ns |input>  { info commands ${input} }
+
+                    ::pipecase \
+                        caseresult.= ::list $base $what |,basens/0,g/1>  {::punk::ns::nseval $basens [::list ::info commands $g]}
+
+                }]
+                #lappend commandlist {*}[@@ok/result= $matchedcommands]
+
+                #need to pull result from matchedcommands dict
+                #set cmd_tails [@@ok/result= $matchedcommands |> {::lmap v $data {punk::ns::nstail $v}}]
+                
+                ::set cmd_tails [::lmap v [::dict get $matchedcommands ok result] {::punk::ns::nstail $v}]
+
+                ::set all_ns_tails [::lmap v $all_ns_commands {::punk::ns::nstail $v}]
+
+                ::foreach c $cmd_tails {
+                    ::if {$c in $all_ns_tails} {
+                        ::if {$do_raw} {
+                            ::lappend commandlist [::list $c $c]
+                        } else {
+                            ::lappend commandlist [::list $c $col[::list $c]$rst]
+                        }
+                    }
+                }
+            }
+            ::list ok [::list result $commandlist]
+            #unless we always return trailing \n - it's impossible to represent a list containing only the empty string using \n (cannot disambiguate between empty list and/or list of 2 empty strings)
+            #we use the convention that a result of just \n represents a list of just the empty string - as we don't require duplicates anyway - so it shouldn't mean two empty strings.
+    }  |data@@ok/result> ::lsort -index 0  |> {::lmap v $data {::lindex $v 1}} |> {::if {![::llength $data]} {::return {}} else {::return [::join $data \n]\n}} <searchlist|  
+
+    interp alias {} nscommands1 {} .= ,'ok'@0.= {
+            set commandns [namespace current]
+            #upvar caseresult caseresult
+            inspect -label namespace_current [namespace current]
+            inspect -label nsthis [nsthis]
+            inspect -label nsthis2 [nsthis2]
+            inspect -label commandns $commandns
+            inspect -label info_procs [info procs]
+            #by using pipeswitch instead of pipeswitchc - we give the ability* for the switch script block to affect vars in the calling scope
+            # (*not a desirable feature from a functional point of view - but useful for debugging, and also potentially faster )
+            pipeswitch {
+                #no glob chars present
+                if {![llength $ns]} {
+                    set ns $commandns
+                } else {
+                    if {![string match ::* $ns]} {
+                        if {$commandns eq "::"} {set commandns ""}
+                        set ns ${commandns}::$ns
+                    }
+                }
+                inspect '$ns'
+                pipecase \
+                    caseresult= $ns |input> \
+                    1.= {expr {[string length [string map [list * "" ? ""] $data]] == [string length $data]}} |>  {
+                        #uplevel 1 [list info commands ${input}::*]
+                        info commands ${input}::*
+                    }
+
+                #pipecase1 ns has one or more of glob chars * or ?
+                pipecase \
+                    caseresult= $ns |input>  {
+                        #uplevel 1 [list info commands ${input}]
+                        info commands ${input}
+                    }
+            }
+    } |data@@ok/result>  {lmap v $data {punk::ns::nstail $v}} |> lsort |> {join $data \n} <ns/0| 
+
+    #todo - package up as navns
+    proc corp {path} {
+        #thanks to Richard Suchenwirth for the original - wiki.tcl-lang.org/page/corp 
+        #Note: modified here to support aliases and relative/absolute name (with respect to namespace .ie ::name vs name)
+        if {[info exists ::auto_index($path)]} {
+            set body "# $::auto_index($path)\n"
+        } else {
+            set body ""
+        }
+
+        if {[string match ::* $path]} {
+            set targetns [nsprefix $path]
+            set name [nstail $path]
+        } else {
+            set thispath [uplevel 1 [list ::nsthis $path]]
+            set targetns [nsprefix $thispath]
+            set name [nstail $thispath]
+        }
+        #puts stderr "corp upns:$upns"
+
+        #set name [string trim $name :]        
+        #set origin [namespace origin ${upns}::$name]
+        set origin [nseval $targetns [list ::namespace origin $name]]
+
+        #An renamed alias may exist that is the same name as a proc that was created later.. so we must check for the proc before looking into aliases!
+        if {$origin ni [info procs $origin]} {
+
+            #It seems an interp alias of "::x""  behaves the same as "x" 
+            #But we can't create both at the same time - and they have to be queried by the exact name.
+            #So we query for alias with and without leading ::
+            set alias_qualified [interp alias {} [string trim $origin :]]
+            set alias_unqualified [interp alias {} $origin]
+            if {[string length $alias_qualified] && [string length $alias_unqualified]} {
+                #our assumptions are wrong.. change in tcl version?
+                puts stderr "corp: Found alias for unqualified name:'[string trim $origin :]' and qualified name: '$origin' - unexpected (assumed impossible as at Tcl 8.6)"
+                if {$alias_qualified ne $alias_unqalified} {
+
+                } else {
+                    set alias $alias_unqualified
+                }
+            } else {
+                set alias ${alias_qualified}${alias_unqualified} ;#concatenate - as at least one should be empty
+            }
+
+            if {[string length $alias]} {
+                #todo - consider following alias-chain to ultimate proc?
+                #it can always be manually done with:
+                #.= corp $name |/1> corp |/1> corp ..
+                #depending on number of aliases in the chain
+                return [list alias {*}$alias]
+            }
+        } 
+        if {[nsprefix $origin] ne [nsprefix [nsjoin ${targetns} $name]]} {
+            append body "# namespace origin $origin" \n
+        }
+
+        append body [info body $origin]
+        set argl {}
+        foreach a [info args $origin] {
+            if {[info default $origin $a def]} {
+                lappend a $def
+            }
+            lappend argl $a
+        }
+        list proc [nsjoin ${targetns} $name] $argl $body
+    }
+
+
+    #review ???
+    proc ns_relative_to_location {name} {
+        if {[string match ::* $name]} {
+            error "ns_relative_to_location accepts a relative namespace name only ie one without leading ::"
+        }
+
+    }
+    proc ns_absolute_to_location {name} {
+
+    }
+
+    interp alias {} nsthis    {} punk::ns::nspath_here_absolute
+    interp alias {} nsorigin {} apply {ns {namespace origin [uplevel 1 ::punk::ns::nspath_here_absolute $ns]} ::}
+    interp alias {} nsvars {} punk::ns::nsvars
+    interp alias {} nsjoin {} punk::ns::nsjoin
+    interp alias {} nsprefix {} punk::ns::nsprefix
+    interp alias {} nstail {} punk::ns::nstail
+    interp alias {} nsparts {} punk::ns::nsparts
+    interp alias {} nstree  {} punk::ns::nstree
+    #namespace/command/proc query
+    interp alias {} nslist {} punk::ns::nslist
+    interp alias {} nslist_dict {} punk::ns::nslist_dict
+
+    #extra slash implies more verbosity (ie display commands instead of just nschildren)
+    interp alias {} :/ {} punk::ns::ns/ /
+    interp alias {} :// {} punk::ns::ns/ //
+    interp alias {} n/ {} punk::ns::ns/ /
+    interp alias {} n// {} punk::ns::ns/ //
+    interp alias {} ::/ {} punk::ns::nsup/ /
+    interp alias {} ::// {} punk::ns::nsup/ //
+    interp alias {} nn/ {} punk::ns::nsup/ /
+    interp alias {} nn// {} punk::ns::nsup/ //
+    interp alias {} :/new {} punk::ns::n/new
+    interp alias {} n/new {} punk::ns::n/new
+
+    interp alias {} corp       {} punk::ns::corp
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# ++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++
+##  Ready   
+package provide punk::ns [namespace eval punk::ns {
+    variable version
+    set version 999999.0a1.0 
+}]
+return
\ No newline at end of file
diff --git a/src/modules/punk/ns-buildversion.txt b/src/modules/punk/ns-buildversion.txt
new file mode 100644
index 00000000..f47d01c8
--- /dev/null
+++ b/src/modules/punk/ns-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/repl-0.1.tm b/src/modules/punk/repl-0.1.tm
index 1a59cc9a..9fc3cab7 100644
--- a/src/modules/punk/repl-0.1.tm
+++ b/src/modules/punk/repl-0.1.tm
@@ -35,6 +35,7 @@ package require Thread
 package require shellfilter
 package require shellrun
 package require punk
+package require punk::ns
 
 
 
@@ -1010,7 +1011,7 @@ proc repl::repl_handler {inputchan prompt_config} {
             append info "repl loopinstance: $loopinstance\n"
             append info "last_run_info\n"
             append  info "length: [llength $::punk::last_run_display]\n"
-            append info "namespace: $punk::ns_current"
+            append info "namespace: $punk::ns::ns_current"
             debug_repl_emit $info
         } else {
             proc debug_repl_emit {msg} {return}
@@ -1056,9 +1057,9 @@ proc repl::repl_handler {inputchan prompt_config} {
             #puts stderr "repl uplevel 0 '$command'"
             set status [catch {
                  #uplevel 1 $run_command_string
-                 #uplevel 1 {namespace eval $punk::ns_current $run_command_string}
+                 #uplevel 1 {namespace eval $punk::ns::ns_current $run_command_string}
                  set weirdns 0
-                 set parts [punk::nsparts $punk::ns_current] 
+                 set parts [punk::ns::nsparts $punk::ns::ns_current] 
                  foreach p $parts {
                      if {[string match :* $p] || [string match *: $p]} {
                          set weirdns 1
@@ -1067,9 +1068,9 @@ proc repl::repl_handler {inputchan prompt_config} {
                  }
                  
                  if {$weirdns} {
-                    uplevel 1 {punk::nseval $punk::ns_current $run_command_string}
+                    uplevel 1 {punk::ns::nseval $punk::ns::ns_current $run_command_string}
                  } else {
-                    uplevel 1 {namespace inscope $punk::ns_current $run_command_string}
+                    uplevel 1 {namespace inscope $punk::ns::ns_current $run_command_string}
                  }
             } raw_result]
         }
@@ -1337,7 +1338,7 @@ proc repl::repl_handler {inputchan prompt_config} {
             puts stderr "*> stdin reader active"
         }
         puts stderr "Attempting restart of repl on input channel: $inputchan"
-        catch {set ::punk::ns_current "::"}
+        catch {set ::punk::ns::ns_current "::"}
         tailcall repl::start $inputchan
 
     }