Index: build.tcl
==================================================================
--- build.tcl
+++ build.tcl
@@ -19,72 +19,17 @@
 # Define procedures
 #####
 
 namespace eval ::practcl {}
 
-proc ::COMPILE {which cfile {extras {}}} {
-  set objfile [file normalize [file join $::PWD build [file tail [file dirname $cfile]]_[file rootname [file tail $cfile]].o]]
-  lappend ::KIT(${which}_OBJS) $objfile
-  if {[file exists $objfile] && [file mtime $objfile] > [file mtime $cfile]} return
-  lappend cmd  $::KIT(cc) {*}$::KIT(cflags_optimize) {*}$::KIT(shlib_cflags) {*}$::KIT(cflags_warning) {*}$::KIT(extra_cflags) {*}$::KIT(defs) {*}$extras
-  foreach path $::KIT(INCLUDES) {
-    lappend cmd -I./[::practcl::file_relative $::PWD $path]
-  }
-  lappend cmd {*}$::KIT(EXTRA_CFLAGS)
-  lappend cmd -c [::practcl::file_relative $::PWD $cfile] -o $objfile
-  puts [list [file tail $cfile] -> [file tail $objfile]]
-  puts $cmd
-  exec {*}$cmd >&@ stdout
-}
-
-proc ::practcl::wrap {PWD name vfspath args} {
-  cd $PWD
-  if {![file exists $vfspath]} {
-    file mkdir $vfspath
-  }
-  package ifneeded zipfile::mkzip 1.2 [list source [file join $::HERE scripts mkzip.tcl]]
-  package require zipfile::mkzip
-
-  set fout [open [file join $vfspath packages.tcl] w]
-  puts $fout {
-set ::PKGIDXFILE [info script]
-set dir [file dirname $::PKGIDXFILE]
-}
-  set buffer [::practcl::pkgindex_path $::KIT(BASEVFS) $vfspath]
-  puts $fout $buffer
-
-  close $fout
-  ::practcl::copyDir $::KIT(BASEVFS) $vfspath
-  #::practcl::copyDir $::KIT(PKGROOT)$::KIT(PKGPREFIX)/lib $vfspath/boot/pkgs
-  foreach arg $args {
-     ::practcl::copyDir $arg $vfspath
-  }
-  ::zipfile::mkzip::mkzip ${name}$::KIT(EXEEXT) -runtime $::TARGET(tclkit_bare) -directory $vfspath
-  if { $::KIT(platform) ne "windows" } {
-    file attributes ${name}$::KIT(EXEEXT) -permissions a+x
-  }
-}
-
 #########################################
 #
 # BEGIN THE KITBUILDING PROCESS HERE
 #
 #########################################
-set _search_paths {{$PWD} {$PWD ..}}
-
-###
-# Can *almost* get it working, but the broken installer
-# leads to chaos under MinGW
-###
-#   tcllibc  {version 0.3.14}
-set ::KIT(PACKAGES) {
-  thread {tag release}
-  sqlite {tag release}
-  udp {tag trunk}
-  canvas3d {tag trunk tk 1}
-  tkimg    {tag trunk tk 1 broken_destroot 1}
-}
+set _search_paths {}
+lappend _search_paths [file dirname [file normalize $PWD]]
 
 if {[file exists [file join $PWD project.rc]]} {
   ###
   # For existing PRACTCL projects, we can steal all of the
   # information we need from the project.rc file
@@ -103,11 +48,11 @@
   set ::KIT(TK_PATCH_LEVEL) $::project(TCL_PATCH_LEVEL)
   set ::KIT(TCL_BUILD_OPTS) {}
   set ::KIT(TK_BUILD_OPTS)  {}
   switch $::project(TEACUP_OS) {
     linux {
-      # Voodoo, bit maintains compadibitity with ActiveState binaries
+      # Voodoo, bit maintains compatibility with ActiveState binaries
       lappend ::KIT(TK_BUILD_OPTS) --enable-xft=no --enable-xss=no
     }
     macosx {
       lappend ::KIT(TCL_BUILD_OPTS) --enable-corefoundation=yes  --enable-framework=no
       # For pre 10.5 use:
@@ -115,11 +60,13 @@
       lappend ::KIT(TK_BUILD_OPTS) --enable-aqua=yes
       # IF doing X11 builds:
       #lappend ::KIT(TK_BUILD_OPTS) --enable-aqua=no --x-includes=/opt/X11/include
     }
   }
-  lappend _search_paths {[file dirname $::project(srcdir)]}
+  if {[info exists ::project(sandbox)] && $::project(sandbox) ne {}} {
+    lappend _search_paths $::project(sandbox)
+  }
 } else {
   if {![file exists [file join $::HERE odieConfig.tcl]]} {
     # Build the local toolset
     cd $HERE
     exec [info nameofexecutable] [file join $HERE autosetup autosetup]
@@ -139,15 +86,35 @@
   set ::KIT(TK_BUILD_OPTS) $::odie_tk(config_flags)
   set ::KIT(HOST) $::odie(host)
   lappend _search_paths $::odie(sandbox)
 }
 
+###
+# Can *almost* get it working, but the broken installer
+# leads to chaos under MinGW
+###
+#   tcllibc  {version 0.3.14}
 set ::KIT(TEAPOT) {}
+set ::KIT(PACKAGES) {
+  thread {tag release}
+  sqlite {tag release}
+  udp {tag trunk}
+  canvas3d {tag trunk tk 1}
+  tkimg    {tag trunk tk 1 broken_destroot 1}
+}
 if {$::KIT(platform) eq "windows"} {
   set ::KIT(TEAPOT) C:/Tcl/lib/teapot/package/win32-ix86/lib
   dict set ::KIT(PACKAGES) twapi {version {3.0.32 4.1.27}}
-} 
+  set ::KIT(EXEEXT) .exe
+  set ::KIT(platform_src_dir) win
+  set USEMSVC [info exists env(VisualStudioVersion)]
+} else {
+  set ::KIT(EXEEXT) {}
+  set ::KIT(platform_src_dir) unix
+  set USEMSVC 0
+}
+set ::KIT(PKGPREFIX) /zvfs
 
 array set build {
   tcl 0
   tk  0
   packages 0
@@ -161,13 +128,20 @@
 ###
 # Begin processing our arguments
 ###
 set COMMAND [lindex $argv 0]
 switch $COMMAND {
+  barekit {
+    set build(tclkit_bare) 1
+    set build(libtoadkit.a) 1
+  }
   localtcl {
     
   }
+  libtoadkit.a {
+    set build(libtoadkit.a) 1
+  }
   toadkit {
     set build(toadkit) 1
   }
   basekit {
     set build(toadkit) 1
@@ -184,21 +158,10 @@
   default {
     error "Unknown command $COMMAND. Valid: clean tcl toadkit wrap"
   }
 }
 
-if { $::KIT(platform) eq "windows" } {
-  set ::KIT(EXEEXT) .exe
-  set ::KIT(platform_src_dir) win
-  set USEMSVC [info exists env(VisualStudioVersion)]
-} else {
-  set ::KIT(EXEEXT) {}
-  set ::KIT(platform_src_dir) unix
-  set USEMSVC 0
-}
-set ::KIT(PKGPREFIX) /zvfs
-
 foreach dpath $_search_paths {
   set path [file normalize [file join {*}[subst $dpath] toadkit$::KIT(TCL_VERSION)$::KIT(TCL_PATCH_LEVEL)]]
   set ::KIT(TCLSRCDIR)  [file join $path tcl]
   set ::KIT(TKSRCDIR)   [file join $path tk]
   set ::KIT(PKGROOT)    [file join $path pkg]
@@ -208,11 +171,10 @@
 
   if {[file exists $::KIT(TCLSRCDIR)]} {
     break
   }
 }
-
 
 ###
 # Sort out our various build products
 ###
 set _TclSrcDir [file join $::KIT(TCLSRCDIR) $::KIT(platform_src_dir)]
@@ -281,66 +243,68 @@
   foreach file [glob -nocomplain *.a] {
     file delete $file
   }
   exit
 }
+file mkdir build
+file mkdir [file join $::KIT(BASEVFS) boot]
+
+::practcl::tclkit create TOADKIT {
+  name toadkit
+  pkg_name toadkit
+  pkg_version 8.6.5
+  platform $::KIT(platform)
+  HOST $::KIT(HOST)
+  TARGET $::KIT(TARGET)
+  USEMSVC $USEMSVC
+  teapot [list $::KIT(TEAPOT)]
+  download [list $::KIT(DOWNLOAD)]
+  sandbox [list $::KIT(SANDBOX)]
+  tclsrdir [list $::KIT(TCLSRCDIR)]
+  prefix [list $::KIT(PKGPREFIX)]
+  installdir [list $::KIT(PKGROOT)]
+  PRACTCL_NAME_LIBRARY $::project(PRACTCL_NAME_LIBRARY)
+  SHLIB_SUFFIX $::project(SHLIB_SUFFIX)
+  PRACTCL_STATIC_LIB $::project(PRACTCL_STATIC_LIB)
+  prefix_broken_destdir $::KIT(SANDBOX)/TEMP.PKG
+}
+::practcl::subproject.core create TCLCORE TOADKIT {
+  name tcl
+  config_opts "$::KIT(TCL_BUILD_OPTS) --with-tzdata"
+  srcroot  "$::KIT(TCLSRCDIR)"
+  tag release
+  static 1
+}
+TCLCORE go
+set _TclSrcDir [TCLCORE define get localsrcdir]
+TOADKIT define set tclsrcdir $_TclSrcDir
+::practcl::subproject.core create TKCORE TOADKIT {
+  name tk
+  config_opts "$::KIT(TK_BUILD_OPTS)"
+  srcroot  "$::KIT(TKSRCDIR)"
+  tag release
+  static 0
+}
+TKCORE go
+set _TkSrcDir [TKCORE define get localsrcdir]
+TOADKIT define set tksrcdir $_TkSrcDir
+
+puts "PLATFORM: $::KIT(platform)"
+puts [list TCLSRCDIR: $_TclSrcDir]
+puts [list TKSRCDIR: $_TkSrcDir]
 
 if {$build(tcl)} {
-  file mkdir build
-  file mkdir [file join $::KIT(BASEVFS) boot]
-  ###
-  # Build a starter VFS for both Tcl and wish
-  ###
-  ::practcl::fossil_sandbox tcl [list srcroot $::KIT(TCLSRCDIR) tag release]
-  if {$USEMSVC} {
-    puts "BUILDING Static Tcl $_TclSrcDir"
-    cd $_TclSrcDir
-    doexec nmake -f makefile.vc INSTALLDIR=$::KIT(PKGROOT) release
-    doexec nmake -f makefile.vc INSTALLDIR=$::KIT(PKGROOT) install
-    cd $PWD
-  } else {
-    if {![file exists $::TARGET(tclConfig.sh)]} {
-      puts "BUILDING Static Tcl $_TclSrcDir"
-      cd $_TclSrcDir
-      set opts {}
-      if {$::KIT(HOST) != $::KIT(TARGET)} {
-        lappend opts --host=$::KIT(TARGET)
-      }
-      lappend opts {*}$::KIT(TCL_BUILD_OPTS) --prefix=$::KIT(PKGPREFIX) --exec_prefix=$::KIT(PKGPREFIX) --with-tzdata --enable-shared=no
-      puts ***
-      puts "CONFIGURE {*}opts"
-      puts ***
-      doexec sh configure {*}$opts
-      domake binaries
-      cd $PWD
-    }
-  }
+  TCLCORE compile
 }
 if {$build(tk)} {
-  set dat [::practcl::fossil_sandbox tk [list srcroot $::KIT(TKSRCDIR) tag release]]
-  if {$USEMSVC} {
-    cd $_TkSrcDir
-    puts "BUILD TK"
-    doexec nmake -f makefile.vc TCLDIR=[file nativename $::KIT(TKSRCDIR)] INSTALLDIR=$::KIT(PKGROOT) release
-    doexec nmake -f makefile.vc TCLDIR=[file nativename $::KIT(TKSRCDIR)] INSTALLDIR=$::KIT(PKGROOT) install
-    cd $PWD
-  } else {
-    if {![file exists $::TARGET(tkConfig.sh)]} {
-      puts "BUILD TK"
-      set opts {}
-      cd $_TkSrcDir
-      if {$::KIT(HOST) != $::KIT(TARGET)} {
-        lappend opts --host=$::KIT(TARGET)
-      }
-      lappend opts {*}$::KIT(TK_BUILD_OPTS) --with-tcl=$_TclSrcDir --enable-shared=yes
-      puts ***
-      puts "CONFIGURE {*}opts"
-      puts ***
-      doexec sh configure {*}$opts
-      domake binaries
-      cd $PWD
-    }
+  TKCORE compile
+}
+
+if {$build(packages)} {  
+  foreach {pkg info} $::KIT(PACKAGES) {
+    set obj [::practcl::subproject create PKG.$pkg TOADKIT [dict merge [list name $pkg pkg_name $pkg static 0] $info]]
+    $obj install
   }
 }
 
 if {$build(toadkit.rc)} {
   set ::KIT(OBJS) {}
@@ -382,32 +346,12 @@
   lappend ::KIT(INCLUDES) [file join $::HERE generic]
   lappend ::KIT(INCLUDES) [file join $::HERE $::KIT(platform_src_dir)]
   
   if { $::KIT(platform) eq "windows" } {
     set ::KIT(EXEEXT) .exe
-    set ::KIT(LDFLAGS_CONSOLE) {-mconsole -pipe -static-libgcc}
-    set ::KIT(LDFLAGS_WINDOW) {-mwindows -pipe -static-libgcc}
-    set ::KIT(EXTRA_CFLAGS) {-DTCL_TOMMATH -DMP_PREC=4 -DUNICODE -D_UNICODE -DBUILD_tcl -DBUILD_tk -DBUILD_ttk -DSTATIC_BUILD}
-
-    if {[file exists [file join $PWD tclkit.rc]]} {
-      set RCSRC [file join $PWD tclkit.rc]
-    } else {
-      set RCSRC [file join $_TkSrcDir rc wish.rc]
-    }
-    doexec windres -o [file join $PWD tclkit.res.o] -DSTATIC_BUILD \
-      --include [file join $::KIT(TCLSRCDIR) generic] --include [file join $::KIT(TKSRCDIR) generic] \
-      --include $_TkSrcDir \
-      --include [file join $_TkSrcDir rc] $RCSRC
-
-    lappend ::KIT(TCLSHELL_OBJS) [file join $PWD tclkit.res.o] 
-    lappend ::KIT(WISHSHELL_OBJS) [file join $PWD tclkit.res.o]
-    lappend ::KIT(INCLUDES) [file join $_TkSrcDir rc]
   } else {
     set ::KIT(EXEEXT) {}
-    set ::KIT(LDFLAGS_CONSOLE) {}
-    set ::KIT(LDFLAGS_WINDOW) {}
-    set ::KIT(EXTRA_CFLAGS) {-DTCL_TOMMATH -DMP_PREC=4 -DBUILD_tk -DBUILD_ttk}
   }
 
   set ::KIT(LIBS) {}
   set ::KIT(defs) $::TK(defs)
   
@@ -434,19 +378,36 @@
   puts $fout "\}"
   close $fout
 } else {
   source $::TARGET(toadkit.rc)
 }
-
+if { $::KIT(platform) eq "windows" } {
+  if {[file exists [file join $PWD tclkit.rc]]} {
+    TOADKIT define set kit_resource_file [file join $PWD tclkit.rc]
+  } else {
+    TOADKIT define set kit_resource_file [file join $_TkSrcDir rc wish.rc]
+  }
+}
+# These values are not known until our static Tcl is built
+TOADKIT define set EXEEXT $::KIT(EXEEXT)
+TOADKIT define set BASEVFS $::KIT(BASEVFS)
+TOADKIT define set tclkit_bare $::TARGET(tclkit_bare)
 
-if {$build(libtoadkit.a)} {
+if {$build(libtoadkit.a) || $build(tclkit_bare)} {
   ###
   # Compile our resident static C library
   ###
   cd $PWD
-  if {[file exists $::TARGET(libtoadkit.a)]} {
-    file delete $::TARGET(libtoadkit.a)
+  if {[file exists $::TARGET(tclkit_bare)]} {
+    file delete $::TARGET(tclkit_bare)
+  }
+  TOADKIT define set include_dir $::KIT(INCLUDES)
+  TOADKIT define add include_dir ../odie/generic
+  if { $::KIT(platform) eq "windows" } {
+    TOADKIT define add include_dir ../odie/win
+  } else {
+    TOADKIT define add include_dir ../odie/unix
   }
   ###
   # Rig ourselves to statically build the bits of
   # zlib we need
   ###
@@ -455,136 +416,39 @@
     adler32.c compress.c crc32.c
     deflate.c infback.c inffast.c
     inflate.c inftrees.c trees.c
     uncompr.c zutil.c
   } {
-    COMPILE LIBTOADKIT [file join $cdir $file]
+    TOADKIT add [file join $cdir $file]
   }
   
   set cdir [file join $::HERE generic]
   foreach file {
     password.c rc4.c tclkit_init.c zvfs.c zvfsboot.c
   } {
-    COMPILE LIBTOADKIT [file join $cdir $file]
+    TOADKIT add [file join $cdir $file]
   }
   
   set cdir [file join $::HERE $::KIT(platform_src_dir)]
+  foreach file {
+    tclsh_packages.c
+  } {
+    TOADKIT add [file join $cdir $file]
+  }
+  
   if { $::KIT(platform) eq "windows" } {
     # tkwinico.c tlink32.c
-    foreach file {
-      tclsh_packages.c
-    } {
-      COMPILE LIBTOADKIT [file join $cdir $file]
-    }
-    COMPILE TCLSHELL [file join $_TclSrcDir tclAppInit.c] [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
-    COMPILE WISHSHELL [file join $_TkSrcDir winMain.c] [list -DTK_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTK_LOCAL_APPINIT=Toadkit_AppInit]
-    lappend ::KIT(LIBTOADKIT_OBJS) [file join $_TclSrcDir libtclstub86.a]
-  } else {
-    foreach file {
-      tclsh_packages.c
-    } {
-      COMPILE LIBTOADKIT [file join $cdir $file]
-    }
-    COMPILE TCLSHELL [file join $_TclSrcDir tclAppInit.c] [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
-    COMPILE WISHSHELL [file join $_TkSrcDir tkAppInit.c] [list -DTK_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTK_LOCAL_APPINIT=Toadkit_AppInit]
-    lappend ::KIT(LIBTOADKIT_OBJS) [file join $_TclSrcDir libtclstub8.6.a]
-  }
-  ###
-  # Link together our executable
-  ###
-  doexec ar cr $::TARGET(libtoadkit.a) {*}$::KIT(LIBTOADKIT_OBJS)
-  doexec ranlib $::TARGET(libtoadkit.a)
-}
-
-if {$build(packages)} {
-  ###
-  # Clean out any packages stuffed in the path where packages that
-  # don't handle DESTROOT properly
-  ###
-  if {$::KIT(PKGPREFIX) in {/usr / /usr/local /opt /opt/local /tcl}} {
-    set BROKENROOT {}
-  } else {
-    catch {
-    set BROKENROOT [::practcl::msys_to_tclpath $::KIT(PKGPREFIX)]
-    puts "BROKENROOT $BROKENROOT"
-    file delete $BROKENROOT
-    }
-  }
-  ###
-  # Clean out our installed package file system
-  ###
-  if {[file exists $::KIT(PKGROOT)]} {
-    file delete -force $::KIT(PKGROOT)
-  }
-  cd $PWD
-  set fossilinfo [list download $::KIT(DOWNLOAD) sandbox $::KIT(SANDBOX)]
-  set tclconfiginfo [::practcl::fossil_sandbox tclconfig [dict merge $fossilinfo {}]]
-  set tclconfig_path [dict get $tclconfiginfo srcroot]
-  foreach {pkg info} $::KIT(PACKAGES) {
-    if {[dict exists $info version]} {
-      set found 0
-      foreach ver [dict get $info version] {
-        set teapath [file join $::KIT(TEAPOT) $pkg$ver]
-        if {[file exists $teapath]} {
-          set dest  [file join $::KIT(PKGROOT) [string trimleft $::KIT(PKGPREFIX) /] lib [file tail $teapath]]
-          puts [list Copying $pkg from teapot to $dest]
-          ::practcl::copyDir $teapath $dest
-          set found 1
-          break
-        }
-      }
-      if {$found} continue
-    }
-    set pkginfo [::practcl::fossil_sandbox $pkg [dict merge $fossilinfo $info]]
-    set pkgpath [dict get $pkginfo srcroot]
-    puts [list BUILDING $pkg in $pkgpath]
-    cd $pkgpath
-    foreach m4file {tcl.m4 install-sh} {
-      if {![file exists [file join $pkgpath tclconfig $m4file]]} {
-        file mkdir [file join $pkgpath tclconfig]
-        file copy [file join $tclconfig_path $m4file] [file join $pkgpath tclconfig $m4file]
-      }
-    }
-    if {![file exists [file join $pkgpath Makefile]]} {
-      if {[file exists [file join $pkgpath Makefile.in]]} {
-        set opts [list --with-tcl=$_TclSrcDir --with-tclinclude=[file join $::KIT(TCLSRCDIR) generic] --with-tzdata --enable-shared --enable-threads]
-        if {[dict exists $info tk]} {
-          lappend opts --with-tk=$_TkSrcDir --with-tkinclude=[file join $::KIT(TKSRCDIR) generic]
-        }
-        doexec sh configure {*}$opts
-      } else {
-        continue
-      }
-    }
-    puts "INSTALLING to VFS [file tail $pkgpath]"
-    domake install DESTDIR=$::KIT(PKGROOT)
-  }
-
-  if {$::KIT(PKGPREFIX) in {/usr / /usr/local /opt /opt/local /tcl}} {
-    set BROKENROOT {}
-  } else {
-    catch {
-    set BROKENROOT [::practcl::msys_to_tclpath $::KIT(PKGPREFIX)]
-    puts [list COPY $BROKENROOT -> $::KIT(PKGROOT)$::KIT(PKGPREFIX)]
-    ::practcl::copyDir $BROKENROOT $::KIT(PKGROOT)$::KIT(PKGPREFIX)
-    file delete -force $BROKENROOT
-    }
-  }
-}
-
-if {$build(tclkit_bare)} {
-  cd $PWD
-  # Build a Tcl-only shell
-  set cmd [list $::KIT(cc)  {*}$::KIT(cflags_optimize) {*}$::KIT(shlib_cflags)]
-  lappend cmd {*}$::KIT(TCLSHELL_OBJS)
-  foreach item [glob ${_TclSrcDir}/*.a] {
-    lappend cmd $item
-  }
-  lappend cmd $::TARGET(libtoadkit.a) {*}$::TCL(libs)
-  lappend cmd -o $::TARGET(tclkit_bare) {*}$::KIT(LDFLAGS_CONSOLE)
-  doexec {*}$cmd
-}
+    TOADKIT add class csource filename [file join $_TclSrcDir tclAppInit.c] extra [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
+  } else {
+    TOADKIT add class csource filename [file join $_TclSrcDir tclAppInit.c] extra [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
+  }
+  # Link together our executable
+  TOADKIT generate-static-tclsh $::TARGET(tclkit_bare) [array get ::TCL] [array get ::KIT]
+}
+TOADKIT define set EXEEXT $::KIT(EXEEXT)
+TOADKIT define set BASEVFS $::KIT(BASEVFS)
+TOADKIT define set tclkit_bare $::TARGET(tclkit_bare)
 
 if {$build(basekitvfs)} {
   cd $PWD
   if {[file exists $::KIT(BASEVFS)]} {
     file delete -force $::KIT(BASEVFS)
@@ -627,12 +491,11 @@
 package ifneeded Tk @TKVERSION@ [list load $::tk_library/@TKDLL@ Tk]
   }]
   close $fout
 }
 if {$COMMAND eq "toadkit"} {
-  ::practcl::wrap $::PWD toadkit toadkit-vfs 
+  TOADKIT wrap $::PWD toadkit toadkit-vfs 
 }
 
 if {$COMMAND eq "wrap"} {
-  puts "WRAP {*}[lrange $argv 1 end]"
-  ::practcl::wrap $::PWD {*}[lrange $argv 1 end]
+  TOADKIT wrap $::PWD {*}[lrange $argv 1 end]
 }