3431

Improvements to syntax highlighting, particularly for Mu code in C++ files.
author: Kartik K. Agaram <vc@akkartik.com> 2016-09-30 10:45:14 -0700
committer: Kartik K. Agaram <vc@akkartik.com> 2016-09-30 10:45:14 -0700
commit: 3e1349d29fa00db1fab3a811b60bc9d8de0355e4 (patch)
tree: 93afedf36b8b211432a458ca9c0c7bfaf76e2425
parent: 6c69569a4c4ca3a23635d4d7a40f0fe557194619 (diff)
download: mu-3e1349d29fa00db1fab3a811b60bc9d8de0355e4.tar.gz
102 files changed, 1644 insertions, 1569 deletions
diff --git a/html/010vm.cc.html b/html/010vm.cc.html
index 3955c7cd..341348d3 100644
--- a/html/010vm.cc.html
+++ b/html/010vm.cc.html
@@ -15,6 +15,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .SalientComment { color: #00ffff; }
@@ -290,7 +291,7 @@ restore_snapshots<span class="Delimiter">();</span>
 <span class="SalientComment">//:: Helpers</span>
 
 <span class="Delimiter">:(code)</span>
-recipe::recipe<span class="Delimiter">()</span> <span class="Delimiter">{</span>
+<span class="muRecipe">recipe</span>::recipe<span class="Delimiter">()</span> <span class="Delimiter">{</span>
   <span class="Comment">// End recipe Constructor</span>
 <span class="Delimiter">}</span>
 
diff --git a/html/011load.cc.html b/html/011load.cc.html
index bf642aaf..febd4f72 100644
--- a/html/011load.cc.html
+++ b/html/011load.cc.html
@@ -16,12 +16,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -37,7 +38,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenarios load)</span>  <span class="Comment">// use 'load' instead of 'run' in all scenarios in this layer</span>
 <span class="Delimiter">:(scenario first_recipe)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
 <span class="traceContains">+parse: instruction: copy</span>
@@ -264,7 +265,7 @@ Disable_redefine_checks = <span class="Constant">false</span><span class="Delimi
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario recipe_instead_of_def)</span>
-recipe main [
+<span class="muRecipe">recipe</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
 <span class="traceContains">+parse: instruction: copy</span>
@@ -273,10 +274,10 @@ recipe main [
 
 <span class="Delimiter">:(scenario parse_comment_outside_recipe)</span>
 <span class="Comment"># this comment will be dropped by the tangler, so we need a dummy recipe to stop that</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
 ]
 <span class="Comment"># this comment will go through to 'load'</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
 <span class="traceContains">+parse: instruction: copy</span>
@@ -284,7 +285,7 @@ def main [
 <span class="traceContains">+parse:   product: {1: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario parse_comment_amongst_instruction)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># comment</span>
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
@@ -293,7 +294,7 @@ def main [
 <span class="traceContains">+parse:   product: {1: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario parse_comment_amongst_instruction_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># comment</span>
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
   <span class="Comment"># comment</span>
@@ -303,7 +304,7 @@ def main [
 <span class="traceContains">+parse:   product: {1: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario parse_comment_amongst_instruction_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
   <span class="Comment"># comment</span>
   <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
@@ -316,7 +317,7 @@ def main [
 <span class="traceContains">+parse:   product: {2: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario parse_comment_after_instruction)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>  <span class="Comment"># comment</span>
 ]
 <span class="traceContains">+parse: instruction: copy</span>
@@ -324,19 +325,19 @@ def main [
 <span class="traceContains">+parse:   product: {1: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario parse_label)</span>
-def main [
+<span class="muRecipe">def</span> main [
   +foo
 ]
 <span class="traceContains">+parse: label: +foo</span>
 
 <span class="Delimiter">:(scenario parse_dollar_as_recipe_name)</span>
-def main [
+<span class="muRecipe">def</span> main [
   $foo
 ]
 <span class="traceContains">+parse: instruction: $foo</span>
 
 <span class="Delimiter">:(scenario parse_multiple_properties)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>/foo:bar:baz
 ]
 <span class="traceContains">+parse: instruction: copy</span>
@@ -344,7 +345,7 @@ def main [
 <span class="traceContains">+parse:   product: {1: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario parse_multiple_products)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Delimiter">,</span> <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
 <span class="traceContains">+parse: instruction: copy</span>
@@ -353,7 +354,7 @@ def main [
 <span class="traceContains">+parse:   product: {2: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario parse_multiple_ingredients)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Delimiter">,</span> <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">4</span>:number
 ]
 <span class="traceContains">+parse: instruction: copy</span>
@@ -363,7 +364,7 @@ def main [
 <span class="traceContains">+parse:   product: {2: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario parse_multiple_types)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Delimiter">,</span> <span class="Constant">2</span>:address:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">4</span>:number
 ]
 <span class="traceContains">+parse: instruction: copy</span>
@@ -373,7 +374,7 @@ def main [
 <span class="traceContains">+parse:   product: {2: (&quot;address&quot; &quot;number&quot;)}</span>
 
 <span class="Delimiter">:(scenario parse_properties)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:number/lookup<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
 <span class="traceContains">+parse:   product: {1: (&quot;address&quot; &quot;number&quot;), &quot;lookup&quot;: ()}</span>
@@ -390,19 +391,19 @@ def main [
 
 <span class="Delimiter">:(scenario forbid_redefining_recipes)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">24</span>
 ]
 <span class="traceContains">+error: redefining recipe main</span>
 
 <span class="Delimiter">:(scenario permit_forcibly_redefining_recipes)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
-def! main [
+<span class="muRecipe">def</span>! main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">24</span>
 ]
 <span class="traceAbsent">-error: redefining recipe main</span>
diff --git a/html/014literal_string.cc.html b/html/014literal_string.cc.html
index 10456661..c19da0af 100644
--- a/html/014literal_string.cc.html
+++ b/html/014literal_string.cc.html
@@ -15,12 +15,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -42,13 +43,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenarios load)</span>
 <span class="Delimiter">:(scenario string_literal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc def]
 ]
 <span class="traceContains">+parse:   ingredient: {&quot;abc def&quot;: &quot;literal-string&quot;}</span>
 
 <span class="Delimiter">:(scenario string_literal_with_colons)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc:def/ghi]
 ]
 <span class="traceContains">+parse:   ingredient: {&quot;abc:def/ghi&quot;: &quot;literal-string&quot;}</span>
@@ -202,26 +203,26 @@ string emit_literal_string<span class="Delimiter">(</span>string name<span class
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario string_literal_nested)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc [def]]
 ]
 <span class="traceContains">+parse:   ingredient: {&quot;abc [def]&quot;: &quot;literal-string&quot;}</span>
 
 <span class="Delimiter">:(scenario string_literal_escaped)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc \[def]
 ]
 <span class="traceContains">+parse:   ingredient: {&quot;abc [def&quot;: &quot;literal-string&quot;}</span>
 
 <span class="Delimiter">:(scenario string_literal_escaped_twice)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [
 abc \\[def]
 ]
 <span class="traceContains">+parse:   ingredient: {&quot;\nabc \[def&quot;: &quot;literal-string&quot;}</span>
 
 <span class="Delimiter">:(scenario string_literal_and_comment)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc]  <span class="Comment"># comment</span>
 ]
 <span class="traceContains">+parse: --- defining main</span>
@@ -231,14 +232,14 @@ def main [
 <span class="traceContains">+parse:   product: {1: (&quot;address&quot; &quot;array&quot; &quot;character&quot;)}</span>
 
 <span class="Delimiter">:(scenario string_literal_escapes_newlines_in_trace)</span>
-def main [
+<span class="muRecipe">def</span> main [
   copy [abc
-def]
+<span class="muRecipe">def</span>]
 ]
 <span class="traceContains">+parse:   ingredient: {&quot;abc\ndef&quot;: &quot;literal-string&quot;}</span>
 
 <span class="Delimiter">:(scenario string_literal_can_skip_past_comments)</span>
-def main [
+<span class="muRecipe">def</span> main [
   copy [
     <span class="Comment"># ']' inside comment</span>
     bar
@@ -247,15 +248,15 @@ def main [
 <span class="traceContains">+parse:   ingredient: {&quot;\n    # ']' inside comment\n    bar\n  &quot;: &quot;literal-string&quot;}</span>
 
 <span class="Delimiter">:(scenario string_literal_empty)</span>
-def main [
+<span class="muRecipe">def</span> main [
   copy []
 ]
 <span class="traceContains">+parse:   ingredient: {&quot;&quot;: &quot;literal-string&quot;}</span>
 
 <span class="Delimiter">:(scenario multiple_unfinished_recipes)</span>
 <span class="Special">% Hide_errors = true;</span>
-def f1 [
-def f2 [
+<span class="muRecipe">def</span> f1 [
+<span class="muRecipe">def</span> f2 [
 <span class="traceContains">+error: unbalanced '['</span>
 </pre>
 </body>
diff --git a/html/015literal_noninteger.cc.html b/html/015literal_noninteger.cc.html
index c8fd93f3..dd45673a 100644
--- a/html/015literal_noninteger.cc.html
+++ b/html/015literal_noninteger.cc.html
@@ -15,12 +15,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -36,7 +37,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenarios load)</span>
 <span class="Delimiter">:(scenario noninteger_literal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">3.14159</span>
 ]
 <span class="traceContains">+parse:   ingredient: {3.14159: &quot;literal-fractional-number&quot;}</span>
diff --git a/html/016dilated_reagent.cc.html b/html/016dilated_reagent.cc.html
index 3454ae68..65d8ba2e 100644
--- a/html/016dilated_reagent.cc.html
+++ b/html/016dilated_reagent.cc.html
@@ -15,14 +15,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .cSpecial { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Error { color: #ffffff; background-color: #ff6060; padding-bottom: 1px; }
 .PreProc { color: #800080; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -40,27 +41,27 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenarios load)</span>
 <span class="Delimiter">:(scenario dilated_reagent)</span>
-def main [
+<span class="muRecipe">def</span> 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="traceContains">+parse:   product: {1: &quot;number&quot;, &quot;foo&quot;: &quot;bar&quot;}</span>
 
 <span class="Delimiter">:(scenario load_trailing_space_after_curly_bracket)</span>
-def main [
+<span class="muRecipe">def</span> main [
 <span class="PreProc">  </span><span class="Comment"># line below has a space at the end</span>
   <span class="Delimiter">{</span><span class="Error"> </span>
 ]
 <span class="Comment"># successfully parsed</span>
 
 <span class="Delimiter">:(scenario dilated_reagent_with_comment)</span>
-def main [
+<span class="muRecipe">def</span> 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>
 ]
 <span class="traceContains">+parse:   product: {1: &quot;number&quot;, &quot;foo&quot;: &quot;bar&quot;}</span>
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario dilated_reagent_with_comment_immediately_following)</span>
-def main [
+<span class="muRecipe">def</span> 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>
 ]
 $error: <span class="Constant">0</span>
diff --git a/html/017parse_tree.cc.html b/html/017parse_tree.cc.html
index c9cfae37..0ff64fb1 100644
--- a/html/017parse_tree.cc.html
+++ b/html/017parse_tree.cc.html
@@ -14,12 +14,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -46,7 +48,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenarios load)</span>
 <span class="Delimiter">:(scenario dilated_reagent_with_nested_brackets)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Delimiter">{</span><span class="Constant">1</span>: number<span class="Delimiter">,</span> foo: <span class="Delimiter">(</span>bar <span class="Delimiter">(</span>baz quux<span class="Delimiter">))}</span><span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="traceContains">+parse:   product: {1: &quot;number&quot;, &quot;foo&quot;: (&quot;bar&quot; (&quot;baz&quot; &quot;quux&quot;))}</span>
@@ -114,13 +116,13 @@ string_tree* parse_string_tree<span class="Delimiter">(</span>istream&amp; in<sp
 
 <span class="Delimiter">:(scenario dilated_reagent_with_type_tree)</span>
 <span class="Special">% Hide_errors = true;  // 'map' isn't defined yet</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>foo <span class="Delimiter">(</span>address array character<span class="Delimiter">)</span> <span class="Delimiter">(</span>bar number<span class="Delimiter">))}</span><span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="Comment"># just to avoid errors</span>
-container foo [
+<span class="muData">container</span> foo [
 ]
-container bar [
+<span class="muData">container</span> bar [
 ]
 <span class="traceContains">+parse:   product: {1: (&quot;foo&quot; (&quot;address&quot; &quot;array&quot; &quot;character&quot;) (&quot;bar&quot; &quot;number&quot;))}</span>
 </pre>
diff --git a/html/018type_abbreviations.cc.html b/html/018type_abbreviations.cc.html
index abb190c1..342d614b 100644
--- a/html/018type_abbreviations.cc.html
+++ b/html/018type_abbreviations.cc.html
@@ -13,15 +13,17 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.Constant { color: #00a0a0; }
+.muData { color: #ffff00; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Constant { color: #00a0a0; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -37,8 +39,8 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario type_abbreviations)</span>
-type foo = number
-def main [
+<span class="muData">type</span> foo = number
+<span class="muRecipe">def</span> main [
   <span class="Normal">a</span>:foo<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="traceContains">+transform: product type after expanding abbreviations: &quot;number&quot;</span>
@@ -106,28 +108,28 @@ string_tree* parse_string_list<span class="Delimiter">(</span><span class="Norma
 
 <span class="Delimiter">:(scenario type_error1)</span>
 <span class="Special">% Hide_errors = true;</span>
-type foo
+<span class="muData">type</span> foo
 <span class="traceContains">+error: incomplete 'type' statement 'type foo'</span>
 
 <span class="Delimiter">:(scenario type_error2)</span>
 <span class="Special">% Hide_errors = true;</span>
-type foo =
+<span class="muData">type</span> foo =
 <span class="traceContains">+error: incomplete 'type' statement 'type foo ='</span>
 
 <span class="Delimiter">:(scenario type_error3)</span>
 <span class="Special">% Hide_errors = true;</span>
-type foo bar baz
+<span class="muData">type</span> foo bar baz
 <span class="traceContains">+error: 'type' statements must be of the form 'type &lt;new type name&gt; = &lt;type expression&gt;' but got 'type foo bar'</span>
 
 <span class="Delimiter">:(scenario type_conflict_error)</span>
 <span class="Special">% Hide_errors = true;</span>
-type foo = bar
-type foo = baz
+<span class="muData">type</span> foo = bar
+<span class="muData">type</span> foo = baz
 <span class="traceContains">+error: 'type' conflict: 'foo' defined as both 'bar' and 'baz'</span>
 
 <span class="Delimiter">:(scenario type_abbreviation_for_compound)</span>
-type foo = address:number
-def main [
+<span class="muData">type</span> foo = address:number
+<span class="muRecipe">def</span> main [
   <span class="Normal">a</span>:foo<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+transform: product type after expanding abbreviations: (&quot;address&quot; &quot;number&quot;)</span>
@@ -165,8 +167,8 @@ put<span class="Delimiter">(</span>Type_abbreviations<span class="Delimiter">,</
 put<span class="Delimiter">(</span>Type_abbreviations<span class="Delimiter">,</span> <span class="Constant">&quot;char&quot;</span><span class="Delimiter">,</span> new_type_tree<span class="Delimiter">(</span><span class="Constant">&quot;character&quot;</span><span class="Delimiter">));</span>
 
 <span class="Delimiter">:(scenario use_type_abbreviations_when_declaring_type_abbreviations)</span>
-type foo = &amp;:num
-def main [
+<span class="muData">type</span> foo = &amp;:num
+<span class="muRecipe">def</span> main [
   <span class="Normal">a</span>:foo<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+transform: product type after expanding abbreviations: (&quot;address&quot; &quot;number&quot;)</span>
@@ -176,14 +178,14 @@ def main [
 <span class="Comment">//: before we use them.</span>
 
 <span class="Delimiter">:(scenario abbreviations_for_address_and_array)</span>
-def main [
+<span class="muRecipe">def</span> main [
   f <span class="Constant">1</span>:&amp;:num  <span class="Comment"># abbreviation for 'address:number'</span>
   f <span class="Constant">2</span>:@:num  <span class="Comment"># abbreviation for 'array:number'</span>
   f <span class="Constant">3</span>:&amp;:@:num  <span class="Comment"># combining '&amp;' and '@'</span>
   f <span class="Constant">4</span>:&amp;:&amp;:@:&amp;:@:num  <span class="Comment"># ..any number of times</span>
   f <span class="Delimiter">{</span><span class="Constant">5</span>: <span class="Delimiter">(</span>array <span class="Delimiter">(</span>&amp; num<span class="Delimiter">)</span> <span class="Constant">3</span><span class="Delimiter">)}</span>  <span class="Comment"># support for dilated reagents and more complex parse trees</span>
 ]
-def f [
+<span class="muRecipe">def</span> f [
 ]
 <span class="traceContains">+transform: --- expand type abbreviations in recipe 'main'</span>
 <span class="traceContains">+transform: ingredient type after expanding abbreviations: (&quot;address&quot; &quot;number&quot;)</span>
diff --git a/html/020run.cc.html b/html/020run.cc.html
index fca868e8..ffecb92f 100644
--- a/html/020run.cc.html
+++ b/html/020run.cc.html
@@ -13,18 +13,19 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.Constant { color: #00a0a0; }
-.traceAbsent { color: #c00000; }
-.cSpecial { color: #008000; }
-.traceContains { color: #008000; }
 .SalientComment { color: #00ffff; }
-.Comment { color: #9090ff; }
+.CommentedCode { color: #6c6c6c; }
+.muRecipe { color: #ff8700; }
+.traceContains { color: #008000; }
 .Delimiter { color: #800080; }
+.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.cSpecial { color: #008000; }
+.traceAbsent { color: #c00000; }
+.Comment { color: #9090ff; }
+.Constant { color: #00a0a0; }
 .Special { color: #c00000; }
 .Identifier { color: #fcb165; }
-.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
 .PreProc { color: #800080; }
-.CommentedCode { color: #6c6c6c; }
 -->
 </style>
 
@@ -48,14 +49,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: another. Later layers will add more primitives.</span>
 
 <span class="Delimiter">:(scenario copy_literal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
 ]
 <span class="traceContains">+run: {1: &quot;number&quot;} &lt;- copy {23: &quot;literal&quot;}</span>
 <span class="traceContains">+mem: storing 23 in location 1</span>
 
 <span class="Delimiter">:(scenario copy)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:num
 ]
@@ -64,7 +65,7 @@ def main [
 <span class="traceContains">+mem: storing 23 in location 2</span>
 
 <span class="Delimiter">:(scenario copy_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">24</span>
 ]
 <span class="traceContains">+mem: storing 23 in location 1</span>
@@ -401,7 +402,7 @@ vector&lt;<span class="Normal">double</span>&gt; read_memory<span class="Delimit
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario run_label)</span>
-def main [
+<span class="muRecipe">def</span> main [
   +foo
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:num
@@ -411,14 +412,14 @@ def main [
 <span class="traceAbsent">-run: +foo</span>
 
 <span class="Delimiter">:(scenario run_dummy)</span>
-def main [
+<span class="muRecipe">def</span> main [
   _<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+run: _ &lt;- copy {0: &quot;literal&quot;}</span>
 
 <span class="Delimiter">:(scenario write_to_0_disallowed)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">0</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="traceAbsent">-mem: storing 34 in location 0</span>
@@ -427,25 +428,25 @@ def main [
 <span class="Comment">//: to put spaces around the '&lt;-'.</span>
 
 <span class="Delimiter">:(scenario comma_without_space)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">2</span><span class="Delimiter">,</span><span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 1</span>
 
 <span class="Delimiter">:(scenario space_without_comma)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">2</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 1</span>
 
 <span class="Delimiter">:(scenario comma_before_space)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 1</span>
 
 <span class="Delimiter">:(scenario comma_after_space)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">2</span> <span class="Delimiter">,</span><span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 1</span>
diff --git a/html/021check_instruction.cc.html b/html/021check_instruction.cc.html
index 111355b4..bd53bd82 100644
--- a/html/021check_instruction.cc.html
+++ b/html/021check_instruction.cc.html
@@ -15,6 +15,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 .traceContains { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
@@ -79,34 +80,34 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 
 <span class="Delimiter">:(scenario copy_checks_reagent_count)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+error: main: ingredients and products should match in '1:num &lt;- copy 34, 35'</span>
 
 <span class="Delimiter">:(scenario write_scalar_to_array_disallowed)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="traceContains">+error: main: can't copy '34' to '1:array:num'; types don't match</span>
 
 <span class="Delimiter">:(scenario write_scalar_to_array_disallowed_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:array:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+error: main: can't copy '35' to '2:array:num'; types don't match</span>
 
 <span class="Delimiter">:(scenario write_scalar_to_address_disallowed)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="traceContains">+error: main: can't copy '34' to '1:address:num'; types don't match</span>
 
 <span class="Delimiter">:(scenario write_address_to_number_allowed)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>/unsafe
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:address:num
 ]
@@ -114,7 +115,7 @@ def main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario write_boolean_to_number_allowed)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">1</span>/<span class="Constant">true</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:<span class="Normal">bool</span>
 ]
@@ -122,7 +123,7 @@ def main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario write_number_to_boolean_allowed)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:num
 ]
diff --git a/html/022arithmetic.cc.html b/html/022arithmetic.cc.html
index 476f505a..c8fefec6 100644
--- a/html/022arithmetic.cc.html
+++ b/html/022arithmetic.cc.html
@@ -15,6 +15,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 .traceContains { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
@@ -70,13 +71,13 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario add_literal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+mem: storing 57 in location 1</span>
 
 <span class="Delimiter">:(scenario add)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -84,21 +85,21 @@ def main [
 <span class="traceContains">+mem: storing 57 in location 3</span>
 
 <span class="Delimiter">:(scenario add_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
 <span class="traceContains">+mem: storing 12 in location 1</span>
 
 <span class="Delimiter">:(scenario add_checks_type)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">2</span>:<span class="Normal">bool</span><span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
 <span class="traceContains">+error: main: 'add' requires number ingredients, but got '2:bool'</span>
 
 <span class="Delimiter">:(scenario add_checks_return_type)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>add <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+error: main: 'add' should yield a number, but got '1:address:num'</span>
@@ -145,13 +146,13 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario subtract_literal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>subtract <span class="Constant">5</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 3 in location 1</span>
 
 <span class="Delimiter">:(scenario subtract)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>subtract <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -159,7 +160,7 @@ def main [
 <span class="traceContains">+mem: storing -11 in location 3</span>
 
 <span class="Delimiter">:(scenario subtract_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>subtract <span class="Constant">6</span><span class="Delimiter">,</span> <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
@@ -198,13 +199,13 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario multiply_literal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>multiply <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">3</span>
 ]
 <span class="traceContains">+mem: storing 6 in location 1</span>
 
 <span class="Delimiter">:(scenario multiply)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">4</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">6</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>multiply <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -212,7 +213,7 @@ def main [
 <span class="traceContains">+mem: storing 24 in location 3</span>
 
 <span class="Delimiter">:(scenario multiply_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>multiply <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
 ]
 <span class="traceContains">+mem: storing 24 in location 1</span>
@@ -254,13 +255,13 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario divide_literal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">8</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 4 in location 1</span>
 
 <span class="Delimiter">:(scenario divide)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">27</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -268,7 +269,7 @@ def main [
 <span class="traceContains">+mem: storing 9 in location 3</span>
 
 <span class="Delimiter">:(scenario divide_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">12</span><span class="Delimiter">,</span> <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 1</span>
@@ -322,14 +323,14 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario divide_with_remainder_literal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>divide-with-remainder <span class="Constant">9</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 4 in location 1</span>
 <span class="traceContains">+mem: storing 1 in location 2</span>
 
 <span class="Delimiter">:(scenario divide_with_remainder)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">27</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">11</span>
   <span class="Constant">3</span>:num<span class="Delimiter">,</span> <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>divide-with-remainder <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -338,20 +339,20 @@ def main [
 <span class="traceContains">+mem: storing 5 in location 4</span>
 
 <span class="Delimiter">:(scenario divide_with_decimal_point)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">5</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 2.5 in location 1</span>
 
 <span class="Delimiter">:(scenario divide_by_zero)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing inf in location 1</span>
 
 <span class="Delimiter">:(scenario divide_by_zero_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide-with-remainder <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
 <span class="Comment"># integer division can't return floating-point infinity</span>
@@ -399,32 +400,32 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario shift_left_by_zero)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
 
 <span class="Delimiter">:(scenario shift_left_1)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">4</span>
 ]
 <span class="traceContains">+mem: storing 16 in location 1</span>
 
 <span class="Delimiter">:(scenario shift_left_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 12 in location 1</span>
 
 <span class="Delimiter">:(scenario shift_left_by_negative)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">3</span><span class="Delimiter">,</span> -<span class="Constant">1</span>
 ]
 <span class="traceContains">+error: main: second ingredient can't be negative in '1:num &lt;- shift-left 3, -1'</span>
 
 <span class="Delimiter">:(scenario shift_left_ignores_fractional_part)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
@@ -470,32 +471,32 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario shift_right_by_zero)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
 
 <span class="Delimiter">:(scenario shift_right_1)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">1024</span><span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
 <span class="traceContains">+mem: storing 512 in location 1</span>
 
 <span class="Delimiter">:(scenario shift_right_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
 
 <span class="Delimiter">:(scenario shift_right_by_negative)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">4</span><span class="Delimiter">,</span> -<span class="Constant">1</span>
 ]
 <span class="traceContains">+error: main: second ingredient can't be negative in '1:num &lt;- shift-right 4, -1'</span>
 
 <span class="Delimiter">:(scenario shift_right_ignores_fractional_part)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
@@ -536,25 +537,25 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario and_bits_1)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">and</span>-bits <span class="Constant">8</span><span class="Delimiter">,</span> <span class="Constant">3</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
 
 <span class="Delimiter">:(scenario and_bits_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">and</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 1</span>
 
 <span class="Delimiter">:(scenario and_bits_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">and</span>-bits <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">3</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 1</span>
 
 <span class="Delimiter">:(scenario and_bits_negative)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">and</span>-bits -<span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
 ]
 <span class="traceContains">+mem: storing 4 in location 1</span>
@@ -594,19 +595,19 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario or_bits_1)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">or</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">8</span>
 ]
 <span class="traceContains">+mem: storing 11 in location 1</span>
 
 <span class="Delimiter">:(scenario or_bits_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">or</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">10</span>
 ]
 <span class="traceContains">+mem: storing 11 in location 1</span>
 
 <span class="Delimiter">:(scenario or_bits_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">or</span>-bits <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">6</span>
 ]
 <span class="traceContains">+mem: storing 6 in location 1</span>
@@ -646,19 +647,19 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario xor_bits_1)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">xor</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">8</span>
 ]
 <span class="traceContains">+mem: storing 11 in location 1</span>
 
 <span class="Delimiter">:(scenario xor_bits_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">xor</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">10</span>
 ]
 <span class="traceContains">+mem: storing 9 in location 1</span>
 
 <span class="Delimiter">:(scenario xor_bits_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">xor</span>-bits <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">6</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 1</span>
@@ -697,25 +698,25 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario flip_bits_zero)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>flip-bits <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing -1 in location 1</span>
 
 <span class="Delimiter">:(scenario flip_bits_negative)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>flip-bits -<span class="Constant">1</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
 
 <span class="Delimiter">:(scenario flip_bits_1)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>flip-bits <span class="Constant">3</span>
 ]
 <span class="traceContains">+mem: storing -4 in location 1</span>
 
 <span class="Delimiter">:(scenario flip_bits_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>flip-bits <span class="Constant">12</span>
 ]
 <span class="traceContains">+mem: storing -13 in location 1</span>
@@ -744,7 +745,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario round_to_nearest_integer)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>round <span class="Constant">12.2</span>
 ]
 <span class="traceContains">+mem: storing 12 in location 1</span>
diff --git a/html/023boolean.cc.html b/html/023boolean.cc.html
index 0faab3e0..38d2a665 100644
--- a/html/023boolean.cc.html
+++ b/html/023boolean.cc.html
@@ -15,6 +15,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 .traceContains { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
@@ -67,7 +68,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario and)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">2</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">and</span> <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Delimiter">,</span> <span class="Constant">2</span>:<span class="Normal">bool</span>
@@ -75,19 +76,19 @@ def main [
 <span class="traceContains">+mem: storing 0 in location 3</span>
 
 <span class="Delimiter">:(scenario and_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">and</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
 
 <span class="Delimiter">:(scenario and_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">and</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
 
 <span class="Delimiter">:(scenario and_multiple_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">and</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
@@ -125,7 +126,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario or)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">2</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">or</span> <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Delimiter">,</span> <span class="Constant">2</span>:<span class="Normal">bool</span>
@@ -133,19 +134,19 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario or_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">or</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
 
 <span class="Delimiter">:(scenario or_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">and</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
 
 <span class="Delimiter">:(scenario or_multiple_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">or</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
@@ -185,14 +186,14 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario not)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">2</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">not</span> <span class="Constant">1</span>:<span class="Normal">bool</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 2</span>
 
 <span class="Delimiter">:(scenario not_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Delimiter">,</span> <span class="Constant">2</span>:<span class="Normal">bool</span><span class="Delimiter">,</span> <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">not</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
diff --git a/html/024jump.cc.html b/html/024jump.cc.html
index f222fa52..077373b7 100644
--- a/html/024jump.cc.html
+++ b/html/024jump.cc.html
@@ -16,12 +16,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -36,8 +37,8 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: Jump primitives</span>
 
 <span class="Delimiter">:(scenario jump_can_skip_instructions)</span>
-def main [
-  jump <span class="Constant">1</span>:offset
+<span class="muRecipe">def</span> main [
+  jump <span class="Constant">1:offset</span>
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
 <span class="traceContains">+run: jump {1: &quot;offset&quot;}</span>
@@ -73,11 +74,11 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 put<span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;offset&quot;</span><span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario jump_backward)</span>
-def main [
-  jump <span class="Constant">1</span>:offset  <span class="Comment"># 0 -+</span>
-  jump <span class="Constant">3</span>:offset  <span class="Comment">#    |   +-+ 1</span>
+<span class="muRecipe">def</span> main [
+  jump <span class="Constant">1:offset</span>  <span class="Comment"># 0 -+</span>
+  jump <span class="Constant">3:offset</span>  <span class="Comment">#    |   +-+ 1</span>
                  <span class="Comment">#   \/  /\ |</span>
-  jump -<span class="Constant">2</span>:offset <span class="Comment">#  2 +--&gt;+ |</span>
+  jump <span class="Constant">-2:offset</span> <span class="Comment">#  2 +--&gt;+ |</span>
 ]                <span class="Comment">#         \/ 3</span>
 <span class="traceContains">+run: jump {1: &quot;offset&quot;}</span>
 <span class="traceContains">+run: jump {-2: &quot;offset&quot;}</span>
@@ -117,8 +118,8 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario jump_if)</span>
-def main [
-  jump-<span class="Normal">if</span> <span class="Constant">999</span><span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+<span class="muRecipe">def</span> main [
+  jump-<span class="Normal">if</span> <span class="Constant">999</span><span class="Delimiter">,</span> <span class="Constant">1:offset</span>
   <span class="Constant">123</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
 <span class="traceContains">+run: jump-if {999: &quot;literal&quot;}, {1: &quot;offset&quot;}</span>
@@ -127,8 +128,8 @@ def main [
 <span class="traceAbsent">-mem: storing 1 in location 123</span>
 
 <span class="Delimiter">:(scenario jump_if_fallthrough)</span>
-def main [
-  jump-<span class="Normal">if</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+<span class="muRecipe">def</span> main [
+  jump-<span class="Normal">if</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1:offset</span>
   <span class="Constant">123</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
 <span class="traceContains">+run: jump-if {0: &quot;literal&quot;}, {1: &quot;offset&quot;}</span>
@@ -170,8 +171,8 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario jump_unless)</span>
-def main [
-  jump-unless <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+<span class="muRecipe">def</span> main [
+  jump-unless <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1:offset</span>
   <span class="Constant">123</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
 <span class="traceContains">+run: jump-unless {0: &quot;literal&quot;}, {1: &quot;offset&quot;}</span>
@@ -180,8 +181,8 @@ def main [
 <span class="traceAbsent">-mem: storing 1 in location 123</span>
 
 <span class="Delimiter">:(scenario jump_unless_fallthrough)</span>
-def main [
-  jump-unless <span class="Constant">999</span><span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+<span class="muRecipe">def</span> main [
+  jump-unless <span class="Constant">999</span><span class="Delimiter">,</span> <span class="Constant">1:offset</span>
   <span class="Constant">123</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
 <span class="traceContains">+run: jump-unless {999: &quot;literal&quot;}, {1: &quot;offset&quot;}</span>
diff --git a/html/025compare.cc.html b/html/025compare.cc.html
index 987b6602..805d3735 100644
--- a/html/025compare.cc.html
+++ b/html/025compare.cc.html
@@ -15,6 +15,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 .traceContains { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
@@ -77,7 +78,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario equal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -87,7 +88,7 @@ def main [
 <span class="traceContains">+mem: storing 0 in location 3</span>
 
 <span class="Delimiter">:(scenario equal_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -97,13 +98,13 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario equal_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
 
 <span class="Delimiter">:(scenario equal_multiple_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
@@ -143,7 +144,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario not_equal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">not</span>-equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -153,7 +154,7 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario not_equal_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span><span class="Normal">not</span>-equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -202,7 +203,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario greater_than)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>greater-than <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -210,7 +211,7 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario greater_than_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>greater-than <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -218,13 +219,13 @@ def main [
 <span class="traceContains">+mem: storing 0 in location 3</span>
 
 <span class="Delimiter">:(scenario greater_than_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>greater-than <span class="Constant">36</span><span class="Delimiter">,</span> <span class="Constant">35</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
 
 <span class="Delimiter">:(scenario greater_than_multiple_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>greater-than <span class="Constant">36</span><span class="Delimiter">,</span> <span class="Constant">35</span><span class="Delimiter">,</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
@@ -269,7 +270,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario lesser_than)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">32</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>lesser-than <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -277,7 +278,7 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario lesser_than_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>lesser-than <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -285,13 +286,13 @@ def main [
 <span class="traceContains">+mem: storing 0 in location 3</span>
 
 <span class="Delimiter">:(scenario lesser_than_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>lesser-than <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span><span class="Delimiter">,</span> <span class="Constant">36</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
 
 <span class="Delimiter">:(scenario lesser_than_multiple_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>lesser-than <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span><span class="Delimiter">,</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
@@ -336,7 +337,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario greater_or_equal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>greater-<span class="Normal">or</span>-equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -344,7 +345,7 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario greater_or_equal_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>greater-<span class="Normal">or</span>-equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -352,7 +353,7 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario greater_or_equal_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>greater-<span class="Normal">or</span>-equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -360,13 +361,13 @@ def main [
 <span class="traceContains">+mem: storing 0 in location 3</span>
 
 <span class="Delimiter">:(scenario greater_or_equal_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>greater-<span class="Normal">or</span>-equal <span class="Constant">36</span><span class="Delimiter">,</span> <span class="Constant">35</span><span class="Delimiter">,</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
 
 <span class="Delimiter">:(scenario greater_or_equal_multiple_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>greater-<span class="Normal">or</span>-equal <span class="Constant">36</span><span class="Delimiter">,</span> <span class="Constant">35</span><span class="Delimiter">,</span> <span class="Constant">36</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
@@ -411,7 +412,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario lesser_or_equal)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">32</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>lesser-<span class="Normal">or</span>-equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -419,7 +420,7 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario lesser_or_equal_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>lesser-<span class="Normal">or</span>-equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -427,7 +428,7 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario lesser_or_equal_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>lesser-<span class="Normal">or</span>-equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -435,13 +436,13 @@ def main [
 <span class="traceContains">+mem: storing 0 in location 3</span>
 
 <span class="Delimiter">:(scenario lesser_or_equal_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>lesser-<span class="Normal">or</span>-equal <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span><span class="Delimiter">,</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
 
 <span class="Delimiter">:(scenario lesser_or_equal_multiple_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>lesser-<span class="Normal">or</span>-equal <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
diff --git a/html/026call.cc.html b/html/026call.cc.html
index fc0cd90d..4afc0186 100644
--- a/html/026call.cc.html
+++ b/html/026call.cc.html
@@ -15,13 +15,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -36,22 +37,22 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: So far the recipes we define can't run each other. Let's fix that.</span>
 
 <span class="Delimiter">:(scenario calling_recipe)</span>
-def main [
+<span class="muRecipe">def</span> main [
   f
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 4 in location 3</span>
 
 <span class="Delimiter">:(scenario return_on_fallthrough)</span>
-def main [
+<span class="muRecipe">def</span> main [
   f
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
@@ -165,14 +166,14 @@ call&amp; current_call<span class="Delimiter">()</span> <span class="Delimiter">
 
 <span class="Delimiter">:(scenario calling_undefined_recipe_fails)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   foo
 ]
 <span class="traceContains">+error: main: undefined operation in 'foo '</span>
 
 <span class="Delimiter">:(scenario calling_undefined_recipe_handles_missing_result)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>foo
 ]
 <span class="traceContains">+error: main: undefined operation in 'x:num &lt;- foo '</span>
diff --git a/html/027call_ingredient.cc.html b/html/027call_ingredient.cc.html
index 95aed732..01d66d38 100644
--- a/html/027call_ingredient.cc.html
+++ b/html/027call_ingredient.cc.html
@@ -15,12 +15,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -36,20 +37,20 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: ingredients, use 'next-ingredient'.</span>
 
 <span class="Delimiter">:(scenario next_ingredient)</span>
-def main [
+<span class="muRecipe">def</span> main [
   f <span class="Constant">2</span>
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>next-ingredient
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">12</span>:num
 ]
 <span class="traceContains">+mem: storing 3 in location 13</span>
 
 <span class="Delimiter">:(scenario next_ingredient_missing)</span>
-def main [
+<span class="muRecipe">def</span> main [
   f
 ]
-def f [
+<span class="muRecipe">def</span> f [
   _<span class="Delimiter">,</span> <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>next-ingredient
 ]
 <span class="traceContains">+mem: storing 0 in location 12</span>
@@ -121,19 +122,19 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario next_ingredient_fail_on_missing)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   f
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>next-ingredient
 ]
 <span class="traceContains">+error: f: no ingredient to save in '11:num'</span>
 
 <span class="Delimiter">:(scenario rewind_ingredients)</span>
-def main [
+<span class="muRecipe">def</span> main [
   f <span class="Constant">2</span>
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># consume ingredient</span>
   _<span class="Delimiter">,</span> <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># will not find any ingredients</span>
   rewind-ingredients
@@ -159,10 +160,10 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario ingredient)</span>
-def main [
+<span class="muRecipe">def</span> main [
   f <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>ingredient <span class="Constant">1</span>  <span class="Comment"># consume second ingredient first</span>
   <span class="Constant">13</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># next-ingredient tries to scan past that</span>
 ]
diff --git a/html/028call_reply.cc.html b/html/028call_reply.cc.html
index 3e4de57d..cea9db3e 100644
--- a/html/028call_reply.cc.html
+++ b/html/028call_reply.cc.html
@@ -15,12 +15,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -35,10 +36,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: Calls can also generate products, using 'reply' or 'return'.</span>
 
 <span class="Delimiter">:(scenario return)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>f <span class="Constant">34</span>
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>next-ingredient
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">12</span>:num
   reply <span class="Constant">12</span>:num<span class="Delimiter">,</span> <span class="Constant">13</span>:num
@@ -135,10 +136,10 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 
 <span class="Delimiter">:(scenario return_type_mismatch)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>f <span class="Constant">2</span>
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>next-ingredient
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:point<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>:point/<span class="Special">raw</span>
@@ -153,22 +154,22 @@ def f [
 
 <span class="Delimiter">:(scenario return_same_as_ingredient)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>test1 <span class="Constant">1</span>:num  <span class="Comment"># call with different ingredient and product</span>
 ]
-def test1 [
+<span class="muRecipe">def</span> test1 [
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>next-ingredient
   <span class="Identifier">return</span> <span class="Constant">10</span>:num/same-as-ingredient:<span class="Constant">0</span>
 ]
 <span class="traceContains">+error: main: '2:num &lt;- test1 1:num' should write to '1:num' rather than '2:num'</span>
 
 <span class="Delimiter">:(scenario return_same_as_ingredient_dummy)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   _<span class="Special"> &lt;- </span>test1 <span class="Constant">1</span>:num  <span class="Comment"># call with different ingredient and product</span>
 ]
-def test1 [
+<span class="muRecipe">def</span> test1 [
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>next-ingredient
   <span class="Identifier">return</span> <span class="Constant">10</span>:num/same-as-ingredient:<span class="Constant">0</span>
 ]
diff --git a/html/029tools.cc.html b/html/029tools.cc.html
index 1005b991..f9e4f000 100644
--- a/html/029tools.cc.html
+++ b/html/029tools.cc.html
@@ -15,14 +15,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.traceContains { color: #008000; }
+.CommentedCode { color: #6c6c6c; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .cSpecial { color: #008000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.CommentedCode { color: #6c6c6c; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -37,7 +38,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: Allow mu programs to log facts just like we've been doing in C++ so far.</span>
 
 <span class="Delimiter">:(scenario trace)</span>
-def main [
+<span class="muRecipe">def</span> main [
   trace <span class="Constant">1</span><span class="Delimiter">,</span> [foo]<span class="Delimiter">,</span> [<span class="Normal">this</span> is a trace in mu]
 ]
 <span class="traceContains">+foo: this is a trace in mu</span>
@@ -97,19 +98,19 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario stash_literal_string)</span>
-def main [
+<span class="muRecipe">def</span> main [
   stash [foo]
 ]
 <span class="traceContains">+app: foo</span>
 
 <span class="Delimiter">:(scenario stash_literal_number)</span>
-def main [
+<span class="muRecipe">def</span> main [
   stash [foo:]<span class="Delimiter">,</span> <span class="Constant">4</span>
 ]
 <span class="traceContains">+app: foo: 4</span>
 
 <span class="Delimiter">:(scenario stash_number)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   stash [foo:]<span class="Delimiter">,</span> <span class="Constant">1</span>:num
 ]
@@ -227,7 +228,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario assert)</span>
 <span class="Special">% Hide_errors = true;  // '%' lines insert arbitrary C code into tests before calling 'run' with the lines below. Must be immediately after :(scenario) line.</span>
-def main [
+<span class="muRecipe">def</span> main [
   assert <span class="Constant">0</span><span class="Delimiter">,</span> [<span class="Normal">this</span> is an assert in mu]
 ]
 <span class="traceContains">+error: this is an assert in mu</span>
diff --git a/html/030container.cc.html b/html/030container.cc.html
index 040af497..7bb979a9 100644
--- a/html/030container.cc.html
+++ b/html/030container.cc.html
@@ -16,13 +16,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -52,7 +54,7 @@ get<span class="Delimiter">(</span>Type<span class="Delimiter">,</span> point<sp
 <span class="Comment">//: container. Don't do this in general. I'm tagging exceptions with /unsafe to</span>
 <span class="Comment">//: skip later checks.</span>
 <span class="Delimiter">:(scenario copy_multiple_locations)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">3</span>:point<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:point/unsafe
@@ -63,7 +65,7 @@ def main [
 <span class="Comment">//: trying to copy to a differently-typed destination will fail</span>
 <span class="Delimiter">:(scenario copy_checks_size)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">2</span>:point<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:num
 ]
 <span class="traceContains">+error: main: can't copy '1:num' to '2:point'; types don't match</span>
@@ -79,7 +81,7 @@ get<span class="Delimiter">(</span>Type<span class="Delimiter">,</span> point_nu
 get<span class="Delimiter">(</span>Type<span class="Delimiter">,</span> point_number<span class="Delimiter">).</span>elements<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>reagent<span class="Delimiter">(</span><span class="Constant">&quot;z:number&quot;</span><span class="Delimiter">));</span>
 
 <span class="Delimiter">:(scenario copy_handles_nested_container_elements)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
@@ -89,10 +91,10 @@ def main [
 
 <span class="Comment">//: products of recipes can include containers</span>
 <span class="Delimiter">:(scenario return_container)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">3</span>:point<span class="Special"> &lt;- </span>f <span class="Constant">2</span>
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>next-ingredient
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Identifier">return</span> <span class="Constant">12</span>:point/<span class="Special">raw</span>
@@ -105,7 +107,7 @@ def f [
 <span class="Comment">//: numbers, no matter how large they are.</span>
 
 <span class="Delimiter">:(scenario compare_multiple_locations)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>  <span class="Comment"># first</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
@@ -117,7 +119,7 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 7</span>
 
 <span class="Delimiter">:(scenario compare_multiple_locations_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>  <span class="Comment"># first</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
@@ -310,7 +312,7 @@ container_metadata&amp; get<span class="Delimiter">(</span>vector&lt;pair&lt;typ
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario stash_container)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>  <span class="Comment"># first</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
@@ -448,10 +450,10 @@ def main [
 <span class="Comment">//: appropriate element of the container value.</span>
 
 <span class="Delimiter">:(scenario get)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
-  <span class="Constant">15</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">12</span>:point/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1</span>:offset  <span class="Comment"># unsafe</span>
+  <span class="Constant">15</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">12</span>:point/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1:offset</span>  <span class="Comment"># unsafe</span>
 ]
 <span class="traceContains">+mem: storing 35 in location 15</span>
 
@@ -540,62 +542,62 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario get_handles_nested_container_elements)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  <span class="Constant">15</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1</span>:offset  <span class="Comment"># unsafe</span>
+  <span class="Constant">15</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1:offset</span>  <span class="Comment"># unsafe</span>
 ]
 <span class="traceContains">+mem: storing 36 in location 15</span>
 
 <span class="Delimiter">:(scenario get_out_of_bounds)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  get <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">2</span>:offset  <span class="Comment"># point-number occupies 3 locations but has only 2 fields; out of bounds</span>
+  get <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">2:offset</span>  <span class="Comment"># point-number occupies 3 locations but has only 2 fields; out of bounds</span>
 ]
 <span class="traceContains">+error: main: invalid offset '2' for 'point-number'</span>
 
 <span class="Delimiter">:(scenario get_out_of_bounds_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  get <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> -<span class="Constant">1</span>:offset
+  get <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">-1:offset</span>
 ]
 <span class="traceContains">+error: main: invalid offset '-1' for 'point-number'</span>
 
 <span class="Delimiter">:(scenario get_product_type_mismatch)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  <span class="Constant">15</span>:address:num<span class="Special"> &lt;- </span>get <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+  <span class="Constant">15</span>:address:num<span class="Special"> &lt;- </span>get <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1:offset</span>
 ]
 <span class="traceContains">+error: main: 'get 12:point-number/raw, 1:offset' should write to number but '15' has type (address number)</span>
 
 <span class="Comment">//: we might want to call 'get' without saving the results, say in a sandbox</span>
 
 <span class="Delimiter">:(scenario get_without_product)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
-  get <span class="Constant">12</span>:point/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1</span>:offset  <span class="Comment"># unsafe</span>
+  get <span class="Constant">12</span>:point/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1:offset</span>  <span class="Comment"># unsafe</span>
 ]
 <span class="Comment"># just don't die</span>
 
 <span class="SalientComment">//:: To write to elements of containers, use 'put'.</span>
 
 <span class="Delimiter">:(scenario put)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   $clear-trace
-  <span class="Constant">12</span>:point<span class="Special"> &lt;- </span>put <span class="Constant">12</span>:point<span class="Delimiter">,</span> <span class="Constant">1</span>:offset<span class="Delimiter">,</span> <span class="Constant">36</span>
+  <span class="Constant">12</span>:point<span class="Special"> &lt;- </span>put <span class="Constant">12</span>:point<span class="Delimiter">,</span> <span class="Constant">1:offset</span><span class="Delimiter">,</span> <span class="Constant">36</span>
 ]
 <span class="traceContains">+mem: storing 36 in location 13</span>
 <span class="traceAbsent">-mem: storing 34 in location 12</span>
@@ -680,11 +682,11 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario put_product_error)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   load-ingredients
   <span class="Constant">1</span>:point<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
-  <span class="Constant">3</span>:point<span class="Special"> &lt;- </span>put <span class="Constant">1</span>:point<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">36</span>
+  <span class="Constant">3</span>:point<span class="Special"> &lt;- </span>put <span class="Constant">1</span>:point<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">36</span>
 ]
 <span class="traceContains">+error: main: product of 'put' must be first ingredient '1:point', but got '3:point'</span>
 
@@ -692,7 +694,7 @@ def main [
 
 <span class="Delimiter">:(scenarios load)</span>
 <span class="Delimiter">:(scenario container)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
@@ -701,11 +703,11 @@ container foo [
 <span class="traceContains">+parse: element: {y: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario container_use_before_definition)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
@@ -724,18 +726,18 @@ container bar [
 <span class="Comment">//: if a container is defined again, the new fields add to the original definition</span>
 <span class="Delimiter">:(scenarios run)</span>
 <span class="Delimiter">:(scenario container_extend)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
 ]
 <span class="Comment"># add to previous definition</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
-  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
-  <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">0:offset</span>
+  <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">1:offset</span>
 ]
 <span class="traceContains">+mem: storing 34 in location 3</span>
 <span class="traceContains">+mem: storing 35 in location 4</span>
@@ -827,7 +829,7 @@ Num_calls_to_transform_all_at_first_definition = -<span class="Constant">1</span
 
 <span class="Delimiter">:(scenario multi_word_line_in_container_declaration)</span>
 <span class="Special">% Hide_errors = true;</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num y:num
 ]
 <span class="traceContains">+error: container 'foo' contains multiple elements on a single line. Containers and exclusive containers must only contain elements, one to a line, no code.</span>
@@ -835,13 +837,13 @@ container foo [
 <span class="Comment">//: support type abbreviations in container definitions</span>
 
 <span class="Delimiter">:(scenario type_abbreviations_in_containers)</span>
-type foo = number
-container bar [
+<span class="muData">type</span> foo = number
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:foo
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
-  <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:bar/unsafe<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
+  <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:bar/unsafe<span class="Delimiter">,</span> <span class="Constant">0:offset</span>
 ]
 <span class="traceContains">+mem: storing 34 in location 2</span>
 
@@ -885,17 +887,17 @@ assert<span class="Delimiter">(</span>Next_type_ordinal &lt; <span class="Consta
 
 <span class="Delimiter">:(scenario run_complains_on_unknown_types)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># integer is not a type</span>
   <span class="Constant">1</span>:integer<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <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>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:bar<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/unsafe
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
 ]
 $error: <span class="Constant">0</span>
@@ -937,14 +939,14 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 
 <span class="Delimiter">:(scenario container_unknown_field)</span>
 <span class="Special">% Hide_errors = true;</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
 <span class="traceContains">+error: foo: unknown type in y</span>
 
 <span class="Delimiter">:(scenario read_container_with_bracket_in_comment)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Comment"># ']' in comment</span>
   <span class="Normal">y</span>:num
@@ -954,7 +956,7 @@ container foo [
 <span class="traceContains">+parse: element: {y: &quot;number&quot;}</span>
 
 <span class="Delimiter">:(scenario container_with_compound_field_type)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Delimiter">{</span>x: <span class="Delimiter">(</span>address array <span class="Delimiter">(</span>address array character<span class="Delimiter">))}</span>
 ]
 $error: <span class="Constant">0</span>
diff --git a/html/031merge.cc.html b/html/031merge.cc.html
index 9f3e8440..c2e9b5d0 100644
--- a/html/031merge.cc.html
+++ b/html/031merge.cc.html
@@ -13,15 +13,17 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.Constant { color: #00a0a0; }
+.muData { color: #ffff00; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
 .PreProc { color: #800080; }
+.Constant { color: #00a0a0; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -36,11 +38,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: Construct types out of their constituent fields.</span>
 
 <span class="Delimiter">:(scenario merge)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
 ]
 <span class="traceContains">+mem: storing 3 in location 1</span>
@@ -67,21 +69,21 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Comment">//: type-check 'merge' to avoid interpreting numbers as addresses</span>
 
 <span class="Delimiter">:(scenario merge_check)</span>
-def main [
+<span class="muRecipe">def</span> 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>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_missing_element)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:point<span class="Special"> &lt;- </span>merge <span class="Constant">3</span>
 ]
 <span class="traceContains">+error: main: too few ingredients in '1:point &lt;- merge 3'</span>
 
 <span class="Delimiter">:(scenario merge_check_extra_element)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> 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="Delimiter">,</span> <span class="Constant">5</span>
 ]
 <span class="traceContains">+error: main: too many ingredients in '1:point &lt;- merge 3, 4, 5'</span>
@@ -92,7 +94,7 @@ def main [
 <span class="Comment">//: container fields.</span>
 
 <span class="Delimiter">:(scenario merge_check_recursive_containers)</span>
-def main [
+<span class="muRecipe">def</span> 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>
 ]
@@ -100,28 +102,28 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_recursive_containers_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> 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">2</span>:point-number<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:point
 ]
 <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>
-def main [
+<span class="muRecipe">def</span> 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>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_recursive_containers_4)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> 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="traceContains">+error: main: too few ingredients in '1:point-number &lt;- merge 3, 4'</span>
 
 <span class="Delimiter">:(scenario merge_check_reflexive)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> 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">2</span>:point<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:point
 ]
@@ -246,7 +248,7 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 
 <span class="Delimiter">:(scenario merge_check_product)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>merge <span class="Constant">3</span>
 ]
 <span class="traceContains">+error: main: 'merge' should yield a container in '1:num &lt;- merge 3'</span>
diff --git a/html/032array.cc.html b/html/032array.cc.html
index 77cfb88c..a9f545f9 100644
--- a/html/032array.cc.html
+++ b/html/032array.cc.html
@@ -15,13 +15,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -42,7 +44,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Comment">//: You can create arrays using 'create-array'.</span>
 <span class="Delimiter">:(scenario create_array)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># create an array occupying locations 1 (for the size) and 2-4 (for the elements)</span>
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
 ]
@@ -111,7 +113,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Comment"># size in memory at run-time. We'll call a variable with an explicit size a</span>
 <span class="Comment"># 'static' array, and one without a 'dynamic' array since it can contain</span>
 <span class="Comment"># arrays of many different sizes.</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -124,7 +126,7 @@ def main [
 <span class="traceContains">+mem: storing 16 in location 8</span>
 
 <span class="Delimiter">:(scenario stash_array)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -154,14 +156,14 @@ def main [
 <span class="Comment">//: advance</span>
 
 <span class="Delimiter">:(scenario container_permits_static_array_element)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:array:num:<span class="Constant">3</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario container_disallows_dynamic_array_element)</span>
 <span class="Special">% Hide_errors = true;</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:array:num
 ]
 <span class="traceContains">+error: container 'foo' cannot determine size of element 'x'</span>
@@ -175,11 +177,11 @@ container foo [
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario merge_static_array_into_container)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:array:num:<span class="Constant">3</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">10</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">1</span>:array:num:<span class="Constant">3</span>
 ]
@@ -206,19 +208,19 @@ def main [
 
 <span class="Delimiter">:(scenario code_inside_container)</span>
 <span class="Special">% Hide_errors = true;</span>
-container card [
+<span class="muData">container</span> card [
   <span class="Normal">rank</span>:num<span class="Special"> &lt;- </span>next-ingredient
 ]
-def foo [
+<span class="muRecipe">def</span> foo [
   <span class="Constant">1</span>:card<span class="Special"> &lt;- </span>merge <span class="Constant">3</span>
-  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:card rank:offset
+  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:card <span class="Constant">rank:offset</span>
 ]
 <span class="Comment"># shouldn't die</span>
 
 <span class="SalientComment">//:: To access elements of an array, use 'index'</span>
 
 <span class="Delimiter">:(scenario index)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -228,7 +230,7 @@ def main [
 <span class="traceContains">+mem: storing 14 in location 5</span>
 
 <span class="Delimiter">:(scenario index_compound_element)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>array <span class="Delimiter">(</span>address number<span class="Delimiter">)</span> <span class="Constant">3</span><span class="Delimiter">)}</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -238,7 +240,7 @@ def main [
 <span class="traceContains">+mem: storing 14 in location 5</span>
 
 <span class="Delimiter">:(scenario index_direct_offset)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -342,7 +344,7 @@ type_tree* copy_array_element<span class="Delimiter">(</span><span class="Normal
 
 <span class="Delimiter">:(scenario index_out_of_bounds)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -356,7 +358,7 @@ def main [
 
 <span class="Delimiter">:(scenario index_out_of_bounds_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:point:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -370,7 +372,7 @@ def main [
 
 <span class="Delimiter">:(scenario index_product_type_mismatch)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:point:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -385,7 +387,7 @@ def main [
 <span class="Comment">//: we might want to call 'index' without saving the results, say in a sandbox</span>
 
 <span class="Delimiter">:(scenario index_without_product)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -397,7 +399,7 @@ def main [
 <span class="SalientComment">//:: To write to elements of arrays, use 'put'.</span>
 
 <span class="Delimiter">:(scenario put_index)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -478,7 +480,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario put_index_out_of_bounds)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:point:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -493,7 +495,7 @@ def main [
 
 <span class="Delimiter">:(scenario put_index_out_of_bounds_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:point:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -508,7 +510,7 @@ def main [
 
 <span class="Delimiter">:(scenario put_index_product_error)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   load-ingredients
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
@@ -519,7 +521,7 @@ def main [
 <span class="SalientComment">//:: compute the length of an array</span>
 
 <span class="Delimiter">:(scenario array_length)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
diff --git a/html/033exclusive_container.cc.html b/html/033exclusive_container.cc.html
index f0d129e3..d2bc91c3 100644
--- a/html/033exclusive_container.cc.html
+++ b/html/033exclusive_container.cc.html
@@ -15,13 +15,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -55,7 +57,7 @@ get<span class="Delimiter">(</span>Type<span class="Delimiter">,</span> tmp<span
 <span class="Comment">//: checks in future layers from flagging them.</span>
 <span class="Delimiter">:(scenario copy_exclusive_container)</span>
 <span class="Comment"># Copying exclusive containers copies all their contents and an extra location for the tag.</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>  <span class="Comment"># 'point' variant</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
@@ -104,11 +106,11 @@ def main [
 put<span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;variant&quot;</span><span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario maybe_convert)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  <span class="Constant">20</span>:point<span class="Delimiter">,</span> <span class="Constant">22</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> <span class="Constant">1</span>:variant
+  <span class="Constant">20</span>:point<span class="Delimiter">,</span> <span class="Constant">22</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> <span class="Constant">1:variant</span>
 ]
 <span class="Comment"># boolean</span>
 <span class="traceContains">+mem: storing 1 in location 22</span>
@@ -117,11 +119,11 @@ def main [
 <span class="traceContains">+mem: storing 36 in location 21</span>
 
 <span class="Delimiter">:(scenario maybe_convert_fail)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  <span class="Constant">20</span>:num<span class="Delimiter">,</span> <span class="Constant">21</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> <span class="Constant">0</span>:variant
+  <span class="Constant">20</span>:num<span class="Delimiter">,</span> <span class="Constant">21</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> <span class="Constant">0:variant</span>
 ]
 <span class="Comment"># boolean</span>
 <span class="traceContains">+mem: storing 0 in location 21</span>
@@ -234,27 +236,27 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario maybe_convert_product_type_mismatch)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  <span class="Constant">20</span>:num<span class="Delimiter">,</span> <span class="Constant">21</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> <span class="Constant">1</span>:variant
+  <span class="Constant">20</span>:num<span class="Delimiter">,</span> <span class="Constant">21</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> <span class="Constant">1:variant</span>
 ]
 <span class="traceContains">+error: main: 'maybe-convert 12:number-or-point/unsafe, 1:variant' should write to point but '20' has type number</span>
 
 <span class="Delimiter">:(scenario maybe_convert_dummy_product)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  _<span class="Delimiter">,</span> <span class="Constant">21</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> <span class="Constant">1</span>:variant
+  _<span class="Delimiter">,</span> <span class="Constant">21</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> <span class="Constant">1:variant</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="SalientComment">//:: Allow exclusive containers to be defined in mu code.</span>
 
 <span class="Delimiter">:(scenario exclusive_container)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
@@ -271,25 +273,25 @@ exclusive-container foo [
 <span class="Comment">//: fixed in advance</span>
 
 <span class="Delimiter">:(scenario exclusive_container_contains_array)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:array:num:<span class="Constant">3</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario exclusive_container_disallows_dynamic_array_element)</span>
 <span class="Special">% Hide_errors = true;</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:array:num
 ]
 <span class="traceContains">+error: container 'foo' cannot determine size of element 'x'</span>
 
 <span class="SalientComment">//:: To construct exclusive containers out of variant types, use 'merge'.</span>
 <span class="Delimiter">:(scenario lift_to_exclusive_container)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">1</span>:num  <span class="Comment"># tag must be a literal when merging exclusive containers</span>
   <span class="Constant">4</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">1</span>:num
@@ -302,14 +304,14 @@ def main [
 <span class="Comment">//: type-checking for 'merge' on exclusive containers</span>
 
 <span class="Delimiter">:(scenario merge_handles_exclusive_container)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">z</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
@@ -318,29 +320,29 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_requires_literal_tag_for_exclusive_container)</span>
 <span class="Special">% Hide_errors = true;</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">z</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+error: main: ingredient 0 of 'merge' should be a literal, for the tag of exclusive-container 'foo' in '2:foo &lt;- merge 1:num, 34'</span>
 
 <span class="Delimiter">:(scenario merge_handles_exclusive_container_inside_exclusive_container)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-exclusive-container bar [
+<span class="muData">exclusive-container</span> bar [
   <span class="Normal">a</span>:num
   <span class="Normal">b</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/a<span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Constant">4</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">2</span>:bar
@@ -376,15 +378,15 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario merge_check_container_containing_exclusive_container)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-exclusive-container bar [
+<span class="muData">exclusive-container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+mem: storing 23 in location 1</span>
@@ -394,29 +396,29 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_container_containing_exclusive_container_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-exclusive-container bar [
+<span class="muData">exclusive-container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
 ]
 <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>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
@@ -425,44 +427,44 @@ def main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_exclusive_container_containing_container_2)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">23</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_exclusive_container_containing_container_3)</span>
 <span class="Special">% Hide_errors = true;</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">23</span>
 ]
 <span class="traceContains">+error: main: too few ingredients in '1:foo &lt;- merge 1/y, 23'</span>
 
 <span class="Delimiter">:(scenario merge_check_exclusive_container_containing_container_4)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">a</span>:num
   <span class="Normal">b</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">24</span>
   <span class="Constant">3</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">1</span>:bar
 ]
@@ -484,15 +486,15 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario merge_exclusive_container_with_mismatched_sizes)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-exclusive-container bar [
+<span class="muData">exclusive-container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:foo
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">3</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">1</span>:num
diff --git a/html/034address.cc.html b/html/034address.cc.html
index ea739cf3..f7f575e0 100644
--- a/html/034address.cc.html
+++ b/html/034address.cc.html
@@ -15,13 +15,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.CommentedCode { color: #6c6c6c; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.CommentedCode { color: #6c6c6c; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -157,15 +158,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Delimiter">:(scenario new)</span>
 <span class="Comment"># call 'new' two times with identical types without modifying the results; you</span>
 <span class="Comment"># should get back different results</span>
-def main [
-  <span class="Constant">1</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type
-  <span class="Constant">2</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
+  <span class="Constant">2</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal <span class="Constant">1</span>:address:num/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">2</span>:address:num/<span class="Special">raw</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 3</span>
 
 <span class="Delimiter">:(scenario dilated_reagent_with_new)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>address number<span class="Delimiter">)</span>: type<span class="Delimiter">}</span>
 ]
 <span class="traceContains">+new: size of (&quot;address&quot; &quot;number&quot;) is 1</span>
@@ -375,15 +376,15 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">:(scenario new_initializes)</span>
 <span class="Special">% Memory_allocated_until = 10;</span>
 <span class="Special">% put(Memory, Memory_allocated_until, 1);</span>
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 10</span>
 
 <span class="Delimiter">:(scenario new_array)</span>
-def main [
-  <span class="Constant">1</span>:address:array:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">5</span>
-  <span class="Constant">2</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:array:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">5</span>
+  <span class="Constant">2</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">3</span>:num/<span class="Special">raw &lt;- </span>subtract <span class="Constant">2</span>:address:num/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:array:num/<span class="Special">raw</span>
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;array&quot; &quot;number&quot;), &quot;raw&quot;: ()} &lt;- new {number: &quot;type&quot;}, {5: &quot;literal&quot;}</span>
@@ -392,9 +393,9 @@ def main [
 <span class="traceContains">+mem: storing 7 in location 3</span>
 
 <span class="Delimiter">:(scenario new_empty_array)</span>
-def main [
-  <span class="Constant">1</span>:address:array:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">0</span>
-  <span class="Constant">2</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:array:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">0</span>
+  <span class="Constant">2</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">3</span>:num/<span class="Special">raw &lt;- </span>subtract <span class="Constant">2</span>:address:num/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:array:num/<span class="Special">raw</span>
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;array&quot; &quot;number&quot;), &quot;raw&quot;: ()} &lt;- new {number: &quot;type&quot;}, {0: &quot;literal&quot;}</span>
@@ -405,9 +406,9 @@ def main [
 <span class="Comment">//: If a routine runs out of its initial allocation, it should allocate more.</span>
 <span class="Delimiter">:(scenario new_overflow)</span>
 <span class="Special">% Initial_memory_per_routine = 3;  // barely enough room for point allocation below</span>
-def main [
-  <span class="Constant">1</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type
-  <span class="Constant">2</span>:address:point/<span class="Special">raw &lt;- </span><span class="Normal">new</span> point:type  <span class="Comment"># not enough room in initial page</span>
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
+  <span class="Constant">2</span>:address:point/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">point:type</span>  <span class="Comment"># not enough room in initial page</span>
 ]
 <span class="traceContains">+new: routine allocated memory from 1000 to 1003</span>
 <span class="traceContains">+new: routine allocated memory from 1003 to 1006</span>
diff --git a/html/035lookup.cc.html b/html/035lookup.cc.html
index 967f4e6d..b9993bac 100644
--- a/html/035lookup.cc.html
+++ b/html/035lookup.cc.html
@@ -16,13 +16,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -69,7 +70,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: 'new'.</span>
 
 <span class="Delimiter">:(scenario copy_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Comment"># This loads location 1 as an address and looks up *that* location.</span>
@@ -84,7 +85,7 @@ canonize<span class="Delimiter">(</span>x<span class="Delimiter">);</span>
 <span class="Comment">//: similarly, write to addresses pointing at other locations using the</span>
 <span class="Comment">//: 'lookup' property</span>
 <span class="Delimiter">:(scenario store_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Constant">1</span>:address:num/lookup<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
@@ -96,7 +97,7 @@ canonize<span class="Delimiter">(</span>x<span class="Delimiter">);</span>
 <span class="Comment">//: writes to address 0 always loudly fail</span>
 <span class="Delimiter">:(scenario store_to_0_fails)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">1</span>:address:num/lookup<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
@@ -218,33 +219,33 @@ assert<span class="Delimiter">(</span>!has_property<span class="Delimiter">(</sp
 <span class="Comment">//: 'products' variables in run_current_routine().</span>
 
 <span class="Delimiter">:(scenario get_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:point<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
-  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
+  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> <span class="Constant">0:offset</span>
 ]
 <span class="traceContains">+mem: storing 34 in location 2</span>
 
 <span class="Delimiter">:(scenario get_indirect2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:point<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">2</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">20</span>/unsafe
-  <span class="Constant">2</span>:address:num/lookup<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
+  <span class="Constant">2</span>:address:num/lookup<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> <span class="Constant">0:offset</span>
 ]
 <span class="traceContains">+mem: storing 34 in location 21</span>
 
 <span class="Delimiter">:(scenario include_nonlookup_properties)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:point<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
-  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:address:point/lookup/foo<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
+  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:address:point/lookup/foo<span class="Delimiter">,</span> <span class="Constant">0:offset</span>
 ]
 <span class="traceContains">+mem: storing 34 in location 2</span>
 
@@ -256,12 +257,12 @@ def main [
 canonize<span class="Delimiter">(</span>base<span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario put_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:point<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
-  <span class="Constant">1</span>:address:point/lookup<span class="Special"> &lt;- </span>put <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> <span class="Constant">0</span>:offset<span class="Delimiter">,</span> <span class="Constant">36</span>
+  <span class="Constant">1</span>:address:point/lookup<span class="Special"> &lt;- </span>put <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> <span class="Constant">0:offset</span><span class="Delimiter">,</span> <span class="Constant">36</span>
 ]
 <span class="traceContains">+mem: storing 36 in location 11</span>
 
@@ -274,12 +275,12 @@ canonize<span class="Delimiter">(</span>base<span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario put_product_error_with_lookup)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:point<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
-  <span class="Constant">1</span>:address:point<span class="Special"> &lt;- </span>put <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">36</span>
+  <span class="Constant">1</span>:address:point<span class="Special"> &lt;- </span>put <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">36</span>
 ]
 <span class="traceContains">+error: main: product of 'put' must be first ingredient '1:address:point/lookup', but got '1:address:point'</span>
 
@@ -295,8 +296,8 @@ reagent<span class="Comment">/*</span><span class="Comment">copy</span><span cla
 
 <span class="Delimiter">:(scenario new_error)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
-  <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
 ]
 <span class="traceContains">+error: main: product of 'new' has incorrect type: '1:num/raw &lt;- new number:type'</span>
 
@@ -304,7 +305,7 @@ def main [
 canonize_type<span class="Delimiter">(</span>product<span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario copy_array_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
@@ -319,7 +320,7 @@ def main [
 <span class="traceContains">+mem: storing 16 in location 5</span>
 
 <span class="Delimiter">:(scenario create_array_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1000</span>:num/<span class="Special">raw &lt;- </span>copy <span class="Constant">1</span>  <span class="Comment"># pretend refcount</span>
   <span class="Constant">1</span>:address:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>copy <span class="Constant">1000</span>/unsafe  <span class="Comment"># pretend allocation</span>
   <span class="Constant">1</span>:address:array:num:<span class="Constant">3</span>/lookup<span class="Special"> &lt;- </span>create-array
@@ -332,7 +333,7 @@ def main [
 canonize<span class="Delimiter">(</span>product<span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario index_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
@@ -356,7 +357,7 @@ canonize<span class="Delimiter">(</span>base<span class="Delimiter">);</span>
 canonize<span class="Delimiter">(</span>index<span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario put_index_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
@@ -368,7 +369,7 @@ def main [
 <span class="traceContains">+mem: storing 34 in location 13</span>
 
 <span class="Delimiter">:(scenario put_index_indirect_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">15</span>
@@ -382,7 +383,7 @@ def main [
 
 <span class="Delimiter">:(scenario put_index_product_error_with_lookup)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
@@ -404,9 +405,9 @@ reagent<span class="Comment">/*</span><span class="Comment">copy</span><span cla
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario dilated_reagent_in_static_array)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>array <span class="Delimiter">(</span>address number<span class="Delimiter">)</span> <span class="Constant">3</span><span class="Delimiter">)}</span><span class="Special"> &lt;- </span>create-array
-  <span class="Constant">5</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Constant">5</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>array <span class="Delimiter">(</span>address number<span class="Delimiter">)</span> <span class="Constant">3</span><span class="Delimiter">)}</span><span class="Special"> &lt;- </span>put-index <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>array <span class="Delimiter">(</span>address number<span class="Delimiter">)</span> <span class="Constant">3</span><span class="Delimiter">)},</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">5</span>:address:num
   *<span class="Constant">5</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">6</span>:num<span class="Special"> &lt;- </span>copy *<span class="Constant">5</span>:address:num
@@ -427,7 +428,7 @@ canonize<span class="Delimiter">(</span>base<span class="Delimiter">);</span>
 canonize<span class="Delimiter">(</span>index<span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario length_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:array:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">14</span>
@@ -444,33 +445,33 @@ def main [
 canonize<span class="Delimiter">(</span>array<span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario maybe_convert_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:number-<span class="Normal">or</span>-point<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/number<span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
-  <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point/lookup<span class="Delimiter">,</span> i:variant
+  <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point/lookup<span class="Delimiter">,</span> <span class="Constant">i:variant</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 3</span>
 <span class="traceContains">+mem: storing 34 in location 2</span>
 
 <span class="Delimiter">:(scenario maybe_convert_indirect_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:number-<span class="Normal">or</span>-point<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/number<span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Constant">2</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">20</span>/unsafe
-  <span class="Constant">2</span>:address:num/lookup<span class="Delimiter">,</span> <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point/lookup<span class="Delimiter">,</span> i:variant
+  <span class="Constant">2</span>:address:num/lookup<span class="Delimiter">,</span> <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point/lookup<span class="Delimiter">,</span> <span class="Constant">i:variant</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 3</span>
 <span class="traceContains">+mem: storing 34 in location 21</span>
 
 <span class="Delimiter">:(scenario maybe_convert_indirect_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:number-<span class="Normal">or</span>-point<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/number<span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Constant">2</span>:address:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">20</span>/unsafe
-  <span class="Constant">3</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:address:<span class="Normal">bool</span>/lookup<span class="Special"> &lt;- </span>maybe-convert <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point/lookup<span class="Delimiter">,</span> i:variant
+  <span class="Constant">3</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:address:<span class="Normal">bool</span>/lookup<span class="Special"> &lt;- </span>maybe-convert <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point/lookup<span class="Delimiter">,</span> <span class="Constant">i:variant</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 21</span>
 <span class="traceContains">+mem: storing 34 in location 3</span>
@@ -490,7 +491,7 @@ canonize<span class="Delimiter">(</span>product<span class="Delimiter">);</span>
 canonize<span class="Delimiter">(</span>status<span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario merge_exclusive_container_indirect)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Constant">1</span>:address:number-<span class="Normal">or</span>-point/lookup<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/number<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
@@ -504,7 +505,7 @@ canonize<span class="Delimiter">(</span>x<span class="Delimiter">);</span>
 <span class="Comment">//: abbreviation for '/lookup': a prefix '*'</span>
 
 <span class="Delimiter">:(scenario lookup_abbreviation)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:number<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
diff --git a/html/036refcount.cc.html b/html/036refcount.cc.html
index 2b42b63f..757a96fe 100644
--- a/html/036refcount.cc.html
+++ b/html/036refcount.cc.html
@@ -15,14 +15,16 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
-.SalientComment { color: #00ffff; }
+.muRecipe { color: #ff8700; }
+.Todo { color: #000000; background-color: #ffff00; padding-bottom: 1px; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.Todo { color: #000000; background-color: #ffff00; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
+.SalientComment { color: #00ffff; }
 -->
 </style>
 
@@ -38,7 +40,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: The top of the address layer has more on refcounts.</span>
 
 <span class="Delimiter">:(scenario refcounts)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">1000</span>/unsafe
   <span class="Constant">2</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:address:num
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -122,8 +124,8 @@ def main [
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario refcounts_reflexive)</span>
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Comment"># idempotent copies leave refcount unchanged</span>
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:address:num
 ]
@@ -134,14 +136,14 @@ def main [
 <span class="traceContains">+mem: decrementing refcount of 1000: 2 -&gt; 1</span>
 
 <span class="Delimiter">:(scenario refcounts_call)</span>
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Comment"># passing in addresses to recipes increments refcount</span>
   foo <span class="Constant">1</span>:address:num
   <span class="Comment"># return does NOT yet decrement refcount; memory must be explicitly managed</span>
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
 ]
-def foo [
+<span class="muRecipe">def</span> foo [
   <span class="Constant">2</span>:address:num<span class="Special"> &lt;- </span>next-ingredient
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span>
@@ -157,13 +159,13 @@ def foo [
 <span class="Comment">//: before the RUN switch, and write_memory after</span>
 
 <span class="Delimiter">:(scenario refcounts_put)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
-  <span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> foo:type
-  *<span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">2</span>:address:foo<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
+  <span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
+  *<span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">2</span>:address:foo<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span>
 <span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span>
@@ -180,8 +182,8 @@ element<span class="Delimiter">.</span>set_value<span class="Delimiter">(</span>
 update_any_refcounts<span class="Delimiter">(</span>element<span class="Delimiter">,</span> ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">2</span><span class="Delimiter">));</span>
 
 <span class="Delimiter">:(scenario refcounts_put_index)</span>
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:address:array:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>address number<span class="Delimiter">)</span>: type<span class="Delimiter">},</span> <span class="Constant">3</span>
   *<span class="Constant">2</span>:address:array:address:num<span class="Special"> &lt;- </span>put-index *<span class="Constant">2</span>:address:array:address:num<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
 ]
@@ -197,14 +199,14 @@ def main [
 update_any_refcounts<span class="Delimiter">(</span>element<span class="Delimiter">,</span> value<span class="Delimiter">);</span>
 
 <span class="Delimiter">:(scenario refcounts_maybe_convert)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">p</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/p<span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
-  <span class="Constant">4</span>:address:num<span class="Delimiter">,</span> <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">2</span>:foo<span class="Delimiter">,</span> <span class="Constant">1</span>:variant/p
+  <span class="Constant">4</span>:address:num<span class="Delimiter">,</span> <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">2</span>:foo<span class="Delimiter">,</span> <span class="Constant">1:variant/p</span>
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span>
 <span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span>
@@ -225,13 +227,13 @@ update_any_refcounts<span class="Delimiter">(</span>product<span class="Delimite
 <span class="SalientComment">//:: manage refcounts in instructions that copy multiple locations at a time</span>
 
 <span class="Delimiter">:(scenario refcounts_copy_nested)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:address:num  <span class="Comment"># address inside container</span>
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
-  <span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> foo:type
-  *<span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">2</span>:address:foo<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
+  <span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
+  *<span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">2</span>:address:foo<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
   <span class="Constant">3</span>:foo<span class="Special"> &lt;- </span>copy *<span class="Constant">2</span>:address:foo
 ]
 <span class="traceContains">+transform: compute address offsets for container foo</span>
@@ -752,17 +754,17 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario refcounts_put_container)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">a</span>:bar  <span class="Comment"># contains an address</span>
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:address:num
-  <span class="Constant">3</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> foo:type
-  *<span class="Constant">3</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">3</span>:address:foo<span class="Delimiter">,</span> a:offset<span class="Delimiter">,</span> <span class="Constant">2</span>:bar
+  <span class="Constant">3</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
+  *<span class="Constant">3</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">3</span>:address:foo<span class="Delimiter">,</span> <span class="Constant">a:offset</span><span class="Delimiter">,</span> <span class="Constant">2</span>:bar
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span>
 <span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span>
@@ -773,13 +775,13 @@ def main [
 <span class="traceContains">+mem: incrementing refcount of 1000: 2 -&gt; 3</span>
 
 <span class="Delimiter">:(scenario refcounts_put_index_array)</span>
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:address:num
-  <span class="Constant">3</span>:address:array:bar<span class="Special"> &lt;- </span><span class="Normal">new</span> bar:type<span class="Delimiter">,</span> <span class="Constant">3</span>
+  <span class="Constant">3</span>:address:array:bar<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">bar:type</span><span class="Delimiter">,</span> <span class="Constant">3</span>
   *<span class="Constant">3</span>:address:array:bar<span class="Special"> &lt;- </span>put-index *<span class="Constant">3</span>:address:array:bar<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">2</span>:bar
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span>
@@ -791,18 +793,18 @@ def main [
 <span class="traceContains">+mem: incrementing refcount of 1000: 2 -&gt; 3</span>
 
 <span class="Delimiter">:(scenario refcounts_maybe_convert_container)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">a</span>:num
   <span class="Normal">b</span>:bar  <span class="Comment"># contains an address</span>
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:address:num
   <span class="Constant">3</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/b<span class="Delimiter">,</span> <span class="Constant">2</span>:bar
-  <span class="Constant">5</span>:bar<span class="Delimiter">,</span> <span class="Constant">6</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">3</span>:foo<span class="Delimiter">,</span> <span class="Constant">1</span>:variant/b
+  <span class="Constant">5</span>:bar<span class="Delimiter">,</span> <span class="Constant">6</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">3</span>:foo<span class="Delimiter">,</span> <span class="Constant">1:variant/b</span>
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span>
 <span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span>
@@ -814,24 +816,24 @@ def main [
 <span class="traceContains">+mem: incrementing refcount of 1000: 3 -&gt; 4</span>
 
 <span class="Delimiter">:(scenario refcounts_copy_doubly_nested)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">a</span>:bar  <span class="Comment"># no addresses</span>
   <span class="Normal">b</span>:curr  <span class="Comment"># contains addresses</span>
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-container curr [
+<span class="muData">container</span> curr [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:address:num  <span class="Comment"># address inside container inside container</span>
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
-  <span class="Constant">2</span>:address:curr<span class="Special"> &lt;- </span><span class="Normal">new</span> curr:type
-  *<span class="Constant">2</span>:address:curr<span class="Special"> &lt;- </span>put *<span class="Constant">2</span>:address:curr<span class="Delimiter">,</span> <span class="Constant">1</span>:offset/y<span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
-  <span class="Constant">3</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> foo:type
-  *<span class="Constant">3</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">3</span>:address:foo<span class="Delimiter">,</span> <span class="Constant">1</span>:offset/b<span class="Delimiter">,</span> *<span class="Constant">2</span>:address:curr
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
+  <span class="Constant">2</span>:address:curr<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">curr:type</span>
+  *<span class="Constant">2</span>:address:curr<span class="Special"> &lt;- </span>put *<span class="Constant">2</span>:address:curr<span class="Delimiter">,</span> <span class="Constant">1:offset/y</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
+  <span class="Constant">3</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
+  *<span class="Constant">3</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">3</span>:address:foo<span class="Delimiter">,</span> <span class="Constant">1:offset/b</span><span class="Delimiter">,</span> *<span class="Constant">2</span>:address:curr
   <span class="Constant">4</span>:foo<span class="Special"> &lt;- </span>copy *<span class="Constant">3</span>:address:foo
 ]
 <span class="traceContains">+transform: compute address offsets for container foo</span>
@@ -850,17 +852,17 @@ def main [
 <span class="traceContains">+mem: incrementing refcount of 1000: 3 -&gt; 4</span>
 
 <span class="Delimiter">:(scenario refcounts_copy_exclusive_container_within_container)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">a</span>:num
   <span class="Normal">b</span>:bar
 ]
-exclusive-container bar [
+<span class="muData">exclusive-container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
   <span class="Normal">z</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Constant">3</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">12</span><span class="Delimiter">,</span> <span class="Constant">2</span>:bar
   <span class="Constant">5</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">35</span>
@@ -880,17 +882,17 @@ def main [
 <span class="traceContains">+mem: incrementing refcount of 1000: 3 -&gt; 4</span>
 
 <span class="Delimiter">:(scenario refcounts_copy_container_within_exclusive_container)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">a</span>:num
   <span class="Normal">b</span>:bar
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
   <span class="Normal">z</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/a<span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Constant">6</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/a<span class="Delimiter">,</span> <span class="Constant">35</span>
   <span class="Constant">10</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">2</span>/x<span class="Delimiter">,</span> <span class="Constant">15</span>/y<span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
@@ -908,16 +910,16 @@ def main [
 <span class="traceContains">+mem: incrementing refcount of 1000: 3 -&gt; 4</span>
 
 <span class="Delimiter">:(scenario refcounts_copy_exclusive_container_within_exclusive_container)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">a</span>:num
   <span class="Normal">b</span>:bar
 ]
-exclusive-container bar [
+<span class="muData">exclusive-container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">10</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/b<span class="Delimiter">,</span> <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
   <span class="Constant">20</span>:foo<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>:foo
 ]
@@ -930,13 +932,13 @@ def main [
 <span class="traceContains">+mem: incrementing refcount of 1000: 2 -&gt; 3</span>
 
 <span class="Delimiter">:(scenario refcounts_copy_array_within_container)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:address:array:num
 ]
-def main [
-  <span class="Constant">1</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">3</span>
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">3</span>
   <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:address:array:num
-  <span class="Constant">3</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">5</span>
+  <span class="Constant">3</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">5</span>
   <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">3</span>:address:array:num
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;array&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}, {3: &quot;literal&quot;}</span>
@@ -947,19 +949,19 @@ def main [
 <span class="traceContains">+mem: decrementing refcount of 1000: 2 -&gt; 1</span>
 
 <span class="Delimiter">:(scenario refcounts_handle_exclusive_containers_with_different_tags)</span>
-container foo1 [
+<span class="muData">container</span> foo1 [
   <span class="Normal">x</span>:address:num
   <span class="Normal">y</span>:num
 ]
-container foo2 [
+<span class="muData">container</span> foo2 [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:address:num
 ]
-exclusive-container bar [
+<span class="muData">exclusive-container</span> bar [
   <span class="Normal">a</span>:foo1
   <span class="Normal">b</span>:foo2
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">12000</span>/unsafe  <span class="Comment"># pretend allocation</span>
   *<span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/foo1<span class="Delimiter">,</span> <span class="Constant">1</span>:address:num<span class="Delimiter">,</span> <span class="Constant">97</span>
diff --git a/html/037abandon.cc.html b/html/037abandon.cc.html
index 6984c154..3c1d2c2f 100644
--- a/html/037abandon.cc.html
+++ b/html/037abandon.cc.html
@@ -15,12 +15,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.CommentedCode { color: #6c6c6c; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.CommentedCode { color: #6c6c6c; }
 .Identifier { color: #fcb165; }
 -->
 </style>
@@ -37,11 +39,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: The top of the address layer has the complete life cycle of memory.</span>
 
 <span class="Delimiter">:(scenario new_reclaim)</span>
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:address:num  <span class="Comment"># because 1 will get reset during abandon below</span>
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># abandon</span>
-  <span class="Constant">3</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type  <span class="Comment"># must be same size as abandoned memory to reuse</span>
+  <span class="Constant">3</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>  <span class="Comment"># must be same size as abandoned memory to reuse</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>:address:num
   <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">4</span>:num
 ]
@@ -109,11 +111,11 @@ map&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span cla
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario new_differing_size_no_reclaim)</span>
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:address:num
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># abandon</span>
-  <span class="Constant">3</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">2</span>  <span class="Comment"># different size</span>
+  <span class="Constant">3</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">2</span>  <span class="Comment"># different size</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>:address:array:num
   <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">4</span>:num
 ]
@@ -121,11 +123,11 @@ def main [
 <span class="traceContains">+mem: storing 0 in location 5</span>
 
 <span class="Delimiter">:(scenario new_reclaim_array)</span>
-def main [
-  <span class="Constant">1</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">2</span>
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">2</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:address:array:num
   <span class="Constant">1</span>:address:array:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># abandon</span>
-  <span class="Constant">3</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">2</span>  <span class="Comment"># same size</span>
+  <span class="Constant">3</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">2</span>  <span class="Comment"># same size</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>:address:array:num
   <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">4</span>:num
 ]
@@ -133,10 +135,10 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 5</span>
 
 <span class="Delimiter">:(scenario abandon_on_overwrite)</span>
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Comment"># over-writing one allocation with another</span>
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span>
@@ -145,13 +147,13 @@ def main [
 <span class="traceContains">+mem: automatically abandoning 1000</span>
 
 <span class="Delimiter">:(scenario abandon_after_call)</span>
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Comment"># passing in addresses to recipes increments refcount</span>
   foo <span class="Constant">1</span>:address:num
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-def foo [
+<span class="muRecipe">def</span> foo [
   <span class="Constant">2</span>:address:num<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># return does NOT yet decrement refcount; memory must be explicitly managed</span>
   <span class="Constant">2</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -169,13 +171,13 @@ def foo [
 <span class="traceContains">+mem: automatically abandoning 1000</span>
 
 <span class="Delimiter">:(scenario abandon_on_overwrite_array)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">30</span>
   <span class="Comment"># allocate an array</span>
-  <span class="Constant">10</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">20</span>
+  <span class="Constant">10</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">20</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>:address:array:num  <span class="Comment"># doesn't increment refcount</span>
   <span class="Comment"># allocate another array in its place, implicitly freeing the previous allocation</span>
-  <span class="Constant">10</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">25</span>
+  <span class="Constant">10</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">25</span>
 ]
 <span class="traceContains">+run: {10: (&quot;address&quot; &quot;array&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}, {25: &quot;literal&quot;}</span>
 <span class="Comment"># abandoned array is of old size (20, not 25)</span>
@@ -183,13 +185,13 @@ def main [
 
 <span class="Delimiter">:(scenario refcounts_abandon_address_in_container)</span>
 <span class="Comment"># container containing an address</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
-  <span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> foo:type
-  *<span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">2</span>:address:foo<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
+  <span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
+  *<span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">2</span>:address:foo<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
@@ -212,8 +214,8 @@ def main [
 
 <span class="Comment"># todo: move past dilated reagent</span>
 <span class="Delimiter">:(scenario refcounts_abandon_address_in_array)</span>
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:address:array:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>address number<span class="Delimiter">)</span>: type<span class="Delimiter">},</span> <span class="Constant">3</span>
   *<span class="Constant">2</span>:address:array:address:num<span class="Special"> &lt;- </span>put-index *<span class="Constant">2</span>:address:array:address:num<span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:num
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -232,12 +234,12 @@ def main [
 
 <span class="Delimiter">:(scenario refcounts_abandon_address_in_container_in_array)</span>
 <span class="Comment"># container containing an address</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:address:num
 ]
-def main [
-  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
-  <span class="Constant">2</span>:address:array:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> foo:type<span class="Delimiter">,</span> <span class="Constant">3</span>
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
+  <span class="Constant">2</span>:address:array:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span><span class="Delimiter">,</span> <span class="Constant">3</span>
   <span class="Constant">3</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:address:num
   *<span class="Constant">2</span>:address:array:foo<span class="Special"> &lt;- </span>put-index *<span class="Constant">2</span>:address:array:foo<span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">3</span>:foo
   <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
diff --git a/html/038new_text.cc.html b/html/038new_text.cc.html
index 81b50bde..4b024918 100644
--- a/html/038new_text.cc.html
+++ b/html/038new_text.cc.html
@@ -14,13 +14,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
-.traceContains { color: #008000; }
+.CommentedCode { color: #6c6c6c; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.CommentedCode { color: #6c6c6c; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -39,7 +40,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 put<span class="Delimiter">(</span>Type_abbreviations<span class="Delimiter">,</span> <span class="Constant">&quot;text&quot;</span><span class="Delimiter">,</span> new_type_tree<span class="Delimiter">(</span><span class="Constant">&quot;address:array:character&quot;</span><span class="Delimiter">));</span>
 
 <span class="Delimiter">:(scenario new_string)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc def]
   <span class="Constant">2</span>:<span class="Normal">char</span><span class="Special"> &lt;- </span>index *<span class="Constant">1</span>:text<span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
@@ -47,7 +48,7 @@ def main [
 <span class="traceContains">+mem: storing 101 in location 2</span>
 
 <span class="Delimiter">:(scenario new_string_handles_unicode)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [a«c]
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>length *<span class="Constant">1</span>:text
   <span class="Constant">3</span>:<span class="Normal">char</span><span class="Special"> &lt;- </span>index *<span class="Constant">1</span>:text<span class="Delimiter">,</span> <span class="Constant">1</span>
@@ -99,7 +100,7 @@ def main [
 <span class="Comment">//: stash recognizes strings</span>
 
 <span class="Delimiter">:(scenario stash_string)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   stash [foo:]<span class="Delimiter">,</span> <span class="Constant">1</span>:text
 ]
@@ -112,21 +113,21 @@ def main [
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario unicode_string)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [♠]
   stash [foo:]<span class="Delimiter">,</span> <span class="Constant">1</span>:text
 ]
 <span class="traceContains">+app: foo: ♠</span>
 
 <span class="Delimiter">:(scenario stash_space_after_string)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   stash <span class="Constant">1</span>:text<span class="Delimiter">,</span> [foo]
 ]
 <span class="traceContains">+app: abc foo</span>
 
 <span class="Delimiter">:(scenario stash_string_as_array)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   stash *<span class="Constant">1</span>:text
 ]
@@ -139,8 +140,8 @@ def main [
 <span class="Comment">//: Allocate more to routine when initializing a literal string</span>
 <span class="Delimiter">:(scenario new_string_overflow)</span>
 <span class="Special">% Initial_memory_per_routine = 3;</span>
-def main [
-  <span class="Constant">1</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:address:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:text/<span class="Special">raw &lt;- </span><span class="Normal">new</span> [a]  <span class="Comment"># not enough room in initial page, if you take the refcount and array length into account</span>
 ]
 <span class="traceContains">+new: routine allocated memory from 1000 to 1003</span>
diff --git a/html/040brace.cc.html b/html/040brace.cc.html
index 8ce5fff1..edfa2020 100644
--- a/html/040brace.cc.html
+++ b/html/040brace.cc.html
@@ -14,8 +14,9 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
-.cSpecial { color: #008000; }
 .traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
+.cSpecial { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
@@ -56,7 +57,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario brace_conversion)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Delimiter">{</span>
     <span class="Identifier">break</span>
     <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -136,14 +137,14 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
     <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>old_name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;-if&quot;</span><span class="Delimiter">)</span> != string::npos || inst<span class="Delimiter">.</span>old_name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;-unless&quot;</span><span class="Delimiter">)</span> != string::npos<span class="Delimiter">)</span> <span class="Delimiter">{</span>
       <span class="Comment">// conditional branches check arg 1</span>
       <span class="Normal">if</span> <span class="Delimiter">(</span>SIZE<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> &gt; <span class="Constant">1</span> &amp;&amp; is_literal<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
-        trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; inst<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">' '</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>name &lt;&lt; <span class="Constant">&quot;:offset&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
+        trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; inst<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">' '</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>name &lt;&lt; <span class="Constant">&quot;:offset</span><span class="Constant">&quot; &lt;&lt; end();</span>
         <span class="Identifier">continue</span><span class="Delimiter">;</span>
       <span class="Delimiter">}</span>
     <span class="Delimiter">}</span>
     <span class="Normal">else</span> <span class="Delimiter">{</span>
       <span class="Comment">// unconditional branches check arg 0</span>
       <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; is_literal<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
-        trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;jump &quot;</span> &lt;&lt; inst<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;:offset&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
+        trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;jump &quot;</span> &lt;&lt; inst<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;:offset</span><span class="Constant">&quot; &lt;&lt; end();</span>
         <span class="Identifier">continue</span><span class="Delimiter">;</span>
       <span class="Delimiter">}</span>
     <span class="Delimiter">}</span>
@@ -160,9 +161,9 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
     inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>target<span class="Delimiter">);</span>
     <span class="Comment">// log computed target</span>
     <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>name == <span class="Constant">&quot;jump&quot;</span><span class="Delimiter">)</span>
-      trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;jump &quot;</span> &lt;&lt; no_scientific<span class="Delimiter">(</span>target<span class="Delimiter">.</span>value<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;:offset&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
+      trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;jump &quot;</span> &lt;&lt; no_scientific<span class="Delimiter">(</span>target<span class="Delimiter">.</span>value<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;:offset</span><span class="Constant">&quot; &lt;&lt; end();</span>
     <span class="Normal">else</span>
-      trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; inst<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">' '</span> &lt;&lt; inst<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> &lt;&lt; no_scientific<span class="Delimiter">(</span>target<span class="Delimiter">.</span>value<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;:offset&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
+      trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; inst<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">' '</span> &lt;&lt; inst<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> &lt;&lt; no_scientific<span class="Delimiter">(</span>target<span class="Delimiter">.</span>value<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;:offset</span><span class="Constant">&quot; &lt;&lt; end();</span>
   <span class="Delimiter">}</span>
 <span class="Delimiter">}</span>
 
@@ -180,7 +181,7 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario loop)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
@@ -195,7 +196,7 @@ def main [
 <span class="traceContains">+transform: jump -2:offset</span>
 
 <span class="Delimiter">:(scenario break_empty_block)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
     <span class="Identifier">break</span>
@@ -206,7 +207,7 @@ def main [
 <span class="traceContains">+transform: jump 0:offset</span>
 
 <span class="Delimiter">:(scenario break_cascading)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
     <span class="Identifier">break</span>
@@ -221,7 +222,7 @@ def main [
 <span class="traceContains">+transform: jump 0:offset</span>
 
 <span class="Delimiter">:(scenario break_cascading_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
@@ -240,7 +241,7 @@ def main [
 <span class="traceContains">+transform: jump 0:offset</span>
 
 <span class="Delimiter">:(scenario break_if)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
@@ -259,7 +260,7 @@ def main [
 <span class="traceContains">+transform: jump 0:offset</span>
 
 <span class="Delimiter">:(scenario break_nested)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
     <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -273,7 +274,7 @@ def main [
 <span class="traceContains">+transform: jump 4:offset</span>
 
 <span class="Delimiter">:(scenario break_nested_degenerate)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
     <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -286,7 +287,7 @@ def main [
 <span class="traceContains">+transform: jump 3:offset</span>
 
 <span class="Delimiter">:(scenario break_nested_degenerate_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
     <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -299,16 +300,16 @@ def main [
 
 <span class="Delimiter">:(scenario break_label)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
-    <span class="Identifier">break</span> +foo:offset
+    <span class="Identifier">break</span> <span class="Constant">+foo:offset</span>
   <span class="Delimiter">}</span>
 ]
 <span class="traceContains">+transform: jump +foo:offset</span>
 
 <span class="Delimiter">:(scenario break_unless)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
@@ -323,7 +324,7 @@ def main [
 <span class="traceContains">+transform: copy ...</span>
 
 <span class="Delimiter">:(scenario loop_unless)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
@@ -338,7 +339,7 @@ def main [
 <span class="traceContains">+transform: copy ...</span>
 
 <span class="Delimiter">:(scenario loop_nested)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
     <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -353,7 +354,7 @@ def main [
 <span class="traceContains">+transform: jump-if 4, -5:offset</span>
 
 <span class="Delimiter">:(scenario loop_label)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   +foo
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -365,7 +366,7 @@ def main [
 <span class="Comment">//: test how things actually run</span>
 <span class="Delimiter">:(scenarios run)</span>
 <span class="Delimiter">:(scenario brace_conversion_and_run)</span>
-def test-factorial [
+<span class="muRecipe">def</span> test-factorial [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Delimiter">{</span>
@@ -382,14 +383,14 @@ def test-factorial [
 
 <span class="Delimiter">:(scenario break_outside_braces_fails)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Identifier">break</span>
 ]
 <span class="traceContains">+error: 'break' needs a '{' before</span>
 
 <span class="Delimiter">:(scenario break_conditional_without_ingredient_fails)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Delimiter">{</span>
     <span class="Identifier">break</span>-<span class="Normal">if</span>
   <span class="Delimiter">}</span>
@@ -399,20 +400,20 @@ def main [
 <span class="Comment">//: Using break we can now implement conditional returns.</span>
 
 <span class="Delimiter">:(scenario return_if)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>test1
 ]
-def test1 [
+<span class="muRecipe">def</span> test1 [
   <span class="Identifier">return</span>-<span class="Normal">if</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Identifier">return</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+mem: storing 35 in location 1</span>
 
 <span class="Delimiter">:(scenario return_if_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>test1
 ]
-def test1 [
+<span class="muRecipe">def</span> test1 [
   <span class="Identifier">return</span>-<span class="Normal">if</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Identifier">return</span> <span class="Constant">35</span>
 ]
diff --git a/html/041jump_target.cc.html b/html/041jump_target.cc.html
index 766bd7da..23cda500 100644
--- a/html/041jump_target.cc.html
+++ b/html/041jump_target.cc.html
@@ -16,6 +16,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
+.muRecipe { color: #ff8700; }
 .traceContains { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
@@ -43,8 +44,8 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: iteration of some containing loop nest.</span>
 
 <span class="Delimiter">:(scenario jump_to_label)</span>
-def main [
-  jump +target:label
+<span class="muRecipe">def</span> main [
+  jump <span class="Constant">+target:label</span>
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   +target
 ]
@@ -127,10 +128,10 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario break_to_label)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Delimiter">{</span>
     <span class="Delimiter">{</span>
-      <span class="Identifier">break</span> +target:label
+      <span class="Identifier">break</span> <span class="Constant">+target:label</span>
       <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
     <span class="Delimiter">}</span>
   <span class="Delimiter">}</span>
@@ -139,10 +140,10 @@ def main [
 <span class="traceAbsent">-mem: storing 0 in location 1</span>
 
 <span class="Delimiter">:(scenario jump_if_to_label)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Delimiter">{</span>
     <span class="Delimiter">{</span>
-      jump-<span class="Normal">if</span> <span class="Constant">1</span><span class="Delimiter">,</span> +target:label
+      jump-<span class="Normal">if</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">+target:label</span>
       <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
     <span class="Delimiter">}</span>
   <span class="Delimiter">}</span>
@@ -151,10 +152,10 @@ def main [
 <span class="traceAbsent">-mem: storing 0 in location 1</span>
 
 <span class="Delimiter">:(scenario loop_unless_to_label)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Delimiter">{</span>
     <span class="Delimiter">{</span>
-      loop-unless <span class="Constant">0</span><span class="Delimiter">,</span> +target:label  <span class="Comment"># loop/break with a label don't care about braces</span>
+      loop-unless <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">+target:label</span>  <span class="Comment"># loop/break with a label don't care about braces</span>
       <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
     <span class="Delimiter">}</span>
   <span class="Delimiter">}</span>
@@ -163,12 +164,12 @@ def main [
 <span class="traceAbsent">-mem: storing 0 in location 1</span>
 
 <span class="Delimiter">:(scenario jump_runs_code_after_label)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># first a few lines of padding to exercise the offset computation</span>
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
-  jump +target:label
+  jump <span class="Constant">+target:label</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   +target
   <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -178,21 +179,21 @@ def main [
 
 <span class="Delimiter">:(scenario jump_fails_without_target)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   jump
 ]
 <span class="traceContains">+error: main: 'jump' expects an ingredient but got none</span>
 
 <span class="Delimiter">:(scenario jump_fails_without_target_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   jump-<span class="Normal">if</span> <span class="Constant">1</span>/<span class="Constant">true</span>
 ]
 <span class="traceContains">+error: main: 'jump-if' expects 2 ingredients but got 1</span>
 
 <span class="Delimiter">:(scenario recipe_fails_on_duplicate_jump_target)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   +label
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   +label
@@ -202,12 +203,12 @@ def main [
 
 <span class="Delimiter">:(scenario jump_ignores_nontarget_label)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># first a few lines of padding to exercise the offset computation</span>
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
-  jump $target:label
+  jump <span class="Constant">$target:label</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   $target
   <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
diff --git a/html/042name.cc.html b/html/042name.cc.html
index 829cc216..a397562f 100644
--- a/html/042name.cc.html
+++ b/html/042name.cc.html
@@ -16,13 +16,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.CommentedCode { color: #6c6c6c; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.CommentedCode { color: #6c6c6c; }
 .Identifier { color: #fcb165; }
 -->
 </style>
@@ -40,7 +41,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: convenience.</span>
 
 <span class="Delimiter">:(scenario transform_names)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+name: assign x 1</span>
@@ -49,7 +50,7 @@ def main [
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario transform_names_fails_on_use_before_define)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy y:num
 ]
 <span class="traceContains">+error: main: use before set: 'y'</span>
@@ -191,7 +192,7 @@ type_ordinal skip_addresses<span class="Delimiter">(</span>type_tree* type<span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario transform_names_supports_containers)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:point<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
 ]
@@ -200,7 +201,7 @@ def main [
 <span class="traceContains">+name: assign y 3</span>
 
 <span class="Delimiter">:(scenario transform_names_supports_static_arrays)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:@:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
 ]
@@ -210,7 +211,7 @@ def main [
 
 <span class="Delimiter">:(scenario transform_names_passes_dummy)</span>
 <span class="Comment"># _ is just a dummy result that never gets consumed</span>
-def main [
+<span class="muRecipe">def</span> main [
   _<span class="Delimiter">,</span> x:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
 <span class="traceContains">+name: assign x 1</span>
@@ -220,7 +221,7 @@ def main [
 <span class="Delimiter">:(scenarios run)</span>
 <span class="Delimiter">:(scenario transform_names_passes_raw)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num/<span class="Special">raw &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceAbsent">-name: assign x 1</span>
@@ -229,28 +230,28 @@ def main [
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario transform_names_fails_when_mixing_names_and_numeric_locations)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:num
 ]
 <span class="traceContains">+error: main: mixing variable names and numeric addresses</span>
 
 <span class="Delimiter">:(scenario transform_names_fails_when_mixing_names_and_numeric_locations_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy x:num
 ]
 <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>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:num/<span class="Special">raw</span>
 ]
 <span class="traceAbsent">-error: main: mixing variable names and numeric addresses</span>
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario transform_names_does_not_fail_when_mixing_names_and_literals)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
 <span class="traceAbsent">-error: main: mixing variable names and numeric addresses</span>
@@ -260,10 +261,10 @@ $error: <span class="Constant">0</span>
 <span class="Comment">//: (get-location is implemented later)</span>
 
 <span class="Delimiter">:(scenario transform_names_transforms_container_elements)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
-  <span class="Normal">a</span>:num<span class="Special"> &lt;- </span>get *p:&amp;:point<span class="Delimiter">,</span> y:offset
-  <span class="Normal">b</span>:num<span class="Special"> &lt;- </span>get *p:&amp;:point<span class="Delimiter">,</span> x:offset
+  <span class="Normal">a</span>:num<span class="Special"> &lt;- </span>get *p:&amp;:point<span class="Delimiter">,</span> <span class="Constant">y:offset</span>
+  <span class="Normal">b</span>:num<span class="Special"> &lt;- </span>get *p:&amp;:point<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
 ]
 <span class="traceContains">+name: element y of type point is at offset 1</span>
 <span class="traceContains">+name: element x of type point is at offset 0</span>
@@ -293,7 +294,7 @@ def main [
 <span class="Comment">//: this test is actually illegal so can't call run</span>
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario transform_names_handles_containers)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">a</span>:point<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/unsafe
   <span class="Normal">b</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/unsafe
 ]
@@ -304,11 +305,11 @@ def main [
 
 <span class="Delimiter">:(scenarios run)</span>
 <span class="Delimiter">:(scenario transform_names_handles_exclusive_containers)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  <span class="Constant">20</span>:point<span class="Delimiter">,</span> <span class="Constant">22</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> p:variant
+  <span class="Constant">20</span>:point<span class="Delimiter">,</span> <span class="Constant">22</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert <span class="Constant">12</span>:number-<span class="Normal">or</span>-point/unsafe<span class="Delimiter">,</span> <span class="Constant">p:variant</span>
 ]
 <span class="traceContains">+name: variant p of type number-or-point has tag 1</span>
 <span class="traceContains">+mem: storing 1 in location 22</span>
diff --git a/html/043space.cc.html b/html/043space.cc.html
index 036f7def..1c862968 100644
--- a/html/043space.cc.html
+++ b/html/043space.cc.html
@@ -16,13 +16,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -47,7 +49,7 @@ put<span class="Delimiter">(</span>Type_abbreviations<span class="Delimiter">,</
 <span class="Delimiter">:(scenario set_default_space)</span>
 <span class="Comment"># if default-space is 10, and if an array of 5 locals lies from location 12 to 16 (inclusive),</span>
 <span class="Comment"># then local 0 is really location 12, local 1 is really location 13, and so on.</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># pretend address:array:location; in practice we'll use new</span>
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>  <span class="Comment"># length</span>
@@ -57,7 +59,7 @@ def main [
 <span class="traceContains">+mem: storing 23 in location 13</span>
 
 <span class="Delimiter">:(scenario lookup_sidesteps_default_space)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># pretend pointer from outside (2000 reserved for refcount)</span>
   <span class="Constant">2001</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Comment"># pretend address:array:location; in practice we'll use new</span>
@@ -73,7 +75,7 @@ def main [
 <span class="SalientComment">//:: first disable name conversion for 'default-space'</span>
 <span class="Delimiter">:(scenario convert_names_passes_default_space)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">default</span>-space:num<span class="Delimiter">,</span> x:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
 <span class="traceContains">+name: assign x 1</span>
@@ -136,7 +138,7 @@ absolutize<span class="Delimiter">(</span>x<span class="Delimiter">);</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario get_default_space)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Constant">1</span>:space/<span class="Special">raw &lt;- </span>copy <span class="Normal">default</span>-space:space
 ]
@@ -152,7 +154,7 @@ def main [
 <span class="SalientComment">//:: fix 'get'</span>
 
 <span class="Delimiter">:(scenario lookup_sidesteps_default_space_in_get)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># pretend pointer to container from outside (2000 reserved for refcount)</span>
   <span class="Constant">2001</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2002</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
@@ -162,7 +164,7 @@ def main [
   <span class="Comment"># actual start of this recipe</span>
   <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span>copy <span class="Constant">1000</span>/unsafe
   <span class="Constant">1</span>:&amp;:point<span class="Special"> &lt;- </span>copy <span class="Constant">2000</span>/unsafe
-  <span class="Constant">9</span>:num/<span class="Special">raw &lt;- </span>get *<span class="Constant">1</span>:&amp;:point<span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+  <span class="Constant">9</span>:num/<span class="Special">raw &lt;- </span>get *<span class="Constant">1</span>:&amp;:point<span class="Delimiter">,</span> <span class="Constant">1:offset</span>
 ]
 <span class="traceContains">+mem: storing 35 in location 9</span>
 
@@ -172,7 +174,7 @@ element<span class="Delimiter">.</span>properties<span class="Delimiter">.</span
 <span class="SalientComment">//:: fix 'index'</span>
 
 <span class="Delimiter">:(scenario lookup_sidesteps_default_space_in_index)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># pretend pointer to array from outside (2000 reserved for refcount)</span>
   <span class="Constant">2001</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">2</span>  <span class="Comment"># length</span>
   <span class="Constant">2002</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
@@ -194,7 +196,7 @@ element<span class="Delimiter">.</span>properties<span class="Delimiter">.</span
 <span class="SalientComment">//:: allocate in a default space with names</span>
 
 <span class="Delimiter">:(scenario new_default_space)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">new</span>-<span class="Normal">default</span>-space
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
@@ -233,12 +235,12 @@ def main [
 <span class="SalientComment">//:: default-space when the routine exits</span>
 
 <span class="Delimiter">:(scenario local_scope)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:&amp;<span class="Special"> &lt;- </span>foo
   <span class="Constant">2</span>:&amp;<span class="Special"> &lt;- </span>foo
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:&amp;<span class="Delimiter">,</span> <span class="Constant">2</span>:&amp;
 ]
-def foo [
+<span class="muRecipe">def</span> foo [
   local-scope
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Identifier">return</span> <span class="Normal">default</span>-space:space
@@ -247,7 +249,7 @@ def foo [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario local_scope_frees_up_addresses)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">x</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
 ]
@@ -342,21 +344,21 @@ Update_refcounts_in_write_memory = <span class="Constant">true</span><span class
   <span class="Normal">if</span> <span class="Delimiter">(</span>!curr<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>empty<span class="Delimiter">())</span>
     raise &lt;&lt; to_original_string<span class="Delimiter">(</span>curr<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot; can't take any ingredients</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
   curr<span class="Delimiter">.</span>name = <span class="Constant">&quot;new&quot;</span><span class="Delimiter">;</span>
-  curr<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>reagent<span class="Delimiter">(</span><span class="Constant">&quot;location:type&quot;</span><span class="Delimiter">));</span>
-  curr<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>reagent<span class="Delimiter">(</span><span class="Constant">&quot;number-of-locals:literal&quot;</span><span class="Delimiter">));</span>
+  <span class="Constant">curr.ingredients.push_back(reagent(&quot;location:type</span><span class="Constant">&quot;));</span>
+  <span class="Constant">curr.ingredients.push_back(reagent(&quot;number-of-locals:literal</span><span class="Constant">&quot;));</span>
   <span class="Normal">if</span> <span class="Delimiter">(</span>!curr<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">())</span>
     raise &lt;&lt; <span class="Constant">&quot;new-default-space can't take any results</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
   curr<span class="Delimiter">.</span>products<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>reagent<span class="Delimiter">(</span><span class="Constant">&quot;default-space:space&quot;</span><span class="Delimiter">));</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario local_scope_frees_up_addresses_inside_containers)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:&amp;:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Normal">y</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> x:&amp;:num
   <span class="Comment"># x and y are both cleared when main returns</span>
 ]
@@ -367,24 +369,24 @@ def main [
 <span class="traceContains">+mem: automatically abandoning 1006</span>
 
 <span class="Delimiter">:(scenario local_scope_returns_addresses_inside_containers)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:&amp;:num
 ]
-def f [
+<span class="muRecipe">def</span> f [
   local-scope
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *x:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
   <span class="Normal">y</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> x:&amp;:num
   <span class="Comment"># since y is 'escaping' f, it should not be cleared</span>
   <span class="Identifier">return</span> y:foo
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>f
-  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> x:offset
-  <span class="Constant">4</span>:&amp;:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> y:offset
+  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
+  <span class="Constant">4</span>:&amp;:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">y:offset</span>
   <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>copy *<span class="Constant">4</span>:&amp;:num
-  <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>put <span class="Constant">1</span>:foo<span class="Delimiter">,</span> y:offset<span class="Delimiter">,</span> <span class="Constant">0</span>
+  <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>put <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">y:offset</span><span class="Delimiter">,</span> <span class="Constant">0</span>
   <span class="Constant">4</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 34 in location 1</span>
@@ -403,12 +405,12 @@ def main [
 <span class="traceContains">+mem: automatically abandoning 1006</span>
 
 <span class="Delimiter">:(scenario local_scope_claims_return_values_when_not_saved)</span>
-def f [
+<span class="muRecipe">def</span> f [
   local-scope
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   reply x:&amp;:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   f  <span class="Comment"># doesn't save result</span>
 ]
 <span class="Comment"># x reclaimed</span>
diff --git a/html/044space_surround.cc.html b/html/044space_surround.cc.html
index bd9f07ef..70ef4d46 100644
--- a/html/044space_surround.cc.html
+++ b/html/044space_surround.cc.html
@@ -15,12 +15,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -40,7 +41,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenario surrounding_space)</span>
 <span class="Comment"># location 1 in space 1 refers to the space surrounding the default space, here 20.</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># pretend address:array:location; in practice we'll use new</span>
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>  <span class="Comment"># length</span>
@@ -53,7 +54,7 @@ def main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">32</span>
   <span class="Constant">1</span>:num/space:<span class="Constant">1</span><span class="Special"> &lt;- </span>copy <span class="Constant">33</span>
 ]
-def dummy [  <span class="Comment"># just for the /names: property above</span>
+<span class="muRecipe">def</span> dummy [  <span class="Comment"># just for the /names: property above</span>
 ]
 <span class="Comment"># chain space: 10 + (refcount and length) 2</span>
 <span class="traceContains">+mem: storing 20 in location 12</span>
@@ -94,7 +95,7 @@ def dummy [  <span class="Comment"># just for the /names: property above</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario permit_space_as_variable_name)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">space</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 </pre>
diff --git a/html/045closure_name.cc.html b/html/045closure_name.cc.html
index c4f9a0ef..a51ebcbc 100644
--- a/html/045closure_name.cc.html
+++ b/html/045closure_name.cc.html
@@ -14,8 +14,9 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
-.cSpecial { color: #008000; }
 .traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
+.cSpecial { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
@@ -39,20 +40,20 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: surrounding space of the surrounding space, etc.</span>
 
 <span class="Delimiter">:(scenario closure)</span>
-def main [
-  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span><span class="Normal">new</span> location:type<span class="Delimiter">,</span> <span class="Constant">30</span>
+<span class="muRecipe">def</span> main [
+  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">location:type</span><span class="Delimiter">,</span> <span class="Constant">30</span>
   <span class="Constant">1</span>:space/names:<span class="Normal">new</span>-counter<span class="Special"> &lt;- </span><span class="Normal">new</span>-counter
   <span class="Constant">2</span>:num/<span class="Special">raw &lt;- </span>increment-counter <span class="Constant">1</span>:space/names:<span class="Normal">new</span>-counter
   <span class="Constant">3</span>:num/<span class="Special">raw &lt;- </span>increment-counter <span class="Constant">1</span>:space/names:<span class="Normal">new</span>-counter
 ]
-def <span class="Normal">new</span>-counter [
-  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span><span class="Normal">new</span> location:type<span class="Delimiter">,</span> <span class="Constant">30</span>
+<span class="muRecipe">def</span> <span class="Normal">new</span>-counter [
+  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">location:type</span><span class="Delimiter">,</span> <span class="Constant">30</span>
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>  <span class="Comment"># variable that will be incremented</span>
   <span class="Identifier">return</span> <span class="Normal">default</span>-space:space
 ]
-def increment-counter [
-  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span><span class="Normal">new</span> location:type<span class="Delimiter">,</span> <span class="Constant">30</span>
+<span class="muRecipe">def</span> increment-counter [
+  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">location:type</span><span class="Delimiter">,</span> <span class="Constant">30</span>
   <span class="Constant">0</span>:space/names:<span class="Normal">new</span>-counter<span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># outer space must be created by 'new-counter' above</span>
   <span class="Normal">y</span>:num/space:<span class="Constant">1</span><span class="Special"> &lt;- </span>add y:num/space:<span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">1</span>  <span class="Comment"># increment</span>
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">234</span>  <span class="Comment"># dummy</span>
@@ -175,7 +176,7 @@ recipe_ordinal lookup_surrounding_recipe<span class="Delimiter">(</span><span cl
 
 <span class="Delimiter">:(scenario missing_surrounding_space)</span>
 <span class="Special">% Hide_errors = true;</span>
-def f [
+<span class="muRecipe">def</span> f [
   local-scope
   <span class="Normal">x</span>:num/space:<span class="Constant">1</span><span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
@@ -184,19 +185,19 @@ def f [
 
 <span class="Comment">//: extra test for try_reclaim_locals() from previous layers</span>
 <span class="Delimiter">:(scenario local_scope_ignores_nonlocal_spaces)</span>
-def <span class="Normal">new</span>-scope [
+<span class="muRecipe">def</span> <span class="Normal">new</span>-scope [
   <span class="Normal">new</span>-<span class="Normal">default</span>-space
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *x:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Identifier">return</span> <span class="Normal">default</span>-space:space
 ]
-def use-scope [
+<span class="muRecipe">def</span> use-scope [
   local-scope
   <span class="Normal">outer</span>:space<span class="Special"> &lt;- </span>next-ingredient
   <span class="Constant">0</span>:space/names:<span class="Normal">new</span>-scope<span class="Special"> &lt;- </span>copy outer:space
   <span class="Identifier">return</span> *x:&amp;:num/space:<span class="Constant">1</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:space/<span class="Special">raw &lt;- </span><span class="Normal">new</span>-scope
   <span class="Constant">2</span>:num/<span class="Special">raw &lt;- </span>use-scope <span class="Constant">1</span>:space/<span class="Special">raw</span>
 ]
diff --git a/html/046global.cc.html b/html/046global.cc.html
index df8ba426..4bae44f9 100644
--- a/html/046global.cc.html
+++ b/html/046global.cc.html
@@ -15,12 +15,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -44,7 +45,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: entirely.</span>
 
 <span class="Delimiter">:(scenario global_space)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># pretend address:array:location; in practice we'll use new</span>
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>  <span class="Comment"># length</span>
@@ -55,7 +56,7 @@ def main [
   global-space:space<span class="Special"> &lt;- </span>copy <span class="Constant">20</span>/unsafe
   <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
-  <span class="Constant">1</span>:num/space:global<span class="Special"> &lt;- </span>copy <span class="Constant">24</span>
+  <span class="Special">1:num/space:global</span><span class="Special"> &lt;- </span>copy <span class="Constant">24</span>
 ]
 <span class="Comment"># store to default space: 10 + (skip refcount and length) 2 + (index) 1</span>
 <span class="traceContains">+mem: storing 23 in location 13</span>
@@ -96,10 +97,10 @@ 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>
-def main [
-  global-space:space<span class="Special"> &lt;- </span><span class="Normal">new</span> location:type<span class="Delimiter">,</span> <span class="Constant">10</span>
+<span class="muRecipe">def</span> main [
+  global-space:space<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">location:type</span><span class="Delimiter">,</span> <span class="Constant">10</span>
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
-  <span class="Constant">1</span>:num/space:global<span class="Special"> &lt;- </span>copy <span class="Constant">24</span>
+  <span class="Special">1:num/space:global</span><span class="Special"> &lt;- </span>copy <span class="Constant">24</span>
 ]
 <span class="Comment"># don't complain about mixing numeric addresses and names</span>
 $error: <span class="Constant">0</span>
diff --git a/html/047check_type_by_name.cc.html b/html/047check_type_by_name.cc.html
index 433b67aa..c5199c12 100644
--- a/html/047check_type_by_name.cc.html
+++ b/html/047check_type_by_name.cc.html
@@ -15,12 +15,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -42,7 +43,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenario transform_fails_on_reusing_name_with_different_type)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Normal">x</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
@@ -101,7 +102,7 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario transform_fills_in_missing_types)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
@@ -109,7 +110,7 @@ def main [
 <span class="traceContains">+mem: storing 2 in location 2</span>
 
 <span class="Delimiter">:(scenario transform_fills_in_missing_types_in_product)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   x<span class="Special"> &lt;- </span>copy <span class="Constant">2</span>
 ]
@@ -117,7 +118,7 @@ def main [
 <span class="traceContains">+mem: storing 2 in location 1</span>
 
 <span class="Delimiter">:(scenario transform_fills_in_missing_types_in_product_and_ingredient)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   x<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
@@ -126,7 +127,7 @@ def main [
 
 <span class="Delimiter">:(scenario transform_fails_on_missing_types_in_first_mention)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   x<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">2</span>
 ]
@@ -134,24 +135,24 @@ def main [
 
 <span class="Delimiter">:(scenario typo_in_address_type_fails)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
-  <span class="Normal">y</span>:&amp;:charcter<span class="Special"> &lt;- </span><span class="Normal">new</span> character:type
+<span class="muRecipe">def</span> main [
+  <span class="Normal">y</span>:&amp;:charcter<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">character:type</span>
   *y<span class="Special"> &lt;- </span>copy <span class="Constant">67</span>
 ]
 <span class="traceContains">+error: main: unknown type charcter in 'y:&amp;:charcter &lt;- new character:type'</span>
 
 <span class="Delimiter">:(scenario array_type_without_size_fails)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">x</span>:@:num<span class="Special"> &lt;- </span>merge <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">12</span><span class="Delimiter">,</span> <span class="Constant">13</span>
 ]
 <span class="traceContains">+error: main can't determine the size of array variable 'x'. Either allocate it separately and make the type of 'x' an address, or specify the length of the array in the type of 'x'.</span>
 
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario transform_checks_types_of_identical_reagents_in_multiple_spaces)</span>
-def foo [  <span class="Comment"># dummy</span>
+<span class="muRecipe">def</span> foo [  <span class="Comment"># dummy</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Constant">0</span>:space/names:foo<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># specify surrounding space</span>
   <span class="Normal">x</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">1</span>/<span class="Constant">true</span>
diff --git a/html/050scenario.cc.html b/html/050scenario.cc.html
index 2a1e847e..a4217e06 100644
--- a/html/050scenario.cc.html
+++ b/html/050scenario.cc.html
@@ -13,17 +13,19 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.Constant { color: #00a0a0; }
-.traceAbsent { color: #c00000; }
-.cSpecial { color: #008000; }
-.traceContains { color: #008000; }
 .SalientComment { color: #00ffff; }
-.Comment { color: #9090ff; }
+.CommentedCode { color: #6c6c6c; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
+.traceContains { color: #008000; }
 .Delimiter { color: #800080; }
+.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.cSpecial { color: #008000; }
+.traceAbsent { color: #c00000; }
+.Comment { color: #9090ff; }
+.Constant { color: #00a0a0; }
 .Special { color: #c00000; }
 .Identifier { color: #fcb165; }
-.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.CommentedCode { color: #6c6c6c; }
 -->
 </style>
 
@@ -42,7 +44,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: handy to check the values of specific variables</span>
 <span class="Delimiter">:(scenarios run_mu_scenario)</span>
 <span class="Delimiter">:(scenario scenario_block)</span>
-scenario foo [
+<span class="muScenario">scenario</span> foo [
   run [
     <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">13</span>
   ]
@@ -53,7 +55,7 @@ scenario foo [
 <span class="Comment"># checks are inside scenario</span>
 
 <span class="Delimiter">:(scenario scenario_multiple_blocks)</span>
-scenario foo [
+<span class="muScenario">scenario</span> foo [
   run [
     <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">13</span>
   ]
@@ -71,7 +73,7 @@ scenario foo [
 <span class="Comment"># checks are inside scenario</span>
 
 <span class="Delimiter">:(scenario scenario_check_memory_and_trace)</span>
-scenario foo [
+<span class="muScenario">scenario</span> foo [
   run [
     <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">13</span>
     trace <span class="Constant">1</span><span class="Delimiter">,</span> [a]<span class="Delimiter">,</span> [a b c]
@@ -112,7 +114,7 @@ vector&lt;scenario&gt; Scenarios<span class="Delimiter">;</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(code)</span>
-scenario parse_scenario<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">)</span> <span class="Delimiter">{</span>
+<span class="muScenario">scenario</span> parse_scenario<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">)</span> <span class="Delimiter">{</span>
   scenario result<span class="Delimiter">;</span>
   result<span class="Delimiter">.</span>name = next_word<span class="Delimiter">(</span>in<span class="Delimiter">);</span>
   skip_whitespace_and_comments<span class="Delimiter">(</span>in<span class="Delimiter">);</span>
@@ -132,14 +134,14 @@ scenario parse_scenario<span class="Delimiter">(</span>istream&amp; in<span clas
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario read_scenario_with_bracket_in_comment)</span>
-scenario foo [
+<span class="muScenario">scenario</span> foo [
   <span class="Comment"># ']' in comment</span>
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+run: {1: &quot;number&quot;} &lt;- copy {0: &quot;literal&quot;}</span>
 
 <span class="Delimiter">:(scenario read_scenario_with_bracket_in_comment_in_nested_string)</span>
-scenario foo [
+<span class="muScenario">scenario</span> foo [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [<span class="Comment"># not a comment]</span>
 ]
 <span class="traceContains">+run: {1: (&quot;address&quot; &quot;array&quot; &quot;character&quot;)} &lt;- new {&quot;# not a comment&quot;: &quot;literal-string&quot;}</span>
@@ -279,10 +281,10 @@ Name[r][<span class="Constant">&quot;__maybe_make_raw_test__&quot;</span>] = Res
 <span class="Delimiter">:(scenario forbid_redefining_scenario_even_if_forced)</span>
 <span class="Special">% Hide_errors = true;</span>
 <span class="Special">% Disable_redefine_checks = true;</span>
-def scenario-foo [
+<span class="muRecipe">def</span> scenario-foo [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
-def scenario-foo [
+<span class="muRecipe">def</span> scenario-foo [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
 ]
 <span class="traceContains">+error: redefining recipe scenario-foo</span>
@@ -297,7 +299,7 @@ def scenario-foo [
 <span class="Comment">//: tested from any setup or teardown</span>
 
 <span class="Delimiter">:(scenario run)</span>
-def main [
+<span class="muRecipe">def</span> main [
   run [
     <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">13</span>
   ]
@@ -314,7 +316,7 @@ def main [
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario run_multiple)</span>
-def main [
+<span class="muRecipe">def</span> main [
   run [
     <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">13</span>
   ]
@@ -336,7 +338,7 @@ Scenario_testing_scenario = <span class="Constant">false</span><span class="Deli
 <span class="Delimiter">:(scenario memory_check)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   memory-should-contain [
     <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">13</span>
   ]
@@ -458,7 +460,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">:(scenario memory_check_multiple)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   memory-should-contain [
     <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
     <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
@@ -469,7 +471,7 @@ def main [
 <span class="Delimiter">:(scenario memory_check_string_length)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">97</span>  <span class="Comment"># 'a'</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">98</span>  <span class="Comment"># 'b'</span>
@@ -481,7 +483,7 @@ def main [
 <span class="traceContains">+error: expected location '1' to contain length 2 of string [ab] but saw 3</span>
 
 <span class="Delimiter">:(scenario memory_check_string)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">97</span>  <span class="Comment"># 'a'</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">98</span>  <span class="Comment"># 'b'</span>
@@ -498,7 +500,7 @@ def main [
 <span class="Delimiter">:(scenario memory_invalid_string_check)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   memory-should-contain [
     <span class="Constant">1</span><span class="Special"> &lt;- </span>[abc]
   ]
@@ -508,7 +510,7 @@ def main [
 <span class="Delimiter">:(scenario memory_check_with_comment)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   memory-should-contain [
     <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">34</span>  <span class="Comment"># comment</span>
   ]
@@ -524,7 +526,7 @@ def main [
 <span class="Delimiter">:(scenario trace_check_fails)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   trace-should-contain [
     <span class="Normal">a</span>: b
     <span class="Normal">a</span>: d
@@ -593,7 +595,7 @@ vector&lt;trace_line&gt; parse_trace<span class="Delimiter">(</span><span class=
 <span class="Delimiter">:(scenario trace_check_fails_in_nonfirst_line)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   run [
     trace <span class="Constant">1</span><span class="Delimiter">,</span> [a]<span class="Delimiter">,</span> [b]
   ]
@@ -606,7 +608,7 @@ def main [
 
 <span class="Delimiter">:(scenario trace_check_passes_silently)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   run [
     trace <span class="Constant">1</span><span class="Delimiter">,</span> [a]<span class="Delimiter">,</span> [b]
   ]
@@ -624,7 +626,7 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">:(scenario trace_negative_check_fails)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   run [
     trace <span class="Constant">1</span><span class="Delimiter">,</span> [a]<span class="Delimiter">,</span> [b]
   ]
@@ -667,7 +669,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario trace_negative_check_passes_silently)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   trace-should-<span class="Normal">not</span>-contain [
     <span class="Normal">a</span>: b
   ]
@@ -678,7 +680,7 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">:(scenario trace_negative_check_fails_on_any_unexpected_line)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   run [
     trace <span class="Constant">1</span><span class="Delimiter">,</span> [a]<span class="Delimiter">,</span> [d]
   ]
@@ -690,7 +692,7 @@ def main [
 <span class="traceContains">+error: unexpected [d] in trace with label 'a'</span>
 
 <span class="Delimiter">:(scenario trace_count_check)</span>
-def main [
+<span class="muRecipe">def</span> main [
   run [
     trace <span class="Constant">1</span><span class="Delimiter">,</span> [a]<span class="Delimiter">,</span> [foo]
   ]
@@ -742,7 +744,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">:(scenario trace_count_check_2)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   run [
     trace <span class="Constant">1</span><span class="Delimiter">,</span> [a]<span class="Delimiter">,</span> [foo]
   ]
@@ -759,7 +761,7 @@ def main [
 
 <span class="Delimiter">:(scenario recipe_name_with_underscore)</span>
 <span class="Special">% Hide_errors = true;</span>
-def foo_bar [
+<span class="muRecipe">def</span> foo_bar [
 ]
 <span class="traceContains">+error: foo_bar: don't create recipes with '_' in the name</span>
 
diff --git a/html/051scenario_test.mu.html b/html/051scenario_test.mu.html
index 951c5858..2b1151be 100644
--- a/html/051scenario_test.mu.html
+++ b/html/051scenario_test.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/052tangle.cc.html b/html/052tangle.cc.html
index f3c04e19..b3106faa 100644
--- a/html/052tangle.cc.html
+++ b/html/052tangle.cc.html
@@ -16,12 +16,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -42,12 +43,12 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: todo: switch recipe.steps to a more efficient data structure.</span>
 
 <span class="Delimiter">:(scenario tangle_before)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   &lt;label1&gt;
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-before &lt;label1&gt; [
+<span class="muRecipe">before</span> &lt;label1&gt; [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
@@ -198,15 +199,15 @@ check_insert_fragments<span class="Delimiter">();</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario tangle_before_and_after)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   &lt;label1&gt;
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-before &lt;label1&gt; [
+<span class="muRecipe">before</span> &lt;label1&gt; [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
@@ -219,33 +220,33 @@ $mem: <span class="Constant">4</span>
 
 <span class="Delimiter">:(scenario tangle_ignores_jump_target)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   +label1
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-before +label1 [
+<span class="muRecipe">before</span> +label1 [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+error: can't tangle before label +label1</span>
 
 <span class="Delimiter">:(scenario tangle_keeps_labels_separate)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   &lt;label1&gt;
   &lt;label2&gt;
   <span class="Constant">6</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-before &lt;label1&gt; [
+<span class="muRecipe">before</span> &lt;label1&gt; [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-before &lt;label2&gt; [
+<span class="muRecipe">before</span> &lt;label2&gt; [
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-after &lt;label2&gt; [
+<span class="muRecipe">after</span> &lt;label2&gt; [
   <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
@@ -261,21 +262,21 @@ after &lt;label2&gt; [
 $mem: <span class="Constant">6</span>
 
 <span class="Delimiter">:(scenario tangle_stacks_multiple_fragments)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   &lt;label1&gt;
   <span class="Constant">6</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-before &lt;label1&gt; [
+<span class="muRecipe">before</span> &lt;label1&gt; [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-before &lt;label1&gt; [
+<span class="muRecipe">before</span> &lt;label1&gt; [
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceContains">+mem: storing 0 in location 1</span>
@@ -291,16 +292,16 @@ after &lt;label1&gt; [
 $mem: <span class="Constant">6</span>
 
 <span class="Delimiter">:(scenario tangle_supports_fragments_with_multiple_instructions)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   &lt;label1&gt;
   <span class="Constant">6</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-before &lt;label1&gt; [
+<span class="muRecipe">before</span> &lt;label1&gt; [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
@@ -315,21 +316,21 @@ after &lt;label1&gt; [
 $mem: <span class="Constant">6</span>
 
 <span class="Delimiter">:(scenario tangle_tangles_into_all_labels_with_same_name)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
   &lt;label1&gt;
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
   recipe2
 ]
-def recipe2 [
+<span class="muRecipe">def</span> recipe2 [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">11</span>
   &lt;label1&gt;
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">11</span>
 ]
-before &lt;label1&gt; [
+<span class="muRecipe">before</span> &lt;label1&gt; [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
 ]
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
 ]
 <span class="traceContains">+mem: storing 10 in location 1</span>
@@ -347,16 +348,16 @@ after &lt;label1&gt; [
 $mem: <span class="Constant">8</span>
 
 <span class="Delimiter">:(scenario tangle_tangles_into_all_labels_with_same_name_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
   &lt;label1&gt;
   &lt;label1&gt;
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
 ]
-before &lt;label1&gt; [
+<span class="muRecipe">before</span> &lt;label1&gt; [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
 ]
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
 ]
 <span class="traceContains">+mem: storing 10 in location 1</span>
@@ -371,19 +372,19 @@ after &lt;label1&gt; [
 $mem: <span class="Constant">6</span>
 
 <span class="Delimiter">:(scenario tangle_tangles_into_all_labels_with_same_name_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
   &lt;label1&gt;
   &lt;foo&gt;
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
 ]
-before &lt;label1&gt; [
+<span class="muRecipe">before</span> &lt;label1&gt; [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
 ]
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
 ]
-after &lt;foo&gt; [
+<span class="muRecipe">after</span> &lt;foo&gt; [
   &lt;label1&gt;
 ]
 <span class="traceContains">+mem: storing 10 in location 1</span>
@@ -398,13 +399,13 @@ after &lt;foo&gt; [
 $mem: <span class="Constant">6</span>
 
 <span class="Delimiter">:(scenario tangle_handles_jump_target_inside_fragment)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
   &lt;label1&gt;
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
 ]
-before &lt;label1&gt; [
-  jump +label2:label
+<span class="muRecipe">before</span> &lt;label1&gt; [
+  jump <span class="Constant">+label2:label</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
   +label2
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
@@ -419,14 +420,14 @@ before &lt;label1&gt; [
 $mem: <span class="Constant">3</span>
 
 <span class="Delimiter">:(scenario tangle_renames_jump_target)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
   &lt;label1&gt;
   +label2
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
 ]
-before &lt;label1&gt; [
-  jump +label2:label
+<span class="muRecipe">before</span> &lt;label1&gt; [
+  jump <span class="Constant">+label2:label</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
   +label2  <span class="Comment"># renamed</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
@@ -441,14 +442,14 @@ before &lt;label1&gt; [
 $mem: <span class="Constant">3</span>
 
 <span class="Delimiter">:(scenario tangle_jump_to_base_recipe)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
   &lt;label1&gt;
   +label2
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
 ]
-before &lt;label1&gt; [
-  jump +label2:label
+<span class="muRecipe">before</span> &lt;label1&gt; [
+  jump <span class="Constant">+label2:label</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
 ]
diff --git a/html/053recipe_header.cc.html b/html/053recipe_header.cc.html
index f3beba5b..8be8212d 100644
--- a/html/053recipe_header.cc.html
+++ b/html/053recipe_header.cc.html
@@ -15,15 +15,16 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
-.cSpecial { color: #008000; }
 .traceContains { color: #008000; }
-.SalientComment { color: #00ffff; }
+.muRecipe { color: #ff8700; }
+.cSpecial { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
 .Identifier { color: #fcb165; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
 .Error { color: #ffffff; background-color: #ff6060; padding-bottom: 1px; }
+.SalientComment { color: #00ffff; }
 -->
 </style>
 
@@ -39,10 +40,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: number of ingredients and yields some fixed number of products.</span>
 
 <span class="Delimiter">:(scenario recipe_with_header)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add2 <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
-def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
   <span class="Normal">z</span>:num<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> y
@@ -87,10 +88,10 @@ has_header = <span class="Constant">false</span><span class="Delimiter">;</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario recipe_handles_stray_comma)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add2 <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
-def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> z:num<span class="Delimiter">,</span> [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:num<span class="Delimiter">,</span> [
   local-scope
   load-ingredients
   <span class="Normal">z</span>:num<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> y
@@ -99,32 +100,32 @@ def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&g
 <span class="traceContains">+mem: storing 8 in location 1</span>
 
 <span class="Delimiter">:(scenario recipe_handles_stray_comma_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   foo
 ]
-def foo<span class="Delimiter">,</span> [
+<span class="muRecipe">def</span> foo<span class="Delimiter">,</span> [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">2</span>
 ]
-def bar [
+<span class="muRecipe">def</span> bar [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">3</span>
 ]
 <span class="traceContains">+mem: storing 4 in location 1</span>
 
 <span class="Delimiter">:(scenario recipe_handles_wrong_arrow)</span>
 <span class="Special">% Hide_errors = true;</span>
-def foo a:num<span class="Special"> &lt;- </span>b:num [
+<span class="muRecipe">def</span> foo a:num<span class="Special"> &lt;- </span>b:num [
 ]
 <span class="traceContains">+error: recipe foo should say '-&gt;' and not '&lt;-'</span>
 
 <span class="Delimiter">:(scenario recipe_handles_missing_bracket)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main
+<span class="muRecipe">def</span> main
 <span class="Error">]</span>
 <span class="traceContains">+error: main: recipe body must begin with '['</span>
 
 <span class="Delimiter">:(scenario recipe_handles_missing_bracket_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main
+<span class="muRecipe">def</span> main
   local-scope
   <span class="Delimiter">{</span>
   <span class="Delimiter">}</span>
@@ -135,7 +136,7 @@ def main
 
 <span class="Delimiter">:(scenario recipe_handles_missing_bracket_3)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main  <span class="Comment"># comment</span>
+<span class="muRecipe">def</span> main  <span class="Comment"># comment</span>
   local-scope
   <span class="Delimiter">{</span>
   <span class="Delimiter">}</span>
@@ -155,7 +156,7 @@ out &lt;&lt; <span class="Constant">&quot;products:</span><span class="cSpecial"
 <span class="Comment">//: If a recipe never mentions any ingredients or products, assume it has a header.</span>
 
 <span class="Delimiter">:(scenario recipe_without_ingredients_or_products_has_header)</span>
-def test [
+<span class="muRecipe">def</span> test [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="traceContains">+parse: recipe test has a header</span>
@@ -182,12 +183,12 @@ def test [
 <span class="Comment">//: Support type abbreviations in headers.</span>
 
 <span class="Delimiter">:(scenario type_abbreviations_in_recipe_headers)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">a</span>:text<span class="Special"> &lt;- </span>foo
   <span class="Constant">1</span>:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>index *a<span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
-def foo <span class="Delimiter">-&gt;</span> a:text [  <span class="Comment"># 'text' is an abbreviation</span>
+<span class="muRecipe">def</span> foo<span class="muRecipe"> -&gt; </span>a:text [  <span class="Comment"># 'text' is an abbreviation</span>
   local-scope
   load-ingredients
   a<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
@@ -253,10 +254,10 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario show_clear_error_on_bad_call)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">34</span>
 ]
-def foo x:point <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:point<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -265,10 +266,10 @@ def foo x:point <span class="Delimiter">-&gt;</span> y:num [
 
 <span class="Delimiter">:(scenario show_clear_error_on_bad_call_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:point<span class="Special"> &lt;- </span>foo <span class="Constant">34</span>
 ]
-def foo x:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> x
@@ -305,7 +306,7 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario recipe_headers_are_checked)</span>
 <span class="Special">% Hide_errors = true;</span>
-def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
   <span class="Normal">z</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/unsafe
@@ -337,7 +338,7 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 
 <span class="Delimiter">:(scenario recipe_headers_are_checked_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def add2 x:num<span class="Delimiter">,</span> y:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num [
   local-scope
   load-ingredients
   <span class="Normal">z</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/unsafe
@@ -347,7 +348,7 @@ def add2 x:num<span class="Delimiter">,</span> y:num [
 
 <span class="Delimiter">:(scenario recipe_headers_check_for_duplicate_names)</span>
 <span class="Special">% Hide_errors = true;</span>
-def add2 x:num<span class="Delimiter">,</span> x:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> x:num<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> z
@@ -377,10 +378,10 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 
 <span class="Delimiter">:(scenarios run)</span>
 <span class="Delimiter">:(scenario deduce_instruction_types_from_recipe_header)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add2 <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
-def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
   z<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> y  <span class="Comment"># no type for z</span>
@@ -434,10 +435,10 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 <span class="Comment">//: in the header.</span>
 
 <span class="Delimiter">:(scenario return_based_on_header)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add2 <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
-def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
   z<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> y
@@ -485,10 +486,10 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario explicit_reply_ignores_header)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">2</span>:num/<span class="Special">raw &lt;- </span>add2 <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
-def add2 a:num<span class="Delimiter">,</span> b:num <span class="Delimiter">-&gt;</span> y:num<span class="Delimiter">,</span> z:num [
+<span class="muRecipe">def</span> add2 a:num<span class="Delimiter">,</span> b:num<span class="muRecipe"> -&gt; </span>y:num<span class="Delimiter">,</span> z:num [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>add a<span class="Delimiter">,</span> b
@@ -499,10 +500,10 @@ def add2 a:num<span class="Delimiter">,</span> b:num <span class="Delimiter">-&g
 <span class="traceContains">+mem: storing -2 in location 2</span>
 
 <span class="Delimiter">:(scenario return_on_fallthrough_based_on_header)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add2 <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
-def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
   z<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> y
@@ -511,10 +512,10 @@ def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&g
 <span class="traceContains">+mem: storing 8 in location 1</span>
 
 <span class="Delimiter">:(scenario return_on_fallthrough_already_exists)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add2 <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
-def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
   z<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> y  <span class="Comment"># no type for z</span>
@@ -525,10 +526,10 @@ def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&g
 <span class="traceContains">+mem: storing 8 in location 1</span>
 
 <span class="Delimiter">:(scenario return_after_conditional_reply_based_on_header)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add2 <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
-def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
   z<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> y  <span class="Comment"># no type for z</span>
@@ -538,12 +539,12 @@ def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&g
 
 <span class="Delimiter">:(scenario recipe_headers_perform_same_ingredient_check)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>add2 <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
 ]
-def add2 x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> x:num [
+<span class="muRecipe">def</span> add2 x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>x:num [
   local-scope
   load-ingredients
 ]
diff --git a/html/054static_dispatch.cc.html b/html/054static_dispatch.cc.html
index cfcbde40..2e0c7318 100644
--- a/html/054static_dispatch.cc.html
+++ b/html/054static_dispatch.cc.html
@@ -16,12 +16,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -38,13 +40,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: names like 'print' or 'length' in many mutually extensible ways.</span>
 
 <span class="Delimiter">:(scenario static_dispatch)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">7</span>:num/<span class="Special">raw &lt;- </span>test <span class="Constant">3</span>
 ]
-def test a:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:num [
   z<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
-def test a:num<span class="Delimiter">,</span> b:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> test a:num<span class="Delimiter">,</span> b:num<span class="muRecipe"> -&gt; </span>z:num [
   z<span class="Special"> &lt;- </span>copy <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 7</span>
@@ -153,13 +155,13 @@ string next_unused_recipe_name<span class="Delimiter">(</span><span class="Norma
 <span class="Comment">//: call with the most suitable variant.</span>
 
 <span class="Delimiter">:(scenario static_dispatch_picks_most_similar_variant)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">7</span>:num/<span class="Special">raw &lt;- </span>test <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
-def test a:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:num [
   z<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
-def test a:num<span class="Delimiter">,</span> b:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> test a:num<span class="Delimiter">,</span> b:num<span class="muRecipe"> -&gt; </span>z:num [
   z<span class="Special"> &lt;- </span>copy <span class="Constant">2</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 7</span>
@@ -420,10 +422,10 @@ vector&lt;recipe_ordinal&gt; matching_variants<span class="Delimiter">(</span><s
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario static_dispatch_disabled_in_recipe_without_variants)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>test <span class="Constant">3</span>
 ]
-def test [
+<span class="muRecipe">def</span> test [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># ensure no header</span>
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
@@ -431,26 +433,26 @@ def test [
 
 <span class="Delimiter">:(scenario static_dispatch_disabled_on_headerless_definition)</span>
 <span class="Special">% Hide_errors = true;</span>
-def test a:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:num [
   z<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
-def test [
+<span class="muRecipe">def</span> test [
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+error: redefining recipe test</span>
 
 <span class="Delimiter">:(scenario static_dispatch_disabled_on_headerless_definition_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def test [
+<span class="muRecipe">def</span> test [
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def test a:num <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:num [
   z<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
 <span class="traceContains">+error: redefining recipe test</span>
 
 <span class="Delimiter">:(scenario static_dispatch_on_primitive_names)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -459,7 +461,7 @@ def main [
   <span class="Constant">6</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">4</span>:<span class="Normal">bool</span><span class="Delimiter">,</span> <span class="Constant">5</span>:<span class="Normal">bool</span>
 ]
 <span class="Comment"># temporarily hardcode number equality to always fail</span>
-def equal x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&gt;</span> z:<span class="Normal">bool</span> [
+<span class="muRecipe">def</span> equal x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:<span class="Normal">bool</span> [
   local-scope
   load-ingredients
   z<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/<span class="Constant">false</span>
@@ -470,15 +472,15 @@ def equal x:num<span class="Delimiter">,</span> y:num <span class="Delimiter">-&
 <span class="traceContains">+mem: storing 1 in location 6</span>
 
 <span class="Delimiter">:(scenario static_dispatch_works_with_dummy_results_for_containers)</span>
-def main [
+<span class="muRecipe">def</span> main [
   _<span class="Special"> &lt;- </span>test <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
 ]
-def test a:num <span class="Delimiter">-&gt;</span> z:point [
+<span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:point [
   local-scope
   load-ingredients
   z<span class="Special"> &lt;- </span>merge a<span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
-def test a:num<span class="Delimiter">,</span> b:num <span class="Delimiter">-&gt;</span> z:point [
+<span class="muRecipe">def</span> test a:num<span class="Delimiter">,</span> b:num<span class="muRecipe"> -&gt; </span>z:point [
   local-scope
   load-ingredients
   z<span class="Special"> &lt;- </span>merge a<span class="Delimiter">,</span> b
@@ -486,55 +488,55 @@ def test a:num<span class="Delimiter">,</span> b:num <span class="Delimiter">-&g
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario static_dispatch_works_with_compound_type_containing_container_defined_after_first_use)</span>
-def main [
-  <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> foo:type
+<span class="muRecipe">def</span> main [
+  <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
   test x
 ]
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
 ]
-def test a:&amp;:foo <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> test a:&amp;:foo<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
-  <span class="Normal">z</span>:num<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> x:offset
+  <span class="Normal">z</span>:num<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario static_dispatch_works_with_compound_type_containing_container_defined_after_second_use)</span>
-def main [
-  <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> foo:type
+<span class="muRecipe">def</span> main [
+  <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
   test x
 ]
-def test a:&amp;:foo <span class="Delimiter">-&gt;</span> z:num [
+<span class="muRecipe">def</span> test a:&amp;:foo<span class="muRecipe"> -&gt; </span>z:num [
   local-scope
   load-ingredients
-  <span class="Normal">z</span>:num<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> x:offset
+  <span class="Normal">z</span>:num<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
 ]
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario static_dispatch_prefers_literals_to_be_numbers_rather_than_addresses)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">0</span>
 ]
-def foo x:&amp;:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:&amp;:num<span class="muRecipe"> -&gt; </span>y:num [
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo x:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
   <span class="Identifier">return</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+mem: storing 35 in location 1</span>
 
 <span class="Delimiter">:(scenario static_dispatch_on_non_literal_character_ignores_variant_with_numbers)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">x</span>:<span class="Normal">char</span><span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/newline
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo x
 ]
-def foo x:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
@@ -542,15 +544,15 @@ def foo x:num <span class="Delimiter">-&gt;</span> y:num [
 <span class="traceAbsent">-mem: storing 34 in location 1</span>
 
 <span class="Delimiter">:(scenario static_dispatch_dispatches_literal_to_boolean_before_character)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo <span class="Constant">0</span>  <span class="Comment"># valid literal for boolean</span>
 ]
-def foo x:<span class="Normal">char</span> <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:<span class="Normal">char</span><span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo x:<span class="Normal">bool</span> <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:<span class="Normal">bool</span><span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -559,15 +561,15 @@ def foo x:<span class="Normal">bool</span> <span class="Delimiter">-&gt;</span>
 <span class="traceContains">+mem: storing 35 in location 1</span>
 
 <span class="Delimiter">:(scenario static_dispatch_dispatches_literal_to_character_when_out_of_boolean_range)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo <span class="Constant">97</span>  <span class="Comment"># not a valid literal for boolean</span>
 ]
-def foo x:<span class="Normal">char</span> <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:<span class="Normal">char</span><span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo x:<span class="Normal">bool</span> <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:<span class="Normal">bool</span><span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -576,15 +578,15 @@ def foo x:<span class="Normal">bool</span> <span class="Delimiter">-&gt;</span>
 <span class="traceContains">+mem: storing 34 in location 1</span>
 
 <span class="Delimiter">:(scenario static_dispatch_dispatches_literal_to_number_if_at_all_possible)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo <span class="Constant">97</span>
 ]
-def foo x:<span class="Normal">char</span> <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:<span class="Normal">char</span><span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo x:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -608,21 +610,21 @@ string header_label<span class="Delimiter">(</span><span class="Normal">const</s
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario reload_variant_retains_other_variants)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">1</span>:num
 ]
-def foo x:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo x:&amp;:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:&amp;:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
 ]
-def! foo x:&amp;:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span>! foo x:&amp;:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">36</span>
@@ -632,15 +634,15 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario dispatch_errors_come_after_unknown_name_errors)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>foo x
 ]
-def foo a:num <span class="Delimiter">-&gt;</span> b:num [
+<span class="muRecipe">def</span> foo a:num<span class="muRecipe"> -&gt; </span>b:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo a:<span class="Normal">bool</span> <span class="Delimiter">-&gt;</span> b:num [
+<span class="muRecipe">def</span> foo a:<span class="Normal">bool</span><span class="muRecipe"> -&gt; </span>b:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -649,16 +651,16 @@ def foo a:<span class="Normal">bool</span> <span class="Delimiter">-&gt;</span>
 <span class="traceContains">+error: main: failed to find a matching call for 'y:num &lt;- foo x'</span>
 
 <span class="Delimiter">:(scenario override_methods_with_type_abbreviations)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">s</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo s
 ]
-def foo a:address:array:character <span class="Delimiter">-&gt;</span> result:number [
+<span class="muRecipe">def</span> foo a:address:array:character<span class="muRecipe"> -&gt; </span>result:number [
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
 <span class="Comment"># identical to previous variant once you take type abbreviations into account</span>
-def! foo a:text <span class="Delimiter">-&gt;</span> result:num [
+<span class="muRecipe">def</span>! foo a:text<span class="muRecipe"> -&gt; </span>result:num [
   <span class="Identifier">return</span> <span class="Constant">35</span>
 ]
 <span class="traceContains">+mem: storing 35 in location 1</span>
diff --git a/html/055shape_shifting_container.cc.html b/html/055shape_shifting_container.cc.html
index 42065f9c..eaaae3ae 100644
--- a/html/055shape_shifting_container.cc.html
+++ b/html/055shape_shifting_container.cc.html
@@ -13,16 +13,18 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.Constant { color: #00a0a0; }
+.muData { color: #ffff00; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 .traceContains { color: #008000; }
-.cSpecial { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .SalientComment { color: #00ffff; }
 .Identifier { color: #fcb165; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
 .CommentedCode { color: #6c6c6c; }
+.Constant { color: #00a0a0; }
+.cSpecial { color: #008000; }
 -->
 </style>
 
@@ -57,11 +59,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Normal">if</span> <span class="Delimiter">(</span>!base_type<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> base_type = base_type<span class="Delimiter">-&gt;</span>left<span class="Delimiter">;</span>
 
 <span class="Delimiter">:(scenario size_of_shape_shifting_container)</span>
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:num<span class="Special"> &lt;- </span>merge <span class="Constant">12</span><span class="Delimiter">,</span> <span class="Constant">13</span>
   <span class="Constant">3</span>:foo:point<span class="Special"> &lt;- </span>merge <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">15</span><span class="Delimiter">,</span> <span class="Constant">16</span>
 ]
@@ -73,21 +75,21 @@ def main [
 
 <span class="Delimiter">:(scenario size_of_shape_shifting_container_2)</span>
 <span class="Comment"># multiple type ingredients</span>
-container foo:_a:_b [
+<span class="muData">container</span> foo:_a:_b [
   <span class="Normal">x</span>:_a
   <span class="Normal">y</span>:_b
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:num:<span class="Normal">bool</span><span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">1</span>/<span class="Constant">true</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario size_of_shape_shifting_container_3)</span>
-container foo:_a:_b [
+<span class="muData">container</span> foo:_a:_b [
   <span class="Normal">x</span>:_a
   <span class="Normal">y</span>:_b
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   <span class="Comment"># compound types for type ingredients</span>
   <span class="Delimiter">{</span><span class="Constant">2</span>: <span class="Delimiter">(</span>foo number <span class="Delimiter">(</span>address array character<span class="Delimiter">))}</span><span class="Special"> &lt;- </span>merge <span class="Constant">34</span>/x<span class="Delimiter">,</span> <span class="Constant">1</span>:text/y
@@ -95,42 +97,42 @@ def main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario size_of_shape_shifting_container_4)</span>
-container foo:_a:_b [
+<span class="muData">container</span> foo:_a:_b [
   <span class="Normal">x</span>:_a
   <span class="Normal">y</span>:_b
 ]
-container bar:_a:_b [
+<span class="muData">container</span> bar:_a:_b [
   <span class="Comment"># dilated element</span>
   <span class="Delimiter">{</span>data: <span class="Delimiter">(</span>foo _a <span class="Delimiter">(</span>address _b<span class="Delimiter">))}</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   <span class="Constant">2</span>:bar:num:@:<span class="Normal">char</span><span class="Special"> &lt;- </span>merge <span class="Constant">34</span>/x<span class="Delimiter">,</span> <span class="Constant">1</span>:text/y
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario shape_shifting_container_extend)</span>
-container foo:_a [
+<span class="muData">container</span> foo:_a [
   <span class="Normal">x</span>:_a
 ]
-container foo:_a [
+<span class="muData">container</span> foo:_a [
   <span class="Normal">y</span>:_a
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario shape_shifting_container_extend_error)</span>
 <span class="Special">% Hide_errors = true;</span>
-container foo:_a [
+<span class="muData">container</span> foo:_a [
   <span class="Normal">x</span>:_a
 ]
-container foo:_b [
+<span class="muData">container</span> foo:_b [
   <span class="Normal">y</span>:_b
 ]
 <span class="traceContains">+error: headers of container 'foo' must use identical type ingredients</span>
 
 <span class="Delimiter">:(scenario type_ingredient_must_start_with_underscore)</span>
 <span class="Special">% Hide_errors = true;</span>
-container foo:t [
+<span class="muData">container</span> foo:t [
   <span class="Normal">x</span>:num
 ]
 <span class="traceContains">+error: foo: type ingredient 't' must begin with an underscore</span>
@@ -236,11 +238,11 @@ map&lt;string<span class="Delimiter">,</span> type_ordinal&gt; type_ingredient_n
   <span class="Identifier">return</span><span class="Delimiter">;</span>
 
 <span class="Delimiter">:(scenario size_of_shape_shifting_exclusive_container)</span>
-exclusive-container foo:_t [
+<span class="muData">exclusive-container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:num<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Constant">3</span>:foo:point<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">15</span><span class="Delimiter">,</span> <span class="Constant">16</span>
   <span class="Constant">6</span>:foo:point<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">23</span>
@@ -260,63 +262,63 @@ def main [
 <span class="Special">% CHECK_EQ(trace_count_prefix(&quot;mem&quot;, &quot;storing&quot;), 7);</span>
 
 <span class="Delimiter">:(scenario get_on_shape_shifting_container)</span>
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:point<span class="Special"> &lt;- </span>merge <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">15</span><span class="Delimiter">,</span> <span class="Constant">16</span>
-  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo:point<span class="Delimiter">,</span> y:offset
+  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo:point<span class="Delimiter">,</span> <span class="Constant">y:offset</span>
 ]
 <span class="traceContains">+mem: storing 16 in location 2</span>
 
 <span class="Delimiter">:(scenario get_on_shape_shifting_container_2)</span>
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:point<span class="Special"> &lt;- </span>merge <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">15</span><span class="Delimiter">,</span> <span class="Constant">16</span>
-  <span class="Constant">2</span>:point<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo:point<span class="Delimiter">,</span> x:offset
+  <span class="Constant">2</span>:point<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo:point<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
 ]
 <span class="traceContains">+mem: storing 14 in location 2</span>
 <span class="traceContains">+mem: storing 15 in location 3</span>
 
 <span class="Delimiter">:(scenario get_on_shape_shifting_container_3)</span>
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:&amp;:point<span class="Special"> &lt;- </span>merge <span class="Constant">34</span>/unsafe<span class="Delimiter">,</span> <span class="Constant">48</span>
-  <span class="Constant">3</span>:&amp;:point<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo:&amp;:point<span class="Delimiter">,</span> x:offset
+  <span class="Constant">3</span>:&amp;:point<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo:&amp;:point<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
 ]
 <span class="traceContains">+mem: storing 34 in location 3</span>
 
 <span class="Delimiter">:(scenario get_on_shape_shifting_container_inside_container)</span>
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:foo:point
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:bar<span class="Special"> &lt;- </span>merge <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">15</span><span class="Delimiter">,</span> <span class="Constant">16</span><span class="Delimiter">,</span> <span class="Constant">17</span>
-  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:bar<span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:bar<span class="Delimiter">,</span> <span class="Constant">1:offset</span>
 ]
 <span class="traceContains">+mem: storing 17 in location 2</span>
 
 <span class="Delimiter">:(scenario get_on_complex_shape_shifting_container)</span>
-container foo:_a:_b [
+<span class="muData">container</span> foo:_a:_b [
   <span class="Normal">x</span>:_a
   <span class="Normal">y</span>:_b
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   <span class="Delimiter">{</span><span class="Constant">2</span>: <span class="Delimiter">(</span>foo number <span class="Delimiter">(</span>address array character<span class="Delimiter">))}</span><span class="Special"> &lt;- </span>merge <span class="Constant">34</span>/x<span class="Delimiter">,</span> <span class="Constant">1</span>:text/y
-  <span class="Constant">3</span>:text<span class="Special"> &lt;- </span>get <span class="Delimiter">{</span><span class="Constant">2</span>: <span class="Delimiter">(</span>foo number <span class="Delimiter">(</span>address array character<span class="Delimiter">))},</span> y:offset
+  <span class="Constant">3</span>:text<span class="Special"> &lt;- </span>get <span class="Delimiter">{</span><span class="Constant">2</span>: <span class="Delimiter">(</span>foo number <span class="Delimiter">(</span>address array character<span class="Delimiter">))},</span> <span class="Constant">y:offset</span>
   <span class="Constant">4</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:text<span class="Delimiter">,</span> <span class="Constant">3</span>:text
 ]
 <span class="traceContains">+mem: storing 1 in location 4</span>
@@ -507,13 +509,13 @@ assert<span class="Delimiter">(</span>!contains_type_ingredient<span class="Deli
 
 <span class="Delimiter">:(scenario get_on_shape_shifting_container_error)</span>
 <span class="Special">% Hide_errors = true;</span>
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">10</span>:foo:point<span class="Special"> &lt;- </span>merge <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">15</span><span class="Delimiter">,</span> <span class="Constant">16</span>
-  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">10</span>:foo<span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">10</span>:foo<span class="Delimiter">,</span> <span class="Constant">1:offset</span>
 ]
 <span class="traceContains">+error: illegal type &quot;foo&quot; seems to be missing a type ingredient or three</span>
 
@@ -641,15 +643,15 @@ type_info&amp; info = get<span class="Delimiter">(</span>Type<span class="Delimi
 <span class="SalientComment">//:: 'merge' on shape-shifting containers</span>
 
 <span class="Delimiter">:(scenario merge_check_shape_shifting_container_containing_exclusive_container)</span>
-container foo:_elem [
+<span class="muData">container</span> foo:_elem [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:_elem
 ]
-exclusive-container bar [
+<span class="muData">exclusive-container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:bar<span class="Special"> &lt;- </span>merge <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+mem: storing 23 in location 1</span>
@@ -659,29 +661,29 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_shape_shifting_container_containing_exclusive_container_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-container foo:_elem [
+<span class="muData">container</span> foo:_elem [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:_elem
 ]
-exclusive-container bar [
+<span class="muData">exclusive-container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:bar<span class="Special"> &lt;- </span>merge <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
 ]
 <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>
-exclusive-container foo:_elem [
+<span class="muData">exclusive-container</span> foo:_elem [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:_elem
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:bar<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+mem: storing 1 in location 1</span>
@@ -690,30 +692,30 @@ def main [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_shape_shifting_exclusive_container_containing_container_2)</span>
-exclusive-container foo:_elem [
+<span class="muData">exclusive-container</span> foo:_elem [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:_elem
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:bar<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">23</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario merge_check_shape_shifting_exclusive_container_containing_container_3)</span>
 <span class="Special">% Hide_errors = true;</span>
-exclusive-container foo:_elem [
+<span class="muData">exclusive-container</span> foo:_elem [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:_elem
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo:bar<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> <span class="Constant">23</span>
 ]
 <span class="traceContains">+error: main: too few ingredients in '1:foo:bar &lt;- merge 1/y, 23'</span>
diff --git a/html/056shape_shifting_recipe.cc.html b/html/056shape_shifting_recipe.cc.html
index 4bfbafc1..dc2c8797 100644
--- a/html/056shape_shifting_recipe.cc.html
+++ b/html/056shape_shifting_recipe.cc.html
@@ -13,17 +13,19 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.Constant { color: #00a0a0; }
-.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.SalientComment { color: #00ffff; }
+.CommentedCode { color: #6c6c6c; }
+.muRecipe { color: #ff8700; }
+.muData { color: #ffff00; }
 .traceContains { color: #008000; }
+.Delimiter { color: #800080; }
+.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
 .cSpecial { color: #008000; }
+.Comment { color: #9090ff; }
+.Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.Delimiter { color: #800080; }
-.SalientComment { color: #00ffff; }
 .Identifier { color: #fcb165; }
-.Comment { color: #9090ff; }
 .PreProc { color: #800080; }
-.CommentedCode { color: #6c6c6c; }
 -->
 </style>
 
@@ -38,18 +40,18 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="SalientComment">//:: Like container definitions, recipes too can contain type parameters.</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">10</span>:point<span class="Special"> &lt;- </span>merge <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">15</span>
   <span class="Constant">11</span>:point<span class="Special"> &lt;- </span>foo <span class="Constant">10</span>:point
 ]
 <span class="Comment"># non-matching variant</span>
-def foo a:num <span class="Delimiter">-&gt;</span> result:num [
+<span class="muRecipe">def</span> foo a:num<span class="muRecipe"> -&gt; </span>result:num [
   local-scope
   load-ingredients
   result<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="Comment"># matching shape-shifting variant</span>
-def foo a:_t <span class="Delimiter">-&gt;</span> result:_t [
+<span class="muRecipe">def</span> foo a:_t<span class="muRecipe"> -&gt; </span>result:_t [
   local-scope
   load-ingredients
   result<span class="Special"> &lt;- </span>copy a
@@ -533,18 +535,18 @@ string inspect<span class="Delimiter">(</span><span class="Normal">const</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">10</span>:point<span class="Special"> &lt;- </span>merge <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">15</span>
   <span class="Constant">11</span>:point<span class="Special"> &lt;- </span>foo <span class="Constant">10</span>:point
 ]
 <span class="Comment"># non-matching shape-shifting variant</span>
-def foo a:_t<span class="Delimiter">,</span> b:_t <span class="Delimiter">-&gt;</span> result:num [
+<span class="muRecipe">def</span> foo a:_t<span class="Delimiter">,</span> b:_t<span class="muRecipe"> -&gt; </span>result:num [
   local-scope
   load-ingredients
   result<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="Comment"># matching shape-shifting variant</span>
-def foo a:_t <span class="Delimiter">-&gt;</span> result:_t [
+<span class="muRecipe">def</span> foo a:_t<span class="muRecipe"> -&gt; </span>result:_t [
   local-scope
   load-ingredients
   result<span class="Special"> &lt;- </span>copy a
@@ -553,17 +555,17 @@ def foo a:_t <span class="Delimiter">-&gt;</span> result:_t [
 <span class="traceContains">+mem: storing 15 in location 12</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_nonroot)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">10</span>:foo:point<span class="Special"> &lt;- </span>merge <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">15</span><span class="Delimiter">,</span> <span class="Constant">16</span>
   <span class="Constant">20</span>:point/<span class="Special">raw &lt;- </span>bar <span class="Constant">10</span>:foo:point
 ]
 <span class="Comment"># shape-shifting recipe with type ingredient following some other type</span>
-def bar a:foo:_t <span class="Delimiter">-&gt;</span> result:_t [
+<span class="muRecipe">def</span> bar a:foo:_t<span class="muRecipe"> -&gt; </span>result:_t [
   local-scope
   load-ingredients
-  result<span class="Special"> &lt;- </span>get a<span class="Delimiter">,</span> x:offset
+  result<span class="Special"> &lt;- </span>get a<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
 ]
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
@@ -571,33 +573,33 @@ container foo:_t [
 <span class="traceContains">+mem: storing 15 in location 21</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_nested)</span>
-container c:_a:_b [
+<span class="muData">container</span> c:_a:_b [
   <span class="Normal">a</span>:_a
   <span class="Normal">b</span>:_b
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">s</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   <span class="Delimiter">{</span>x: <span class="Delimiter">(</span>c <span class="Delimiter">(</span>address array character<span class="Delimiter">)</span> number<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>merge s<span class="Delimiter">,</span> <span class="Constant">34</span>
   foo x
 ]
-def foo x:c:_bar:_baz [
+<span class="muRecipe">def</span> foo x:c:_bar:_baz [
   local-scope
   load-ingredients
 ]
 <span class="Comment"># no errors</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_type_deduction_ignores_offsets)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">10</span>:foo:point<span class="Special"> &lt;- </span>merge <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">15</span><span class="Delimiter">,</span> <span class="Constant">16</span>
   <span class="Constant">20</span>:point/<span class="Special">raw &lt;- </span>bar <span class="Constant">10</span>:foo:point
 ]
-def bar a:foo:_t <span class="Delimiter">-&gt;</span> result:_t [
+<span class="muRecipe">def</span> bar a:foo:_t<span class="muRecipe"> -&gt; </span>result:_t [
   local-scope
   load-ingredients
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
-  result<span class="Special"> &lt;- </span>get a<span class="Delimiter">,</span> x:offset  <span class="Comment"># shouldn't collide with other variable</span>
+  result<span class="Special"> &lt;- </span>get a<span class="Delimiter">,</span> <span class="Constant">x:offset</span>  <span class="Comment"># shouldn't collide with other variable</span>
 ]
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
@@ -605,24 +607,24 @@ container foo:_t [
 <span class="traceContains">+mem: storing 15 in location 21</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_empty)</span>
-def main [
+<span class="muRecipe">def</span> main [
   foo <span class="Constant">1</span>
 ]
 <span class="Comment"># shape-shifting recipe with no body</span>
-def foo a:_t [
+<span class="muRecipe">def</span> foo a:_t [
 ]
 <span class="Comment"># shouldn't crash</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_handles_shape_shifting_new_ingredient)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:&amp;:foo:point<span class="Special"> &lt;- </span>bar <span class="Constant">3</span>
   <span class="Constant">11</span>:foo:point<span class="Special"> &lt;- </span>copy *<span class="Constant">1</span>:&amp;:foo:point
 ]
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
-def bar x:num <span class="Delimiter">-&gt;</span> result:&amp;:foo:_t [
+<span class="muRecipe">def</span> bar x:num<span class="muRecipe"> -&gt; </span>result:&amp;:foo:_t [
   local-scope
   load-ingredients
   <span class="Comment"># new refers to _t in its ingredient *value*</span>
@@ -633,18 +635,18 @@ def bar x:num <span class="Delimiter">-&gt;</span> result:&amp;:foo:_t [
 <span class="traceContains">+mem: storing 0 in location 13</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_handles_shape_shifting_new_ingredient_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:&amp;:foo:point<span class="Special"> &lt;- </span>bar <span class="Constant">3</span>
   <span class="Constant">11</span>:foo:point<span class="Special"> &lt;- </span>copy *<span class="Constant">1</span>:&amp;:foo:point
 ]
-def bar x:num <span class="Delimiter">-&gt;</span> result:&amp;:foo:_t [
+<span class="muRecipe">def</span> bar x:num<span class="muRecipe"> -&gt; </span>result:&amp;:foo:_t [
   local-scope
   load-ingredients
   <span class="Comment"># new refers to _t in its ingredient *value*</span>
   result<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>foo _t<span class="Delimiter">)</span> : type<span class="Delimiter">}</span>
 ]
 <span class="Comment"># container defined after use</span>
-container foo:_t [
+<span class="muData">container</span> foo:_t [
   <span class="Normal">x</span>:_t
   <span class="Normal">y</span>:num
 ]
@@ -653,10 +655,10 @@ container foo:_t [
 <span class="traceContains">+mem: storing 0 in location 13</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_called_with_dummy)</span>
-def main [
+<span class="muRecipe">def</span> main [
   _<span class="Special"> &lt;- </span>bar <span class="Constant">34</span>
 ]
-def bar x:_t <span class="Delimiter">-&gt;</span> result:&amp;:_t [
+<span class="muRecipe">def</span> bar x:_t<span class="muRecipe"> -&gt; </span>result:&amp;:_t [
   local-scope
   load-ingredients
   result<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -691,13 +693,13 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_supports_compound_types)</span>
-def main [
-  <span class="Constant">1</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
-  *<span class="Constant">1</span>:&amp;:point<span class="Special"> &lt;- </span>put *<span class="Constant">1</span>:&amp;:point<span class="Delimiter">,</span> y:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">point:type</span>
+  *<span class="Constant">1</span>:&amp;:point<span class="Special"> &lt;- </span>put *<span class="Constant">1</span>:&amp;:point<span class="Delimiter">,</span> <span class="Constant">y:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span>
   <span class="Constant">3</span>:&amp;:point<span class="Special"> &lt;- </span>bar <span class="Constant">1</span>:&amp;:point  <span class="Comment"># specialize _t to address:point</span>
   <span class="Constant">4</span>:point<span class="Special"> &lt;- </span>copy *<span class="Constant">3</span>:&amp;:point
 ]
-def bar a:_t <span class="Delimiter">-&gt;</span> result:_t [
+<span class="muRecipe">def</span> bar a:_t<span class="muRecipe"> -&gt; </span>result:_t [
   local-scope
   load-ingredients
   result<span class="Special"> &lt;- </span>copy a
@@ -706,26 +708,26 @@ def bar a:_t <span class="Delimiter">-&gt;</span> result:_t [
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_error)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">a</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
   <span class="Normal">b</span>:&amp;:num<span class="Special"> &lt;- </span>foo a
 ]
-def foo a:_t <span class="Delimiter">-&gt;</span> b:_t [
+<span class="muRecipe">def</span> foo a:_t<span class="muRecipe"> -&gt; </span>b:_t [
   load-ingredients
   b<span class="Special"> &lt;- </span>copy a
 ]
 <span class="traceContains">+error: main: no call found for 'b:&amp;:num &lt;- foo a'</span>
 
 <span class="Delimiter">:(scenario specialize_inside_recipe_without_header)</span>
-def main [
+<span class="muRecipe">def</span> main [
   foo <span class="Constant">3</span>
 ]
-def foo [
+<span class="muRecipe">def</span> foo [
   local-scope
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># ensure no header</span>
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>bar x  <span class="Comment"># call a shape-shifting recipe</span>
 ]
-def bar x:_elem <span class="Delimiter">-&gt;</span> y:_elem [
+<span class="muRecipe">def</span> bar x:_elem<span class="muRecipe"> -&gt; </span>y:_elem [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> <span class="Constant">1</span>
@@ -733,12 +735,12 @@ def bar 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)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Comment"># permit literal to map to number</span>
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo <span class="Constant">3</span>
 ]
-def foo x:_elem <span class="Delimiter">-&gt;</span> y:_elem [
+<span class="muRecipe">def</span> foo x:_elem<span class="muRecipe"> -&gt; </span>y:_elem [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> <span class="Constant">1</span>
@@ -746,12 +748,12 @@ def 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_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Comment"># permit literal to map to character</span>
   <span class="Constant">1</span>:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>foo <span class="Constant">3</span>
 ]
-def foo x:_elem <span class="Delimiter">-&gt;</span> y:_elem [
+<span class="muRecipe">def</span> foo x:_elem<span class="muRecipe"> -&gt; </span>y:_elem [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>add x<span class="Delimiter">,</span> <span class="Constant">1</span>
@@ -759,12 +761,12 @@ def 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>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Comment"># permit '0' to map to address to shape-shifting type-ingredient</span>
   <span class="Constant">1</span>:&amp;:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>foo <span class="Constant">0</span>
 ]
-def foo x:&amp;:_elem <span class="Delimiter">-&gt;</span> y:&amp;:_elem [
+<span class="muRecipe">def</span> foo x:&amp;:_elem<span class="muRecipe"> -&gt; </span>y:&amp;:_elem [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>copy x
@@ -774,12 +776,12 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario specialize_with_literal_4)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Comment"># ambiguous call: what's the type of its ingredient?!</span>
   foo <span class="Constant">0</span>
 ]
-def foo x:&amp;:_elem <span class="Delimiter">-&gt;</span> y:&amp;:_elem [
+<span class="muRecipe">def</span> foo x:&amp;:_elem<span class="muRecipe"> -&gt; </span>y:&amp;:_elem [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>copy x
@@ -787,10 +789,10 @@ def foo x:&amp;:_elem <span class="Delimiter">-&gt;</span> y:&amp;:_elem [
 <span class="traceContains">+error: main: instruction 'foo' has no valid specialization</span>
 
 <span class="Delimiter">:(scenario specialize_with_literal_5)</span>
-def main [
+<span class="muRecipe">def</span> main [
   foo <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>  <span class="Comment"># recipe mapping two variables to literals</span>
 ]
-def foo x:_elem<span class="Delimiter">,</span> y:_elem [
+<span class="muRecipe">def</span> foo x:_elem<span class="Delimiter">,</span> y:_elem [
   local-scope
   load-ingredients
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>add x<span class="Delimiter">,</span> y
@@ -799,28 +801,28 @@ def foo x:_elem<span class="Delimiter">,</span> y:_elem [
 
 <span class="Delimiter">:(scenario multiple_shape_shifting_variants)</span>
 <span class="Comment"># try to call two different shape-shifting recipes with the same name</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">e1</span>:d1:num<span class="Special"> &lt;- </span>merge <span class="Constant">3</span>
   <span class="Normal">e2</span>:d2:num<span class="Special"> &lt;- </span>merge <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">5</span>
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo e1
   <span class="Constant">2</span>:num/<span class="Special">raw &lt;- </span>foo e2
 ]
 <span class="Comment"># the two shape-shifting definitions</span>
-def foo a:d1:_elem <span class="Delimiter">-&gt;</span> b:num [
+<span class="muRecipe">def</span> foo a:d1:_elem<span class="muRecipe"> -&gt; </span>b:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo a:d2:_elem <span class="Delimiter">-&gt;</span> b:num [
+<span class="muRecipe">def</span> foo a:d2:_elem<span class="muRecipe"> -&gt; </span>b:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
 ]
 <span class="Comment"># the shape-shifting containers they use</span>
-container d1:_elem [
+<span class="muData">container</span> d1:_elem [
   <span class="Normal">x</span>:_elem
 ]
-container d2:_elem [
+<span class="muData">container</span> d2:_elem [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:_elem
 ]
@@ -829,26 +831,26 @@ container d2:_elem [
 
 <span class="Delimiter">:(scenario multiple_shape_shifting_variants_2)</span>
 <span class="Comment"># static dispatch between shape-shifting variants, _including pointer lookups_</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">e1</span>:d1:num<span class="Special"> &lt;- </span>merge <span class="Constant">3</span>
   <span class="Normal">e2</span>:&amp;:d2:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>d2 number<span class="Delimiter">)</span>: type<span class="Delimiter">}</span>
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo e1
   <span class="Constant">2</span>:num/<span class="Special">raw &lt;- </span>foo *e2  <span class="Comment"># different from previous scenario</span>
 ]
-def foo a:d1:_elem <span class="Delimiter">-&gt;</span> b:num [
+<span class="muRecipe">def</span> foo a:d1:_elem<span class="muRecipe"> -&gt; </span>b:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo a:d2:_elem <span class="Delimiter">-&gt;</span> b:num [
+<span class="muRecipe">def</span> foo a:d2:_elem<span class="muRecipe"> -&gt; </span>b:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
 ]
-container d1:_elem [
+<span class="muData">container</span> d1:_elem [
   <span class="Normal">x</span>:_elem
 ]
-container d2:_elem [
+<span class="muData">container</span> d2:_elem [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:_elem
 ]
@@ -857,17 +859,17 @@ container d2:_elem [
 
 <span class="Delimiter">:(scenario missing_type_in_shape_shifting_recipe)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">a</span>:d1:num<span class="Special"> &lt;- </span>merge <span class="Constant">3</span>
   foo a
 ]
-def foo a:d1:_elem <span class="Delimiter">-&gt;</span> b:num [
+<span class="muRecipe">def</span> foo a:d1:_elem<span class="muRecipe"> -&gt; </span>b:num [
   local-scope
   load-ingredients
   copy e  <span class="Comment"># no such variable</span>
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-container d1:_elem [
+<span class="muData">container</span> d1:_elem [
   <span class="Normal">x</span>:_elem
 ]
 <span class="traceContains">+error: foo: unknown type for 'e' in 'copy e' (check the name for typos)</span>
@@ -876,17 +878,17 @@ container d1:_elem [
 
 <span class="Delimiter">:(scenario missing_type_in_shape_shifting_recipe_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">a</span>:d1:num<span class="Special"> &lt;- </span>merge <span class="Constant">3</span>
   foo a
 ]
-def foo a:d1:_elem <span class="Delimiter">-&gt;</span> b:num [
+<span class="muRecipe">def</span> foo a:d1:_elem<span class="muRecipe"> -&gt; </span>b:num [
   local-scope
   load-ingredients
-  get e<span class="Delimiter">,</span> x:offset  <span class="Comment"># unknown variable in a 'get', which does some extra checking</span>
+  get e<span class="Delimiter">,</span> <span class="Constant">x:offset</span>  <span class="Comment"># unknown variable in a 'get', which does some extra checking</span>
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-container d1:_elem [
+<span class="muData">container</span> d1:_elem [
   <span class="Normal">x</span>:_elem
 ]
 <span class="traceContains">+error: foo: unknown type for 'e' in 'get e, x:offset' (check the name for typos)</span>
@@ -895,11 +897,11 @@ container d1:_elem [
 
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario specialize_recursive_shape_shifting_recipe)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">1</span>:num
 ]
-def foo x:_elem <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:_elem<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Delimiter">{</span>
@@ -913,16 +915,16 @@ def foo x:_elem <span class="Delimiter">-&gt;</span> y:num [
 
 <span class="Delimiter">:(scenarios run)</span>
 <span class="Delimiter">:(scenario specialize_most_similar_variant)</span>
-def main [
-  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">1</span>:&amp;:num
 ]
-def foo x:_elem <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:_elem<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo x:&amp;:_elem <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:&amp;:_elem<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -931,19 +933,19 @@ def foo x:&amp;:_elem <span class="Delimiter">-&gt;</span> y:num [
 
 <span class="Delimiter">:(scenario specialize_most_similar_variant_2)</span>
 <span class="Comment"># version with headers padded with lots of unrelated concrete types</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
   <span class="Constant">2</span>:&amp;:@:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">2</span>:&amp;:@:num<span class="Delimiter">,</span> <span class="Constant">1</span>:num
 ]
 <span class="Comment"># variant with concrete type</span>
-def foo dummy:&amp;:@:num<span class="Delimiter">,</span> x:num <span class="Delimiter">-&gt;</span> y:num<span class="Delimiter">,</span> dummy:&amp;:@:num [
+<span class="muRecipe">def</span> foo dummy:&amp;:@:num<span class="Delimiter">,</span> x:num<span class="muRecipe"> -&gt; </span>y:num<span class="Delimiter">,</span> dummy:&amp;:@:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
 <span class="Comment"># shape-shifting variant</span>
-def foo dummy:&amp;:@:num<span class="Delimiter">,</span> x:_elem <span class="Delimiter">-&gt;</span> y:num<span class="Delimiter">,</span> dummy:&amp;:@:num [
+<span class="muRecipe">def</span> foo dummy:&amp;:@:num<span class="Delimiter">,</span> x:_elem<span class="muRecipe"> -&gt; </span>y:num<span class="Delimiter">,</span> dummy:&amp;:@:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -952,29 +954,29 @@ def foo dummy:&amp;:@:num<span class="Delimiter">,</span> x:_elem <span class="D
 <span class="traceContains">+mem: storing 34 in location 3</span>
 
 <span class="Delimiter">:(scenario specialize_most_similar_variant_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   foo <span class="Constant">1</span>:text
 ]
-def foo x:text [
+<span class="muRecipe">def</span> foo x:text [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
-def foo x:&amp;:_elem [
+<span class="muRecipe">def</span> foo x:&amp;:_elem [
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
 ]
 <span class="Comment"># make sure the more precise version was used</span>
 <span class="traceContains">+mem: storing 34 in location 2</span>
 
 <span class="Delimiter">:(scenario specialize_literal_as_number)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">23</span>
 ]
-def foo x:_elem <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:_elem<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
-def foo x:<span class="Normal">char</span> <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:<span class="Normal">char</span><span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -983,17 +985,17 @@ def foo x:<span class="Normal">char</span> <span class="Delimiter">-&gt;</span>
 
 <span class="Delimiter">:(scenario specialize_literal_as_number_2)</span>
 <span class="Comment"># version calling with literal</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">0</span>
 ]
 <span class="Comment"># variant with concrete type</span>
-def foo x:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
 <span class="Comment"># shape-shifting variant</span>
-def foo x:&amp;:_elem <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:&amp;:_elem<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -1002,17 +1004,17 @@ def foo x:&amp;:_elem <span class="Delimiter">-&gt;</span> y:num [
 <span class="traceContains">+mem: storing 34 in location 1</span>
 
 <span class="Delimiter">:(scenario specialize_literal_as_address)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">0</span>
 ]
 <span class="Comment"># variant with concrete address type</span>
-def foo x:&amp;:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:&amp;:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">34</span>
 ]
 <span class="Comment"># shape-shifting variant</span>
-def foo x:&amp;:_elem <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> foo x:&amp;:_elem<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   <span class="Identifier">return</span> <span class="Constant">35</span>
@@ -1023,13 +1025,13 @@ def foo x:&amp;:_elem <span class="Delimiter">-&gt;</span> y:num [
 <span class="Delimiter">:(scenario missing_type_during_specialization)</span>
 <span class="Special">% Hide_errors = true;</span>
 <span class="Comment"># define a shape-shifting recipe</span>
-def foo a:_elem [
+<span class="muRecipe">def</span> foo a:_elem [
 ]
 <span class="Comment"># define a container with field 'z'</span>
-container foo2 [
+<span class="muData">container</span> foo2 [
   <span class="Normal">z</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">x</span>:foo2<span class="Special"> &lt;- </span>merge <span class="Constant">34</span>
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>get x<span class="Delimiter">,</span> z:offse  <span class="Comment"># typo in 'offset'</span>
@@ -1043,13 +1045,13 @@ def main [
 <span class="Delimiter">:(scenario missing_type_during_specialization2)</span>
 <span class="Special">% Hide_errors = true;</span>
 <span class="Comment"># define a shape-shifting recipe</span>
-def foo a:_elem [
+<span class="muRecipe">def</span> foo a:_elem [
 ]
 <span class="Comment"># define a container with field 'z'</span>
-container foo2 [
+<span class="muData">container</span> foo2 [
   <span class="Normal">z</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">x</span>:foo2<span class="Special"> &lt;- </span>merge <span class="Constant">34</span>
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>get x<span class="Delimiter">,</span> z:offse  <span class="Comment"># typo in 'offset'</span>
@@ -1062,17 +1064,17 @@ def main [
 
 <span class="Delimiter">:(scenario tangle_shape_shifting_recipe)</span>
 <span class="Comment"># shape-shifting recipe</span>
-def foo a:_elem [
+<span class="muRecipe">def</span> foo a:_elem [
   local-scope
   load-ingredients
   &lt;label1&gt;
 ]
 <span class="Comment"># tangle some code that refers to the type ingredient</span>
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Normal">b</span>:_elem<span class="Special"> &lt;- </span>copy a
 ]
 <span class="Comment"># trigger specialization</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   foo <span class="Constant">34</span>
 ]
@@ -1080,17 +1082,17 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario tangle_shape_shifting_recipe_with_type_abbreviation)</span>
 <span class="Comment"># shape-shifting recipe</span>
-def foo a:_elem [
+<span class="muRecipe">def</span> foo a:_elem [
   local-scope
   load-ingredients
   &lt;label1&gt;
 ]
 <span class="Comment"># tangle some code that refers to the type ingredient</span>
-after &lt;label1&gt; [
+<span class="muRecipe">after</span> &lt;label1&gt; [
   <span class="Normal">b</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># type abbreviation</span>
 ]
 <span class="Comment"># trigger specialization</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   foo <span class="Constant">34</span>
 ]
@@ -1098,10 +1100,10 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario shape_shifting_recipe_coexists_with_primitive)</span>
 <span class="Comment"># recipe overloading a primitive with a generic type</span>
-def add a:&amp;:foo:_elem [
+<span class="muRecipe">def</span> add a:&amp;:foo:_elem [
   assert <span class="Constant">0</span><span class="Delimiter">,</span> [should <span class="Normal">not</span> get here]
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># call primitive add with literal 0</span>
   add <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">0</span>
 ]
diff --git a/html/057immutable.cc.html b/html/057immutable.cc.html
index 94d6d42f..e1e6faf2 100644
--- a/html/057immutable.cc.html
+++ b/html/057immutable.cc.html
@@ -15,13 +15,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
+.Todo { color: #000000; background-color: #ffff00; padding-bottom: 1px; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.Todo { color: #000000; background-color: #ffff00; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -40,40 +42,40 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenario can_modify_ingredients_that_are_also_products)</span>
 <span class="Comment"># mutable container</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">p</span>:point<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
   p<span class="Special"> &lt;- </span>foo p
 ]
-def foo p:point <span class="Delimiter">-&gt;</span> p:point [
+<span class="muRecipe">def</span> foo p:point<span class="muRecipe"> -&gt; </span>p:point [
   local-scope
   load-ingredients
-  p<span class="Special"> &lt;- </span>put p<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
+  p<span class="Special"> &lt;- </span>put p<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario can_modify_ingredients_that_are_also_products_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">point:type</span>
   p<span class="Special"> &lt;- </span>foo p
 ]
 <span class="Comment"># mutable address to container</span>
-def foo p:&amp;:point <span class="Delimiter">-&gt;</span> p:&amp;:point [
+<span class="muRecipe">def</span> foo p:&amp;:point<span class="muRecipe"> -&gt; </span>p:&amp;:point [
   local-scope
   load-ingredients
-  *p<span class="Special"> &lt;- </span>put *p<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
+  *p<span class="Special"> &lt;- </span>put *p<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario can_modify_ingredients_that_are_also_products_3)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:@:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">3</span>
+  <span class="Normal">p</span>:&amp;:@:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">3</span>
   p<span class="Special"> &lt;- </span>foo p
 ]
 <span class="Comment"># mutable address</span>
-def foo p:&amp;:@:num <span class="Delimiter">-&gt;</span> p:&amp;:@:num [
+<span class="muRecipe">def</span> foo p:&amp;:@:num<span class="muRecipe"> -&gt; </span>p:&amp;:@:num [
   local-scope
   load-ingredients
   *p<span class="Special"> &lt;- </span>put-index *p<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span>
@@ -81,19 +83,19 @@ def foo p:&amp;:@:num <span class="Delimiter">-&gt;</span> p:&amp;:@:num [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario ignore_literal_ingredients_for_immutability_checks)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:d1<span class="Special"> &lt;- </span><span class="Normal">new</span> d1:type
+  <span class="Normal">p</span>:&amp;:d1<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">d1:type</span>
   <span class="Normal">q</span>:num<span class="Special"> &lt;- </span>foo p
 ]
-def foo p:&amp;:d1 <span class="Delimiter">-&gt;</span> q:num [
+<span class="muRecipe">def</span> foo p:&amp;:d1<span class="muRecipe"> -&gt; </span>q:num [
   local-scope
   load-ingredients
-  <span class="Normal">x</span>:&amp;:d1<span class="Special"> &lt;- </span><span class="Normal">new</span> d1:type
-  *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> p:offset<span class="Delimiter">,</span> <span class="Constant">34</span>  <span class="Comment"># ignore this 'p'</span>
+  <span class="Normal">x</span>:&amp;:d1<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">d1:type</span>
+  *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> <span class="Constant">p:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span>  <span class="Comment"># ignore this 'p'</span>
   reply <span class="Constant">36</span>
 ]
-container d1 [
+<span class="muData">container</span> d1 [
   <span class="Normal">p</span>:num
   <span class="Normal">q</span>:num
 ]
@@ -101,13 +103,13 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario cannot_modify_immutable_ingredients)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   foo x
 ]
 <span class="Comment"># immutable address to primitive</span>
-def foo x:&amp;:num [
+<span class="muRecipe">def</span> foo x:&amp;:num [
   local-scope
   load-ingredients
   *x<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
@@ -116,31 +118,31 @@ def foo x:&amp;:num [
 
 <span class="Delimiter">:(scenario cannot_modify_immutable_containers)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">x</span>:point-number<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span><span class="Delimiter">,</span> <span class="Constant">36</span>
   foo x
 ]
 <span class="Comment"># immutable container</span>
-def foo x:point-number [
+<span class="muRecipe">def</span> foo x:point-number [
   local-scope
   load-ingredients
   <span class="Comment"># copy an element: ok</span>
-  <span class="Normal">y</span>:point<span class="Special"> &lt;- </span>get x<span class="Delimiter">,</span> xy:offset
+  <span class="Normal">y</span>:point<span class="Special"> &lt;- </span>get x<span class="Delimiter">,</span> <span class="Constant">xy:offset</span>
   <span class="Comment"># modify the element: boom</span>
   <span class="Comment"># This could be ok if y contains no addresses, but we're not going to try to be that smart.</span>
   <span class="Comment"># It also makes the rules easier to reason about. If it's just an ingredient, just don't try to change it.</span>
-  y<span class="Special"> &lt;- </span>put y<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">37</span>
+  y<span class="Special"> &lt;- </span>put y<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">37</span>
 ]
 <span class="traceContains">+error: foo: cannot modify 'y' in instruction 'y &lt;- put y, x:offset, 37' because that would modify 'x' which is an ingredient of recipe foo but not also a product</span>
 
 <span class="Delimiter">:(scenario can_modify_immutable_pointers)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   foo x
 ]
-def foo x:&amp;:num [
+<span class="muRecipe">def</span> foo x:&amp;:num [
   local-scope
   load-ingredients
   <span class="Comment"># modify the address, not the payload</span>
@@ -150,16 +152,16 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario can_modify_immutable_pointers_but_not_their_payloads)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   foo x
 ]
-def foo x:&amp;:num [
+<span class="muRecipe">def</span> foo x:&amp;:num [
   local-scope
   load-ingredients
   <span class="Comment"># modify address; ok</span>
-  x<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  x<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Comment"># modify payload: boom</span>
   <span class="Comment"># this could be ok, but we're not going to try to be that smart</span>
   *x<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
@@ -168,17 +170,17 @@ def foo x:&amp;:num [
 
 <span class="Delimiter">:(scenario cannot_call_mutating_recipes_on_immutable_ingredients)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">point:type</span>
   foo p
 ]
-def foo p:&amp;:point [
+<span class="muRecipe">def</span> foo p:&amp;:point [
   local-scope
   load-ingredients
   bar p
 ]
-def bar p:&amp;:point <span class="Delimiter">-&gt;</span> p:&amp;:point [
+<span class="muRecipe">def</span> bar p:&amp;:point<span class="muRecipe"> -&gt; </span>p:&amp;:point [
   local-scope
   load-ingredients
   <span class="Comment"># p could be modified here, but it doesn't have to be, it's already marked</span>
@@ -188,72 +190,72 @@ def bar p:&amp;:point <span class="Delimiter">-&gt;</span> p:&amp;:point [
 
 <span class="Delimiter">:(scenario cannot_modify_copies_of_immutable_ingredients)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">point:type</span>
   foo p
 ]
-def foo p:&amp;:point [
+<span class="muRecipe">def</span> foo p:&amp;:point [
   local-scope
   load-ingredients
   <span class="Normal">q</span>:&amp;:point<span class="Special"> &lt;- </span>copy p
-  *q<span class="Special"> &lt;- </span>put *q<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
+  *q<span class="Special"> &lt;- </span>put *q<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+error: foo: cannot modify 'q' in instruction '*q &lt;- put *q, x:offset, 34' because that would modify p which is an ingredient of recipe foo but not also a product</span>
 
 <span class="Delimiter">:(scenario can_modify_copies_of_mutable_ingredients)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">point:type</span>
   foo p
 ]
-def foo p:&amp;:point <span class="Delimiter">-&gt;</span> p:&amp;:point [
+<span class="muRecipe">def</span> foo p:&amp;:point<span class="muRecipe"> -&gt; </span>p:&amp;:point [
   local-scope
   load-ingredients
   <span class="Normal">q</span>:&amp;:point<span class="Special"> &lt;- </span>copy p
-  *q<span class="Special"> &lt;- </span>put *q<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
+  *q<span class="Special"> &lt;- </span>put *q<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario cannot_modify_address_inside_immutable_ingredients)</span>
 <span class="Special">% Hide_errors = true;</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:&amp;:@:num  <span class="Comment"># contains an address</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># don't run anything</span>
 ]
-def foo a:&amp;:foo [
+<span class="muRecipe">def</span> foo a:&amp;:foo [
   local-scope
   load-ingredients
-  <span class="Normal">x</span>:&amp;:@:num<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> x:offset  <span class="Comment"># just a regular get of the container</span>
+  <span class="Normal">x</span>:&amp;:@:num<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> <span class="Constant">x:offset</span>  <span class="Comment"># just a regular get of the container</span>
   *x<span class="Special"> &lt;- </span>put-index *x<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span>  <span class="Comment"># but then a put-index on the result</span>
 ]
 <span class="traceContains">+error: foo: cannot modify 'x' in instruction '*x &lt;- put-index *x, 0, 34' because that would modify a which is an ingredient of recipe foo but not also a product</span>
 
 <span class="Delimiter">:(scenario cannot_modify_address_inside_immutable_ingredients_2)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:&amp;:@:num  <span class="Comment"># contains an address</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># don't run anything</span>
 ]
-def foo a:&amp;:foo [
+<span class="muRecipe">def</span> foo a:&amp;:foo [
   local-scope
   load-ingredients
   <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>
   <span class="Comment"># modify b, completely unrelated to immutable ingredient a</span>
-  <span class="Normal">x</span>:&amp;:@:num<span class="Special"> &lt;- </span>get b<span class="Delimiter">,</span> x:offset
+  <span class="Normal">x</span>:&amp;:@:num<span class="Special"> &lt;- </span>get b<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
   *x<span class="Special"> &lt;- </span>put-index *x<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario cannot_modify_address_inside_immutable_ingredients_3)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># don't run anything</span>
 ]
-def foo a:&amp;:@:&amp;:num [
+<span class="muRecipe">def</span> foo a:&amp;:@:&amp;:num [
   local-scope
   load-ingredients
   <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span>index *a<span class="Delimiter">,</span> <span class="Constant">0</span>  <span class="Comment"># just a regular index of the array</span>
@@ -262,10 +264,10 @@ def foo a:&amp;:@:&amp;:num [
 <span class="traceContains">+error: foo: cannot modify 'x' in instruction '*x &lt;- copy 34' because that would modify a which is an ingredient of recipe foo but not also a product</span>
 
 <span class="Delimiter">:(scenario cannot_modify_address_inside_immutable_ingredients_4)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># don't run anything</span>
 ]
-def foo a:&amp;:@:&amp;:num [
+<span class="muRecipe">def</span> foo a:&amp;:@:&amp;:num [
   local-scope
   load-ingredients
   <span class="Normal">b</span>:&amp;:@:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>address number<span class="Delimiter">)</span>: type<span class="Delimiter">},</span> <span class="Constant">3</span>
@@ -276,10 +278,10 @@ def foo a:&amp;:@:&amp;:num [
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario latter_ingredient_of_index_is_immutable)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># don't run anything</span>
 ]
-def foo a:&amp;:@:&amp;:@:num<span class="Delimiter">,</span> b:num <span class="Delimiter">-&gt;</span> a:&amp;:@:&amp;:@:num [
+<span class="muRecipe">def</span> foo a:&amp;:@:&amp;:@:num<span class="Delimiter">,</span> b:num<span class="muRecipe"> -&gt; </span>a:&amp;:@:&amp;:@:num [
   local-scope
   load-ingredients
   <span class="Normal">x</span>:&amp;:@:num<span class="Special"> &lt;- </span>index *a<span class="Delimiter">,</span> b
@@ -288,39 +290,39 @@ def foo a:&amp;:@:&amp;:@:num<span class="Delimiter">,</span> b:num <span class=
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario can_traverse_immutable_ingredients)</span>
-container test-list [
+<span class="muData">container</span> test-list [
   <span class="Normal">next</span>:&amp;:test-list
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> test-list:type
+  <span class="Normal">p</span>:&amp;:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">test-list:type</span>
   foo p
 ]
-def foo p:&amp;:test-list [
+<span class="muRecipe">def</span> foo p:&amp;:test-list [
   local-scope
   load-ingredients
   <span class="Normal">p2</span>:&amp;:test-list<span class="Special"> &lt;- </span>bar p
 ]
-def bar x:&amp;:test-list <span class="Delimiter">-&gt;</span> y:&amp;:test-list [
+<span class="muRecipe">def</span> bar x:&amp;:test-list<span class="muRecipe"> -&gt; </span>y:&amp;:test-list [
   local-scope
   load-ingredients
-  y<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> next:offset
+  y<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> <span class="Constant">next:offset</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario treat_optional_ingredients_as_mutable)</span>
-def main [
-  <span class="Normal">k</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Normal">k</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   test k
 ]
 <span class="Comment"># recipe taking an immutable address ingredient</span>
-def test k:&amp;:num [
+<span class="muRecipe">def</span> test k:&amp;:num [
   local-scope
   load-ingredients
   foo k
 ]
 <span class="Comment"># ..calling a recipe with an optional address ingredient</span>
-def foo <span class="Delimiter">-&gt;</span> [
+<span class="muRecipe">def</span> foo<span class="muRecipe"> -&gt; </span>[
   local-scope
   load-ingredients
   <span class="Normal">k</span>:&amp;:num<span class="Delimiter">,</span> found?:<span class="Normal">bool</span><span class="Special"> &lt;- </span>next-ingredient
@@ -330,17 +332,17 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario treat_optional_ingredients_as_mutable_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">point:type</span>
   foo p
 ]
-def foo p:&amp;:point [
+<span class="muRecipe">def</span> foo p:&amp;:point [
   local-scope
   load-ingredients
   bar p
 ]
-def bar [
+<span class="muRecipe">def</span> bar [
   local-scope
   load-ingredients
   <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># optional ingredient; assumed to be mutable</span>
@@ -349,17 +351,17 @@ def bar [
 
 <span class="Comment">//: when checking for immutable ingredients, remember to take space into account</span>
 <span class="Delimiter">:(scenario check_space_of_reagents_in_immutability_checks)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">a</span>:space<span class="Special"> &lt;- </span><span class="Normal">new</span>-closure
-  <span class="Normal">b</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">b</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   run-closure b:&amp;:num<span class="Delimiter">,</span> a:space
 ]
-def <span class="Normal">new</span>-closure [
+<span class="muRecipe">def</span> <span class="Normal">new</span>-closure [
   <span class="Normal">new</span>-<span class="Normal">default</span>-space
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Identifier">return</span> <span class="Normal">default</span>-space
 ]
-def run-closure x:&amp;:num<span class="Delimiter">,</span> s:space [
+<span class="muRecipe">def</span> run-closure x:&amp;:num<span class="Delimiter">,</span> s:space [
   local-scope
   load-ingredients
   <span class="Constant">0</span>:space/names:<span class="Normal">new</span>-closure<span class="Special"> &lt;- </span>copy s
@@ -447,25 +449,25 @@ set&lt;<span class="Normal">int</span>&gt; scan_contained_in_product_indices<spa
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario immutability_infects_contained_in_variables)</span>
 <span class="Special">% Hide_errors = true;</span>
-container test-list [
+<span class="muData">container</span> test-list [
   <span class="Normal">value</span>:num
   <span class="Normal">next</span>:&amp;:test-list
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> test-list:type
+  <span class="Normal">p</span>:&amp;:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">test-list:type</span>
   foo p
 ]
-def foo p:&amp;:test-list [  <span class="Comment"># p is immutable</span>
+<span class="muRecipe">def</span> foo p:&amp;:test-list [  <span class="Comment"># p is immutable</span>
   local-scope
   load-ingredients
   <span class="Normal">p2</span>:&amp;:test-list<span class="Special"> &lt;- </span>test-next p  <span class="Comment"># p2 is immutable</span>
-  *p2<span class="Special"> &lt;- </span>put *p2<span class="Delimiter">,</span> value:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
+  *p2<span class="Special"> &lt;- </span>put *p2<span class="Delimiter">,</span> <span class="Constant">value:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
-def test-next x:&amp;:test-list <span class="Delimiter">-&gt;</span> y:&amp;:test-list/contained-in:x [
+<span class="muRecipe">def</span> test-next x:&amp;:test-list<span class="muRecipe"> -&gt; </span>y:&amp;:test-list/contained-in:x [
   local-scope
   load-ingredients
-  y<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> next:offset
+  y<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> <span class="Constant">next:offset</span>
 ]
 <span class="traceContains">+error: foo: cannot modify 'p2' in instruction '*p2 &lt;- put *p2, value:offset, 34' because that would modify p which is an ingredient of recipe foo but not also a product</span>
 
@@ -567,30 +569,30 @@ set&lt;<span class="Normal">int</span>&gt; ingredient_indices<span class="Delimi
 
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario can_modify_contained_in_addresses)</span>
-container test-list [
+<span class="muData">container</span> test-list [
   <span class="Normal">value</span>:num
   <span class="Normal">next</span>:&amp;:test-list
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">p</span>:&amp;:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> test-list:type
+  <span class="Normal">p</span>:&amp;:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">test-list:type</span>
   foo p
 ]
-def foo p:&amp;:test-list <span class="Delimiter">-&gt;</span> p:&amp;:test-list [
+<span class="muRecipe">def</span> foo p:&amp;:test-list<span class="muRecipe"> -&gt; </span>p:&amp;:test-list [
   local-scope
   load-ingredients
   <span class="Normal">p2</span>:&amp;:test-list<span class="Special"> &lt;- </span>test-next p
   p<span class="Special"> &lt;- </span>test-remove p2<span class="Delimiter">,</span> p
 ]
-def test-next x:&amp;:test-list <span class="Delimiter">-&gt;</span> y:&amp;:test-list [
+<span class="muRecipe">def</span> test-next x:&amp;:test-list<span class="muRecipe"> -&gt; </span>y:&amp;:test-list [
   local-scope
   load-ingredients
-  y<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> next:offset
+  y<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> <span class="Constant">next:offset</span>
 ]
-def test-remove x:&amp;:test-list/contained-in:from<span class="Delimiter">,</span> from:&amp;:test-list <span class="Delimiter">-&gt;</span> from:&amp;:test-list [
+<span class="muRecipe">def</span> test-remove x:&amp;:test-list/contained-in:from<span class="Delimiter">,</span> from:&amp;:test-list<span class="muRecipe"> -&gt; </span>from:&amp;:test-list [
   local-scope
   load-ingredients
-  *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> value:offset<span class="Delimiter">,</span> <span class="Constant">34</span>  <span class="Comment"># can modify x</span>
+  *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> <span class="Constant">value:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span>  <span class="Comment"># can modify x</span>
 ]
 $error: <span class="Constant">0</span>
 
diff --git a/html/059to_text.mu.html b/html/059to_text.mu.html
index 820a9b47..baeb650e 100644
--- a/html/059to_text.mu.html
+++ b/html/059to_text.mu.html
@@ -13,11 +13,11 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
-.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/060rewrite_literal_string.cc.html b/html/060rewrite_literal_string.cc.html
index 980157d8..17c3a310 100644
--- a/html/060rewrite_literal_string.cc.html
+++ b/html/060rewrite_literal_string.cc.html
@@ -14,12 +14,13 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -34,10 +35,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: allow using literal strings anywhere that will accept immutable strings</span>
 
 <span class="Delimiter">:(scenario passing_literals_to_recipes)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo [abc]
 ]
-def foo x:text <span class="Delimiter">-&gt;</span> n:num [
+<span class="muRecipe">def</span> foo x:text<span class="muRecipe"> -&gt; </span>n:num [
   local-scope
   load-ingredients
   n<span class="Special"> &lt;- </span>length *x
diff --git a/html/061text.mu.html b/html/061text.mu.html
index 12a4c4e0..11271ed6 100644
--- a/html/061text.mu.html
+++ b/html/061text.mu.html
@@ -13,14 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
-.muData { color: #ffff00; }
-.muScenario { color: #00af00; }
 .Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
+.muData { color: #ffff00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -1127,7 +1127,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Delimiter">{</span>
     empty?:bool<span class="Special"> &lt;- </span>equal len, <span class="Constant">0</span>
     <span class="muControl">break-unless</span> empty?
-    result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(address array character): <span class="muData">type</span><span class="Delimiter">}</span>, <span class="Constant">0</span>
+    result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(address array character): type<span class="Delimiter">}</span>, <span class="Constant">0</span>
     <span class="muControl">return</span>
   <span class="Delimiter">}</span>
   <span class="Comment"># count #pieces we need room for</span>
@@ -1142,7 +1142,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="muControl">loop</span>
   <span class="Delimiter">}</span>
   <span class="Comment"># allocate space</span>
-  result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(address array character): <span class="muData">type</span><span class="Delimiter">}</span>, count
+  result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(address array character): type<span class="Delimiter">}</span>, count
   <span class="Comment"># repeatedly copy slices start..end until delimiter into result[curr-result]</span>
   curr-result:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   start:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
diff --git a/html/062convert_ingredients_to_text.cc.html b/html/062convert_ingredients_to_text.cc.html
index 2228229c..6fef4186 100644
--- a/html/062convert_ingredients_to_text.cc.html
+++ b/html/062convert_ingredients_to_text.cc.html
@@ -14,12 +14,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.CommentedCode { color: #6c6c6c; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.CommentedCode { color: #6c6c6c; }
 .Identifier { color: #fcb165; }
 -->
 </style>
@@ -36,7 +38,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario rewrite_stashes_to_text)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">n</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   stash n
@@ -45,7 +47,7 @@ def main [
 <span class="traceContains">+transform: stash {stash_2_0: (&quot;address&quot; &quot;array&quot; &quot;character&quot;)}</span>
 
 <span class="Delimiter">:(scenario rewrite_traces_to_text)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">n</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   trace <span class="Constant">2</span><span class="Delimiter">,</span> [app]<span class="Delimiter">,</span> n
@@ -57,16 +59,16 @@ def main [
 <span class="Comment">//: passing addresses around</span>
 
 <span class="Delimiter">:(scenario rewrite_stashes_of_arrays)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">n</span>:&amp;:@:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">3</span>
+  <span class="Normal">n</span>:&amp;:@:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">3</span>
   stash *n
 ]
 <span class="traceContains">+transform: {stash_2_0: (&quot;address&quot; &quot;array&quot; &quot;character&quot;)} &lt;- array-to-text-line {n: (&quot;address&quot; &quot;array&quot; &quot;number&quot;)}</span>
 <span class="traceContains">+transform: stash {stash_2_0: (&quot;address&quot; &quot;array&quot; &quot;character&quot;)}</span>
 
 <span class="Delimiter">:(scenario ignore_stashes_of_static_arrays)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">n</span>:@:num:<span class="Constant">3</span><span class="Special"> &lt;- </span>create-array
   stash n
@@ -74,10 +76,10 @@ def main [
 <span class="traceContains">+transform: stash {n: (&quot;array&quot; &quot;number&quot; &quot;3&quot;)}</span>
 
 <span class="Delimiter">:(scenario rewrite_stashes_of_recipe_header_products)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
 ]
-def bar <span class="Delimiter">-&gt;</span> x:foo [
+<span class="muRecipe">def</span> bar<span class="muRecipe"> -&gt; </span>x:foo [
   local-scope
   load-ingredients
   x<span class="Special"> &lt;- </span>merge <span class="Constant">34</span>
@@ -180,7 +182,7 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
 
 <span class="Delimiter">:(scenarios run)</span>
 <span class="Delimiter">:(scenario append_other_types_to_text)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">n</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">11</span>
   <span class="Normal">c</span>:character<span class="Special"> &lt;- </span>copy <span class="Constant">111</span>/o
@@ -194,11 +196,11 @@ def main [
 
 <span class="Delimiter">:(scenario rewrite_stash_continues_to_fall_back_to_default_implementation)</span>
 <span class="Comment"># type without a to-text implementation</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">x</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
   stash x
diff --git a/html/063array.mu.html b/html/063array.mu.html
index 01ed3938..b0578215 100644
--- a/html/063array.mu.html
+++ b/html/063array.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
+.muControl { color: #c0a020; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/064list.mu.html b/html/064list.mu.html
index a0b2d805..2fad0c10 100644
--- a/html/064list.mu.html
+++ b/html/064list.mu.html
@@ -13,14 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
-.muScenario { color: #00af00; }
+.muControl { color: #c0a020; }
 .Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -45,7 +45,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> push x:_elem, in:&amp;:list:_elem<span class="muRecipe"> -&gt; </span>result:&amp;:list:_elem [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(list _elem): <span class="muData">type</span><span class="Delimiter">}</span>
+  result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(list _elem): type<span class="Delimiter">}</span>
   *result<span class="Special"> &lt;- </span>merge x, in
 ]
 
@@ -95,7 +95,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> insert x:_elem, in:&amp;:list:_elem<span class="muRecipe"> -&gt; </span>in:&amp;:list:_elem [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  new-node:&amp;:list:_elem<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(list _elem): <span class="muData">type</span><span class="Delimiter">}</span>
+  new-node:&amp;:list:_elem<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(list _elem): type<span class="Delimiter">}</span>
   *new-node<span class="Special"> &lt;- </span>put *new-node, <span class="Constant">value:offset</span>, x
   next-node:&amp;:list:_elem<span class="Special"> &lt;- </span>get *in, <span class="Constant">next:offset</span>
   *in<span class="Special"> &lt;- </span>put *in, <span class="Constant">next:offset</span>, new-node
diff --git a/html/065duplex_list.mu.html b/html/065duplex_list.mu.html
index 430e9f71..af84549a 100644
--- a/html/065duplex_list.mu.html
+++ b/html/065duplex_list.mu.html
@@ -13,14 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
-.muScenario { color: #00af00; }
+.muControl { color: #c0a020; }
 .Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -44,7 +44,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> push x:_elem, in:&amp;:duplex-list:_elem<span class="muRecipe"> -&gt; </span>in:&amp;:duplex-list:_elem [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  result:&amp;:duplex-list:_elem<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(duplex-list _elem): <span class="muData">type</span><span class="Delimiter">}</span>
+  result:&amp;:duplex-list:_elem<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(duplex-list _elem): type<span class="Delimiter">}</span>
   *result<span class="Special"> &lt;- </span>merge x, in, <span class="Constant">0</span>
   <span class="Delimiter">{</span>
     <span class="muControl">break-unless</span> in
@@ -121,7 +121,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> insert x:_elem, in:&amp;:duplex-list:_elem<span class="muRecipe"> -&gt; </span>in:&amp;:duplex-list:_elem [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  new-node:&amp;:duplex-list:_elem<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(duplex-list _elem): <span class="muData">type</span><span class="Delimiter">}</span>
+  new-node:&amp;:duplex-list:_elem<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(duplex-list _elem): type<span class="Delimiter">}</span>
   *new-node<span class="Special"> &lt;- </span>put *new-node, <span class="Constant">value:offset</span>, x
   <span class="Comment"># save old next before changing it</span>
   next-node:&amp;:duplex-list:_elem<span class="Special"> &lt;- </span>get *in, <span class="Constant">next:offset</span>
diff --git a/html/066stream.mu.html b/html/066stream.mu.html
index 6f4f0752..c477233c 100644
--- a/html/066stream.mu.html
+++ b/html/066stream.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
+.muControl { color: #c0a020; }
 .Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -40,7 +40,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> new-stream s:&amp;:@:_elem<span class="muRecipe"> -&gt; </span>result:&amp;:stream:_elem [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(stream _elem): <span class="muData">type</span><span class="Delimiter">}</span>
+  result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(stream _elem): type<span class="Delimiter">}</span>
   *result<span class="Special"> &lt;- </span>put *result, <span class="Constant">index:offset</span>, <span class="Constant">0</span>
   *result<span class="Special"> &lt;- </span>put *result, <span class="Constant">data:offset</span>, s
 ]
diff --git a/html/068random.mu.html b/html/068random.mu.html
index 84ca32c8..52707f10 100644
--- a/html/068random.mu.html
+++ b/html/068random.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
-.muScenario { color: #00af00; }
 .Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/069hash.cc.html b/html/069hash.cc.html
index 1b4a1b15..c71609da 100644
--- a/html/069hash.cc.html
+++ b/html/069hash.cc.html
@@ -15,12 +15,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 .traceContains { color: #008000; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .cSpecial { color: #008000; }
 .Identifier { color: #fcb165; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
 .CommentedCode { color: #6c6c6c; }
 -->
 </style>
@@ -163,11 +165,11 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario hash_container_checks_all_elements)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:<span class="Normal">char</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">97</span>/a
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:foo
   <span class="Identifier">return</span>-unless <span class="Constant">3</span>:num
@@ -180,15 +182,15 @@ def main [
 <span class="traceContains">+mem: storing 0 in location 7</span>
 
 <span class="Delimiter">:(scenario hash_exclusive_container_checks_all_elements)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:bar
   <span class="Normal">y</span>:num
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">a</span>:num
   <span class="Normal">b</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:foo
   <span class="Identifier">return</span>-unless <span class="Constant">4</span>:num
@@ -201,11 +203,11 @@ def main [
 <span class="traceContains">+mem: storing 0 in location 9</span>
 
 <span class="Delimiter">:(scenario hash_can_ignore_container_elements)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:<span class="Normal">char</span>/ignore-<span class="Normal">for</span>-hash
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">97</span>/a
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:foo
   <span class="Identifier">return</span>-unless <span class="Constant">3</span>:num
@@ -221,7 +223,7 @@ def main [
 <span class="Comment">//: current implementation works like we think it does.</span>
 
 <span class="Delimiter">:(scenario hash_of_zero_address)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:&amp;:num
 ]
@@ -230,7 +232,7 @@ def main [
 <span class="Comment">//: This is probably too aggressive, but we need some way to avoid depending</span>
 <span class="Comment">//: on the precise bit pattern of a floating-point number.</span>
 <span class="Delimiter">:(scenario hash_of_numbers_ignores_fractional_part)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1.5</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
@@ -238,7 +240,7 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 3</span>
 
 <span class="Delimiter">:(scenario hash_of_array_same_as_string)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">97</span>
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">98</span>
@@ -253,11 +255,11 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 5</span>
 
 <span class="Delimiter">:(scenario hash_ignores_address_value)</span>
-def main [
-  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *<span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:&amp;:num
-  <span class="Constant">3</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Constant">3</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *<span class="Constant">3</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">3</span>:&amp;:num
   <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">4</span>:num
@@ -266,8 +268,8 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 5</span>
 
 <span class="Delimiter">:(scenario hash_ignores_address_refcount)</span>
-def main [
-  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *<span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:&amp;:num
   <span class="Identifier">return</span>-unless <span class="Constant">2</span>:num
@@ -281,15 +283,15 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 5</span>
 
 <span class="Delimiter">:(scenario hash_container_depends_only_on_elements)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:<span class="Normal">char</span>
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:<span class="Normal">char</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">97</span>/a
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:foo
   <span class="Identifier">return</span>-unless <span class="Constant">3</span>:num
@@ -302,18 +304,18 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 7</span>
 
 <span class="Delimiter">:(scenario hash_container_depends_only_on_elements_2)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:<span class="Normal">char</span>
   <span class="Normal">z</span>:&amp;:num
 ]
-def main [
-  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> main [
+  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *<span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">97</span>/a<span class="Delimiter">,</span> <span class="Constant">1</span>:&amp;:num
   <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">2</span>:foo
   <span class="Identifier">return</span>-unless <span class="Constant">5</span>:num
-  <span class="Constant">6</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Constant">6</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *<span class="Constant">6</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">7</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">97</span>/a<span class="Delimiter">,</span> <span class="Constant">6</span>:&amp;:num
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">7</span>:foo
@@ -324,16 +326,16 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 11</span>
 
 <span class="Delimiter">:(scenario hash_container_depends_only_on_elements_3)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:<span class="Normal">char</span>
   <span class="Normal">z</span>:bar
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">97</span>/a<span class="Delimiter">,</span> <span class="Constant">47</span><span class="Delimiter">,</span> <span class="Constant">48</span>
   <span class="Constant">6</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:foo
   <span class="Identifier">return</span>-unless <span class="Constant">6</span>:num
@@ -346,15 +348,15 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 13</span>
 
 <span class="Delimiter">:(scenario hash_exclusive_container_ignores_tag)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:bar
   <span class="Normal">y</span>:num
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">a</span>:num
   <span class="Normal">b</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>/x<span class="Delimiter">,</span> <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:foo
   <span class="Identifier">return</span>-unless <span class="Constant">4</span>:num
@@ -371,7 +373,7 @@ def main [
 <span class="Comment">//: version around and check that the new one is consistent with it.</span>
 
 <span class="Delimiter">:(scenario hash_matches_old_version)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>hash <span class="Constant">1</span>:text
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>hash_old <span class="Constant">1</span>:text
diff --git a/html/070table.mu.html b/html/070table.mu.html
index 42dae611..b144969e 100644
--- a/html/070table.mu.html
+++ b/html/070table.mu.html
@@ -13,14 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
-.muData { color: #ffff00; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
+.muControl { color: #c0a020; }
+.muData { color: #ffff00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -75,8 +75,8 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> new-table capacity:num<span class="muRecipe"> -&gt; </span>result:&amp;:table:_key:_value [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(table _key _value): <span class="muData">type</span><span class="Delimiter">}</span>
-  data:&amp;:@:table_row:_key:_value<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(table_row _key _value): <span class="muData">type</span><span class="Delimiter">}</span>, capacity
+  result<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(table _key _value): type<span class="Delimiter">}</span>
+  data:&amp;:@:table_row:_key:_value<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(table_row _key _value): type<span class="Delimiter">}</span>, capacity
   *result<span class="Special"> &lt;- </span>merge <span class="Constant">0/length</span>, capacity, data
 ]
 
diff --git a/html/071recipe.cc.html b/html/071recipe.cc.html
index fd4b234a..f661b770 100644
--- a/html/071recipe.cc.html
+++ b/html/071recipe.cc.html
@@ -15,13 +15,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -40,10 +41,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: todo: support storing shape-shifting recipes into recipe variables and calling them</span>
 
 <span class="Delimiter">:(scenario call_literal_recipe)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>call f<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
-def f x:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> f x:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>copy x
@@ -51,11 +52,11 @@ def f x:num <span class="Delimiter">-&gt;</span> y:num [
 <span class="traceContains">+mem: storing 34 in location 1</span>
 
 <span class="Delimiter">:(scenario call_variable)</span>
-def main [
-  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number <span class="Delimiter">-&gt;</span> number<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f
-  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>call <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number <span class="Delimiter">-&gt;</span> number<span class="Delimiter">)},</span> <span class="Constant">34</span>
+<span class="muRecipe">def</span> main [
+  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number<span class="muRecipe"> -&gt; </span>number<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f
+  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>call <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number<span class="muRecipe"> -&gt; </span>number<span class="Delimiter">)},</span> <span class="Constant">34</span>
 ]
-def f x:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> f x:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>copy x
@@ -113,7 +114,7 @@ get_or_insert<span class="Delimiter">(</span>Type<span class="Delimiter">,</span
 <span class="Comment">//: assume variable types override recipe literals.</span>
 <span class="Delimiter">:(scenario error_on_recipe_literal_used_as_a_variable)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">a</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Identifier">break</span> <span class="Constant">0</span>
   <span class="Normal">break</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -160,10 +161,10 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario call_check_literal_recipe)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>call f<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
-def f x:point <span class="Delimiter">-&gt;</span> y:point [
+<span class="muRecipe">def</span> f x:point<span class="muRecipe"> -&gt; </span>y:point [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>copy x
@@ -173,11 +174,11 @@ def f x:point <span class="Delimiter">-&gt;</span> y:point [
 
 <span class="Delimiter">:(scenario call_check_variable_recipe)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
-  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe point <span class="Delimiter">-&gt;</span> point<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f
-  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>call <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe point <span class="Delimiter">-&gt;</span> point<span class="Delimiter">)},</span> <span class="Constant">34</span>
+<span class="muRecipe">def</span> main [
+  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe point<span class="muRecipe"> -&gt; </span>point<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f
+  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>call <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe point<span class="muRecipe"> -&gt; </span>point<span class="Delimiter">)},</span> <span class="Constant">34</span>
 ]
-def f x:point <span class="Delimiter">-&gt;</span> y:point [
+<span class="muRecipe">def</span> f x:point<span class="muRecipe"> -&gt; </span>y:point [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>copy x
@@ -211,7 +212,7 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa
   <span class="Delimiter">}</span>
 <span class="Delimiter">}</span>
 
-recipe from_reagent<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
+<span class="muRecipe">recipe</span> from_reagent<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
   assert<span class="Delimiter">(</span>r<span class="Delimiter">.</span>type<span class="Delimiter">);</span>
   recipe result_header<span class="Delimiter">;</span>  <span class="Comment">// will contain only ingredients and products, nothing else</span>
   result_header<span class="Delimiter">.</span>has_header = <span class="Constant">true</span><span class="Delimiter">;</span>
@@ -289,12 +290,12 @@ reagent next_recipe_reagent<span class="Delimiter">(</span><span class="Normal">
 
 <span class="Delimiter">:(scenario copy_typecheck_recipe_variable)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>  <span class="Comment"># abc def</span>
-  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number <span class="Delimiter">-&gt;</span> number<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f  <span class="Comment"># store literal in a matching variable</span>
-  <span class="Delimiter">{</span><span class="Constant">2</span>: <span class="Delimiter">(</span>recipe boolean <span class="Delimiter">-&gt;</span> boolean<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number <span class="Delimiter">-&gt;</span> number<span class="Delimiter">)}</span>  <span class="Comment"># mismatch between recipe variables</span>
+  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number<span class="muRecipe"> -&gt; </span>number<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f  <span class="Comment"># store literal in a matching variable</span>
+  <span class="Delimiter">{</span><span class="Constant">2</span>: <span class="Delimiter">(</span>recipe boolean<span class="muRecipe"> -&gt; </span>boolean<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number<span class="muRecipe"> -&gt; </span>number<span class="Delimiter">)}</span>  <span class="Comment"># mismatch between recipe variables</span>
 ]
-def f x:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> f x:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>copy x
@@ -303,10 +304,10 @@ def f x:num <span class="Delimiter">-&gt;</span> y:num [
 
 <span class="Delimiter">:(scenario copy_typecheck_recipe_variable_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
-  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number <span class="Delimiter">-&gt;</span> number<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f  <span class="Comment"># mismatch with a recipe literal</span>
+<span class="muRecipe">def</span> main [
+  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe number<span class="muRecipe"> -&gt; </span>number<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f  <span class="Comment"># mismatch with a recipe literal</span>
 ]
-def f x:<span class="Normal">bool</span> <span class="Delimiter">-&gt;</span> y:<span class="Normal">bool</span> [
+<span class="muRecipe">def</span> f x:<span class="Normal">bool</span><span class="muRecipe"> -&gt; </span>y:<span class="Normal">bool</span> [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>copy x
@@ -333,12 +334,12 @@ def f x:<span class="Normal">bool</span> <span class="Delimiter">-&gt;</span> y:
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario call_variable_compound_ingredient)</span>
-def main [
-  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe <span class="Delimiter">(</span>address number<span class="Delimiter">)</span> <span class="Delimiter">-&gt;</span> number<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f
+<span class="muRecipe">def</span> main [
+  <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe <span class="Delimiter">(</span>address number<span class="Delimiter">)</span><span class="muRecipe"> -&gt; </span>number<span class="Delimiter">)}</span><span class="Special"> &lt;- </span>copy f
   <span class="Constant">2</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
-  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>call <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe <span class="Delimiter">(</span>address number<span class="Delimiter">)</span> <span class="Delimiter">-&gt;</span> number<span class="Delimiter">)},</span> <span class="Constant">2</span>:&amp;:num
+  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>call <span class="Delimiter">{</span><span class="Constant">1</span>: <span class="Delimiter">(</span>recipe <span class="Delimiter">(</span>address number<span class="Delimiter">)</span><span class="muRecipe"> -&gt; </span>number<span class="Delimiter">)},</span> <span class="Constant">2</span>:&amp;:num
 ]
-def f x:&amp;:num <span class="Delimiter">-&gt;</span> y:num [
+<span class="muRecipe">def</span> f x:&amp;:num<span class="muRecipe"> -&gt; </span>y:num [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>copy x
@@ -348,10 +349,10 @@ $error: <span class="Constant">0</span>
 <span class="Comment">//: make sure we don't accidentally break on a function literal</span>
 <span class="Delimiter">:(scenario jump_forbidden_on_recipe_literals)</span>
 <span class="Special">% Hide_errors = true;</span>
-def foo [
+<span class="muRecipe">def</span> foo [
   local-scope
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Delimiter">{</span>
     <span class="Identifier">break</span>-<span class="Normal">if</span> foo
diff --git a/html/072scheduler.cc.html b/html/072scheduler.cc.html
index 1d2681fa..648f22b7 100644
--- a/html/072scheduler.cc.html
+++ b/html/072scheduler.cc.html
@@ -16,14 +16,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .Constant { color: #00a0a0; }
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.CommentedCode { color: #6c6c6c; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.CommentedCode { color: #6c6c6c; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -39,14 +40,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: guarantees on how the operations in each are interleaved with each other.</span>
 
 <span class="Delimiter">:(scenario scheduler)</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   start-running f2
   <span class="Comment"># wait for f2 to run</span>
   <span class="Delimiter">{</span>
     jump-unless <span class="Constant">1</span>:num<span class="Delimiter">,</span> -<span class="Constant">1</span>
   <span class="Delimiter">}</span>
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
 ]
 <span class="traceContains">+schedule: f1</span>
@@ -232,7 +233,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario scheduler_runs_single_routine)</span>
 <span class="Special">% Scheduling_interval = 1;</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
@@ -243,12 +244,12 @@ def f1 [
 
 <span class="Delimiter">:(scenario scheduler_interleaves_routines)</span>
 <span class="Special">% Scheduling_interval = 1;</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   start-running f2
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
@@ -264,14 +265,14 @@ def f2 [
 <span class="traceContains">+run: {2: &quot;number&quot;} &lt;- copy {0: &quot;literal&quot;}</span>
 
 <span class="Delimiter">:(scenario start_running_takes_ingredients)</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   start-running f2<span class="Delimiter">,</span> <span class="Constant">3</span>
   <span class="Comment"># wait for f2 to run</span>
   <span class="Delimiter">{</span>
     jump-unless <span class="Constant">1</span>:num<span class="Delimiter">,</span> -<span class="Constant">1</span>
   <span class="Delimiter">}</span>
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>next-ingredient
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>
 ]
@@ -281,21 +282,21 @@ def f2 [
 
 <span class="Delimiter">:(scenario start_running_immediately_updates_refcounts_of_ingredients)</span>
 <span class="Special">% Scheduling_interval = 1;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   create-<span class="Normal">new</span>-routine
   <span class="Comment"># padding to make sure we run new-routine before returning</span>
   <span class="Normal">dummy</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Normal">dummy</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-def create-<span class="Normal">new</span>-routine [
+<span class="muRecipe">def</span> create-<span class="Normal">new</span>-routine [
   local-scope
-  <span class="Normal">n</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">n</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *n<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   start-running <span class="Normal">new</span>-routine<span class="Delimiter">,</span> n
   <span class="Comment"># refcount of n decremented</span>
 ]
-def <span class="Normal">new</span>-routine n:&amp;:num [
+<span class="muRecipe">def</span> <span class="Normal">new</span>-routine n:&amp;:num [
   local-scope
   load-ingredients
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>copy *n
@@ -318,11 +319,11 @@ increment_any_refcounts<span class="Delimiter">(</span>ingredient<span class="De
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario next_ingredient_never_leaks_refcounts)</span>
-def create-space n:&amp;:num <span class="Delimiter">-&gt;</span> <span class="Normal">default</span>-space:space [
-  <span class="Normal">default</span>-space<span class="Special"> &lt;- </span><span class="Normal">new</span> location:type<span class="Delimiter">,</span> <span class="Constant">2</span>
+<span class="muRecipe">def</span> create-space n:&amp;:num<span class="muRecipe"> -&gt; </span><span class="Normal">default</span>-space:space [
+  <span class="Normal">default</span>-space<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">location:type</span><span class="Delimiter">,</span> <span class="Constant">2</span>
   load-ingredients
 ]
-def use-space [
+<span class="muRecipe">def</span> use-space [
   local-scope
   <span class="Constant">0</span>:space/names:create-space<span class="Special"> &lt;- </span>next-ingredient
   <span class="Normal">n</span>:&amp;:num/space:<span class="Constant">1</span><span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># should decrement refcount</span>
@@ -330,7 +331,7 @@ def use-space [
   <span class="Normal">n2</span>:num<span class="Special"> &lt;- </span>add *n/space:<span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">1</span>
   reply n2
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">n</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">12000</span>/unsafe  <span class="Comment"># pretend allocation with a known address</span>
   *n<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
@@ -345,10 +346,10 @@ def main [
 <span class="Comment">//: back to testing 'start-running'</span>
 
 <span class="Delimiter">:(scenario start_running_returns_routine_id)</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>start-running f2
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">44</span>
 ]
 <span class="traceContains">+mem: storing 2 in location 1</span>
@@ -362,7 +363,7 @@ def f2 [
 <span class="Special">% Routines.push_back(new routine(f2));</span>
 <span class="Special">% Routines.back()-&gt;state = COMPLETED;  // f2 not meant to run</span>
 <span class="Comment"># must have at least one routine without escaping</span>
-def f3 [
+<span class="muRecipe">def</span> f3 [
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="Comment"># by interleaving '+' lines with '-' lines, we allow f1 and f3 to run in any order</span>
@@ -376,7 +377,7 @@ def f3 [
 <span class="Delimiter">:(scenario scheduler_starts_at_middle_of_routines)</span>
 <span class="Special">% Routines.push_back(new routine(COPY));</span>
 <span class="Special">% Routines.back()-&gt;state = COMPLETED;</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
@@ -388,12 +389,12 @@ def f1 [
 <span class="Delimiter">:(scenario scheduler_terminates_routines_after_errors)</span>
 <span class="Special">% Hide_errors = true;</span>
 <span class="Special">% Scheduling_interval = 2;</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   start-running f2
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Comment"># divide by 0 twice</span>
   <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>divide-with-remainder <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">0</span>
   <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>divide-with-remainder <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">0</span>
@@ -410,11 +411,11 @@ def f2 [
 <span class="SalientComment">//:: Routines are marked completed when their parent completes.</span>
 
 <span class="Delimiter">:(scenario scheduler_kills_orphans)</span>
-def main [
+<span class="muRecipe">def</span> main [
   start-running f1
   <span class="Comment"># f1 never actually runs because its parent completes without waiting for it</span>
 ]
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
 ]
 <span class="traceAbsent">-schedule: f1</span>
@@ -442,13 +443,13 @@ def f1 [
 
 <span class="Delimiter">:(scenario routine_state_test)</span>
 <span class="Special">% Scheduling_interval = 2;</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">1</span>:num/child-id<span class="Special"> &lt;- </span>start-running f2
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># race condition since we don't care about location 12</span>
   <span class="Comment"># thanks to Scheduling_interval, f2's one instruction runs in between here and completes</span>
   <span class="Constant">2</span>:num/state<span class="Special"> &lt;- </span>routine-state <span class="Constant">1</span>:num/child-id
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Comment"># trying to run a second instruction marks routine as completed</span>
 ]
@@ -536,16 +537,16 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario routine_discontinues_past_limit)</span>
 <span class="Special">% Scheduling_interval = 2;</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">1</span>:num/child-id<span class="Special"> &lt;- </span>start-running f2
   limit-time <span class="Constant">1</span>:num/child-id<span class="Delimiter">,</span> <span class="Constant">10</span>
   <span class="Comment"># padding loop just to make sure f2 has time to completed</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">20</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>subtract <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>
-  jump-<span class="Normal">if</span> <span class="Constant">2</span>:num<span class="Delimiter">,</span> -<span class="Constant">2</span>:offset
+  jump-<span class="Normal">if</span> <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">-2:offset</span>
 ]
-def f2 [
-  jump -<span class="Constant">1</span>:offset  <span class="Comment"># run forever</span>
+<span class="muRecipe">def</span> f2 [
+  jump <span class="Constant">-1:offset</span>  <span class="Comment"># run forever</span>
   $print [should never get here]<span class="Delimiter">,</span> <span class="Constant">10</span>/newline
 ]
 <span class="Comment"># f2 terminates</span>
@@ -660,14 +661,14 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario number_of_instructions)</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">10</span>:num/child-id<span class="Special"> &lt;- </span>start-running f2
   <span class="Delimiter">{</span>
     loop-unless <span class="Constant">20</span>:num
   <span class="Delimiter">}</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>number-of-instructions <span class="Constant">10</span>:num
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Comment"># 2 instructions worth of work</span>
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">20</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
@@ -678,14 +679,14 @@ def f2 [
 
 <span class="Delimiter">:(scenario number_of_instructions_across_multiple_scheduling_intervals)</span>
 <span class="Special">% Scheduling_interval = 1;</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">10</span>:num/child-id<span class="Special"> &lt;- </span>start-running f2
   <span class="Delimiter">{</span>
     loop-unless <span class="Constant">20</span>:num
   <span class="Delimiter">}</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>number-of-instructions <span class="Constant">10</span>:num
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Comment"># 4 instructions worth of work</span>
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
@@ -699,16 +700,16 @@ def f2 [
 <span class="SalientComment">//:: make sure that each routine gets a different alloc to start</span>
 
 <span class="Delimiter">:(scenario new_concurrent)</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   start-running f2
-  <span class="Constant">1</span>:&amp;:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Constant">1</span>:&amp;:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Comment"># wait for f2 to complete</span>
   <span class="Delimiter">{</span>
     loop-unless <span class="Constant">4</span>:num/<span class="Special">raw</span>
   <span class="Delimiter">}</span>
 ]
-def f2 [
-  <span class="Constant">2</span>:&amp;:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> number:type
+<span class="muRecipe">def</span> f2 [
+  <span class="Constant">2</span>:&amp;:num/<span class="Special">raw &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   <span class="Comment"># hack: assumes scheduler implementation</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal <span class="Constant">1</span>:&amp;:num/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">2</span>:&amp;:num/<span class="Special">raw</span>
   <span class="Comment"># signal f2 complete</span>
diff --git a/html/073wait.cc.html b/html/073wait.cc.html
index 74c5ce2f..ffc27bb9 100644
--- a/html/073wait.cc.html
+++ b/html/073wait.cc.html
@@ -15,14 +15,16 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
-.SalientComment { color: #00ffff; }
+.muRecipe { color: #ff8700; }
+.CommentedCode { color: #6c6c6c; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.CommentedCode { color: #6c6c6c; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
+.SalientComment { color: #00ffff; }
 -->
 </style>
 
@@ -40,7 +42,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: operate.</span>
 
 <span class="Delimiter">:(scenario wait_for_location)</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   start-running f2
   <span class="Constant">20</span>:location<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
@@ -48,7 +50,7 @@ def f1 [
   <span class="Comment"># wait for f2 to run and reset location 1</span>
   <span class="Constant">30</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>:num
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Constant">10</span>:location<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/unsafe
 ]
 <span class="traceContains">+schedule: f1</span>
@@ -175,10 +177,10 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Comment">//: containers within containers yet.</span>
 
 <span class="Delimiter">:(scenario get_location)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
-  <span class="Constant">15</span>:location<span class="Special"> &lt;- </span>get-location <span class="Constant">12</span>:point<span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+  <span class="Constant">15</span>:location<span class="Special"> &lt;- </span>get-location <span class="Constant">12</span>:point<span class="Delimiter">,</span> <span class="Constant">1:offset</span>
 ]
 <span class="traceContains">+mem: storing 13 in location 15</span>
 
@@ -258,63 +260,63 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario get_location_out_of_bounds)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  get-location <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">2</span>:offset  <span class="Comment"># point-number occupies 3 locations but has only 2 fields; out of bounds</span>
+  get-location <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">2:offset</span>  <span class="Comment"># point-number occupies 3 locations but has only 2 fields; out of bounds</span>
 ]
 <span class="traceContains">+error: main: invalid offset 2 for 'point-number'</span>
 
 <span class="Delimiter">:(scenario get_location_out_of_bounds_2)</span>
 <span class="Special">% Hide_errors = true;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">14</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">36</span>
-  get-location <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> -<span class="Constant">1</span>:offset
+  get-location <span class="Constant">12</span>:point-number/<span class="Special">raw</span><span class="Delimiter">,</span> <span class="Constant">-1:offset</span>
 ]
 <span class="traceContains">+error: main: invalid offset -1 for 'point-number'</span>
 
 <span class="Delimiter">:(scenario get_location_product_type_mismatch)</span>
 <span class="Special">% Hide_errors = true;</span>
-container boolbool [
+<span class="muData">container</span> boolbool [
   <span class="Normal">x</span>:<span class="Normal">bool</span>
   <span class="Normal">y</span>:<span class="Normal">bool</span>
 ]
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">12</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
   <span class="Constant">13</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
-  <span class="Constant">15</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>get-location <span class="Constant">12</span>:boolbool<span class="Delimiter">,</span> <span class="Constant">1</span>:offset
+  <span class="Constant">15</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>get-location <span class="Constant">12</span>:boolbool<span class="Delimiter">,</span> <span class="Constant">1:offset</span>
 ]
 <span class="traceContains">+error: main: 'get-location 12:boolbool, 1:offset' should write to type location but '15' has type 'boolean'</span>
 
 <span class="Delimiter">:(scenario get_location_indirect)</span>
 <span class="Comment"># 'get-location' can read from container address</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
-  <span class="Constant">4</span>:location<span class="Special"> &lt;- </span>get-location <span class="Constant">1</span>:&amp;:point/lookup<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
+  <span class="Constant">4</span>:location<span class="Special"> &lt;- </span>get-location <span class="Constant">1</span>:&amp;:point/lookup<span class="Delimiter">,</span> <span class="Constant">0:offset</span>
 ]
 <span class="traceContains">+mem: storing 11 in location 4</span>
 
 <span class="Delimiter">:(scenario get_location_indirect_2)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>
   <span class="Comment"># 10 reserved for refcount</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Constant">4</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">20</span>/unsafe
-  <span class="Constant">4</span>:&amp;:location/lookup<span class="Special"> &lt;- </span>get-location <span class="Constant">1</span>:&amp;:point/lookup<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
+  <span class="Constant">4</span>:&amp;:location/lookup<span class="Special"> &lt;- </span>get-location <span class="Constant">1</span>:&amp;:point/lookup<span class="Delimiter">,</span> <span class="Constant">0:offset</span>
 ]
 <span class="traceContains">+mem: storing 11 in location 21</span>
 
 <span class="Comment">//: allow waiting on a routine to complete</span>
 
 <span class="Delimiter">:(scenario wait_for_routine)</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Comment"># add a few routines to run</span>
   <span class="Constant">1</span>:num/routine<span class="Special"> &lt;- </span>start-running f2
   <span class="Constant">2</span>:num/routine<span class="Special"> &lt;- </span>start-running f3
@@ -322,12 +324,12 @@ def f1 [
   <span class="Comment"># now wait for f2 to *complete* and modify location 13 before using its value</span>
   <span class="Constant">20</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">13</span>:num
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># just padding</span>
   <span class="Normal">switch</span>  <span class="Comment"># simulate a block; routine f1 shouldn't restart at this point</span>
   <span class="Constant">13</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
-def f3 [
+<span class="muRecipe">def</span> f3 [
   <span class="Comment"># padding routine just to help simulate the block in f2 using 'switch'</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">12</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -458,13 +460,13 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Comment">//: (just for tests; use wait_for_routine above wherever possible)</span>
 
 <span class="Delimiter">:(scenario wait_for_routine_to_block)</span>
-def f1 [
+<span class="muRecipe">def</span> f1 [
   <span class="Constant">1</span>:num/routine<span class="Special"> &lt;- </span>start-running f2
   wait-<span class="Normal">for</span>-routine-to-block <span class="Constant">1</span>:num/routine
   <span class="Comment"># now wait for f2 to run and modify location 10 before using its value</span>
   <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>:num
 ]
-def f2 [
+<span class="muRecipe">def</span> f2 [
   <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 <span class="traceContains">+schedule: f1</span>
@@ -596,7 +598,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 
 <span class="Delimiter">:(scenario cannot_restart_completed_routine)</span>
 <span class="Special">% Scheduling_interval = 1;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">r</span>:num/routine-id<span class="Special"> &lt;- </span>start-running f
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># wait for f to be scheduled</span>
@@ -604,14 +606,14 @@ def main [
   restart r  <span class="Comment"># should have no effect</span>
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># give f time to be scheduled (though it shouldn't be)</span>
 ]
-def f [
+<span class="muRecipe">def</span> f [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>copy <span class="Constant">1</span>
 ]
 <span class="Comment"># shouldn't crash</span>
 
 <span class="Delimiter">:(scenario restart_blocked_routine)</span>
 <span class="Special">% Scheduling_interval = 1;</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">r</span>:num/routine-id<span class="Special"> &lt;- </span>start-running f
   wait-<span class="Normal">for</span>-routine-to-block r  <span class="Comment"># get past the block in f below</span>
@@ -619,7 +621,7 @@ def main [
   wait-<span class="Normal">for</span>-routine-to-block r  <span class="Comment"># should run f to completion</span>
 ]
 <span class="Comment"># function with one block</span>
-def f [
+<span class="muRecipe">def</span> f [
   current-routine-is-blocked
   <span class="Comment"># 8 instructions of padding, many more than 'main' above</span>
   <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>
diff --git a/html/074deep_copy.cc.html b/html/074deep_copy.cc.html
index bd40721c..1085c615 100644
--- a/html/074deep_copy.cc.html
+++ b/html/074deep_copy.cc.html
@@ -15,12 +15,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muData { color: #ffff00; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -45,7 +47,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">// to new cycles in the product.</span>
 
 <span class="Delimiter">:(scenario deep_copy_number)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>deep-copy x
@@ -55,11 +57,11 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 10</span>
 
 <span class="Delimiter">:(scenario deep_copy_container_without_address)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">a</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span>
   <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>deep-copy a
@@ -70,7 +72,7 @@ def main [
 
 <span class="Delimiter">:(scenario deep_copy_address)</span>
 <span class="Special">% Memory_allocated_until = 200;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span>
   <span class="Comment"># that the result is deterministic</span>
   <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">100</span>/unsafe  <span class="Comment"># pretend allocation</span>
@@ -92,7 +94,7 @@ def main [
 
 <span class="Delimiter">:(scenario deep_copy_address_to_container)</span>
 <span class="Special">% Memory_allocated_until = 200;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span>
   <span class="Comment"># that the result is deterministic</span>
   <span class="Constant">1</span>:&amp;:point<span class="Special"> &lt;- </span>copy <span class="Constant">100</span>/unsafe  <span class="Comment"># pretend allocation</span>
@@ -108,7 +110,7 @@ def main [
 
 <span class="Delimiter">:(scenario deep_copy_address_to_address)</span>
 <span class="Special">% Memory_allocated_until = 200;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span>
   <span class="Comment"># that the result is deterministic</span>
   <span class="Constant">1</span>:&amp;:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">100</span>/unsafe  <span class="Comment"># pretend allocation</span>
@@ -128,7 +130,7 @@ def main [
 
 <span class="Delimiter">:(scenario deep_copy_array)</span>
 <span class="Special">% Memory_allocated_until = 200;</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span>
   <span class="Comment"># that the result is deterministic</span>
   <span class="Constant">100</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>  <span class="Comment"># pretend refcount</span>
@@ -152,18 +154,18 @@ def main [
 <span class="traceContains">+mem: storing 1 in location 11</span>
 
 <span class="Delimiter">:(scenario deep_copy_container_with_address)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:&amp;:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">y0</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">y0</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *y0<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
   <span class="Normal">a</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> y0
   <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>deep-copy a
   <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal a<span class="Delimiter">,</span> b
-  <span class="Normal">y1</span>:&amp;:num<span class="Special"> &lt;- </span>get b<span class="Delimiter">,</span> y:offset
+  <span class="Normal">y1</span>:&amp;:num<span class="Special"> &lt;- </span>get b<span class="Delimiter">,</span> <span class="Constant">y:offset</span>
   <span class="Constant">11</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal y0<span class="Delimiter">,</span> y1
   <span class="Constant">12</span>:num/<span class="Special">raw &lt;- </span>copy *y1
 ]
@@ -174,18 +176,18 @@ def main [
 <span class="traceContains">+mem: storing 35 in location 12</span>
 
 <span class="Delimiter">:(scenario deep_copy_exclusive_container_with_address)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:&amp;:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">y0</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">y0</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *y0<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Normal">a</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> y0
   <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>deep-copy a
   <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal a<span class="Delimiter">,</span> b
-  <span class="Normal">y1</span>:&amp;:num<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert b<span class="Delimiter">,</span> y:variant
+  <span class="Normal">y1</span>:&amp;:num<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert b<span class="Delimiter">,</span> <span class="Constant">y:variant</span>
   <span class="Constant">11</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal y0<span class="Delimiter">,</span> y1
   <span class="Constant">12</span>:num/<span class="Special">raw &lt;- </span>copy *y1
 ]
@@ -196,23 +198,23 @@ def main [
 <span class="traceContains">+mem: storing 34 in location 12</span>
 
 <span class="Delimiter">:(scenario deep_copy_exclusive_container_with_container_with_address)</span>
-exclusive-container foo [
+<span class="muData">exclusive-container</span> foo [
   <span class="Normal">x</span>:num
   <span class="Normal">y</span>:bar  <span class="Comment"># inline</span>
 ]
-container bar [
+<span class="muData">container</span> bar [
   <span class="Normal">x</span>:&amp;:num
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">y0</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">y0</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *y0<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
   <span class="Normal">a</span>:bar<span class="Special"> &lt;- </span>merge y0
   <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> a
   <span class="Normal">c</span>:foo<span class="Special"> &lt;- </span>deep-copy b
   <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal b<span class="Delimiter">,</span> c
-  <span class="Normal">d</span>:bar<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert c<span class="Delimiter">,</span> y:variant
-  <span class="Normal">y1</span>:&amp;:num<span class="Special"> &lt;- </span>get d<span class="Delimiter">,</span> x:offset
+  <span class="Normal">d</span>:bar<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert c<span class="Delimiter">,</span> <span class="Constant">y:variant</span>
+  <span class="Normal">y1</span>:&amp;:num<span class="Special"> &lt;- </span>get d<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
   <span class="Constant">11</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal y0<span class="Delimiter">,</span> y1
   <span class="Constant">12</span>:num/<span class="Special">raw &lt;- </span>copy *y1
 ]
@@ -335,81 +337,81 @@ vector&lt;<span class="Normal">double</span>&gt; deep_copy<span class="Delimiter
 <span class="Comment">//: moar tests, just because I can't believe it all works</span>
 
 <span class="Delimiter">:(scenario deep_copy_stress_test_1)</span>
-container foo1 [
+<span class="muData">container</span> foo1 [
   <span class="Normal">p</span>:&amp;:num
 ]
-container foo2 [
+<span class="muData">container</span> foo2 [
   <span class="Normal">p</span>:&amp;:foo1
 ]
-exclusive-container foo3 [
+<span class="muData">exclusive-container</span> foo3 [
   <span class="Normal">p</span>:&amp;:foo1
   <span class="Normal">q</span>:&amp;:foo2
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *x<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
-  <span class="Normal">a</span>:&amp;:foo1<span class="Special"> &lt;- </span><span class="Normal">new</span> foo1:type
+  <span class="Normal">a</span>:&amp;:foo1<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo1:type</span>
   *a<span class="Special"> &lt;- </span>merge x
-  <span class="Normal">b</span>:&amp;:foo2<span class="Special"> &lt;- </span><span class="Normal">new</span> foo2:type
+  <span class="Normal">b</span>:&amp;:foo2<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo2:type</span>
   *b<span class="Special"> &lt;- </span>merge a
   <span class="Normal">c</span>:foo3<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/q<span class="Delimiter">,</span> b
   <span class="Normal">d</span>:foo3<span class="Special"> &lt;- </span>deep-copy c
-  <span class="Normal">e</span>:&amp;:foo2<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert d<span class="Delimiter">,</span> q:variant
-  <span class="Normal">f</span>:&amp;:foo1<span class="Special"> &lt;- </span>get *e<span class="Delimiter">,</span> p:offset
-  <span class="Normal">g</span>:&amp;:num<span class="Special"> &lt;- </span>get *f<span class="Delimiter">,</span> p:offset
+  <span class="Normal">e</span>:&amp;:foo2<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert d<span class="Delimiter">,</span> <span class="Constant">q:variant</span>
+  <span class="Normal">f</span>:&amp;:foo1<span class="Special"> &lt;- </span>get *e<span class="Delimiter">,</span> <span class="Constant">p:offset</span>
+  <span class="Normal">g</span>:&amp;:num<span class="Special"> &lt;- </span>get *f<span class="Delimiter">,</span> <span class="Constant">p:offset</span>
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>copy *g
 ]
 <span class="traceContains">+mem: storing 34 in location 1</span>
 
 <span class="Delimiter">:(scenario deep_copy_stress_test_2)</span>
-container foo1 [
+<span class="muData">container</span> foo1 [
   <span class="Normal">p</span>:&amp;:num
 ]
-container foo2 [
+<span class="muData">container</span> foo2 [
   <span class="Normal">p</span>:&amp;:foo1
 ]
-exclusive-container foo3 [
+<span class="muData">exclusive-container</span> foo3 [
   <span class="Normal">p</span>:&amp;:foo1
   <span class="Normal">q</span>:&amp;:foo2
 ]
-container foo4 [
+<span class="muData">container</span> foo4 [
   <span class="Normal">p</span>:num
   <span class="Normal">q</span>:&amp;:foo3
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
   *x<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
-  <span class="Normal">a</span>:&amp;:foo1<span class="Special"> &lt;- </span><span class="Normal">new</span> foo1:type
+  <span class="Normal">a</span>:&amp;:foo1<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo1:type</span>
   *a<span class="Special"> &lt;- </span>merge x
-  <span class="Normal">b</span>:&amp;:foo2<span class="Special"> &lt;- </span><span class="Normal">new</span> foo2:type
+  <span class="Normal">b</span>:&amp;:foo2<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo2:type</span>
   *b<span class="Special"> &lt;- </span>merge a
-  <span class="Normal">c</span>:&amp;:foo3<span class="Special"> &lt;- </span><span class="Normal">new</span> foo3:type
+  <span class="Normal">c</span>:&amp;:foo3<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo3:type</span>
   *c<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/q<span class="Delimiter">,</span> b
   <span class="Normal">d</span>:foo4<span class="Special"> &lt;- </span>merge <span class="Constant">35</span><span class="Delimiter">,</span> c
   <span class="Normal">e</span>:foo4<span class="Special"> &lt;- </span>deep-copy d
-  <span class="Normal">f</span>:&amp;:foo3<span class="Special"> &lt;- </span>get e<span class="Delimiter">,</span> q:offset
-  <span class="Normal">g</span>:&amp;:foo2<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert *f<span class="Delimiter">,</span> q:variant
-  <span class="Normal">h</span>:&amp;:foo1<span class="Special"> &lt;- </span>get *g<span class="Delimiter">,</span> p:offset
-  <span class="Normal">y</span>:&amp;:num<span class="Special"> &lt;- </span>get *h<span class="Delimiter">,</span> p:offset
+  <span class="Normal">f</span>:&amp;:foo3<span class="Special"> &lt;- </span>get e<span class="Delimiter">,</span> <span class="Constant">q:offset</span>
+  <span class="Normal">g</span>:&amp;:foo2<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert *f<span class="Delimiter">,</span> <span class="Constant">q:variant</span>
+  <span class="Normal">h</span>:&amp;:foo1<span class="Special"> &lt;- </span>get *g<span class="Delimiter">,</span> <span class="Constant">p:offset</span>
+  <span class="Normal">y</span>:&amp;:num<span class="Special"> &lt;- </span>get *h<span class="Delimiter">,</span> <span class="Constant">p:offset</span>
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>copy *y
 ]
 <span class="traceContains">+mem: storing 34 in location 1</span>
 
 <span class="Delimiter">:(scenario deep_copy_cycles)</span>
-container foo [
+<span class="muData">container</span> foo [
   <span class="Normal">p</span>:num
   <span class="Normal">q</span>:&amp;:foo
 ]
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
-  <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> foo:type
-  *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> p:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
-  *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> q:offset<span class="Delimiter">,</span> x  <span class="Comment"># create a cycle</span>
+  <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
+  *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> <span class="Constant">p:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span>
+  *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> <span class="Constant">q:offset</span><span class="Delimiter">,</span> x  <span class="Comment"># create a cycle</span>
   <span class="Normal">y</span>:&amp;:foo<span class="Special"> &lt;- </span>deep-copy x
-  <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>get *y<span class="Delimiter">,</span> p:offset
-  <span class="Normal">y2</span>:&amp;:foo<span class="Special"> &lt;- </span>get *y<span class="Delimiter">,</span> q:offset
+  <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>get *y<span class="Delimiter">,</span> <span class="Constant">p:offset</span>
+  <span class="Normal">y2</span>:&amp;:foo<span class="Special"> &lt;- </span>get *y<span class="Delimiter">,</span> <span class="Constant">q:offset</span>
   stash y [vs] y2
   <span class="Constant">2</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal y<span class="Delimiter">,</span> y2  <span class="Comment"># is it still a cycle?</span>
   <span class="Constant">3</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal x<span class="Delimiter">,</span> y  <span class="Comment"># is it the same cycle?</span>
diff --git a/html/075channel.mu.html b/html/075channel.mu.html
index e02135ef..862329f8 100644
--- a/html/075channel.mu.html
+++ b/html/075channel.mu.html
@@ -13,16 +13,16 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
 .muData { color: #ffff00; }
-.SalientComment { color: #00ffff; }
+.muControl { color: #c0a020; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
+.SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
 .CommentedCode { color: #6c6c6c; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -83,15 +83,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> new-channel capacity:num<span class="muRecipe"> -&gt; </span>in:&amp;:source:_elem, out:&amp;:sink:_elem [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  result:&amp;:channel:_elem<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(channel _elem): <span class="muData">type</span><span class="Delimiter">}</span>
+  result:&amp;:channel:_elem<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(channel _elem): type<span class="Delimiter">}</span>
   *result<span class="Special"> &lt;- </span>put *result, <span class="Constant">first-full:offset</span>, <span class="Constant">0</span>
   *result<span class="Special"> &lt;- </span>put *result, <span class="Constant">first-free:offset</span>, <span class="Constant">0</span>
   capacity<span class="Special"> &lt;- </span>add capacity, <span class="Constant">1</span>  <span class="Comment"># unused slot for 'full?' below</span>
   data:&amp;:@:_elem<span class="Special"> &lt;- </span>new <span class="Constant">_elem:type</span>, capacity
   *result<span class="Special"> &lt;- </span>put *result, <span class="Constant">data:offset</span>, data
-  in<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(source _elem): <span class="muData">type</span><span class="Delimiter">}</span>
+  in<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(source _elem): type<span class="Delimiter">}</span>
   *in<span class="Special"> &lt;- </span>put *in, <span class="Constant">chan:offset</span>, result
-  out<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(sink _elem): <span class="muData">type</span><span class="Delimiter">}</span>
+  out<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(sink _elem): type<span class="Delimiter">}</span>
   *out<span class="Special"> &lt;- </span>put *out, <span class="Constant">chan:offset</span>, result
 ]
 
diff --git a/html/081print.mu.html b/html/081print.mu.html
index 74318453..e4dffe1e 100644
--- a/html/081print.mu.html
+++ b/html/081print.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
-.muScenario { color: #00af00; }
+.muControl { color: #c0a020; }
 .Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
 .CommentedCode { color: #6c6c6c; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/082scenario_screen.cc.html b/html/082scenario_screen.cc.html
index 54d80832..a4daf46a 100644
--- a/html/082scenario_screen.cc.html
+++ b/html/082scenario_screen.cc.html
@@ -17,11 +17,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 .traceAbsent { color: #c00000; }
 .cSpecial { color: #008000; }
 .traceContains { color: #008000; }
+.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
 .Identifier { color: #fcb165; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -46,7 +48,7 @@ recipes_taking_literal_strings<span class="Delimiter">.</span>insert<span class=
 
 <span class="Delimiter">:(scenarios run_mu_scenario)</span>
 <span class="Delimiter">:(scenario screen_in_scenario)</span>
-scenario screen-in-scenario [
+<span class="muScenario">scenario</span> screen-in-scenario [
   local-scope
   assume-screen <span class="Constant">5</span>/width<span class="Delimiter">,</span> <span class="Constant">3</span>/height
   run [
@@ -63,7 +65,7 @@ scenario screen-in-scenario [
 <span class="Comment"># checks are inside scenario</span>
 
 <span class="Delimiter">:(scenario screen_in_scenario_unicode)</span>
-scenario screen-in-scenario-unicode-color [
+<span class="muScenario">scenario</span> screen-in-scenario-unicode-color [
   local-scope
   assume-screen <span class="Constant">5</span>/width<span class="Delimiter">,</span> <span class="Constant">3</span>/height
   run [
@@ -83,7 +85,7 @@ scenario screen-in-scenario-unicode-color [
 
 <span class="Delimiter">:(scenario screen_in_scenario_color)</span>
 <span class="Comment"># screen-should-contain can check unicode characters in the fake screen</span>
-scenario screen-in-scenario-color [
+<span class="muScenario">scenario</span> screen-in-scenario-color [
   local-scope
   assume-screen <span class="Constant">5</span>/width<span class="Delimiter">,</span> <span class="Constant">3</span>/height
   run [
@@ -120,7 +122,7 @@ scenario screen-in-scenario-color [
 <span class="Delimiter">:(scenario screen_in_scenario_error)</span>
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
-scenario screen-in-scenario-error [
+<span class="muScenario">scenario</span> screen-in-scenario-error [
   local-scope
   assume-screen <span class="Constant">5</span>/width<span class="Delimiter">,</span> <span class="Constant">3</span>/height
   run [
@@ -140,7 +142,7 @@ scenario screen-in-scenario-error [
 <span class="Special">% Scenario_testing_scenario = true;</span>
 <span class="Special">% Hide_errors = true;</span>
 <span class="Comment"># screen-should-contain can check unicode characters in the fake screen</span>
-scenario screen-in-scenario-color [
+<span class="muScenario">scenario</span> screen-in-scenario-color [
   local-scope
   assume-screen <span class="Constant">5</span>/width<span class="Delimiter">,</span> <span class="Constant">3</span>/height
   run [
@@ -159,7 +161,7 @@ scenario screen-in-scenario-color [
 <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>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Normal">screen</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:num
 ]
 <span class="traceAbsent">-error: mixing variable names and numeric addresses in main</span>
@@ -210,7 +212,7 @@ Name[r][<span class="Constant">&quot;screen&quot;</span>] = SCREEN<span class="D
 
 <span class="Delimiter">:(scenario assume_screen_shows_up_in_errors)</span>
 <span class="Special">% Hide_errors = true;</span>
-scenario error-in-assume-screen [
+<span class="muScenario">scenario</span> error-in-assume-screen [
   assume-screen width<span class="Delimiter">,</span> <span class="Constant">5</span>
 ]
 <span class="traceContains">+error: scenario_error-in-assume-screen: missing type for 'width' in 'assume-screen width, 5'</span>
diff --git a/html/083scenario_screen_test.mu.html b/html/083scenario_screen_test.mu.html
index 81fb48ec..26383209 100644
--- a/html/083scenario_screen_test.mu.html
+++ b/html/083scenario_screen_test.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/084console.mu.html b/html/084console.mu.html
index 221a3eb8..3af59b06 100644
--- a/html/084console.mu.html
+++ b/html/084console.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
+.muControl { color: #c0a020; }
 .Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -43,7 +43,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 ]
 
 <span class="muData">container</span> touch-event [
-  <span class="muData">type</span>:num
+  type:num
   row:num
   column:num
 ]
diff --git a/html/085scenario_console.cc.html b/html/085scenario_console.cc.html
index 85303787..b51a7422 100644
--- a/html/085scenario_console.cc.html
+++ b/html/085scenario_console.cc.html
@@ -15,6 +15,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
+.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
@@ -43,7 +44,7 @@ recipes_taking_literal_strings<span class="Delimiter">.</span>insert<span class=
 
 <span class="Delimiter">:(scenarios run_mu_scenario)</span>
 <span class="Delimiter">:(scenario keyboard_in_scenario)</span>
-scenario keyboard-in-scenario [
+<span class="muScenario">scenario</span> keyboard-in-scenario [
   assume-console [
     type [abc]
   ]
@@ -221,7 +222,7 @@ initialize_key_names<span class="Delimiter">();</span>
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario events_in_scenario)</span>
-scenario events-in-scenario [
+<span class="muScenario">scenario</span> events-in-scenario [
   assume-console [
     type [abc]
     left-click <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span>
diff --git a/html/086scenario_console_test.mu.html b/html/086scenario_console_test.mu.html
index a12c99ef..477eda9d 100644
--- a/html/086scenario_console_test.mu.html
+++ b/html/086scenario_console_test.mu.html
@@ -13,11 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
-.muData { color: #ffff00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -35,7 +34,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="muScenario">scenario</span> read-key-in-mu [
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[abc]</span>
+    type <span class="Constant">[abc]</span>
   ]
   run [
     <span class="Constant">1</span>:char, console:&amp;:console, <span class="Constant">2</span>:bool<span class="Special"> &lt;- </span>read-key console:&amp;:console
diff --git a/html/088file.mu.html b/html/088file.mu.html
index 091f18c4..ef8987a2 100644
--- a/html/088file.mu.html
+++ b/html/088file.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
+.muControl { color: #c0a020; }
 .Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/089scenario_filesystem.cc.html b/html/089scenario_filesystem.cc.html
index 2d13d5ca..2f10c895 100644
--- a/html/089scenario_filesystem.cc.html
+++ b/html/089scenario_filesystem.cc.html
@@ -15,6 +15,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
+.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
@@ -39,7 +40,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 
 <span class="Delimiter">:(scenarios run_mu_scenario)</span>
 <span class="Delimiter">:(scenario simple_filesystem)</span>
-scenario assume-filesystem [
+<span class="muScenario">scenario</span> assume-filesystem [
   local-scope
   assume-filesystem [
     <span class="Comment"># file 'a' containing two lines of data</span>
@@ -53,21 +54,21 @@ scenario assume-filesystem [
       |xyz|
     ]
   ]
-  <span class="Normal">data</span>:&amp;:@:file-mapping<span class="Special"> &lt;- </span>get *filesystem:&amp;:filesystem<span class="Delimiter">,</span> data:offset
+  <span class="Normal">data</span>:&amp;:@:file-mapping<span class="Special"> &lt;- </span>get *filesystem:&amp;:filesystem<span class="Delimiter">,</span> <span class="Constant">data:offset</span>
   <span class="Normal">file1</span>:file-mapping<span class="Special"> &lt;- </span>index *data<span class="Delimiter">,</span> <span class="Constant">0</span>
-  file1-name:text<span class="Special"> &lt;- </span>get file1<span class="Delimiter">,</span> name:offset
+  file1-name:text<span class="Special"> &lt;- </span>get file1<span class="Delimiter">,</span> <span class="Constant">name:offset</span>
   <span class="Constant">10</span>:@:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>copy *file1-name
-  file1-contents:text<span class="Special"> &lt;- </span>get file1<span class="Delimiter">,</span> contents:offset
+  file1-contents:text<span class="Special"> &lt;- </span>get file1<span class="Delimiter">,</span> <span class="Constant">contents:offset</span>
   <span class="Constant">100</span>:@:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>copy *file1-contents
   <span class="Normal">file2</span>:file-mapping<span class="Special"> &lt;- </span>index *data<span class="Delimiter">,</span> <span class="Constant">1</span>
-  file2-name:text<span class="Special"> &lt;- </span>get file2<span class="Delimiter">,</span> name:offset
+  file2-name:text<span class="Special"> &lt;- </span>get file2<span class="Delimiter">,</span> <span class="Constant">name:offset</span>
   <span class="Constant">30</span>:@:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>copy *file2-name
-  file2-contents:text<span class="Special"> &lt;- </span>get file2<span class="Delimiter">,</span> contents:offset
+  file2-contents:text<span class="Special"> &lt;- </span>get file2<span class="Delimiter">,</span> <span class="Constant">contents:offset</span>
   <span class="Constant">40</span>:@:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>copy *file2-contents
   <span class="Normal">file3</span>:file-mapping<span class="Special"> &lt;- </span>index *data<span class="Delimiter">,</span> <span class="Constant">2</span>
-  file3-name:text<span class="Special"> &lt;- </span>get file3<span class="Delimiter">,</span> name:offset
+  file3-name:text<span class="Special"> &lt;- </span>get file3<span class="Delimiter">,</span> <span class="Constant">name:offset</span>
   <span class="Constant">50</span>:@:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>copy *file3-name
-  file3-contents:text<span class="Special"> &lt;- </span>get file3<span class="Delimiter">,</span> contents:offset
+  file3-contents:text<span class="Special"> &lt;- </span>get file3<span class="Delimiter">,</span> <span class="Constant">contents:offset</span>
   <span class="Constant">60</span>:@:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>copy *file3-contents
   memory-should-contain [
     <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span>[a]
@@ -83,7 +84,7 @@ de f
 ]
 
 <span class="Delimiter">:(scenario escaping_file_contents)</span>
-scenario assume-filesystem [
+<span class="muScenario">scenario</span> assume-filesystem [
   local-scope
   assume-filesystem [
     <span class="Comment"># file 'a' containing a '|'</span>
@@ -92,11 +93,11 @@ scenario assume-filesystem [
       |x\\\\|yz|
     ]
   ]
-  <span class="Normal">data</span>:&amp;:@:file-mapping<span class="Special"> &lt;- </span>get *filesystem:&amp;:filesystem<span class="Delimiter">,</span> data:offset
+  <span class="Normal">data</span>:&amp;:@:file-mapping<span class="Special"> &lt;- </span>get *filesystem:&amp;:filesystem<span class="Delimiter">,</span> <span class="Constant">data:offset</span>
   <span class="Normal">file1</span>:file-mapping<span class="Special"> &lt;- </span>index *data<span class="Delimiter">,</span> <span class="Constant">0</span>
-  file1-name:text<span class="Special"> &lt;- </span>get file1<span class="Delimiter">,</span> name:offset
+  file1-name:text<span class="Special"> &lt;- </span>get file1<span class="Delimiter">,</span> <span class="Constant">name:offset</span>
   <span class="Constant">10</span>:@:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>copy *file1-name
-  file1-contents:text<span class="Special"> &lt;- </span>get file1<span class="Delimiter">,</span> contents:offset
+  file1-contents:text<span class="Special"> &lt;- </span>get file1<span class="Delimiter">,</span> <span class="Constant">contents:offset</span>
   <span class="Constant">20</span>:@:<span class="Normal">char</span>/<span class="Special">raw &lt;- </span>copy *file1-contents
   memory-should-contain [
     <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span>[a]
diff --git a/html/090scenario_filesystem_test.mu.html b/html/090scenario_filesystem_test.mu.html
index 0832ab96..361b71c2 100644
--- a/html/090scenario_filesystem_test.mu.html
+++ b/html/090scenario_filesystem_test.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
+.muControl { color: #c0a020; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/101run_sandboxed.cc.html b/html/101run_sandboxed.cc.html
index 563c6d3a..f2883e6f 100644
--- a/html/101run_sandboxed.cc.html
+++ b/html/101run_sandboxed.cc.html
@@ -15,13 +15,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 * { font-size: 12pt; font-size: 1em; }
 .Constant { color: #00a0a0; }
 .cSpecial { color: #008000; }
-.traceContains { color: #008000; }
+.CommentedCode { color: #6c6c6c; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #800080; }
 .Special { color: #c00000; }
-.Identifier { color: #fcb165; }
+.traceContains { color: #008000; }
 .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-.CommentedCode { color: #6c6c6c; }
+.Identifier { color: #fcb165; }
 -->
 </style>
 
@@ -37,7 +38,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Comment">//: return some result in string form.</span>
 
 <span class="Delimiter">:(scenario run_interactive_code)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>copy <span class="Constant">0</span>
   <span class="Constant">2</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [<span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>copy <span class="Constant">34</span>]
   run-sandboxed <span class="Constant">2</span>:text
@@ -46,7 +47,7 @@ def main [
 <span class="traceContains">+mem: storing 34 in location 3</span>
 
 <span class="Delimiter">:(scenario run_interactive_empty)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/unsafe
   <span class="Constant">2</span>:text<span class="Special"> &lt;- </span>run-sandboxed <span class="Constant">1</span>:text
 ]
@@ -253,7 +254,7 @@ load<span class="Delimiter">(</span>string<span class="Delimiter">(</span>
   <span class="Normal">if</span> <span class="Delimiter">(</span>s == <span class="Constant">&quot;interactive&quot;</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">&quot;&quot;</span><span class="Delimiter">;</span>
 
 <span class="Delimiter">:(scenario run_interactive_comments)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [<span class="Comment"># ab</span>
 add <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">2</span>]
   <span class="Constant">2</span>:text<span class="Special"> &lt;- </span>run-sandboxed <span class="Constant">1</span>:text
@@ -349,7 +350,7 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario &quot;run_interactive_converts_result_to_text&quot;)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># try to interactively add 2 and 2</span>
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [add <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">2</span>]
   <span class="Constant">2</span>:text<span class="Special"> &lt;- </span>run-sandboxed <span class="Constant">1</span>:text
@@ -359,7 +360,7 @@ def main [
 <span class="traceContains">+mem: storing 52 in location 11</span>
 
 <span class="Delimiter">:(scenario &quot;run_interactive_returns_text&quot;)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># try to interactively add 2 and 2</span>
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [
     <span class="Normal">x</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [a]
@@ -374,10 +375,10 @@ def main [
 <span class="traceContains">+mem: storing 98 in location 12</span>
 
 <span class="Delimiter">:(scenario &quot;run_interactive_returns_errors&quot;)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># run a command that generates an error</span>
   <span class="Constant">1</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [x:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
-get x:num<span class="Delimiter">,</span> foo:offset]
+get x:num<span class="Delimiter">,</span> <span class="Constant">foo:offset</span>]
   <span class="Constant">2</span>:text<span class="Delimiter">,</span> <span class="Constant">3</span>:text<span class="Special"> &lt;- </span>run-sandboxed <span class="Constant">1</span>:text
   <span class="Constant">10</span>:@:<span class="Normal">char</span><span class="Special"> &lt;- </span>copy <span class="Constant">3</span>:text/lookup
 ]
@@ -389,7 +390,7 @@ get x:num<span class="Delimiter">,</span> foo:offset]
 <span class="Comment"># ...</span>
 
 <span class="Delimiter">:(scenario run_interactive_with_comment)</span>
-def main [
+<span class="muRecipe">def</span> main [
   <span class="Comment"># 2 instructions, with a comment after the first</span>
   <span class="Constant">1</span>:&amp;:@:num<span class="Special"> &lt;- </span><span class="Normal">new</span> [a:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># abc</span>
 <span class="Normal">b</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
@@ -529,10 +530,10 @@ put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span
 <span class="Delimiter">}</span>
 
 <span class="Delimiter">:(scenario reload_continues_past_error)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">x</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [recipe foo [
-  get <span class="Constant">1234</span>:num<span class="Delimiter">,</span> foo:offset
+  get <span class="Constant">1234</span>:num<span class="Delimiter">,</span> <span class="Constant">foo:offset</span>
 ]]
   reload x
   <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>copy <span class="Constant">34</span>
@@ -541,7 +542,7 @@ def main [
 
 <span class="Delimiter">:(scenario reload_can_repeatedly_load_container_definitions)</span>
 <span class="Comment"># define a container and try to create it (merge requires knowing container size)</span>
-def main [
+<span class="muRecipe">def</span> main [
   local-scope
   <span class="Normal">x</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [
     container foo [
diff --git a/html/channel.mu.html b/html/channel.mu.html
index f03f05d2..0e0bdffb 100644
--- a/html/channel.mu.html
+++ b/html/channel.mu.html
@@ -13,12 +13,12 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/chessboard.mu.html b/html/chessboard.mu.html
index 8a382806..8e15aa53 100644
--- a/html/chessboard.mu.html
+++ b/html/chessboard.mu.html
@@ -13,16 +13,16 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
-.muScenario { color: #00af00; }
-.Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Special { color: #c00000; }
+.Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
 .CommentedCode { color: #6c6c6c; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -60,7 +60,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-screen <span class="Constant">120/width</span>, <span class="Constant">20/height</span>
   <span class="Comment"># initialize keyboard to type in a move</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[a2-a4</span>
+    type <span class="Constant">[a2-a4</span>
 <span class="Constant">]</span>
   ]
   run [
@@ -146,7 +146,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   correct-length?:boolean<span class="Special"> &lt;- </span>equal len, <span class="Constant">64</span>
   assert correct-length?, <span class="Constant">[chessboard had incorrect size]</span>
   <span class="Comment"># board is an array of pointers to files; file is an array of characters</span>
-  board<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(address array character): <span class="muData">type</span><span class="Delimiter">}</span>, <span class="Constant">8</span>
+  board<span class="Special"> &lt;- </span>new <span class="Delimiter">{</span>(address array character): type<span class="Delimiter">}</span>, <span class="Constant">8</span>
   col:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   <span class="Delimiter">{</span>
     done?:boolean<span class="Special"> &lt;- </span>equal col, <span class="Constant">8</span>
diff --git a/html/console.mu.html b/html/console.mu.html
index 3dcfef93..82b2d70f 100644
--- a/html/console.mu.html
+++ b/html/console.mu.html
@@ -13,12 +13,12 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/counters.mu.html b/html/counters.mu.html
index e1936ded..eab79e04 100644
--- a/html/counters.mu.html
+++ b/html/counters.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/display.mu.html b/html/display.mu.html
index 45db818f..75ccd75d 100644
--- a/html/display.mu.html
+++ b/html/display.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/edit/001-editor.mu.html b/html/edit/001-editor.mu.html
index 38865350..35adc47e 100644
--- a/html/edit/001-editor.mu.html
+++ b/html/edit/001-editor.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
-.muScenario { color: #00af00; }
-.Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Special { color: #c00000; }
+.Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/edit/002-typing.mu.html b/html/edit/002-typing.mu.html
index 3c35ec6f..e8d68e3f 100644
--- a/html/edit/002-typing.mu.html
+++ b/html/edit/002-typing.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
-.Special { color: #c00000; }
-.muScenario { color: #00af00; }
 .Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
+.Special { color: #c00000; }
+.muData { color: #ffff00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muData { color: #ffff00; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -481,7 +481,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   editor-render screen, e
 <span class="Constant">  $clear-trace</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[abc]</span>
+    type <span class="Constant">[abc]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -503,9 +503,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Constant">  $clear-trace</span>
   <span class="Comment"># type two letters at different places</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
     left-click <span class="Constant">1</span>, <span class="Constant">2</span>
-    <span class="muData">type</span> <span class="Constant">[d]</span>
+    type <span class="Constant">[d]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -527,7 +527,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Constant">  $clear-trace</span>
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">5</span>  <span class="Comment"># right of last line</span>
-    <span class="muData">type</span> <span class="Constant">[d]</span>
+    type <span class="Constant">[d]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -551,7 +551,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Constant">  $clear-trace</span>
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">5</span>  <span class="Comment"># right of non-last line</span>
-    <span class="muData">type</span> <span class="Constant">[e]</span>
+    type <span class="Constant">[e]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -574,7 +574,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Constant">  $clear-trace</span>
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">5</span>  <span class="Comment"># below all text</span>
-    <span class="muData">type</span> <span class="Constant">[d]</span>
+    type <span class="Constant">[d]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -598,7 +598,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Constant">  $clear-trace</span>
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">5</span>  <span class="Comment"># below all text</span>
-    <span class="muData">type</span> <span class="Constant">[e]</span>
+    type <span class="Constant">[e]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -623,7 +623,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Constant">  $clear-trace</span>
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">5</span>  <span class="Comment"># below all text</span>
-    <span class="muData">type</span> <span class="Constant">[ef]</span>
+    type <span class="Constant">[ef]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -644,7 +644,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[ab]</span>, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">5/right</span>
   editor-render screen, e
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[01]</span>
+    type <span class="Constant">[01]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -666,7 +666,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   editor-render screen, e
   <span class="Comment"># type a letter</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[e]</span>
+    type <span class="Constant">[e]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -681,7 +681,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># type a second letter</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[f]</span>
+    type <span class="Constant">[f]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -707,7 +707,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># type more text at the start</span>
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">0</span>
-    <span class="muData">type</span> <span class="Constant">[abc]</span>
+    type <span class="Constant">[abc]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -786,7 +786,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[abcde]</span>, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">5/right</span>
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">3</span>  <span class="Comment"># right before the wrap icon</span>
-    <span class="muData">type</span> <span class="Constant">[f]</span>
+    type <span class="Constant">[f]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -821,7 +821,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">4</span>  <span class="Comment"># at end of first line</span>
-    <span class="muData">type</span> <span class="Constant">[de]</span>  <span class="Comment"># trigger wrap</span>
+    type <span class="Constant">[de]</span>  <span class="Comment"># trigger wrap</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -841,7 +841,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[abcde]</span>, screen:&amp;:screen, <span class="Constant">2/left</span>, <span class="Constant">7/right</span>
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">5</span>  <span class="Comment"># line is full; no wrap icon yet</span>
-    <span class="muData">type</span> <span class="Constant">[01]</span>
+    type <span class="Constant">[01]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -876,7 +876,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-screen <span class="Constant">10/width</span>, <span class="Constant">5/height</span>
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[abc]</span>, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">10/right</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0</span>
+    type <span class="Constant">[0</span>
 <span class="Constant">1]</span>
   ]
   run [
@@ -982,7 +982,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-screen <span class="Constant">10/width</span>, <span class="Constant">5/height</span>
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[abc]</span>, screen:&amp;:screen, <span class="Constant">1/left</span>, <span class="Constant">10/right</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0</span>
+    type <span class="Constant">[0</span>
 <span class="Constant">1]</span>
   ]
   run [
@@ -1034,7 +1034,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># position cursor after 'cd' and hit 'newline'</span>
   assume-console [
     left-click <span class="Constant">2</span>, <span class="Constant">8</span>
-    <span class="muData">type</span> [
+    type [
 ]
   ]
   run [
diff --git a/html/edit/003-shortcuts.mu.html b/html/edit/003-shortcuts.mu.html
index e3085a78..f909a4c7 100644
--- a/html/edit/003-shortcuts.mu.html
+++ b/html/edit/003-shortcuts.mu.html
@@ -13,15 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
-.Special { color: #c00000; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
+.muControl { color: #c0a020; }
+.Special { color: #c00000; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muData { color: #ffff00; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -437,7 +436,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="Constant">  $clear-trace</span>
   assume-console [
     press right-arrow
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -547,7 +546,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   check-trace-count-for-label <span class="Constant">0</span>, <span class="Constant">[print-character]</span>
   <span class="Comment"># type something and ensure it goes where it should</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -574,7 +573,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     press right-arrow
     press right-arrow
     press right-arrow  <span class="Comment"># next line</span>
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -695,7 +694,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">3</span>
     press right-arrow
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -724,7 +723,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">2</span>
     press left-arrow
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -798,7 +797,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">0</span>
     press left-arrow
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -826,7 +825,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">0</span>
     press left-arrow
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -856,7 +855,7 @@ d]
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">0</span>
     press left-arrow
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -995,7 +994,7 @@ d]
   ]
   check-trace-count-for-label <span class="Constant">0</span>, <span class="Constant">[print-character]</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1112,7 +1111,7 @@ d]
   ]
   check-trace-count-for-label <span class="Constant">0</span>, <span class="Constant">[print-character]</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1149,7 +1148,7 @@ d]
   ]
   check-trace-count-for-label <span class="Constant">0</span>, <span class="Constant">[print-character]</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1189,7 +1188,7 @@ d]
   ]
   check-trace-count-for-label <span class="Constant">0</span>, <span class="Constant">[print-character]</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1229,7 +1228,7 @@ d]
   ]
   check-trace-count-for-label <span class="Constant">0</span>, <span class="Constant">[print-character]</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1334,7 +1333,7 @@ d]
   ]
   check-trace-count-for-label <span class="Constant">0</span>, <span class="Constant">[print-character]</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1531,7 +1530,7 @@ d]
   check-trace-count-for-label <span class="Constant">0</span>, <span class="Constant">[print-character]</span>
   <span class="Comment"># editor inserts future characters at cursor</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[z]</span>
+    type <span class="Constant">[z]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -2159,7 +2158,7 @@ d]
   <span class="Comment"># position cursor at end, type a character</span>
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">4</span>
-    <span class="muData">type</span> <span class="Constant">[g]</span>
+    type <span class="Constant">[g]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -2189,7 +2188,7 @@ d]
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor s, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">5/right</span>
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">4</span>
-    <span class="muData">type</span> [
+    type [
 ]
   ]
   run [
@@ -2299,7 +2298,7 @@ d]
     <span class="Constant">4</span><span class="Special"> &lt;- </span><span class="Constant">2</span>
   ]
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -2328,7 +2327,7 @@ d]
   ]
   check-trace-count-for-label <span class="Constant">0</span>, <span class="Constant">[print-character]</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
diff --git a/html/edit/004-programming-environment.mu.html b/html/edit/004-programming-environment.mu.html
index 5b97c018..6e6ba954 100644
--- a/html/edit/004-programming-environment.mu.html
+++ b/html/edit/004-programming-environment.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
+.muData { color: #ffff00; }
+.muControl { color: #c0a020; }
 .Special { color: #c00000; }
-.muScenario { color: #00af00; }
 .Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muData { color: #ffff00; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -118,7 +118,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
       <span class="muControl">break-unless</span> is-touch?
       <span class="Comment"># ignore all but 'left-click' events for now</span>
       <span class="Comment"># todo: test this</span>
-      touch-type:num<span class="Special"> &lt;- </span>get t, <span class="muData">type</span>:offset
+      touch-type:num<span class="Special"> &lt;- </span>get t, <span class="Constant">type:offset</span>
       is-left-click?:bool<span class="Special"> &lt;- </span>equal touch-type, <span class="Constant">65513/mouse-left</span>
       <span class="muControl">loop-unless</span> is-left-click?, <span class="Constant">+next-event:label</span>
       click-row:num<span class="Special"> &lt;- </span>get t, <span class="Constant">row:offset</span>
@@ -362,9 +362,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># type one letter in each of them</span>
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">1</span>
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
     left-click <span class="Constant">1</span>, <span class="Constant">17</span>
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     event-loop screen:&amp;:screen, console:&amp;:console, env
@@ -436,7 +436,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># now try typing a letter</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[z]</span>
+    type <span class="Constant">[z]</span>
   ]
   run [
     event-loop screen:&amp;:screen, console:&amp;:console, env
@@ -487,7 +487,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
 ]
 
-<span class="muRecipe">def</span> render-all screen:&amp;:screen, env:&amp;:environment, <span class="Delimiter">{</span>render-editor: (<span class="muRecipe">recipe</span> (address screen) (address editor)<span class="muRecipe"> -&gt; </span>number number (address screen) (address editor))<span class="Delimiter">}</span><span class="muRecipe"> -&gt; </span>screen:&amp;:screen, env:&amp;:environment [
+<span class="muRecipe">def</span> render-all screen:&amp;:screen, env:&amp;:environment, <span class="Delimiter">{</span>render-editor: (recipe (address screen) (address editor)<span class="muRecipe"> -&gt; </span>number number (address screen) (address editor))<span class="Delimiter">}</span><span class="muRecipe"> -&gt; </span>screen:&amp;:screen, env:&amp;:environment [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
   trace <span class="Constant">10</span>, <span class="Constant">[app]</span>, <span class="Constant">[render all]</span>
@@ -519,7 +519,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   show-screen screen
 ]
 
-<span class="muRecipe">def</span> render-recipes screen:&amp;:screen, env:&amp;:environment, <span class="Delimiter">{</span>render-editor: (<span class="muRecipe">recipe</span> (address screen) (address editor)<span class="muRecipe"> -&gt; </span>number number (address screen) (address editor))<span class="Delimiter">}</span><span class="muRecipe"> -&gt; </span>screen:&amp;:screen, env:&amp;:environment [
+<span class="muRecipe">def</span> render-recipes screen:&amp;:screen, env:&amp;:environment, <span class="Delimiter">{</span>render-editor: (recipe (address screen) (address editor)<span class="muRecipe"> -&gt; </span>number number (address screen) (address editor))<span class="Delimiter">}</span><span class="muRecipe"> -&gt; </span>screen:&amp;:screen, env:&amp;:environment [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
   trace <span class="Constant">11</span>, <span class="Constant">[app]</span>, <span class="Constant">[render recipes]</span>
@@ -538,7 +538,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 ]
 
 <span class="Comment"># replaced in a later layer</span>
-<span class="muRecipe">def</span> render-sandbox-side screen:&amp;:screen, env:&amp;:environment, <span class="Delimiter">{</span>render-editor: (<span class="muRecipe">recipe</span> (address screen) (address editor)<span class="muRecipe"> -&gt; </span>number number (address screen) (address editor))<span class="Delimiter">}</span><span class="muRecipe"> -&gt; </span>screen:&amp;:screen, env:&amp;:environment [
+<span class="muRecipe">def</span> render-sandbox-side screen:&amp;:screen, env:&amp;:environment, <span class="Delimiter">{</span>render-editor: (recipe (address screen) (address editor)<span class="muRecipe"> -&gt; </span>number number (address screen) (address editor))<span class="Delimiter">}</span><span class="muRecipe"> -&gt; </span>screen:&amp;:screen, env:&amp;:environment [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
   current-sandbox:&amp;:editor<span class="Special"> &lt;- </span>get *env, <span class="Constant">current-sandbox:offset</span>
diff --git a/html/edit/005-sandbox.mu.html b/html/edit/005-sandbox.mu.html
index 5afc8a83..8f328e91 100644
--- a/html/edit/005-sandbox.mu.html
+++ b/html/edit/005-sandbox.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
+.muData { color: #ffff00; }
+.muControl { color: #c0a020; }
 .Special { color: #c00000; }
-.muScenario { color: #00af00; }
 .Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muData { color: #ffff00; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -134,7 +134,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># run another command</span>
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">80</span>
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
   ]
   run [
@@ -268,7 +268,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Delimiter">}</span>
 ]
 
-<span class="muRecipe">def!</span> render-sandbox-side screen:&amp;:screen, env:&amp;:environment, <span class="Delimiter">{</span>render-editor: (<span class="muRecipe">recipe</span> (address screen) (address editor)<span class="muRecipe"> -&gt; </span>number number (address screen) (address editor))<span class="Delimiter">}</span><span class="muRecipe"> -&gt; </span>screen:&amp;:screen, env:&amp;:environment [
+<span class="muRecipe">def!</span> render-sandbox-side screen:&amp;:screen, env:&amp;:environment, <span class="Delimiter">{</span>render-editor: (recipe (address screen) (address editor)<span class="muRecipe"> -&gt; </span>number number (address screen) (address editor))<span class="Delimiter">}</span><span class="muRecipe"> -&gt; </span>screen:&amp;:screen, env:&amp;:environment [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
   trace <span class="Constant">11</span>, <span class="Constant">[app]</span>, <span class="Constant">[render sandbox side]</span>
@@ -582,7 +582,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-console [
     left-click <span class="Constant">4</span>, <span class="Constant">28</span>  <span class="Comment"># one past the value of the second arg</span>
     press backspace
-    <span class="muData">type</span> <span class="Constant">[3]</span>
+    type <span class="Constant">[3]</span>
     press F4
   ]
   run [
@@ -659,7 +659,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[abc]</span>, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">10/right</span>
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">2</span>
-    <span class="muData">type</span> <span class="Constant">[def]</span>
+    type <span class="Constant">[def]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1002,9 +1002,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># create 2 sandboxes</span>
   assume-console [
     press ctrl-n
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
-    <span class="muData">type</span> <span class="Constant">[add 1, 1]</span>
+    type <span class="Constant">[add 1, 1]</span>
     press F4
   ]
   event-loop screen:&amp;:screen, console:&amp;:console, env
@@ -1153,7 +1153,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># create a sandbox</span>
   assume-console [
     press ctrl-n
-    <span class="muData">type</span> <span class="Constant">[add 1, 1]</span>
+    type <span class="Constant">[add 1, 1]</span>
     press F4
   ]
   event-loop screen:&amp;:screen, console:&amp;:console, env
diff --git a/html/edit/006-sandbox-copy.mu.html b/html/edit/006-sandbox-copy.mu.html
index 4ed88981..c7f0d656 100644
--- a/html/edit/006-sandbox-copy.mu.html
+++ b/html/edit/006-sandbox-copy.mu.html
@@ -13,15 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
-.Special { color: #c00000; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
+.muControl { color: #c0a020; }
+.Special { color: #c00000; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muData { color: #ffff00; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -81,7 +80,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     event-loop screen:&amp;:screen, console:&amp;:console, env
@@ -143,7 +142,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     event-loop screen:&amp;:screen, console:&amp;:console, env
@@ -283,7 +282,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># type something into the sandbox editor, then click on the 'copy' button</span>
   assume-console [
     left-click <span class="Constant">2</span>, <span class="Constant">70</span>  <span class="Comment"># put cursor in sandbox editor</span>
-    <span class="muData">type</span> <span class="Constant">[0]</span>  <span class="Comment"># type something</span>
+    type <span class="Constant">[0]</span>  <span class="Comment"># type something</span>
     left-click <span class="Constant">3</span>, <span class="Constant">70</span>  <span class="Comment"># click 'copy' button</span>
   ]
   run [
@@ -302,7 +301,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     event-loop screen:&amp;:screen, console:&amp;:console, env
diff --git a/html/edit/007-sandbox-delete.mu.html b/html/edit/007-sandbox-delete.mu.html
index 931df954..285e063e 100644
--- a/html/edit/007-sandbox-delete.mu.html
+++ b/html/edit/007-sandbox-delete.mu.html
@@ -13,15 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
-.Special { color: #c00000; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
+.muControl { color: #c0a020; }
+.Special { color: #c00000; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muData { color: #ffff00; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -43,9 +42,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># run a few commands</span>
   assume-console [
     left-click <span class="Constant">1</span>, <span class="Constant">80</span>
-    <span class="muData">type</span> <span class="Constant">[divide-with-remainder 11, 3]</span>
+    type <span class="Constant">[divide-with-remainder 11, 3]</span>
     press F4
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
   ]
   event-loop screen:&amp;:screen, console:&amp;:console, env
@@ -191,9 +190,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># create 2 sandboxes and scroll to second</span>
   assume-console [
     press ctrl-n
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
-    <span class="muData">type</span> <span class="Constant">[add 1, 1]</span>
+    type <span class="Constant">[add 1, 1]</span>
     press F4
     press page-down
   ]
@@ -236,9 +235,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># create 2 sandboxes and scroll to second</span>
   assume-console [
     press ctrl-n
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
-    <span class="muData">type</span> <span class="Constant">[add 1, 1]</span>
+    type <span class="Constant">[add 1, 1]</span>
     press F4
     press page-down
   ]
@@ -281,9 +280,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># create 2 sandboxes and scroll to second</span>
   assume-console [
     press ctrl-n
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
-    <span class="muData">type</span> <span class="Constant">[add 1, 1]</span>
+    type <span class="Constant">[add 1, 1]</span>
     press F4
     press page-down
     press page-down
@@ -328,9 +327,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># create 2 sandboxes</span>
   assume-console [
     press ctrl-n
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
-    <span class="muData">type</span> <span class="Constant">[add 1, 1]</span>
+    type <span class="Constant">[add 1, 1]</span>
     press F4
   ]
   event-loop screen:&amp;:screen, console:&amp;:console, env
diff --git a/html/edit/008-sandbox-edit.mu.html b/html/edit/008-sandbox-edit.mu.html
index 9be5a9a1..b3f3751a 100644
--- a/html/edit/008-sandbox-edit.mu.html
+++ b/html/edit/008-sandbox-edit.mu.html
@@ -13,15 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
-.Special { color: #c00000; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
+.muControl { color: #c0a020; }
+.Special { color: #c00000; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muData { color: #ffff00; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -79,7 +78,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     event-loop screen:&amp;:screen, console:&amp;:console, env
@@ -139,7 +138,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   run [
     event-loop screen:&amp;:screen, console:&amp;:console, env
@@ -261,9 +260,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># create 2 sandboxes and scroll to second</span>
   assume-console [
     press ctrl-n
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
-    <span class="muData">type</span> <span class="Constant">[add 1, 1]</span>
+    type <span class="Constant">[add 1, 1]</span>
     press F4
     press page-down
     press page-down
@@ -308,9 +307,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># create 2 sandboxes</span>
   assume-console [
     press ctrl-n
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
-    <span class="muData">type</span> <span class="Constant">[add 1, 1]</span>
+    type <span class="Constant">[add 1, 1]</span>
     press F4
   ]
   event-loop screen:&amp;:screen, console:&amp;:console, env
diff --git a/html/edit/009-sandbox-test.mu.html b/html/edit/009-sandbox-test.mu.html
index b9095f7e..a2124cd4 100644
--- a/html/edit/009-sandbox-test.mu.html
+++ b/html/edit/009-sandbox-test.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
+.muData { color: #ffff00; }
+.muControl { color: #c0a020; }
 .Special { color: #c00000; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muData { color: #ffff00; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -100,7 +100,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">11</span>  <span class="Comment"># cursor to end of line</span>
     press backspace
-    <span class="muData">type</span> <span class="Constant">[3]</span>
+    type <span class="Constant">[3]</span>
     press F4
   ]
   run [
diff --git a/html/edit/010-sandbox-trace.mu.html b/html/edit/010-sandbox-trace.mu.html
index 0bff823b..599f69b3 100644
--- a/html/edit/010-sandbox-trace.mu.html
+++ b/html/edit/010-sandbox-trace.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
+.muData { color: #ffff00; }
+.muControl { color: #c0a020; }
 .Special { color: #c00000; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muData { color: #ffff00; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/edit/011-errors.mu.html b/html/edit/011-errors.mu.html
index d9228d0e..be2a087f 100644
--- a/html/edit/011-errors.mu.html
+++ b/html/edit/011-errors.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
-.muScenario { color: #00af00; }
-.Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Special { color: #c00000; }
+.Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -197,10 +197,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">80</span>
     <span class="Comment"># create invalid sandbox 1</span>
-    <span class="muData">type</span> <span class="Constant">[get foo, x:offset]</span>
+    type <span class="Constant">[get foo, x:offset]</span>
     press F4
     <span class="Comment"># create invalid sandbox 0</span>
-    <span class="muData">type</span> <span class="Constant">[get foo, x:offset]</span>
+    type <span class="Constant">[get foo, x:offset]</span>
     press F4
   ]
   run [
@@ -220,13 +220,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">80</span>
     <span class="Comment"># create invalid sandbox 2</span>
-    <span class="muData">type</span> <span class="Constant">[get foo, x:offset]</span>
+    type <span class="Constant">[get foo, x:offset]</span>
     press F4
     <span class="Comment"># create invalid sandbox 1</span>
-    <span class="muData">type</span> <span class="Constant">[get foo, x:offset]</span>
+    type <span class="Constant">[get foo, x:offset]</span>
     press F4
     <span class="Comment"># create valid sandbox 0</span>
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>
+    type <span class="Constant">[add 2, 2]</span>
     press F4
   ]
   run [
@@ -252,7 +252,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   assume-console [
     left-click <span class="Constant">3</span>, <span class="Constant">58</span>
     press ctrl-k
-    <span class="muData">type</span> <span class="Constant">[add 2, 2]</span>  <span class="Comment"># valid code</span>
+    type <span class="Constant">[add 2, 2]</span>  <span class="Comment"># valid code</span>
     press F4  <span class="Comment"># update sandbox</span>
   ]
   run [
diff --git a/html/edit/012-editor-undo.mu.html b/html/edit/012-editor-undo.mu.html
index be0db050..38ab0f2d 100644
--- a/html/edit/012-editor-undo.mu.html
+++ b/html/edit/012-editor-undo.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
-.muScenario { color: #00af00; }
-.Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Special { color: #c00000; }
+.Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -140,7 +140,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[]</span>, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">10/right</span>
   editor-render screen, e
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   editor-event-loop screen:&amp;:screen, console:&amp;:console, e
   <span class="Comment"># undo</span>
@@ -159,7 +159,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -203,7 +203,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   insert-from:&amp;:duplex-list:char<span class="Special"> &lt;- </span>next cursor-before
   insert-to:&amp;:duplex-list:char<span class="Special"> &lt;- </span>next insert-from
   op:&amp;:operation<span class="Special"> &lt;- </span>new <span class="Constant">operation:type</span>
-  *op<span class="Special"> &lt;- </span>merge <span class="Constant">0/insert-operation</span>, save-row/<span class="muRecipe">before</span>, save-column/<span class="muRecipe">before</span>, top-before, cursor-row/<span class="muRecipe">after</span>, cursor-column/<span class="muRecipe">after</span>, top-after, insert-from, insert-to, <span class="Constant">1/coalesce</span>
+  *op<span class="Special"> &lt;- </span>merge <span class="Constant">0/insert-operation</span>, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, insert-from, insert-to, <span class="Constant">1/coalesce</span>
   editor<span class="Special"> &lt;- </span>add-operation editor, op
 <span class="Constant">  +done-adding-insert-operation</span>
 ]
@@ -224,7 +224,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   before-cursor:&amp;:duplex-list:char<span class="Special"> &lt;- </span>get *editor, <span class="Constant">before-cursor:offset</span>
   insert-to:&amp;:duplex-list:char<span class="Special"> &lt;- </span>next before-cursor
   op:&amp;:operation<span class="Special"> &lt;- </span>new <span class="Constant">operation:type</span>
-  *op<span class="Special"> &lt;- </span>merge <span class="Constant">0/insert-operation</span>, cursor-row-before, cursor-column-before, top-before, cursor-row/<span class="muRecipe">after</span>, cursor-column/<span class="muRecipe">after</span>, top-after, insert-from, insert-to, <span class="Constant">0/never-coalesce</span>
+  *op<span class="Special"> &lt;- </span>merge <span class="Constant">0/insert-operation</span>, cursor-row-before, cursor-column-before, top-before, cursor-row/after, cursor-column/after, top-after, insert-from, insert-to, <span class="Constant">0/never-coalesce</span>
   editor<span class="Special"> &lt;- </span>add-operation editor, op
 ]
 
@@ -270,7 +270,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[]</span>, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">10/right</span>
   editor-render screen, e
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[012]</span>
+    type <span class="Constant">[012]</span>
   ]
   editor-event-loop screen:&amp;:screen, console:&amp;:console, e
   <span class="Comment"># undo</span>
@@ -297,7 +297,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   editor-render screen, e
   <span class="Comment"># type some characters</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[012]</span>
+    type <span class="Constant">[012]</span>
   ]
   editor-event-loop screen:&amp;:screen, console:&amp;:console, e
   screen-should-contain [
@@ -322,7 +322,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[3]</span>
+    type <span class="Constant">[3]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -383,7 +383,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be at end of line</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -405,7 +405,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[a]</span>, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">10/right</span>
   editor-render screen, e
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[012]</span>
+    type <span class="Constant">[012]</span>
     press ctrl-z
   ]
   editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -431,7 +431,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[3]</span>
+    type <span class="Constant">[3]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -469,7 +469,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[]</span>, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">10/right</span>
   editor-render screen, e
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[012]</span>
+    type <span class="Constant">[012]</span>
     press ctrl-z
   ]
   editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -495,7 +495,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[3]</span>
+    type <span class="Constant">[3]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -518,13 +518,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor contents, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">10/right</span>
   editor-render screen, e
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
     press ctrl-z
   ]
   editor-event-loop screen:&amp;:screen, console:&amp;:console, e
   <span class="Comment"># do some more work</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[0]</span>
+    type <span class="Constant">[0]</span>
   ]
   editor-event-loop screen:&amp;:screen, console:&amp;:console, e
   screen-should-contain [
@@ -560,12 +560,12 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Comment"># insert some text and tabs, hit enter, some more text and tabs</span>
   assume-console [
     press tab
-    <span class="muData">type</span> <span class="Constant">[ab]</span>
+    type <span class="Constant">[ab]</span>
     press tab
-    <span class="muData">type</span> <span class="Constant">[cd]</span>
+    type <span class="Constant">[cd]</span>
     press enter
     press tab
-    <span class="muData">type</span> <span class="Constant">[efg]</span>
+    type <span class="Constant">[efg]</span>
   ]
   editor-event-loop screen:&amp;:screen, console:&amp;:console, e
   screen-should-contain [
@@ -738,7 +738,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -780,7 +780,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="muControl">break</span> <span class="Constant">+done-adding-move-operation:label</span>
   <span class="Delimiter">}</span>
   op:&amp;:operation<span class="Special"> &lt;- </span>new <span class="Constant">operation:type</span>
-  *op<span class="Special"> &lt;- </span>merge <span class="Constant">1/move-operation</span>, cursor-row-before, cursor-column-before, top-before, cursor-row/<span class="muRecipe">after</span>, cursor-column/<span class="muRecipe">after</span>, top-after, undo-coalesce-tag
+  *op<span class="Special"> &lt;- </span>merge <span class="Constant">1/move-operation</span>, cursor-row-before, cursor-column-before, top-before, cursor-row/after, cursor-column/after, top-after, undo-coalesce-tag
   editor<span class="Special"> &lt;- </span>add-operation editor, op
 <span class="Constant">  +done-adding-move-operation</span>
 ]
@@ -850,7 +850,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -894,7 +894,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -945,7 +945,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -990,7 +990,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1173,7 +1173,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1218,7 +1218,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1263,7 +1263,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1308,7 +1308,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1407,7 +1407,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -1442,9 +1442,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   e:&amp;:editor<span class="Special"> &lt;- </span>new-editor <span class="Constant">[]</span>, screen:&amp;:screen, <span class="Constant">0/left</span>, <span class="Constant">10/right</span>
   editor-render screen, e
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[abc]</span>
+    type <span class="Constant">[abc]</span>
     left-click <span class="Constant">1</span>, <span class="Constant">1</span>
-    <span class="muData">type</span> <span class="Constant">[d]</span>
+    type <span class="Constant">[d]</span>
   ]
   editor-event-loop screen:&amp;:screen, console:&amp;:console, e
   <span class="Constant">3</span>:num/<span class="Special">raw &lt;- </span>get *e, <span class="Constant">cursor-row:offset</span>
@@ -1592,7 +1592,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   editor-render screen, e
   <span class="Comment"># insert some text and hit backspace</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[abc]</span>
+    type <span class="Constant">[abc]</span>
     press backspace
     press backspace
   ]
@@ -1683,7 +1683,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Comment"># if not, create a new operation</span>
     op:&amp;:operation<span class="Special"> &lt;- </span>new <span class="Constant">operation:type</span>
     deleted-until:&amp;:duplex-list:char<span class="Special"> &lt;- </span>next before-cursor
-    *op<span class="Special"> &lt;- </span>merge <span class="Constant">2/delete-operation</span>, save-row/<span class="muRecipe">before</span>, save-column/<span class="muRecipe">before</span>, top-before, cursor-row/<span class="muRecipe">after</span>, cursor-column/<span class="muRecipe">after</span>, top-after, backspaced-cell/deleted, before-cursor/delete-from, deleted-until, <span class="Constant">1/coalesce-backspace</span>
+    *op<span class="Special"> &lt;- </span>merge <span class="Constant">2/delete-operation</span>, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, backspaced-cell/deleted, before-cursor/delete-from, deleted-until, <span class="Constant">1/coalesce-backspace</span>
     editor<span class="Special"> &lt;- </span>add-operation editor, op
 <span class="Constant">    +done-adding-backspace-operation</span>
   <span class="Delimiter">}</span>
@@ -1737,7 +1737,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   editor-render screen, e
   <span class="Comment"># insert some text and hit delete and backspace a few times</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[abcdef]</span>
+    type <span class="Constant">[abcdef]</span>
     left-click <span class="Constant">1</span>, <span class="Constant">2</span>
     press delete
     press backspace
@@ -1910,7 +1910,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Comment"># if not, create a new operation</span>
     op:&amp;:operation<span class="Special"> &lt;- </span>new <span class="Constant">operation:type</span>
     deleted-until:&amp;:duplex-list:char<span class="Special"> &lt;- </span>next before-cursor
-    *op<span class="Special"> &lt;- </span>merge <span class="Constant">2/delete-operation</span>, save-row/<span class="muRecipe">before</span>, save-column/<span class="muRecipe">before</span>, top-before, cursor-row/<span class="muRecipe">after</span>, cursor-column/<span class="muRecipe">after</span>, top-after, deleted-cell/deleted, before-cursor/delete-from, deleted-until, <span class="Constant">2/coalesce-delete</span>
+    *op<span class="Special"> &lt;- </span>merge <span class="Constant">2/delete-operation</span>, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, deleted-cell/deleted, before-cursor/delete-from, deleted-until, <span class="Constant">2/coalesce-delete</span>
     editor<span class="Special"> &lt;- </span>add-operation editor, op
 <span class="Constant">    +done-adding-delete-operation</span>
   <span class="Delimiter">}</span>
@@ -1988,7 +1988,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -2013,7 +2013,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     cursor-column:num<span class="Special"> &lt;- </span>get *editor, <span class="Constant">cursor-column:offset</span>
     deleted-until:&amp;:duplex-list:char<span class="Special"> &lt;- </span>next before-cursor
     op:&amp;:operation<span class="Special"> &lt;- </span>new <span class="Constant">operation:type</span>
-    *op<span class="Special"> &lt;- </span>merge <span class="Constant">2/delete-operation</span>, save-row/<span class="muRecipe">before</span>, save-column/<span class="muRecipe">before</span>, top-before, cursor-row/<span class="muRecipe">after</span>, cursor-column/<span class="muRecipe">after</span>, top-after, deleted-cells/deleted, before-cursor/delete-from, deleted-until, <span class="Constant">0/never-coalesce</span>
+    *op<span class="Special"> &lt;- </span>merge <span class="Constant">2/delete-operation</span>, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, deleted-cells/deleted, before-cursor/delete-from, deleted-until, <span class="Constant">0/never-coalesce</span>
     editor<span class="Special"> &lt;- </span>add-operation editor, op
 <span class="Constant">    +done-adding-delete-operation</span>
   <span class="Delimiter">}</span>
@@ -2091,7 +2091,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   ]
   <span class="Comment"># cursor should be in the right place</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[1]</span>
+    type <span class="Constant">[1]</span>
   ]
   run [
     editor-event-loop screen:&amp;:screen, console:&amp;:console, e
@@ -2117,7 +2117,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     deleted-until:&amp;:duplex-list:char<span class="Special"> &lt;- </span>next before-cursor
     cursor-row:num<span class="Special"> &lt;- </span>get *editor, <span class="Constant">cursor-row:offset</span>
     cursor-column:num<span class="Special"> &lt;- </span>get *editor, <span class="Constant">cursor-column:offset</span>
-    *op<span class="Special"> &lt;- </span>merge <span class="Constant">2/delete-operation</span>, save-row/<span class="muRecipe">before</span>, save-column/<span class="muRecipe">before</span>, top-before, cursor-row/<span class="muRecipe">after</span>, cursor-column/<span class="muRecipe">after</span>, top-after, deleted-cells/deleted, before-cursor/delete-from, deleted-until, <span class="Constant">0/never-coalesce</span>
+    *op<span class="Special"> &lt;- </span>merge <span class="Constant">2/delete-operation</span>, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, deleted-cells/deleted, before-cursor/delete-from, deleted-until, <span class="Constant">0/never-coalesce</span>
     editor<span class="Special"> &lt;- </span>add-operation editor, op
 <span class="Constant">    +done-adding-delete-operation</span>
   <span class="Delimiter">}</span>
@@ -2131,7 +2131,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   editor-render screen, e
   <span class="Comment"># insert some text and hit delete and backspace a few times</span>
   assume-console [
-    <span class="muData">type</span> <span class="Constant">[abc]</span>
+    type <span class="Constant">[abc]</span>
     press ctrl-u
     press ctrl-z
   ]
diff --git a/html/example1.mu.html b/html/example1.mu.html
index 66a965cd..3d4d40eb 100644
--- a/html/example1.mu.html
+++ b/html/example1.mu.html
@@ -13,9 +13,9 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/factorial.mu.html b/html/factorial.mu.html
index ccd47c99..43fcad16 100644
--- a/html/factorial.mu.html
+++ b/html/factorial.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
-.muScenario { color: #00af00; }
 .Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
diff --git a/html/filesystem.mu.html b/html/filesystem.mu.html
index fbc5cd20..aaa31fe0 100644
--- a/html/filesystem.mu.html
+++ b/html/filesystem.mu.html
@@ -13,12 +13,12 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/fork.mu.html b/html/fork.mu.html
index 3f847dc3..b1565526 100644
--- a/html/fork.mu.html
+++ b/html/fork.mu.html
@@ -13,11 +13,11 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
-.Comment { color: #9090ff; }
-.Delimiter { color: #800080; }
 .Constant { color: #00a0a0; }
 .muControl { color: #c0a020; }
+.Comment { color: #9090ff; }
+.Delimiter { color: #800080; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/global.mu.html b/html/global.mu.html
index e70038c7..32e227e0 100644
--- a/html/global.mu.html
+++ b/html/global.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/immutable-error.mu.html b/html/immutable-error.mu.html
index 0a757e21..93afe020 100644
--- a/html/immutable-error.mu.html
+++ b/html/immutable-error.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/lambda-to-mu.mu.html b/html/lambda-to-mu.mu.html
index 5383acd5..e591592b 100644
--- a/html/lambda-to-mu.mu.html
+++ b/html/lambda-to-mu.mu.html
@@ -13,16 +13,16 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muScenario { color: #00af00; }
 .muData { color: #ffff00; }
+.muControl { color: #c0a020; }
 .Delimiter { color: #800080; }
-.muRecipe { color: #ff8700; }
 .Special { color: #c00000; }
 .Constant { color: #00a0a0; }
 .SalientComment { color: #00ffff; }
 .CommentedCode { color: #6c6c6c; }
 .Comment { color: #9090ff; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
+.muScenario { color: #00af00; }
 -->
 </style>
 
@@ -378,7 +378,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[(abc def)]</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>parse s
   trace-should-contain [
-    app/parse: &lt; abc | &lt; <span class="muRecipe">def</span> | <span class="Constant">&lt;&gt;</span> &gt; &gt;
+    app/parse: &lt; abc | &lt; def | <span class="Constant">&lt;&gt;</span> &gt; &gt;
   ]
   <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
@@ -406,7 +406,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[ ( abc  def ) ]</span>  <span class="Comment"># extra spaces</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>parse s
   trace-should-contain [
-    app/parse: &lt; abc | &lt; <span class="muRecipe">def</span> | <span class="Constant">&lt;&gt;</span> &gt; &gt;
+    app/parse: &lt; abc | &lt; def | <span class="Constant">&lt;&gt;</span> &gt; &gt;
   ]
   <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
@@ -434,7 +434,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[(abc def ghi)]</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>parse s
   trace-should-contain [
-    app/parse: &lt; abc | &lt; <span class="muRecipe">def</span> | &lt; ghi | <span class="Constant">&lt;&gt;</span> &gt; &gt; &gt;
+    app/parse: &lt; abc | &lt; def | &lt; ghi | <span class="Constant">&lt;&gt;</span> &gt; &gt; &gt;
   ]
   <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
@@ -495,7 +495,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[((abc) def)]</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>parse s
   trace-should-contain [
-    app/parse: &lt; &lt; abc | <span class="Constant">&lt;&gt;</span> &gt; | &lt; <span class="muRecipe">def</span> | <span class="Constant">&lt;&gt;</span> &gt; &gt;
+    app/parse: &lt; &lt; abc | <span class="Constant">&lt;&gt;</span> &gt; | &lt; def | <span class="Constant">&lt;&gt;</span> &gt; &gt;
   ]
   <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
@@ -550,7 +550,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[(abc . def)]</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>parse s
   trace-should-contain [
-    app/parse: &lt; abc | <span class="muRecipe">def</span> &gt;
+    app/parse: &lt; abc | def &gt;
   ]
   <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
@@ -574,7 +574,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[(abc def . ghi)]</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>parse s
   trace-should-contain [
-    app/parse: &lt; abc | &lt; <span class="muRecipe">def</span> | ghi &gt; &gt;
+    app/parse: &lt; abc | &lt; def | ghi &gt; &gt;
   ]
   <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
diff --git a/html/mutable.mu.html b/html/mutable.mu.html
index f8557ee0..82c7ae10 100644
--- a/html/mutable.mu.html
+++ b/html/mutable.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/nqueens.mu.html b/html/nqueens.mu.html
index b05a8618..979690cb 100644
--- a/html/nqueens.mu.html
+++ b/html/nqueens.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .muData { color: #ffff00; }
+.muControl { color: #c0a020; }
 .Delimiter { color: #800080; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/real-files.mu.html b/html/real-files.mu.html
index 3ef5bc3c..c65a88a5 100644
--- a/html/real-files.mu.html
+++ b/html/real-files.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/screen.mu.html b/html/screen.mu.html
index 8ad9d732..5e8d25ca 100644
--- a/html/screen.mu.html
+++ b/html/screen.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/server-socket.mu.html b/html/server-socket.mu.html
index 5bb09e1f..18ce36d6 100644
--- a/html/server-socket.mu.html
+++ b/html/server-socket.mu.html
@@ -13,12 +13,12 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/static-dispatch.mu.html b/html/static-dispatch.mu.html
index 466fbf50..2797735b 100644
--- a/html/static-dispatch.mu.html
+++ b/html/static-dispatch.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/tangle.mu.html b/html/tangle.mu.html
index fb077e0b..86d824dc 100644
--- a/html/tangle.mu.html
+++ b/html/tangle.mu.html
@@ -13,12 +13,12 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Delimiter { color: #800080; }
+.muControl { color: #c0a020; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
-.muControl { color: #c0a020; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/x.mu.html b/html/x.mu.html
index c424087b..2e5b580e 100644
--- a/html/x.mu.html
+++ b/html/x.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 12pt; font-size: 1em; }
-.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #c00000; }
+.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/mu.vim b/mu.vim
index f74b1c72..9d0ce033 100644
--- a/mu.vim
+++ b/mu.vim
@@ -41,17 +41,15 @@ syntax region muScreen start=+ \.+ end=+\.$\|$+
 highlight link muScreen muString
 
 " mu literals
-syntax match muNumber %[^ ]\+:literal/\?[^ ,]*%
-syntax match muNumber %\<[0-9-]\?[0-9]\+\>%
-syntax match muNumber %\<[0-9-]\?[0-9]\+/[^ ,]*%
-highlight link muNumber Constant
-syntax match muLabel "^\s\+[^ 0-9a-zA-Z{}#\[\]][^ ]*\s*$"
-syntax match muLabel %[^ ]\+:label/\?[^ ,]*%
-syntax match muLabel "<[^ ]*>"
-highlight link muLabel Constant
-syntax match muLiteral %[^ ]\+:type/\?[^ ,]*%
-syntax match muLiteral %[^ ]\+:offset/\?[^ ,]*%
-syntax match muLiteral %[^ ]\+:variant/\?[^ ,]*%
+syntax match muLiteral %[^ ]\+:literal/[^ ,]*\|[^ ]\+:literal\>%
+syntax match muLiteral %\<[0-9-]\?[0-9]\+\>%
+syntax match muLiteral %\<[0-9-]\?[0-9]\+/[^ ,]*%
+syntax match muLiteral "^\s\+[^ 0-9a-zA-Z{}#\[\]][^ ]*\s*$"
+syntax match muLiteral %[^ ]\+:label/[^ ,]*\|[^ ]\+:label\>%
+syntax match muLiteral "<[^ ]*>"
+syntax match muLiteral %[^ ]\+:type/[^ ,]*\|[^ ]\+:type\>%
+syntax match muLiteral %[^ ]\+:offset/[^ ,]*\|[^ ]\+:offset\>%
+syntax match muLiteral %[^ ]\+:variant/[^ ,]*\|[^ ]\+:variant\>%
 highlight link muLiteral Constant
 syntax keyword muKeyword default-space global-space new-default-space local-scope next-ingredient ingredient rewind-ingredients load-ingredients | highlight link muKeyword Constant
 
@@ -60,10 +58,9 @@ syntax match muAssign " <- \|\<raw\>" | highlight link muAssign SpecialChar
 syntax match muGlobal %[^ ]\+:global/\?[^ ,]*% | highlight link muGlobal SpecialChar
 syntax keyword muControl reply reply-if reply-unless return return-if return-unless jump jump-if jump-unless loop loop-if loop-unless break break-if break-unless current-continuation continue-from create-delimited-continuation reply-delimited-continuation | highlight muControl ctermfg=3
 " common keywords
-syntax keyword muRecipe recipe recipe! def def! before after | highlight muRecipe ctermfg=208
-syntax match muRecipe " -> "
-syntax keyword muScenario scenario | highlight muScenario ctermfg=34
-syntax keyword muPendingScenario pending-scenario | highlight link muPendingScenario SpecialChar
-syntax keyword muData container exclusive-container type | highlight muData ctermfg=226
+syntax match muRecipe "^recipe\>\|^recipe!\>\|^def\>\|^def!\>\|^before\>\|^after\>\| -> " | highlight muRecipe ctermfg=208
+syntax match muScenario "^scenario\>" | highlight muScenario ctermfg=34
+syntax match muPendingScenario "^pending-scenario\>" | highlight link muPendingScenario SpecialChar
+syntax match muData "^type\>\|^container\>\|^exclusive-container\>" | highlight muData ctermfg=226
 
 let &cpo = s:save_cpo
diff --git a/vimrc.vim b/vimrc.vim
index a3f31d1e..32c96159 100644
--- a/vimrc.vim
+++ b/vimrc.vim
@@ -24,7 +24,19 @@ function! HighlightTangledFile()
   syntax match muCommentedCode /#? .*$/ | highlight link muCommentedCode CommentedCode
   set comments+=n:#
   " Some other bare-bones mu highlighting.
+  syntax match muLiteral %[^ ]\+:literal/[^ ,]*\|[^ ]\+:literal\>%
+  syntax match muLiteral %[^ ]\+:label/[^ ,]*\|[^ ]\+:label\>%
+  syntax match muLiteral %[^ ]\+:type/[^ ,]*\|[^ ]\+:type\>%
+  syntax match muLiteral %[^ ]\+:offset/[^ ,]*\|[^ ]\+:offset\>%
+  syntax match muLiteral %[^ ]\+:variant/[^ ,]*\|[^ ]\+:variant\>%
+  highlight link muLiteral Constant
   syntax match muAssign " <- \|\<raw\>" | highlight link muAssign SpecialChar
+  syntax match muGlobal %[^ ]\+:global/[^ ,]*\|[^ ]\+:global\>% | highlight link muGlobal SpecialChar
+  " common keywords
+  syntax match muRecipe "^recipe\>\|^recipe!\>\|^def\>\|^def!\>\|^before\>\|^after\>\| -> " | highlight muRecipe ctermfg=208
+  syntax match muScenario "^scenario\>" | highlight muScenario ctermfg=34
+  syntax match muPendingScenario "^pending-scenario\>" | highlight link muPendingScenario SpecialChar
+  syntax match muData "^type\>\|^container\>\|^exclusive-container\>" | highlight muData ctermfg=226
 endfunction
 call HighlightTangledFile()
 autocmd BufRead,BufNewFile *.mu set ft=mu
author	Kartik K. Agaram <vc@akkartik.com>	2016-09-30 10:45:14 -0700
committer	Kartik K. Agaram <vc@akkartik.com>	2016-09-30 10:45:14 -0700
commit	3e1349d29fa00db1fab3a811b60bc9d8de0355e4 (patch)
tree	93afedf36b8b211432a458ca9c0c7bfaf76e2425
parent	6c69569a4c4ca3a23635d4d7a40f0fe557194619 (diff)
download	mu-3e1349d29fa00db1fab3a811b60bc9d8de0355e4.tar.gz