2710

28 files changed, 15 insertions, 113 deletions

diff --git a/html/011load.cc.html b/html/011load.cc.html
index 180cda8d..0f1a5ae6 100644
--- a/html/011load.cc.html
+++ b/html/011load.cc.html
@@ -408,7 +408,6 @@ recipe main [
 <span class="traceContains">+error: redefining recipe main</span>
 
 <span class="Delimiter">:(scenario permit_forcibly_redefining_recipes)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
diff --git a/html/020run.cc.html b/html/020run.cc.html
index b3545e30..1dee9e9e 100644
--- a/html/020run.cc.html
+++ b/html/020run.cc.html
@@ -188,7 +188,6 @@ if <span class="Delimiter">(</span>argc &gt; <span class="Constant">1</span><spa
     argc--<span class="Delimiter">;</span>
   <span class="Delimiter">}</span>
   transform_all<span class="Delimiter">();</span>
-<span class="CommentedCode">//?   dump_recipe(&quot;handle-keyboard-event&quot;),  exit(0);</span>
   if <span class="Delimiter">(</span>Run_tests<span class="Delimiter">)</span> Recipe<span class="Delimiter">.</span>erase<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;main&quot;</span><span class="Delimiter">));</span>
   <span class="Comment">// End Loading .mu Files</span>
 <span class="Delimiter">}</span>
diff --git a/html/021check_instruction.cc.html b/html/021check_instruction.cc.html
index 735bf1c1..082c634a 100644
--- a/html/021check_instruction.cc.html
+++ b/html/021check_instruction.cc.html
@@ -107,7 +107,6 @@ recipe main [
 <span class="traceContains">+error: main: can't copy 34 to 1:address:number; types don't match</span>
 
 <span class="Delimiter">:(scenario write_address_to_number_allowed)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   <span class="Constant">1</span>:address:number<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>/unsafe
   <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:address:number
@@ -116,7 +115,6 @@ recipe main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario write_boolean_to_number_allowed)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   <span class="Constant">1</span>:boolean<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>/<span class="Constant">true</span>
   <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:boolean
diff --git a/html/030container.cc.html b/html/030container.cc.html
index 6151c829..80d27f95 100644
--- a/html/030container.cc.html
+++ b/html/030container.cc.html
@@ -557,7 +557,6 @@ recipe main [
 <span class="traceContains">+error: main: unknown type integer in '1:integer &lt;- copy 0'</span>
 
 <span class="Delimiter">:(scenario run_allows_type_definition_after_use)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   <span class="Constant">1</span>:bar<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/unsafe
 ]
@@ -679,7 +678,6 @@ case MERGE: <span class="Delimiter">{</span>
 <span class="Comment">//: type-check 'merge' to avoid interpreting numbers as addresses</span>
 
 <span class="Delimiter">:(scenario merge_check)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   <span class="Constant">1</span>:point<span class="Special"> &lt;- </span>merge <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
 ]
@@ -705,7 +703,6 @@ recipe main [
 <span class="Comment">//: container fields.</span>
 
 <span class="Delimiter">:(scenario merge_check_recursive_containers)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   <span class="Constant">1</span>:point<span class="Special"> &lt;- </span>merge <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
   <span class="Constant">1</span>:point-number<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:point<span class="Delimiter">,</span> <span class="Constant">5</span>
@@ -721,7 +718,6 @@ recipe main [
 <span class="traceContains">+error: main: too few ingredients in '2:point-number &lt;- merge 1:point'</span>
 
 <span class="Delimiter">:(scenario merge_check_recursive_containers_3)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   <span class="Constant">1</span>:point-number<span class="Special"> &lt;- </span>merge <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
diff --git a/html/032array.cc.html b/html/032array.cc.html
index b60c44c9..fc255ce8 100644
--- a/html/032array.cc.html
+++ b/html/032array.cc.html
@@ -16,7 +16,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .SalientComment { color: #00ffff; }
 .traceContains { color: #008000; }
 .cSpecial { color: #008000; }
-.CommentedCode { color: #6c6c6c; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #a04060; }
 .Special { color: #ff6060; }
@@ -147,7 +146,6 @@ if <span class="Delimiter">(</span>r<span class="Delimiter">.</span>type &amp;&a
     raise_error &lt;&lt; maybe<span class="Delimiter">(</span>current_recipe_name<span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;'&quot;</span> &lt;&lt; r<span class="Delimiter">.</span>original_string &lt;&lt; <span class="Constant">&quot;' is an array of what?</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
     <span class="Identifier">return</span> <span class="Constant">1</span><span class="Delimiter">;</span>
   <span class="Delimiter">}</span>
-<span class="CommentedCode">//?   trace(9999, &quot;mem&quot;) &lt;&lt; &quot;computing size of array starting at &quot; &lt;&lt; r.value &lt;&lt; end();</span>
   <span class="Identifier">return</span> <span class="Constant">1</span> + get_or_insert<span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> r<span class="Delimiter">.</span>value<span class="Delimiter">)</span>*size_of<span class="Delimiter">(</span>array_element<span class="Delimiter">(</span>r<span class="Delimiter">.</span>type<span class="Delimiter">));</span>
 <span class="Delimiter">}</span>
 
@@ -155,7 +153,6 @@ if <span class="Delimiter">(</span>r<span class="Delimiter">.</span>type &amp;&a
 <span class="Comment">//: advance</span>
 
 <span class="Delimiter">:(scenario container_contains_array)</span>
-<span class="Special">% Hide_errors = true;</span>
 container foo [
   x:array:number:<span class="Constant">3</span>
 ]
diff --git a/html/033exclusive_container.cc.html b/html/033exclusive_container.cc.html
index c26c885a..81009263 100644
--- a/html/033exclusive_container.cc.html
+++ b/html/033exclusive_container.cc.html
@@ -209,7 +209,6 @@ else if <span class="Delimiter">(</span>command == <span class="Constant">&quot;
 <span class="Comment">//: fixed in advance</span>
 
 <span class="Delimiter">:(scenario exclusive_container_contains_array)</span>
-<span class="Special">% Hide_errors = true;</span>
 exclusive-container foo [
   x:array:number:<span class="Constant">3</span>
 ]
@@ -242,7 +241,6 @@ recipe main [
 <span class="Comment">//: type-checking for 'merge' on exclusive containers</span>
 
 <span class="Delimiter">:(scenario merge_handles_exclusive_container)</span>
-<span class="Special">% Hide_errors = true;</span>
 exclusive-container foo [
   x:number
   y:bar
@@ -297,7 +295,6 @@ case EXCLUSIVE_CONTAINER: <span class="Delimiter">{</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario merge_check_container_containing_exclusive_container)</span>
-<span class="Special">% Hide_errors = true;</span>
 container foo [
   x:number
   y:bar
@@ -330,7 +327,6 @@ recipe main [
 <span class="traceContains">+error: main: too many ingredients in '1:foo &lt;- merge 23, 1/y, 34, 35'</span>
 
 <span class="Delimiter">:(scenario merge_check_exclusive_container_containing_container)</span>
-<span class="Special">% Hide_errors = true;</span>
 exclusive-container foo [
   x:number
   y:bar
@@ -348,7 +344,6 @@ recipe main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_exclusive_container_containing_container_2)</span>
-<span class="Special">% Hide_errors = true;</span>
 exclusive-container foo [
   x:number
   y:bar
diff --git a/html/036call_reply.cc.html b/html/036call_reply.cc.html
index 2334a5c4..b99ecc0d 100644
--- a/html/036call_reply.cc.html
+++ b/html/036call_reply.cc.html
@@ -179,7 +179,6 @@ recipe test1 [
 <span class="traceContains">+error: main: '2:number &lt;- test1 1:number' should write to 1:number rather than 2:number</span>
 
 <span class="Delimiter">:(scenario reply_same_as_ingredient_dummy)</span>
-<span class="Comment"># % Hide_errors = true;</span>
 recipe main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   _<span class="Special"> &lt;- </span>test1 <span class="Constant">1</span>:number  <span class="Comment"># call with different ingredient and product</span>
diff --git a/html/042name.cc.html b/html/042name.cc.html
index e3b73f35..db8ea63b 100644
--- a/html/042name.cc.html
+++ b/html/042name.cc.html
@@ -202,7 +202,6 @@ recipe main [
 <span class="traceContains">+error: main: mixing variable names and numeric addresses</span>
 
 <span class="Delimiter">:(scenario transform_names_does_not_fail_when_mixing_names_and_raw_locations)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   x:number<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:number/<span class="Special">raw</span>
 ]
@@ -210,7 +209,6 @@ recipe main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario transform_names_does_not_fail_when_mixing_names_and_literals)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   x:number<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
diff --git a/html/043space.cc.html b/html/043space.cc.html
index 777562dd..3c17a04e 100644
--- a/html/043space.cc.html
+++ b/html/043space.cc.html
@@ -22,7 +22,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .Special { color: #ff6060; }
 .Identifier { color: #804000; }
 .Constant { color: #00a0a0; }
-.CommentedCode { color: #6c6c6c; }
 -->
 </style>
 
@@ -301,7 +300,6 @@ void check_default_space<span class="Delimiter">(</span>const recipe_ordinal r<s
   if <span class="Delimiter">(</span>caller<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span>
       || caller<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>name != <span class="Constant">&quot;default-space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
     raise_error &lt;&lt; maybe<span class="Delimiter">(</span>caller<span class="Delimiter">.</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot; does not seem to start with default-space or local-scope</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
-<span class="CommentedCode">//?     cerr &lt;&lt; maybe(caller.name) &lt;&lt; &quot; does not seem to start with default-space or local-scope\n&quot; &lt;&lt; '\n';</span>
   <span class="Delimiter">}</span>
 <span class="Delimiter">}</span>
 <span class="Delimiter">:(after &quot;Load .mu Core&quot;)</span>
@@ -316,10 +314,8 @@ bool contains_non_special_name<span class="Delimiter">(</span>const recipe_ordin
   for <span class="Delimiter">(</span>map&lt;string<span class="Delimiter">,</span> long long int&gt;::iterator p = Name[r]<span class="Delimiter">.</span>begin<span class="Delimiter">();</span> p != Name[r]<span class="Delimiter">.</span>end<span class="Delimiter">();</span> ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span>
     if <span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>first<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
     if <span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>first<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;stash_&quot;</span><span class="Delimiter">)</span> == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>  <span class="Comment">// generated by rewrite_stashes_to_text (cross-layer)</span>
-    if <span class="Delimiter">(</span>!is_special_name<span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>first<span class="Delimiter">))</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?       cerr &lt;&lt; &quot;  &quot; &lt;&lt; get(Recipe, r).name &lt;&lt; &quot;: &quot; &lt;&lt; p-&gt;first &lt;&lt; '\n';</span>
+    if <span class="Delimiter">(</span>!is_special_name<span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>first<span class="Delimiter">))</span>
       <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
-    <span class="Delimiter">}</span>
   <span class="Delimiter">}</span>
   <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
 <span class="Delimiter">}</span>
diff --git a/html/044space_surround.cc.html b/html/044space_surround.cc.html
index e58029c4..0baf4873 100644
--- a/html/044space_surround.cc.html
+++ b/html/044space_surround.cc.html
@@ -15,7 +15,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
 .traceContains { color: #008000; }
 .cSpecial { color: #008000; }
-.CommentedCode { color: #6c6c6c; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #a04060; }
 .Special { color: #ff6060; }
@@ -73,12 +72,9 @@ long long int space_base<span class="Delimiter">(</span>const reagent&amp; x<spa
 <span class="Delimiter">}</span>
 
 long long int space_base<span class="Delimiter">(</span>const reagent&amp; x<span class="Delimiter">,</span> long long int space_index<span class="Delimiter">,</span> long long int base<span class="Delimiter">)</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   trace(9999, &quot;space&quot;) &lt;&lt; &quot;space-base: &quot; &lt;&lt; space_index &lt;&lt; &quot; &quot; &lt;&lt; base &lt;&lt; end();</span>
-  if <span class="Delimiter">(</span>space_index == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
+  if <span class="Delimiter">(</span>space_index == <span class="Constant">0</span><span class="Delimiter">)</span>
     <span class="Identifier">return</span> base<span class="Delimiter">;</span>
-  <span class="Delimiter">}</span>
   long long int result = space_base<span class="Delimiter">(</span>x<span class="Delimiter">,</span> space_index-<span class="Constant">1</span><span class="Delimiter">,</span> get_or_insert<span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> base+<span class="Comment">/*</span><span class="Comment">skip length</span><span class="Comment">*/</span><span class="Constant">1</span><span class="Delimiter">))</span>+<span class="Comment">/*</span><span class="Comment">skip refcount</span><span class="Comment">*/</span><span class="Constant">1</span><span class="Delimiter">;</span>
-<span class="CommentedCode">//?   trace(9999, &quot;space&quot;) &lt;&lt; &quot;space-base: &quot; &lt;&lt; space_index &lt;&lt; &quot; &quot; &lt;&lt; base &lt;&lt; &quot; =&gt; &quot; &lt;&lt; result &lt;&lt; end();</span>
   <span class="Identifier">return</span> result<span class="Delimiter">;</span>
 <span class="Delimiter">}</span>
 
diff --git a/html/045closure_name.cc.html b/html/045closure_name.cc.html
index 5f1b3232..8ff3c096 100644
--- a/html/045closure_name.cc.html
+++ b/html/045closure_name.cc.html
@@ -112,7 +112,6 @@ void collect_surrounding_spaces<span class="Delimiter">(</span>const recipe_ordi
         <span class="Identifier">continue</span><span class="Delimiter">;</span>
       <span class="Delimiter">}</span>
       trace<span class="Delimiter">(</span><span class="Constant">9993</span><span class="Delimiter">,</span> <span class="Constant">&quot;name&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;lexically surrounding space for recipe &quot;</span> &lt;&lt; get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name &lt;&lt; <span class="Constant">&quot; comes from &quot;</span> &lt;&lt; surrounding_recipe_name &lt;&lt; end<span class="Delimiter">();</span>
-<span class="CommentedCode">//?       cerr &lt;&lt; &quot;lexically surrounding space for recipe &quot; &lt;&lt; get(Recipe, r).name &lt;&lt; &quot; comes from &quot; &lt;&lt; surrounding_recipe_name &lt;&lt; '\n';</span>
       if <span class="Delimiter">(</span>!contains_key<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> surrounding_recipe_name<span class="Delimiter">))</span> <span class="Delimiter">{</span>
         raise_error &lt;&lt; <span class="Constant">&quot;can't find recipe providing surrounding space for &quot;</span> &lt;&lt; get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; surrounding_recipe_name &lt;&lt; <span class="cSpecial">'\n'</span> &lt;&lt; end<span class="Delimiter">();</span>
         <span class="Identifier">continue</span><span class="Delimiter">;</span>
diff --git a/html/046global.cc.html b/html/046global.cc.html
index b9b8feea..75d02253 100644
--- a/html/046global.cc.html
+++ b/html/046global.cc.html
@@ -99,7 +99,6 @@ global_space = <span class="Constant">0</span><span class="Delimiter">;</span>
 <span class="Comment">//: don't want to make them too comfortable to use.</span>
 
 <span class="Delimiter">:(scenario global_space_with_names)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   global-space:address:shared:array:location<span class="Special"> &lt;- </span>new location:type<span class="Delimiter">,</span> <span class="Constant">10</span>
   x:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
diff --git a/html/050scenario.cc.html b/html/050scenario.cc.html
index 420826b2..35dd216a 100644
--- a/html/050scenario.cc.html
+++ b/html/050scenario.cc.html
@@ -246,14 +246,9 @@ case RUN: <span class="Delimiter">{</span>
   assert<span class="Delimiter">(</span>Name[Next_recipe_ordinal]<span class="Delimiter">.</span>empty<span class="Delimiter">());</span>
   ostringstream tmp<span class="Delimiter">;</span>
   tmp &lt;&lt; <span class="Constant">&quot;recipe run_&quot;</span> &lt;&lt; Next_recipe_ordinal &lt;&lt; <span class="Constant">&quot; [ &quot;</span> &lt;&lt; current_instruction<span class="Delimiter">().</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>name &lt;&lt; <span class="Constant">&quot; ]&quot;</span><span class="Delimiter">;</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; tmp.str() &lt;&lt; '\n';</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;before load\n&quot;;</span>
   vector&lt;recipe_ordinal&gt; tmp_recipe = load<span class="Delimiter">(</span>tmp<span class="Delimiter">.</span>str<span class="Delimiter">());</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;before bind\n&quot;;</span>
   bind_special_scenario_names<span class="Delimiter">(</span>tmp_recipe<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;before transform\n&quot;;</span>
   transform_all<span class="Delimiter">();</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;end\n&quot;;</span>
   if <span class="Delimiter">(</span>Trace_stream<span class="Delimiter">)</span> <span class="Delimiter">{</span>
     ++Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth<span class="Delimiter">;</span>
     trace<span class="Delimiter">(</span><span class="Constant">9998</span><span class="Delimiter">,</span> <span class="Constant">&quot;trace&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;run: incrementing callstack depth to &quot;</span> &lt;&lt; Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth &lt;&lt; end<span class="Delimiter">();</span>
@@ -486,6 +481,7 @@ recipe main [
   ]
 ]
 <span class="traceAbsent">-error: location 1 can't contain non-number 34  # comment</span>
+<span class="Comment"># but there'll be an error signalled by memory-should-contain</span>
 
 <span class="Delimiter">:(code)</span>
 <span class="Comment">//: 'trace-should-contain' is like the '+' lines in our scenarios so far</span>
@@ -568,7 +564,6 @@ recipe main [
 
 <span class="Delimiter">:(scenario trace_check_passes_silently)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   run [
     trace <span class="Constant">1</span><span class="Delimiter">,</span> [a]<span class="Delimiter">,</span> [b]
@@ -630,7 +625,6 @@ bool check_trace_missing<span class="Delimiter">(</span>const string&amp; in<spa
 
 <span class="Delimiter">:(scenario trace_negative_check_passes_silently)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   trace-should-not-contain [
     a: b
diff --git a/html/054dilated_reagent.cc.html b/html/054dilated_reagent.cc.html
index 900a3f8c..a9dc4112 100644
--- a/html/054dilated_reagent.cc.html
+++ b/html/054dilated_reagent.cc.html
@@ -53,7 +53,6 @@ recipe main [
 
 <span class="Delimiter">:(scenarios run)</span>
 <span class="Delimiter">:(scenario dilated_reagent_with_comment)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   <span class="Delimiter">{</span><span class="Constant">1</span>: number<span class="Delimiter">,</span> foo: bar<span class="Delimiter">}</span><span class="Special"> &lt;- </span>copy <span class="Constant">34</span>  <span class="Comment"># test comment</span>
 ]
@@ -61,7 +60,6 @@ recipe main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario dilated_reagent_with_comment_immediately_following)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Delimiter">{</span><span class="Constant">34</span>: literal<span class="Delimiter">}</span>  <span class="Comment"># test comment</span>
 ]
diff --git a/html/057static_dispatch.cc.html b/html/057static_dispatch.cc.html
index ac2db406..5287542c 100644
--- a/html/057static_dispatch.cc.html
+++ b/html/057static_dispatch.cc.html
@@ -15,12 +15,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
 .traceAbsent { color: #c00000; }
 .traceContains { color: #008000; }
-.Identifier { color: #804000; }
 .cSpecial { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #a04060; }
 .Special { color: #ff6060; }
-.CommentedCode { color: #6c6c6c; }
+.Identifier { color: #804000; }
 .Constant { color: #00a0a0; }
 -->
 </style>
@@ -68,7 +67,6 @@ for <span class="Delimiter">(</span>map&lt;string<span class="Delimiter">,</span
 <span class="Comment">// there can only ever be one variant for main</span>
 if <span class="Delimiter">(</span>result<span class="Delimiter">.</span>name != <span class="Constant">&quot;main&quot;</span> &amp;&amp; contains_key<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> result<span class="Delimiter">.</span>name<span class="Delimiter">))</span> <span class="Delimiter">{</span>
   const recipe_ordinal r = get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> result<span class="Delimiter">.</span>name<span class="Delimiter">);</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; result.name &lt;&lt; &quot;: &quot; &lt;&lt; contains_key(Recipe, r) &lt;&lt; (contains_key(Recipe, r) ? get(Recipe, r).has_header : 0) &lt;&lt; matching_variant_name(result) &lt;&lt; '\n';</span>
   if <span class="Delimiter">(</span>!contains_key<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">)</span> || get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>has_header<span class="Delimiter">)</span> <span class="Delimiter">{</span>
     string new_name = matching_variant_name<span class="Delimiter">(</span>result<span class="Delimiter">);</span>
     if <span class="Delimiter">(</span>new_name<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span>
@@ -79,7 +77,6 @@ if <span class="Delimiter">(</span>result<span class="Delimiter">.</span>name !=
     <span class="Delimiter">}</span>
     trace<span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;load&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;switching &quot;</span> &lt;&lt; result<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot; to &quot;</span> &lt;&lt; new_name &lt;&lt; end<span class="Delimiter">();</span>
     result<span class="Delimiter">.</span>name = new_name<span class="Delimiter">;</span>
-<span class="CommentedCode">//?     cerr &lt;&lt; &quot;=&gt; &quot; &lt;&lt; new_name &lt;&lt; '\n';</span>
   <span class="Delimiter">}</span>
 <span class="Delimiter">}</span>
 else <span class="Delimiter">{</span>
@@ -424,7 +421,6 @@ recipe equal x:number<span class="Delimiter">,</span> y:number <span class="Deli
 <span class="traceContains">+mem: storing 1 in location 6</span>
 
 <span class="Delimiter">:(scenario static_dispatch_works_with_dummy_results_for_containers)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   _<span class="Special"> &lt;- </span>test <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
 ]
@@ -441,7 +437,6 @@ recipe test a:number<span class="Delimiter">,</span> b:number <span class="Delim
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario static_dispatch_works_with_compound_type_containing_container_defined_after_first_use)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   x:address:shared:foo<span class="Special"> &lt;- </span>new foo:type
   test x
@@ -457,7 +452,6 @@ recipe test a:address:shared:foo <span class="Delimiter">-&gt;</span> z:number [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario static_dispatch_works_with_compound_type_containing_container_defined_after_second_use)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   x:address:shared:foo<span class="Special"> &lt;- </span>new foo:type
   test x
diff --git a/html/058shape_shifting_container.cc.html b/html/058shape_shifting_container.cc.html
index ef2ac641..88b313cc 100644
--- a/html/058shape_shifting_container.cc.html
+++ b/html/058shape_shifting_container.cc.html
@@ -50,7 +50,6 @@ recipe main [
 <span class="traceContains">+mem: storing 16 in location 5</span>
 
 <span class="Delimiter">:(scenario size_of_shape_shifting_container_2)</span>
-<span class="Special">% Hide_errors = true;</span>
 <span class="Comment"># multiple type ingredients</span>
 container foo:_a:_b [
   x:_a
@@ -62,7 +61,6 @@ recipe main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario size_of_shape_shifting_container_3)</span>
-<span class="Special">% Hide_errors = true;</span>
 container foo:_a:_b [
   x:_a
   y:_b
@@ -75,7 +73,6 @@ recipe main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario size_of_shape_shifting_container_4)</span>
-<span class="Special">% Hide_errors = true;</span>
 container foo:_a:_b [
   x:_a
   y:_b
@@ -507,7 +504,6 @@ if <span class="Delimiter">(</span>type<span class="Delimiter">-&gt;</span>value
 <span class="Comment">//: 'merge' on shape-shifting containers</span>
 
 <span class="Delimiter">:(scenario merge_check_shape_shifting_container_containing_exclusive_container)</span>
-<span class="Special">% Hide_errors = true;</span>
 container foo:_elem [
   x:number
   y:_elem
@@ -540,7 +536,6 @@ recipe main [
 <span class="traceContains">+error: main: too many ingredients in '1:foo:bar &lt;- merge 23, 1/y, 34, 35'</span>
 
 <span class="Delimiter">:(scenario merge_check_shape_shifting_exclusive_container_containing_container)</span>
-<span class="Special">% Hide_errors = true;</span>
 exclusive-container foo:_elem [
   x:number
   y:_elem
@@ -558,7 +553,6 @@ recipe main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_shape_shifting_exclusive_container_containing_container_2)</span>
-<span class="Special">% Hide_errors = true;</span>
 exclusive-container foo:_elem [
   x:number
   y:_elem
diff --git a/html/059shape_shifting_recipe.cc.html b/html/059shape_shifting_recipe.cc.html
index 294f5e7e..c71467b8 100644
--- a/html/059shape_shifting_recipe.cc.html
+++ b/html/059shape_shifting_recipe.cc.html
@@ -717,7 +717,6 @@ recipe foo x:_elem <span class="Delimiter">-&gt;</span> y:_elem [
 <span class="traceContains">+mem: storing 4 in location 1</span>
 
 <span class="Delimiter">:(scenario specialize_with_literal_3)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   local-scope
   <span class="Comment"># permit '0' to map to address to shape-shifting type-ingredient</span>
diff --git a/html/060immutable.cc.html b/html/060immutable.cc.html
index 0b8e2845..167e28b6 100644
--- a/html/060immutable.cc.html
+++ b/html/060immutable.cc.html
@@ -35,7 +35,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="Comment">//: also products. This layer will start enforcing this check.</span>
 
 <span class="Delimiter">:(scenario can_modify_value_ingredients)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   local-scope
   p:address:shared:point<span class="Special"> &lt;- </span>new point:type
@@ -50,7 +49,6 @@ recipe foo p:point [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario can_modify_ingredients_that_are_also_products)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   local-scope
   p:address:shared:point<span class="Special"> &lt;- </span>new point:type
@@ -65,7 +63,6 @@ recipe foo p:address:shared:point <span class="Delimiter">-&gt;</span> p:address
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario ignore_literal_ingredients_for_immutability_checks)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   local-scope
   p:address:shared:d1<span class="Special"> &lt;- </span>new d1:type
@@ -135,7 +132,6 @@ recipe foo p:address:shared:point [
 <span class="traceContains">+error: foo: cannot modify q after instruction 'x:address:number &lt;- get-address *q, x:offset' because that would modify ingredient p which is not also a product of foo</span>
 
 <span class="Delimiter">:(scenario can_traverse_immutable_ingredients)</span>
-<span class="Special">% Hide_errors = true;</span>
 container test-list [
   next:address:shared:test-list
 ]
@@ -157,7 +153,6 @@ recipe bar x:address:shared:test-list <span class="Delimiter">-&gt;</span> y:add
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario handle_optional_ingredients_in_immutability_checks)</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   k:address:shared:number<span class="Special"> &lt;- </span>new number:type
   test k
@@ -343,7 +338,6 @@ set&lt;long long int&gt; ingredient_indices<span class="Delimiter">(</span>const
 
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario can_modify_contained_in_addresses)</span>
-<span class="Special">% Hide_errors = true;</span>
 container test-list [
   next:address:shared:test-list
 ]
diff --git a/html/070text.mu.html b/html/070text.mu.html
index 4c802574..15dddd92 100644
--- a/html/070text.mu.html
+++ b/html/070text.mu.html
@@ -20,7 +20,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
-.CommentedCode { color: #6c6c6c; }
 .Delimiter { color: #a04060; }
 -->
 </style>
@@ -47,7 +46,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="muRecipe">recipe</span> to-text x:address:shared:array:character<span class="muRecipe"> -&gt; </span>y:address:shared:array:character [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-<span class="CommentedCode">#?   $print [to-text text], 10/newline</span>
   <span class="muControl">reply</span> x
 ]
 
@@ -198,7 +196,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="Comment"># most broadly applicable definition of append to a buffer: just call to-text</span>
 <span class="muRecipe">recipe</span> append buf:address:shared:buffer, x:_elem<span class="muRecipe"> -&gt; </span>buf:address:shared:buffer [
   <span class="Constant">local-scope</span>
-<span class="CommentedCode">#?   $print [append _elem to buffer], 10/newline</span>
   <span class="Constant">load-ingredients</span>
   text:address:shared:array:character<span class="Special"> &lt;- </span>to-text x
   len:number<span class="Special"> &lt;- </span>length *text
@@ -215,7 +212,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 
 <span class="muRecipe">recipe</span> append in:address:shared:buffer, c:character<span class="muRecipe"> -&gt; </span>in:address:shared:buffer [
   <span class="Constant">local-scope</span>
-<span class="CommentedCode">#?   $print [append character to buffer], 10/newline</span>
   <span class="Constant">load-ingredients</span>
   len:address:number<span class="Special"> &lt;- </span>get-address *in, <span class="Constant">length:offset</span>
   <span class="Delimiter">{</span>
@@ -427,7 +423,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 
 <span class="muRecipe">recipe</span> append a:address:shared:array:character, b:address:shared:array:character<span class="muRecipe"> -&gt; </span>result:address:shared:array:character [
   <span class="Constant">local-scope</span>
-<span class="CommentedCode">#?   $print [append text to text], 10/newline</span>
   <span class="Constant">load-ingredients</span>
   <span class="Comment"># result = new character[a.length + b.length]</span>
   a-len:number<span class="Special"> &lt;- </span>length *a
diff --git a/html/073list.mu.html b/html/073list.mu.html
index c184e73f..9a1469cb 100644
--- a/html/073list.mu.html
+++ b/html/073list.mu.html
@@ -20,7 +20,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
-.CommentedCode { color: #6c6c6c; }
 .Delimiter { color: #a04060; }
 -->
 </style>
@@ -88,7 +87,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 
 <span class="muRecipe">recipe</span> to-text in:address:shared:list:_elem<span class="muRecipe"> -&gt; </span>result:address:shared:array:character [
   <span class="Constant">local-scope</span>
-<span class="CommentedCode">#?   $print [to text: list], 10/newline</span>
   <span class="Constant">load-ingredients</span>
   buf:address:shared:buffer<span class="Special"> &lt;- </span>new-buffer <span class="Constant">80</span>
   buf<span class="Special"> &lt;- </span>to-buffer in, buf
@@ -98,7 +96,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="Comment"># variant of 'to-text' which stops printing after a few elements (and so is robust to cycles)</span>
 <span class="muRecipe">recipe</span> to-text-line in:address:shared:list:_elem<span class="muRecipe"> -&gt; </span>result:address:shared:array:character [
   <span class="Constant">local-scope</span>
-<span class="CommentedCode">#?   $print [to text line: list], 10/newline</span>
   <span class="Constant">load-ingredients</span>
   buf:address:shared:buffer<span class="Special"> &lt;- </span>new-buffer <span class="Constant">80</span>
   buf<span class="Special"> &lt;- </span>to-buffer in, buf, <span class="Constant">6</span>  <span class="Comment"># max elements to display</span>
@@ -107,7 +104,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 
 <span class="muRecipe">recipe</span> to-buffer in:address:shared:list:_elem, buf:address:shared:buffer<span class="muRecipe"> -&gt; </span>buf:address:shared:buffer [
   <span class="Constant">local-scope</span>
-<span class="CommentedCode">#?   $print [to buffer: list], 10/newline</span>
   <span class="Constant">load-ingredients</span>
   <span class="Delimiter">{</span>
     <span class="muControl">break-if</span> in
@@ -120,7 +116,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
   <span class="Comment"># now prepare next</span>
   next:address:shared:list:_elem<span class="Special"> &lt;- </span>rest in
   nextn:number<span class="Special"> &lt;- </span>copy next
-<span class="CommentedCode">#?   buf &lt;- append buf, nextn</span>
   <span class="muControl">reply-unless</span> next
   space:character<span class="Special"> &lt;- </span>copy <span class="Constant">32/space</span>
   buf<span class="Special"> &lt;- </span>append buf, space:character
diff --git a/html/077hash.cc.html b/html/077hash.cc.html
index d223be71..fc9f3e46 100644
--- a/html/077hash.cc.html
+++ b/html/077hash.cc.html
@@ -66,7 +66,6 @@ case HASH: <span class="Delimiter">{</span>
 
 <span class="Delimiter">:(code)</span>
 size_t hash<span class="Delimiter">(</span>size_t h<span class="Delimiter">,</span> reagent&amp; r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; debug_string(r) &lt;&lt; '\n';</span>
   canonize<span class="Delimiter">(</span>r<span class="Delimiter">);</span>
   if <span class="Delimiter">(</span>is_mu_string<span class="Delimiter">(</span>r<span class="Delimiter">))</span>  <span class="Comment">// optimization</span>
     <span class="Identifier">return</span> hash_mu_string<span class="Delimiter">(</span>h<span class="Delimiter">,</span> r<span class="Delimiter">);</span>
diff --git a/html/082scenario_screen.cc.html b/html/082scenario_screen.cc.html
index 71522122..5c7b4468 100644
--- a/html/082scenario_screen.cc.html
+++ b/html/082scenario_screen.cc.html
@@ -21,7 +21,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .Special { color: #ff6060; }
 .Identifier { color: #804000; }
 .Constant { color: #00a0a0; }
-.CommentedCode { color: #6c6c6c; }
 -->
 </style>
 
@@ -150,7 +149,6 @@ if <span class="Delimiter">(</span>s == <span class="Constant">&quot;screen&quot
 <span class="Delimiter">:(scenarios run)</span>
 <span class="Delimiter">:(scenario convert_names_does_not_fail_when_mixing_special_names_and_numeric_locations)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
-<span class="Special">% Hide_errors = true;</span>
 recipe main [
   screen:number<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:number
 ]
@@ -200,8 +198,6 @@ case SCREEN_SHOULD_CONTAIN: <span class="Delimiter">{</span>
 <span class="Delimiter">}</span>
 <span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
 case SCREEN_SHOULD_CONTAIN: <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; SIZE(get(Recipe_variants, &quot;insert&quot;)) &lt;&lt; '\n';</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; debug_string(get(Recipe, get(Recipe_ordinal, &quot;insert_4&quot;))) &lt;&lt; '\n';</span>
   if <span class="Delimiter">(</span>!Passed<span class="Delimiter">)</span> <span class="Identifier">break</span><span class="Delimiter">;</span>
   assert<span class="Delimiter">(</span>scalar<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)));</span>
   check_screen<span class="Delimiter">(</span>current_instruction<span class="Delimiter">().</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>name<span class="Delimiter">,</span> -<span class="Constant">1</span><span class="Delimiter">);</span>
diff --git a/html/086scenario_console_test.mu.html b/html/086scenario_console_test.mu.html
index 181c8973..f36290b3 100644
--- a/html/086scenario_console_test.mu.html
+++ b/html/086scenario_console_test.mu.html
@@ -17,7 +17,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
-.CommentedCode { color: #6c6c6c; }
 -->
 </style>
 
@@ -54,11 +53,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
     <span class="Constant">8</span><span class="Special"> &lt;- </span><span class="Constant">1</span>
   ]
 ]
-
-<span class="CommentedCode">#? recipe foo-editor [</span>
-<span class="CommentedCode">#?   local-scope</span>
-<span class="CommentedCode">#?   init:address:shared:list:character &lt;- push 97/a, 0</span>
-<span class="CommentedCode">#? ]</span>
 </pre>
 </body>
 </html>
diff --git a/html/091run_interactive.cc.html b/html/091run_interactive.cc.html
index 423e1f89..444f50af 100644
--- a/html/091run_interactive.cc.html
+++ b/html/091run_interactive.cc.html
@@ -15,7 +15,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
 .traceContains { color: #008000; }
 .cSpecial { color: #008000; }
-.CommentedCode { color: #6c6c6c; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #a04060; }
 .Special { color: #ff6060; }
@@ -143,7 +142,6 @@ bool run_interactive<span class="Delimiter">(</span>long long int address<span c
 <span class="Delimiter">}</span>
 
 void run_code_begin<span class="Delimiter">(</span>bool snapshot_recently_added_recipes<span class="Delimiter">)</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;loading new trace\n&quot;;</span>
   <span class="Comment">// stuff to undo later, in run_code_end()</span>
   Hide_errors = <span class="Constant">true</span><span class="Delimiter">;</span>
   Disable_redefine_checks = <span class="Constant">true</span><span class="Delimiter">;</span>
@@ -161,7 +159,6 @@ void run_code_begin<span class="Delimiter">(</span>bool snapshot_recently_added_
 <span class="Delimiter">}</span>
 
 void run_code_end<span class="Delimiter">()</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;back to old trace\n&quot;;</span>
   Hide_errors = <span class="Constant">false</span><span class="Delimiter">;</span>
   Disable_redefine_checks = <span class="Constant">false</span><span class="Delimiter">;</span>
   delete Trace_stream<span class="Delimiter">;</span>
@@ -492,7 +489,6 @@ case RELOAD: <span class="Delimiter">{</span>
 <span class="Delimiter">}</span>
 <span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
 case RELOAD: <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;== reload\n&quot;;</span>
   <span class="Comment">// clear any containers in advance</span>
   for <span class="Delimiter">(</span>long long int i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; SIZE<span class="Delimiter">(</span>Recently_added_types<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
     if <span class="Delimiter">(</span>!contains_key<span class="Delimiter">(</span>Type<span class="Delimiter">,</span> Recently_added_types<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
@@ -500,14 +496,11 @@ case RELOAD: <span class="Delimiter">{</span>
     Type<span class="Delimiter">.</span>erase<span class="Delimiter">(</span>Recently_added_types<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
   <span class="Delimiter">}</span>
   for <span class="Delimiter">(</span>map&lt;string<span class="Delimiter">,</span> vector&lt;recipe_ordinal&gt; &gt;::iterator p = Recipe_variants<span class="Delimiter">.</span>begin<span class="Delimiter">();</span> p != Recipe_variants<span class="Delimiter">.</span>end<span class="Delimiter">();</span> ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?     cerr &lt;&lt; p-&gt;first &lt;&lt; &quot;:\n&quot;;</span>
     vector&lt;recipe_ordinal&gt;&amp; variants = p<span class="Delimiter">-&gt;</span>second<span class="Delimiter">;</span>
     for <span class="Delimiter">(</span>long long int i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; SIZE<span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>second<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
       if <span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)</span> == -<span class="Constant">1</span><span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
-      if <span class="Delimiter">(</span>find<span class="Delimiter">(</span>Recently_added_shape_shifting_recipes<span class="Delimiter">.</span>begin<span class="Delimiter">(),</span> Recently_added_shape_shifting_recipes<span class="Delimiter">.</span>end<span class="Delimiter">(),</span> variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> != Recently_added_shape_shifting_recipes<span class="Delimiter">.</span>end<span class="Delimiter">())</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?         cerr &lt;&lt; &quot;  &quot; &lt;&lt; variants.at(i) &lt;&lt; ' ' &lt;&lt; get(Recipe, variants.at(i)).name &lt;&lt; '\n';</span>
+      if <span class="Delimiter">(</span>find<span class="Delimiter">(</span>Recently_added_shape_shifting_recipes<span class="Delimiter">.</span>begin<span class="Delimiter">(),</span> Recently_added_shape_shifting_recipes<span class="Delimiter">.</span>end<span class="Delimiter">(),</span> variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> != Recently_added_shape_shifting_recipes<span class="Delimiter">.</span>end<span class="Delimiter">())</span>
         variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)</span> = -<span class="Constant">1</span><span class="Delimiter">;</span>  <span class="Comment">// ghost</span>
-      <span class="Delimiter">}</span>
     <span class="Delimiter">}</span>
   <span class="Delimiter">}</span>
   for <span class="Delimiter">(</span>long long int i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; SIZE<span class="Delimiter">(</span>Recently_added_shape_shifting_recipes<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
@@ -530,7 +523,6 @@ case RELOAD: <span class="Delimiter">{</span>
   products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
   products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>trace_error_contents<span class="Delimiter">());</span>
   run_code_end<span class="Delimiter">();</span>  <span class="Comment">// wait until we're done with the trace contents</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;reload done\n&quot;;</span>
   <span class="Identifier">break</span><span class="Delimiter">;</span>
 <span class="Delimiter">}</span>
 
diff --git a/html/999spaces.cc.html b/html/999spaces.cc.html
index 531efb53..cb067563 100644
--- a/html/999spaces.cc.html
+++ b/html/999spaces.cc.html
@@ -74,28 +74,32 @@ assert<span class="Delimiter">(</span>Max_callstack_depth == <span class="Consta
 <span class="Comment">//:   begin instruction modifying transforms</span>
 <span class="Comment">//:     56.2 check header ingredients</span>
 <span class="Comment">//:      ↳ 56.4 fill in reply ingredients</span>
+<span class="Comment">//:     48 check or set types by name</span>
 <span class="Comment">//:</span>
 <span class="Comment">//:     begin type modifying transforms</span>
 <span class="Comment">//:       56.3 deduce types from header</span>
-<span class="Comment">//:       48 check or set types by name</span>
 <span class="Comment">//:     ---</span>
 <span class="Comment">//:       30 check or set invalid containers</span>
 <span class="Comment">//:     end type modifying transforms</span>
-<span class="Comment">//:      ↳ 57 static dispatch</span>
+<span class="Comment">//:         ↱ 46 collect surrounding spaces</span>
+<span class="Comment">//:      ↳ 42 transform names</span>
+<span class="Comment">//:         ↳ 57 static dispatch</span>
 <span class="Comment">//:   ---</span>
 <span class="Comment">//:     13 update instruction operation</span>
 <span class="Comment">//:     40 transform braces</span>
 <span class="Comment">//:     41 transform labels</span>
-<span class="Comment">//:</span>
-<span class="Comment">//:      ↱ 46 collect surrounding spaces</span>
-<span class="Comment">//:     42 transform names</span>
 <span class="Comment">//:   end instruction modifying transforms</span>
+<span class="Comment">//:    ↳ 60 check immutable ingredients</span>
 <span class="Comment">//:</span>
 <span class="Comment">//:   begin checks</span>
 <span class="Comment">//:   ---</span>
 <span class="Comment">//:     21 check instruction</span>
+<span class="Comment">//:     ↳ 61 check indirect calls against header</span>
+<span class="Comment">//:     ↳ 56 check calls against header</span>
 <span class="Comment">//:     ↳ 43 transform 'new' to 'allocate'</span>
-<span class="Comment">//:</span>
+<span class="Comment">//:     30 check merge calls</span>
+<span class="Comment">//:     36 check types of reply instructions</span>
+<span class="Comment">//:     43 check default space</span>
 <span class="Comment">//:     56 check reply instructions against header</span>
 <span class="Comment">//:   end checks</span>
 <span class="Comment">//: end transforms</span>
diff --git a/html/edit/004-programming-environment.mu.html b/html/edit/004-programming-environment.mu.html
index adcb7c8c..4b9e508c 100644
--- a/html/edit/004-programming-environment.mu.html
+++ b/html/edit/004-programming-environment.mu.html
@@ -20,7 +20,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.CommentedCode { color: #6c6c6c; }
 .Delimiter { color: #a04060; }
 .muScenario { color: #00af00; }
 -->
@@ -416,9 +415,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
   <span class="Comment"># top menu</span>
   trace <span class="Constant">11</span>, <span class="Constant">[app]</span>, <span class="Constant">[render top menu]</span>
   width:number<span class="Special"> &lt;- </span>screen-width screen
-<span class="CommentedCode">#?   $print [draw menu], 10/newline</span>
   draw-horizontal screen, <span class="Constant">0</span>, <span class="Constant">0/left</span>, width, <span class="Constant">32/space</span>, <span class="Constant">0/black</span>, <span class="Constant">238/grey</span>
-<span class="CommentedCode">#?   $print [draw menu end], 10/newline</span>
   button-start:number<span class="Special"> &lt;- </span>subtract width, <span class="Constant">20</span>
   button-on-screen?:boolean<span class="Special"> &lt;- </span>greater-or-equal button-start, <span class="Constant">0</span>
   assert button-on-screen?, <span class="Constant">[screen too narrow for menu]</span>
diff --git a/html/edit/005-sandbox.mu.html b/html/edit/005-sandbox.mu.html
index d7a18512..c48f90d7 100644
--- a/html/edit/005-sandbox.mu.html
+++ b/html/edit/005-sandbox.mu.html
@@ -20,7 +20,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.CommentedCode { color: #6c6c6c; }
 .Delimiter { color: #a04060; }
 .muScenario { color: #00af00; }
 -->
@@ -163,14 +162,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
   <span class="Delimiter">{</span>
     do-run?:boolean<span class="Special"> &lt;- </span>equal *k, <span class="Constant">65532/F4</span>
     <span class="muControl">break-unless</span> do-run?
-<span class="CommentedCode">#?     $log [F4 pressed]</span>
     status:address:shared:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[running...       ]</span>
     screen<span class="Special"> &lt;- </span>update-status screen, status, <span class="Constant">245/grey</span>
     error?:boolean, env, screen<span class="Special"> &lt;- </span>run-sandboxes env, screen
     <span class="Comment"># F4 might update warnings and results on both sides</span>
-<span class="CommentedCode">#?     $print [render-all begin], 10/newline</span>
     screen<span class="Special"> &lt;- </span>render-all screen, env
-<span class="CommentedCode">#?     $print [render-all end], 10/newline</span>
     <span class="Delimiter">{</span>
       <span class="muControl">break-if</span> error?
       status:address:shared:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[                 ]</span>
@@ -279,7 +275,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="muRecipe">recipe!</span> render-sandbox-side screen:address:shared:screen, env:address:shared:programming-environment-data<span class="muRecipe"> -&gt; </span>screen:address:shared:screen [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-<span class="CommentedCode">#?   $log [render sandbox side]</span>
   trace <span class="Constant">11</span>, <span class="Constant">[app]</span>, <span class="Constant">[render sandbox side]</span>
   current-sandbox:address:shared:editor-data<span class="Special"> &lt;- </span>get *env, <span class="Constant">current-sandbox:offset</span>
   row:number, column:number<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>, <span class="Constant">0</span>
@@ -304,7 +299,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="muRecipe">recipe</span> render-sandboxes screen:address:shared:screen, sandbox:address:shared:sandbox-data, left:number, right:number, row:number, render-from:number, idx:number<span class="muRecipe"> -&gt; </span>row:number, screen:address:shared:screen, sandbox:address:shared:sandbox-data [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-<span class="CommentedCode">#?   $log [render sandbox]</span>
   <span class="muControl">reply-unless</span> sandbox
   screen-height:number<span class="Special"> &lt;- </span>screen-height screen
   at-bottom?:boolean<span class="Special"> &lt;- </span>greater-or-equal row, screen-height
diff --git a/html/edit/010-errors.mu.html b/html/edit/010-errors.mu.html
index b72ce428..1616c8cf 100644
--- a/html/edit/010-errors.mu.html
+++ b/html/edit/010-errors.mu.html
@@ -20,7 +20,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.CommentedCode { color: #6c6c6c; }
 .Delimiter { color: #a04060; }
 .muScenario { color: #00af00; }
 -->
@@ -44,7 +43,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="muRecipe">recipe!</span> update-recipes env:address:shared:programming-environment-data, screen:address:shared:screen<span class="muRecipe"> -&gt; </span>errors-found?:boolean, env:address:shared:programming-environment-data, screen:address:shared:screen [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-<span class="CommentedCode">#?   $log [update recipes]</span>
   recipes:address:shared:editor-data<span class="Special"> &lt;- </span>get *env, <span class="Constant">recipes:offset</span>
   in:address:shared:array:character<span class="Special"> &lt;- </span>editor-contents recipes
   save <span class="Constant">[recipes.mu]</span>, in
@@ -110,9 +108,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
     status-template:address:shared:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[errors found (_)    ]</span>
     error-index-text:address:shared:array:character<span class="Special"> &lt;- </span>to-text error-index
     status:address:shared:array:character<span class="Special"> &lt;- </span>interpolate status-template, error-index-text
-<span class="CommentedCode">#?     $print [update-status: sandbox error], 10/newline</span>
     update-status screen, status, <span class="Constant">1/red</span>
-<span class="CommentedCode">#?     $print [run sandboxes end], 10/newline</span>
   <span class="Delimiter">}</span>
 ]
 
@@ -123,13 +119,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="muRecipe">recipe!</span> update-sandbox sandbox:address:shared:sandbox-data, env:address:shared:programming-environment-data, idx:number<span class="muRecipe"> -&gt; </span>sandbox:address:shared:sandbox-data, env:address:shared:programming-environment-data [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-<span class="CommentedCode">#?   $log [update sandbox]</span>
   data:address:shared:array:character<span class="Special"> &lt;- </span>get *sandbox, <span class="Constant">data:offset</span>
   response:address:address:shared:array:character<span class="Special"> &lt;- </span>get-address *sandbox, <span class="Constant">response:offset</span>
   errors:address:address:shared:array:character<span class="Special"> &lt;- </span>get-address *sandbox, <span class="Constant">errors:offset</span>
   trace:address:address:shared:array:character<span class="Special"> &lt;- </span>get-address *sandbox, <span class="Constant">trace:offset</span>
   fake-screen:address:address:shared:screen<span class="Special"> &lt;- </span>get-address *sandbox, <span class="Constant">screen:offset</span>
-<span class="CommentedCode">#?   $print [run-interactive], 10/newline</span>
   *response, *errors, *fake-screen, *trace, completed?:boolean<span class="Special"> &lt;- </span>run-interactive data
   <span class="Delimiter">{</span>
     <span class="muControl">break-if</span> *errors
@@ -139,13 +133,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
   <span class="Delimiter">}</span>
   <span class="Delimiter">{</span>
     <span class="muControl">break-unless</span> *errors
-<span class="CommentedCode">#?     $print [setting error-index to ], idx, 10/newline</span>
     error-index:address:number<span class="Special"> &lt;- </span>get-address *env, <span class="Constant">error-index:offset</span>
     error-not-set?:boolean<span class="Special"> &lt;- </span>equal *error-index, <span class="Constant">-1</span>
     <span class="muControl">break-unless</span> error-not-set?
     *error-index<span class="Special"> &lt;- </span>copy idx
   <span class="Delimiter">}</span>
-<span class="CommentedCode">#?   $print [done with run-interactive], 10/newline</span>
 ]
 
 <span class="Comment"># make sure we render any trace</span>