diff --git a/templates/features/activity-body.ezt b/templates/features/activity-body.ezt
new file mode 100644
index 0000000..640b1d3
--- /dev/null
+++ b/templates/features/activity-body.ezt
@@ -0,0 +1,9 @@
+[# This template is used to pre-render the title of an activity so that it can
+   later be accessed as activity.escaped_title.
+]
+
+[is activity_type "ProjectIssueUpdate"]
+  [include "updates-issueupdate-body.ezt"]
+[else]
+  Body?
+[end]
diff --git a/templates/features/activity-title.ezt b/templates/features/activity-title.ezt
new file mode 100644
index 0000000..c7e2f2f
--- /dev/null
+++ b/templates/features/activity-title.ezt
@@ -0,0 +1,9 @@
+[# This template is used to pre-render the title of an activity so that it can
+   later be accessed as activity.escaped_title.
+]
+
+[is activity_type "ProjectIssueUpdate"]
+  [include "updates-issueupdate-title.ezt"]
+[else]
+  title?
+[end]
diff --git a/templates/features/auto-ping-email.ezt b/templates/features/auto-ping-email.ezt
new file mode 100644
index 0000000..47b9f29
--- /dev/null
+++ b/templates/features/auto-ping-email.ezt
@@ -0,0 +1,11 @@
+[ping_comment_content]
+[detail_url]
+
+[for fields][if-any fields.docstring]
+[fields.field_name] field description:
+  [fields.docstring]
+[end][end]
+
+[# TODO(jrobbins): component triage notes]
+[# TODO(jrobbins): hotlist triage notes]
+[# TODO(jrobbins): context comment that set the date value]
diff --git a/templates/features/cues-conduct.ezt b/templates/features/cues-conduct.ezt
new file mode 100644
index 0000000..83a026e
--- /dev/null
+++ b/templates/features/cues-conduct.ezt
@@ -0,0 +1,18 @@
+[define show_code_of_conduct]False[end]
+[is cue "privacy_click_through"][define show_code_of_conduct]True[end][end]
+[is cue "code_of_conduct"][define show_code_of_conduct]True[end][end]
+
+[define code_of_conduct_url]https://chromium.googlesource.com/chromium/src/+/main/CODE_OF_CONDUCT.md[end]
+[is projectname "fuchsia"]
+  [define code_of_conduct_url]https://fuchsia.dev/fuchsia-src/CODE_OF_CONDUCT[end]
+[end]
+
+[is show_code_of_conduct "True"]
+ <table border="0" cellspacing="0" cellpadding="0" class="cue" style="margin: 2px">
+  <tr><td><span>
+      Please keep discussions respectful and constructive.
+      See our <a href="[code_of_conduct_url]" target="_blank">code of conduct</a>.
+      <a href="#" title="Don't show this message again" style="margin-left: 1em" class="dismiss_cue x_icon"></a>
+  </span></td></tr>
+ </table>
+[end]
\ No newline at end of file
diff --git a/templates/features/cues.ezt b/templates/features/cues.ezt
new file mode 100644
index 0000000..5cf059d
--- /dev/null
+++ b/templates/features/cues.ezt
@@ -0,0 +1,178 @@
+[if-any cue account_cue]
+
+[# Do not show cue if there is an alert shown on the page.]
+[if-any alerts.show][else]
+
+
+[# Dialog box for privacy settings.]
+[is cue "privacy_click_through"]
+  <div class="scrim cue">
+    <div id="privacy_dialog">
+      <h2>Email display settings</h2>
+
+      <p>There is a <a href="/hosting/settings" title="Settings"
+      class="dismiss_cue">setting</a> to control how your email
+      address appears on comments and issues that you post.
+
+      [if-any is_privileged_domain_user]
+        Since you are an integral part of this community, that setting
+        defaults to showing your full email address.</p>
+
+        <p>Also, you are being trusted to view email addresses of
+        non-members who post comments in your projects.  Please use
+        those addresses only to request additional information about
+        the posted comments, and do not share other users' email
+        addresses beyond the site.</p>
+      [else]
+        Project members will always see your full email address.  By
+        default, other users who visit the site will see an
+        abbreviated version of your email address.</p>
+
+        <p>If you do not wish your email address to be shared, there
+        are other ways to <a
+        href="http://www.chromium.org/getting-involved">get
+        involved</a> in the community.  To report a problem when using
+        the Chrome browser, you may use the "Report an issue..."  item
+        on the "Help" menu.</p>
+      [end]
+
+      <div class="actions">
+        <a href="#" title="Got it" class="dismiss_cue">GOT IT</a>
+      </div>
+    </div>
+  </div>
+
+[else][if-any account_cue]
+
+  <table id="alert-table" align="center" border="0" cellspacing="0" cellpadding="0">
+   <tr><td class="notice" id="notice">
+    [# Cue card to warn users who are using a child account.]
+    [is account_cue "switch_to_parent_account"]
+        <div>You are signed in to a linked account.</div>
+	<a href="[login_url]">Switch to [parent_email]</a>.
+    [end]
+  </td></tr>
+ </table>
+
+[else][is cue "code_of_conduct"]
+ [# Note: code-of-conduct cue card is implemented in cues-conduct.ezt which is
+    included from forms where users post text.]
+
+[else]
+
+ <table align="center" border="0" cellspacing="0" cellpadding="0" class="cue">
+  <tr><td><span>
+    [# Cue cards to teach users how to join a project.]
+    [is cue "how_to_join_project"]
+      <b>How-to:</b>
+      Join this project by contacting the project owners.
+    [end]
+
+    [# Cue card to teach users how to search for numbers in the issue tracker.]
+    [is cue "search_for_numbers"]
+     [if-any jump_local_id]
+       <b>Tip:</b>
+       To find issues containing "[jump_local_id]", use quotes.
+     [end]
+    [end]
+
+    [# Cue card to teach users how to search for numbers in the issue tracker.]
+    [is cue "dit_keystrokes"]
+      <b>Tip:</b>
+      Press <b>Esc</b> then <b style="font-size:130%"><tt>?</tt></b> for keyboard shortcuts.
+    [end]
+
+    [# Cue card to teach users that italics mean derived values in the issue tracker.]
+    [is cue "italics_mean_derived"]
+      <b>Note:</b>
+      <i>Italics</i> mean that a value was derived by a filter rule.
+      <a href="http://code.google.com/p/monorail/wiki/FilterRules">Learn more</a>
+    [end]
+
+    [# Teach users that color blocks mean that an issue participant may not be available.]
+    [is cue "availability_msgs"]
+      <b>Note:</b>
+      Color blocks (like <span class="availability_unsure" style="padding:0">&#9608;</span> or
+      <span class="availability_never" style="padding:0">&#9608;</span>)
+      mean that a user may not be available.  Tooltip shows the reason.
+    [end]
+
+    [# Cue card to teach users that full-text indexing takes time.]
+    [is cue "stale_fulltext"]
+      <b>Note:</b>
+      Searching for text in issues may show results that are a few minutes out of date.
+    [end]
+
+    [# Cue cards to improve discoverability of people roles.]
+    [is cue "document_team_duties"]
+     [if-any read_only][else]
+       <b>Tip:</b>
+       Document <a href="people/list">each teammate's project duties</a>.
+     [end]
+    [end]
+
+    [# Cue cards to explain grid mode.]
+    [is cue "showing_ids_instead_of_tiles"]
+       <b>Note:</b>
+       Grid mode automatically switches to displaying IDs when there are many results.
+    [end]
+
+    [# Cue cards to explain ownermodified, statusmodified, and componentmodified.]
+    [is cue "issue_timestamps"]
+       <b>Note:</b>
+       ownermodified, statusmodified, and componentmodified are the times at which
+       an issue's owner, status or component were changed.
+    [end]
+
+    [# Cue card to remind the user that they have set a vacation message.]
+    [is cue "you_are_on_vacation"]
+       <b>Note:</b>
+       Your <a href="/hosting/settings">vacation message</a> is set to:
+       "[logged_in_user.avail_message_short]".
+    [end]
+
+    [# Cue card to inform user that email to them bounced and that they must reset.]
+    [is cue "your_email_bounced"]
+       <b>Action required:</b>
+       An email to you bounced.  Once you can reliably receive email, clear the
+       <a href="[logged_in_user.profile_url]">bouncing status</a>.
+    [end]
+
+    [# Cue card to tell users what it means to star a hotlist]
+    [is cue "explain_hotlist_starring"]
+        <b>Note:</b>
+        Starring a hotlist will not cc you on any updates.
+        It simply adds the hotlist to your Starred hotlists category on this
+        page so that you can conveniently revisit it.
+    [end]
+
+   </span>
+    [# Link to dismiss the cue card.]
+    [if-any logged_in_user]
+     [if-any read_only][else]
+      <a href="#" title="Don't show this message again" style="margin-left: 1em" class="dismiss_cue x_icon"></a>
+     [end]
+    [end]
+  </td></tr>
+ </table>
+[end]
+[end]
+[end]
+
+
+ <script type="text/javascript" nonce="[nonce]">
+runOnLoad(function() {
+  var dismissLinks = document.querySelectorAll(".dismiss_cue");
+  for (var i = 0; i < dismissLinks.length; ++i) {
+   var dismissCue = dismissLinks[[]i];
+     dismissCue.addEventListener("click", function(event) {
+         _CS_dismissCue("[format "js"][cue][end]");
+         if (this.getAttribute("href") === "#")
+           event.preventDefault();
+     });
+  }
+});
+ </script>
+
+[end]
+[end]
diff --git a/templates/features/filterrules-preview.ezt b/templates/features/filterrules-preview.ezt
new file mode 100644
index 0000000..adbd7d0
--- /dev/null
+++ b/templates/features/filterrules-preview.ezt
@@ -0,0 +1,8 @@
+<div id="preview_filterrules_area" style="display:none">
+  Filter rules and components will add:
+  <div id="preview_filterrules_labels"></div>
+  <div id="preview_filterrules_owner"></div>
+  <div id="preview_filterrules_ccs"></div>
+  <div id="preview_filterrules_warnings"></div>
+  <div id="preview_filterrules_errors"></div>
+</div>
diff --git a/templates/features/hotlist-create-page.ezt b/templates/features/hotlist-create-page.ezt
new file mode 100644
index 0000000..16b6935
--- /dev/null
+++ b/templates/features/hotlist-create-page.ezt
@@ -0,0 +1,64 @@
+[define title]Create a new hotlist[end]
+[define category_css]css/ph_detail.css[end]
+[include "../framework/header.ezt" "hidetabs"]
+
+<h2>Create a hotlist</h2>
+
+<form action="createHotlist.do" method="POST" id="create_hotlist_form"
+      style="margin: 1em;">
+  <input type="hidden" name="token" value="[form_token]">
+
+  <label for="hotlistname">Hotlist Name:</label><br>
+  <input type="text" id="hotlistname" name="hotlistname" size="30" autocomplete="off"
+         value="[initial_name]">
+  <span class="graytext">Example: My-Hotlist-Name</span>
+  <div class="fielderror">&nbsp;
+    <span id="hotlistnamefeedback">
+       [if-any errors.hotlistname][errors.hotlistname][end]
+    </span>
+  </div>
+
+  <label for="summary">Summary</label><br>
+  <input type="text" id="summary" name="summary" size="75" autocomplete="off"
+         value="[initial_summary]">
+  <div class="fielderror">&nbsp;
+    <span id="summaryfeedback">
+      [if-any errors.summary][errors.summary][end]
+    </span>
+  </div>
+
+  <label for="description">Description</label><br>
+  <textarea id="description" name="description" rows="20" cols="90" wrap="soft">[initial_description]</textarea>
+  <br><br>
+
+  <div>
+    <span>Owner: [logged_in_user.email]</span>
+    <div class="graytext">
+    You will be the owner of this hotlist with permission to edit everything
+    </div>
+  </div>
+  <br>
+
+  <label for="editors">Editors</label><br>
+  <input type="text" id="editors" name="editors" size="75" autocomplete="off"
+  value="[initial_editors]">
+  <span class="graytext">Example: user@email.com, example@email.com</span>
+  <div class="graytext">Editors may add, remove, or rank issues</div>
+  <div class="fielderror">&nbsp;
+    <span id="editorsfeedback">
+      [if-any errors.editors][errors.editors][end]
+    <span>
+  </div>
+
+  <label for="privacy">Viewable by:</label>
+  <select name="is_private" id="privacy">
+    <option disabled="disabled">Select an access level...</option>
+    <option value="no">Anyone on the internet</option>
+    <option value="yes" selected="selected">Hotlist members</option>
+  </select>
+  <br><br>
+
+  <input type="submit" value="Create hotlist">
+</form>
+
+[include "../framework/footer.ezt"]
diff --git a/templates/features/hotlist-details-page.ezt b/templates/features/hotlist-details-page.ezt
new file mode 100644
index 0000000..194f6bd
--- /dev/null
+++ b/templates/features/hotlist-details-page.ezt
@@ -0,0 +1,72 @@
+[define category_css]css/ph_detail.css[end]
+[include "../framework/header.ezt" "showtabs"]
+
+[if-any read_only cant_administer_hotlist][include "read-only-hotlist-details-page.ezt"]
+[else]
+
+<form id="edithotlist" action="details.do" method="POST" autocomplete="off" enctype="multipart/form-data">
+  <input type="hidden" name="token" value="[form_token]">
+
+<h4>Hotlist settings</h4>
+
+<div class="section">
+  Hotlist name:<br>
+  <input type="text" id="name" name="name" size="75" value="[initial_name]"><br>
+  <div class="fielderror">&nbsp;
+    <span id="namefeedback">[if-any errors.name][errors.name][end]</span>
+  </div>
+
+  Hotlist summary:<br>
+  <input type="text" id="summary" name="summary" size="75" value="[initial_summary]"><br>
+  <div class="fielderror">&nbsp;
+    <span id="summaryfeedback">[if-any errors.summary][errors.summary][end]</span>
+  </div>
+
+  Hotlist description:<br>
+  <textarea id="description" name="description" rows="20" cols="90" wrap="soft"
+  	    >[initial_description]</textarea><br>
+</div>
+
+<h4>Hotlist defaults</h4>
+
+<div class="section">
+  Default columns shows in list view:<br/>
+  <input type="text" id="default_col_spec" name="default_col_spec" size="75" value="[initial_default_col_spec]"><br>
+  <div class="fielderror">&nbsp;
+    <span id="default_col_specfeedback">[if-any errors.default_col][errors.default_col][end]</span>
+  </div>
+
+  [# TODO(jojwang): add default issues per page]
+</div>
+
+<h4>Hotlist access</h4>
+
+<div class="section">
+  <select name="is_private" id="is_private">
+    <option disabled="disabled">Select an access level...</option>
+    <option value="no" [if-any initial_is_private][else]selected="selected"[end]>Anyone on the Internet</option>
+    <option value="yes" [if-any initial_is_private]selected="selected"[else][end]>Members only</option>
+  </select>
+  <p>Individual issues in the list can only be seen by users who can normally see them. The privacy status of an issue is considered when it is being displayed (or not displayed) in a hotlist.</p>
+</div>
+
+
+  <input type="hidden" id="delete" name="deletestate" value="false">
+  <input type="submit" id="savechanges" name="btn" value="Save changes" class="submit">
+  <input type="button" id="deletehotlist" name="btn" value="Delete hotlist" class="submit">
+
+</form>
+
+[include "../framework/footer-script.ezt"]
+
+<script type="text/javascript" nonce="[nonce]">
+runOnLoad(function() {
+  $('deletehotlist').addEventListener('click', function () {
+    HTL_deleteHotlist($('edithotlist'));
+  });
+});
+</script>
+
+[end]
+
+[include "../framework/footer.ezt"]
diff --git a/templates/features/hotlist-issues-body.ezt b/templates/features/hotlist-issues-body.ezt
new file mode 100644
index 0000000..3e9406d
--- /dev/null
+++ b/templates/features/hotlist-issues-body.ezt
@@ -0,0 +1,115 @@
+[for panels][# There will always be exactly one panel.]
+ [include "../tracker/issue-list-headings.ezt"]
+[end]
+
+[if-any table_data][else]
+<tr>
+  <td colspan="40" class="id">
+   <div style="padding: 3em; text-align: center">
+       This hotlist currently has no issues.<br>
+     [if-any owner_permissions editor_permissions]
+     Select 'Add issues...' in the above 'Actions...' dropdown menu to add some.
+     [end]
+    </div>
+   </td>
+  </tr>
+[end]
+
+
+
+<script type="text/javascript" nonce="[nonce]">
+runOnLoad(function(){
+  [if-any table_data]
+    var tableData = [[]
+    [for table_data]
+      {
+      "group":
+      [if-any table_data.group][if-any table_data.group.cells]
+        {
+        "rowsInGroup": "[table_data.group.rows_in_group]",
+        "cells": [[]
+        [for table_data.group.cells]
+          {
+          "groupName": "[table_data.group.cells.group_name]",
+          "values": [[]
+          [for table_data.group.cells.values]
+            {
+            "item": [if-any table_data.group.cells.values.item]"[format "js"][table_data.group.cells.values.item][end]"[else]"None"[end],
+            }[if-index table_data.group.cells.values last][else],[end]
+          [end]
+          ],
+          }[if-index table_data.group.cells last][else],[end]
+        [end]
+        ],
+        },
+      [else]"no",[end][else]"no",[end]
+      "cells" : [[]
+      [for table_data.cells]
+        {
+        "type": "[table_data.cells.type]",
+        "values": [[]
+        [for table_data.cells.values]
+          {
+            [is table_data.cells.type "issues"]
+              "id": "[format "js"][table_data.cells.values.item.id][end]",
+              "href": "[format "js"][table_data.cells.values.item.href][end]",
+              "title": "[format "js"][table_data.cells.values.item.title][end]",
+              "closed": "[format "js"][table_data.cells.values.item.closed][end]",
+            [else]
+              "item": "[format "js"][table_data.cells.values.item][end]",
+            [end]
+          "isDerived": "[table_data.cells.values.is_derived]",
+          }[if-index table_data.cells.values last][else],[end]
+        [end]
+        ],
+        "colIndex": "[table_data.cells.col_index]",
+        "align": "[table_data.cells.align]",
+        "noWrap": "[table_data.cells.NOWRAP]",
+        "nonColLabels": [[]
+        [for table_data.cells.non_column_labels]
+          {
+          "value": "[format "js"][table_data.cells.non_column_labels.value][end]",
+          "isDerived": "[table_data.cells.non_column_labels.is_derived]",
+          }[if-index table_data.cells.non_column_labels last][else],[end]
+        [end]
+        ],
+        }[if-index table_data.cells last][else],[end]
+      [end]
+      ],
+      "issueRef": "[table_data.issue_ref]",
+      "idx": "[table_data.idx]",
+      "projectName": "[table_data.project_name]",
+      "localID": "[table_data.local_id]",
+      "projectURL": [format "js"]"[table_data.project_url]"[end],
+      "issueID": "[table_data.issue_id]",
+      "isStarred": "[table_data.starred]",
+      "issueCleanURL": [format "js"]"[table_data.issue_clean_url]"[end],
+      "issueContextURL": [format "js"]"[table_data.issue_ctx_url]"[end],
+      }[if-index table_data last][else],[end]
+    [end]
+    ];
+
+    var pageSettings = {
+    "cursor": "[cursor]",
+    "userLoggedIn": "[if-any logged_in_user]yes[end]",
+    "ownerPerm": "[owner_permissions]",
+    "editorPerm": "[editor_permissions]",
+    "isCrossProject": "[is_cross_project]",
+    "readOnly": "[read_only]",
+    "allowRerank": "[allow_rerank]",
+    "hotlistID": "[hotlist_id]",
+    "colSpec": "[col_spec]",
+    "can": "[can]"
+    };
+
+    renderHotlistTable(tableData, pageSettings);
+    [if-any allow_rerank]
+    activateDragDrop(tableData, pageSettings, "[hotlist_id]");
+    [end]
+  [else]
+  [end]
+});
+</script>
+
+<script type="text/javascript" defer src="[version_base]/static/js/tracker/render-hotlist-table.js" nonce="[nonce]"></script>
+
diff --git a/templates/features/hotlist-issues-page.ezt b/templates/features/hotlist-issues-page.ezt
new file mode 100644
index 0000000..79898e0
--- /dev/null
+++ b/templates/features/hotlist-issues-page.ezt
@@ -0,0 +1,120 @@
+[define title]Hotlist [hotlist.name][end]
+[define category_css]css/ph_list.css[end]
+[define category2_css]css/ph_detail.css[end]
+[include "../framework/header.ezt" "showtabs"]
+
+<table width="100%" cellpadding="0" cellspacing="0" border="0" class="hotlist-issues-page" id="meta-container"
+       style="margin: 1em">
+<tbody class="collapse">
+  <tr>
+    <td nowrap="nowrap" style="min-width:9em;" class="sidebar">
+      <div style="text-align: center">
+       [if-any read_only][else]
+         <a id="hotlist_star"
+         style="color:[if-any hotlist.is_starred]cornflowerblue[else]gray[end]"
+         title="[if-any hotlist.is_starred]Un-s[else]S[end]tar this hotlist">
+         [if-any hotlist.is_starred]&#9733;[else]&#9734;[end]
+         </a>
+       [end]
+       Followed by [hotlist.num_followers]
+      </div>
+      <div id="meta-float">
+        [include "hotlist-meta-part.ezt"]
+      </div>
+    </td>
+    <td width="80%" class="vt" style="padding-left: 1em">
+      <h1 style="margin-top: 0"><a href="[hotlist.url]">Hotlist [hotlist.name]</a></h1>
+      <div>Summary: [hotlist.summary]</div>
+      Description: [hotlist.description]
+     </td>
+  </tr>
+
+
+</tbody>
+</table>
+
+<div id="colcontrol">
+
+  <span id="qq"><input type="hidden" id="searchq" name="q"
+                            value="[query]" autocomplete="off" ignore-dirty></span>
+       [if-any sortspec]<input type="hidden" id="sort" name="sort" value="[sortspec]">[end]
+       [if-any groupby]<input type="hidden" id="groupby" name="groupby" value="[groupby]">[end]
+       [if-any colspec]<span id="search_colspec"><input type="hidden" name="colspec" value="[colspec]"></span>[end]
+       <input type="hidden" id="hotlist_name" value="[hotlist.name]"></input>
+  <input type="hidden"  id="can" value="[can]"></span>
+
+  [if-any grid_mode]
+   [include "../tracker/issue-grid-controls-top.ezt"]
+  [end]
+
+  [if-any list_mode]
+   [include "../tracker/issue-list-controls-top.ezt"]
+  [end]
+
+  [if-any chart_mode]
+   [include "../tracker/issue-chart-controls-top.ezt"]
+  [end]
+
+  [include "../tracker/issue-hovercard.ezt"] [# TODO(jojwang): no hovercard appears right now]
+
+  <div id="cursorarea">
+  <table cellspacing="0" cellpadding="2" border="0" class="results striped drag_container" id="resultstable" width="100%">
+
+    [if-any grid_mode]
+     [include "../tracker/issue-grid-body.ezt"]
+    [end]
+
+    [if-any list_mode]
+     [include "hotlist-issues-body.ezt"]
+    [end]
+
+    [if-any chart_mode]
+     [include "../tracker/issue-chart-body.ezt" "testparam"]
+    [end]
+
+  </table>
+  </div>
+
+  [if-any list_mode]
+    [include "../tracker/issue-list-controls-bottom.ezt"]
+    [for panels]
+      [include "../tracker/issue-list-menus.ezt"]
+    [end]
+  [end]
+</div>
+
+[if-any grid_mode][else]
+  [include "../tracker/issue-list-js.ezt" "hotlist"]
+[end]
+
+<script type="text/javascript" nonce="[nonce]">
+runOnLoad(function() {
+  if ($("hotlist_star")) {
+    [# The user viewing this page wants to star this hotlist]
+    $("hotlist_star").addEventListener("click", function () {
+       _TKR_toggleStar($("hotlist_star"), null, null, null, "[hotlist_id]");
+    });
+  }
+
+
+    window.addEventListener("beforeunload", function(e) {
+      var selectedElement = document.activeElement;
+      if (selectedElement.classList.contains("itemnote")){
+        saveNote(selectedElement, "[hotlist_id]");
+      }
+      return;
+    });
+
+    $("hide-closed").addEventListener("click", function(e) {
+      HTL_toggleIssuesShown(e.target);
+    });
+    $("show-all").addEventListener("click", function(e) {
+      HTL_toggleIssuesShown(e.target);
+    });
+
+});
+</script>
+
+[#TODO(jojwang):make pretty]
+
+[include "../framework/footer.ezt"]
diff --git a/templates/features/hotlist-meta-part.ezt b/templates/features/hotlist-meta-part.ezt
new file mode 100644
index 0000000..0b865c6
--- /dev/null
+++ b/templates/features/hotlist-meta-part.ezt
@@ -0,0 +1,41 @@
+<table cellspacing="0" cellpadding="0">
+  <tr><th align="left" style="padding-right:.3em">Owners:</th>
+    <td width="100%">
+      <div style="margin-left:1em">
+      [if-any hotlist.owners]
+      [for hotlist.owners]
+      [include "../framework/user-link.ezt" hotlist.owners]
+      [end]
+      [end]
+      </div>
+    </td>
+  </tr>
+  <tr><th alight="left" style="padding-right:.3em">Members:</th>
+    <td width="100%">
+      <div style="margin-left:1em">
+      [if-any hotlist.editors]
+      [for hotlist.editors]
+      [include "../framework/user-link.ezt" hotlist.editors]
+      [end]
+      [end]
+      </div>
+    </td>
+  </tr>
+  <tr><th align="left" style="padding-right:.3em">Access:</th>
+    <td width="100%">
+      <div style="margin-left:1em">
+      [if-any hotlist.access_is_private]Private[else]Public[end]
+      </div>
+    </td>
+  </tr>
+  <tr><th align="left">Issues:</th>
+    <td width="100%">
+    <form>
+      <input type="radio" id="hide-closed" name="toggleissues" value="2" [is can "2"]checked[end]>Open<br>
+      <input type="radio" id="show-all" name="toggleissues" value="1" [is can "1"]checked[end]>All<br>
+    </form>
+    </form>
+    </td>
+  </tr>
+</table>
+
diff --git a/templates/features/inboundemail-banned.ezt b/templates/features/inboundemail-banned.ezt
new file mode 100644
index 0000000..f241fef
--- /dev/null
+++ b/templates/features/inboundemail-banned.ezt
@@ -0,0 +1,7 @@
+Subject: You are banned from using this issue tracker
+
+The email message you sent to [project_addr]
+was not processed because your account, [sender_addr],
+has been banned from using this issue tracker.
+
+[include "inboundemail-error-footer-part.ezt"]
diff --git a/templates/features/inboundemail-body-too-long.ezt b/templates/features/inboundemail-body-too-long.ezt
new file mode 100644
index 0000000..515e157
--- /dev/null
+++ b/templates/features/inboundemail-body-too-long.ezt
@@ -0,0 +1,6 @@
+Subject: Email body too long
+
+The email message you sent to [project_addr]
+was not processed because it was too large.
+
+[include "inboundemail-error-footer-part.ezt"]
diff --git a/templates/features/inboundemail-error-footer-part.ezt b/templates/features/inboundemail-error-footer-part.ezt
new file mode 100644
index 0000000..e86cbeb
--- /dev/null
+++ b/templates/features/inboundemail-error-footer-part.ezt
@@ -0,0 +1,2 @@
+To learn more, please visit:
+https://chromium.googlesource.com/infra/infra/+/main/doc/users/index.md
diff --git a/templates/features/inboundemail-no-account.ezt b/templates/features/inboundemail-no-account.ezt
new file mode 100644
index 0000000..0b7392d
--- /dev/null
+++ b/templates/features/inboundemail-no-account.ezt
@@ -0,0 +1,9 @@
+Subject: Could not determine account of sender
+
+The email message you sent to [project_addr]
+was not processed because your address, [sender_addr],
+does not correspond to an account known to the server.
+You must send from an email address that has already
+been used to interact with the issue tracker web UI.
+
+[include "inboundemail-error-footer-part.ezt"]
diff --git a/templates/features/inboundemail-no-artifact.ezt b/templates/features/inboundemail-no-artifact.ezt
new file mode 100644
index 0000000..bbc93fc
--- /dev/null
+++ b/templates/features/inboundemail-no-artifact.ezt
@@ -0,0 +1,7 @@
+Subject: Could not find [artifact_phrase] in project [project_name]
+
+The email message you sent to [project_addr]
+was not processed because [artifact_phrase] does
+not exist in project [project_name].
+
+[include "inboundemail-error-footer-part.ezt"]
diff --git a/templates/features/inboundemail-no-perms.ezt b/templates/features/inboundemail-no-perms.ezt
new file mode 100644
index 0000000..5fe57dc
--- /dev/null
+++ b/templates/features/inboundemail-no-perms.ezt
@@ -0,0 +1,8 @@
+Subject: User does not have permission to add a comment
+
+The email message you sent to [project_addr]
+was not processed because user [sender_addr] 
+does not have permission to add a comment to 
+[artifact_phrase] in [project_name].
+
+[include "inboundemail-error-footer-part.ezt"]
diff --git a/templates/features/inboundemail-not-a-reply.ezt b/templates/features/inboundemail-not-a-reply.ezt
new file mode 100644
index 0000000..9861fd7
--- /dev/null
+++ b/templates/features/inboundemail-not-a-reply.ezt
@@ -0,0 +1,7 @@
+Subject: Your message is not a reply to a notification email
+
+The email message you sent to [project_addr]
+was not processed because it was not a reply to a notification
+email that we sent specifically to [sender_addr].
+
+[include "inboundemail-error-footer-part.ezt"]
diff --git a/templates/features/inboundemail-project-not-found.ezt b/templates/features/inboundemail-project-not-found.ezt
new file mode 100644
index 0000000..d82bac1
--- /dev/null
+++ b/templates/features/inboundemail-project-not-found.ezt
@@ -0,0 +1,6 @@
+Subject: Project not found
+
+The email message you sent to [project_addr]
+was not processed because there is no project at that address.
+
+[include "inboundemail-error-footer-part.ezt"]
diff --git a/templates/features/inboundemail-replies-disabled.ezt b/templates/features/inboundemail-replies-disabled.ezt
new file mode 100644
index 0000000..c95839b
--- /dev/null
+++ b/templates/features/inboundemail-replies-disabled.ezt
@@ -0,0 +1,7 @@
+Subject: Email replies are not enabled in project [project_name]
+
+The email message you sent to [project_addr]
+was not processed because project [project_name]
+has not enabled email replies.
+
+[include "inboundemail-error-footer-part.ezt"]
diff --git a/templates/features/read-only-hotlist-details-page.ezt b/templates/features/read-only-hotlist-details-page.ezt
new file mode 100644
index 0000000..f526aa7
--- /dev/null
+++ b/templates/features/read-only-hotlist-details-page.ezt
@@ -0,0 +1,25 @@
+<h4>Hotlist settings</h4>
+
+<div class="section">
+  Hotlist name:<br>
+  [initial_name]<br>
+
+  Hotlist summary:<br>
+  [initial_summary]<br>
+
+  Hotlist description:<br>
+  [initial_description]<br>
+</div>
+
+<h4>Hotlist defaults</h4>
+
+<div class="section">
+  Default columns shown in list view:<br>
+  [initial_default_col_spec]<br>
+</div>
+
+<h4>Hotlist access</h4>
+<div class="section">
+  <p>Who can view this hotlist: [if-any initial_is_private]Members only[else]Anyone on the internet[end]</p>
+  <p>Individual issues in the list can only be seen by users who can normally see them. The privacy status of an issue is considered when it is being displayed (or not displayed) in a hotlist.</p>
+</div>
diff --git a/templates/features/remove-self-hotlist-form.ezt b/templates/features/remove-self-hotlist-form.ezt
new file mode 100644
index 0000000..cc351c2
--- /dev/null
+++ b/templates/features/remove-self-hotlist-form.ezt
@@ -0,0 +1,19 @@
+<div id="remove-self-container" style="display: [if-any open_dialog]block[else]none[end]">
+  <div id="remove-self-dialog">
+    <h2 style="margin-top:0">
+      Hotlist: [hotlist.name]
+    </h2>
+
+    <section>
+      Would you like to remove yourself as an editor of this hotlist?
+      <input type="checkbox" name="removeself">
+    </section>
+
+    <menu>
+      <button id="cancel-remove-self" type="reset">Cancel</button>
+      <button type="submit">Confirm</button>
+    </menu>
+  </div>
+</div>
+
+<script type="text/javascript" defer src="[version_base]/static/js/hotlists/edit-hotlist.js" nonce="[nonce]"></script>
diff --git a/templates/features/saved-queries-page.ezt b/templates/features/saved-queries-page.ezt
new file mode 100644
index 0000000..69fa654
--- /dev/null
+++ b/templates/features/saved-queries-page.ezt
@@ -0,0 +1,44 @@
+[define title][if-any viewing_self]My[else][viewed_username][end] saved queries[end]
+[define category_css]css/ph_detail.css[end]
+
+[include "../framework/header.ezt" "showusertabs" "t4"]
+
+
+<h3>Saved queries</h3>
+
+[if-any read_only][include "../framework/read-only-rejection.ezt"]
+[else]
+<div class="section">
+
+  <div class="closed">
+    <div>Saved queries allow you to quickly view issue lists that you use frequently.
+     <a class="ifClosed toggleHidden" href="#"
+        style="font-size:90%; margin:0 1em">Learn more</a>
+    </div>
+
+    <div id="filterhelp" class="ifOpened help">
+        Personal saved queries allow you to keep track of the issues that matter most to you.<br/>
+        When you are in a project, you can choose one of your saved queries from the
+        the bottom section of the search dropdown menu that is next to the issue search box.<br/>
+        You can also subscribe to any query to get email notifications when issues that
+        satisfy that query are modified.<br/>
+        Subscription notifications are only generated for users who have visited the
+        site within the past six months.
+    </div>
+    <br>
+
+    <form action="queries.do" method="POST">
+      <input type="hidden" name="token" value="[form_token]">
+      [include "../framework/saved-queries-admin-part.ezt" "user"]
+
+      <input type="submit" id="savechanges" name="btn" value="Save changes"
+             class="submit">
+
+    </form>
+
+  </div>
+</div>
+
+[end][# if not read-only]
+
+[include "../framework/footer.ezt"]
diff --git a/templates/features/transfer-hotlist-form.ezt b/templates/features/transfer-hotlist-form.ezt
new file mode 100644
index 0000000..a837173
--- /dev/null
+++ b/templates/features/transfer-hotlist-form.ezt
@@ -0,0 +1,31 @@
+<div id="transfer-ownership-container" style="display: [if-any open_dialog]block[else]none[end]">
+  <div id="transfer-ownership-dialog">
+    <h2 style="margin-top:0">
+      <a id="hotlist_star"
+            style="color:[if-any hotlist.is_starred]cornflowerblue[else]gray[end]"
+            title="[if-any hotlist.is_starred]Un-s[else]S[end]tar this hotlist">
+            [if-any hotlist.is_starred]&#9733;[else]&#9734;[end]
+            </a>
+      Hotlist: [hotlist.name]
+    </h2>
+
+    <section style="margin: 1em 0">
+      Transfer hotlist ownership to: <input name="changeowners" value="[initial_new_owner_username]" placeholder=[placeholder]>
+      [if-any errors.transfer_ownership]
+        <div class="fielderror">[errors.transfer_ownership]</div>
+      [end]
+    </section>
+
+    <section>
+      Would you like to stay on as an editor of this hotlist?
+      <input type="checkbox" name="becomeeditor" checked>
+    </section>
+
+    <menu>
+      <button id="cancel" type="reset">Cancel</button>
+      <button type="submit">Confirm</button>
+    </menu>
+  </div>
+</div>
+
+<script type="text/javascript" defer src="[version_base]/static/js/hotlists/edit-hotlist.js" nonce="[nonce]"></script>
\ No newline at end of file
diff --git a/templates/features/updates-bulkedit-body.ezt b/templates/features/updates-bulkedit-body.ezt
new file mode 100644
index 0000000..5fc10e7
--- /dev/null
+++ b/templates/features/updates-bulkedit-body.ezt
@@ -0,0 +1 @@
+[is num_issues "1"]Issue [else]Issues [end][for local_ids]<a class="ot-issue-link" href="/p/[project.project_name]/issues/detail?id=[local_ids]">[local_ids]</a>[if-index local_ids last][else], [end][end]
diff --git a/templates/features/updates-ending.ezt b/templates/features/updates-ending.ezt
new file mode 100644
index 0000000..0985311
--- /dev/null
+++ b/templates/features/updates-ending.ezt
@@ -0,0 +1,7 @@
+[is ending_type "in_project"]
+  in project [include "updates-project-link.ezt" "2"]
+[else][is ending_type "by_user"]
+  [define user_profile_url][user.profile_url][end]
+  [define user_display_name][user.display_name][end]
+  by [include "updates-profile-link.ezt" "2"]
+[end][end]
diff --git a/templates/features/updates-entry-part.ezt b/templates/features/updates-entry-part.ezt
new file mode 100644
index 0000000..a1fde4e
--- /dev/null
+++ b/templates/features/updates-entry-part.ezt
@@ -0,0 +1,57 @@
+[# Show one activity.  arg0 is the activity.]
+
+[is arg0.highlight ""]
+  [define column_width]160[end]
+[else]
+  [define column_width]300[end]
+[end]
+
+<li [is even "Yes"]class="even"[end]>
+  <div class="g-section g-tpl-[column_width]">
+    <div class="g-unit g-first">
+      <div class="g-c">
+        [if-any arg0.highlight]
+        <div class="g-section g-tpl-160">
+          <div class="g-unit g-first">
+            <div class="g-c">
+              <span class="date [if-any arg0.escaped_body]below-more[else][end] activity" title="[arg0.date_tooltip]">[arg0.date_relative]</span>
+            </div>
+          </div>
+          <div class="g-unit">
+            <div class="g-c" style="padding-right:1em">
+              <span class="highlight-column">
+                [is arg0.highlight "project"]
+                <a href="/p/[arg0.project_name]/" title="[arg0.project_name]">[arg0.project_name]</a>
+                [else][is arg0.highlight "user"]
+                <a href="[arg0.user.profile_url]" title="[arg0.user.display_name]">[arg0.user.display_name]</a>
+                [end][end]
+              </span>
+            </div>
+          </div>
+        </div>
+        [else]
+        <span class="date [if-any arg0.escaped_body]below-more[end] activity" title="[arg0.date_tooltip]">[arg0.date_relative]</span>
+        [end]
+      </div>
+    </div>
+    <div class="g-unit">
+      <div class="g-c">
+        <span class="content">
+          [# SECURITY: OK to use "raw" here because escaped_title was preprocessed through the template engine.]
+          <span class="title">[format "raw"][arg0.escaped_title][end]</span>
+          [if-any arg0.escaped_body]
+          <span class="details-inline" style="margin-left:.5em">
+            [# SECURITY: OK to use "raw" here because escaped_body was preprocessed through the template engine.]
+            - [format "raw"][arg0.escaped_body][end]
+          </span>
+          <div class="details-wrapper">
+            [# SECURITY: OK to use "raw" here because escaped_body was preprocessed through the template engine.]
+            <div class="details">[format "raw"][arg0.escaped_body][end]</div>
+          </div>
+          [end]
+        </span>
+      </div>
+    </div>
+  </div>
+</li>
+[define even][is even "Yes"]No[else]Yes[end][end]
diff --git a/templates/features/updates-issue-link.ezt b/templates/features/updates-issue-link.ezt
new file mode 100644
index 0000000..d3b6a95
--- /dev/null
+++ b/templates/features/updates-issue-link.ezt
@@ -0,0 +1,5 @@
+<a class="ot-issue-link"
+   [# Go to the first comment with the correct timestamp. That's usually right, and close
+      even in cases where it is wrong.  It avoids exposing a DB ID.]
+   href="/p/[issue.project_name]/issues/detail?id=[issue.local_id][if-any issue_change_id]#c_ts[issue_change_id][end]"
+   >issue [issue.local_id]</a>
diff --git a/templates/features/updates-issueupdate-body.ezt b/templates/features/updates-issueupdate-body.ezt
new file mode 100644
index 0000000..5d0f683
--- /dev/null
+++ b/templates/features/updates-issueupdate-body.ezt
@@ -0,0 +1,16 @@
+[# Format the body of one issue update in the activities list.]
+
+<span class="ot-issue-comment">
+  [for comment.text_runs][include "../tracker/render-rich-text.ezt" comment.text_runs][end]
+</span>
+
+[if-any comment.amendments]
+  <div class="ot-issue-fields">
+    [for comment.amendments]
+      <div class="ot-issue-field-wrapper">
+       <span class="ot-issue-field-name">[comment.amendments.field_name]: </span>
+       <span class="ot-issue-field-value">[comment.amendments.newvalue]</span>
+      </div>
+    [end]
+  </div>
+[end]
diff --git a/templates/features/updates-issueupdate-title.ezt b/templates/features/updates-issueupdate-title.ezt
new file mode 100644
index 0000000..1475df9
--- /dev/null
+++ b/templates/features/updates-issueupdate-title.ezt
@@ -0,0 +1,28 @@
+[# Pre-render the title of an activity for an issue update.]
+
+[include "updates-issue-link.ezt"]
+([issue.short_summary])
+
+[define field_changed][end]
+[define multiple_fields_changed][end]
+[for comment.amendments]
+  [if-any field_changed]
+    [define multiple_fields_changed]True[end]
+  [else]
+    [define field_changed][comment.amendments.field_name][end]
+  [end]
+[end]
+
+[if-any issue_change_id]
+  [if-any multiple_fields_changed]
+    changed
+  [else][if-any field_changed]
+    [field_changed] changed
+  [else]
+    commented on
+  [end][end]
+[else]
+  reported
+[end]
+
+[include "updates-ending.ezt"]
diff --git a/templates/features/updates-newproject-body.ezt b/templates/features/updates-newproject-body.ezt
new file mode 100644
index 0000000..2d0feb0
--- /dev/null
+++ b/templates/features/updates-newproject-body.ezt
@@ -0,0 +1 @@
+<span class="ot-project-summary">[project_summary]</span>
diff --git a/templates/features/updates-page.ezt b/templates/features/updates-page.ezt
new file mode 100644
index 0000000..e5306f3
--- /dev/null
+++ b/templates/features/updates-page.ezt
@@ -0,0 +1,177 @@
+[define title]Updates[end]
+[if-any updates_data]
+
+[define even]Yes[end]
+
+<div id="colcontrol">
+<div class="list">
+    <table style="width: 100%;" cellspacing="0" cellpadding="0">
+     <tbody><tr>
+     <td style="text-align: left;">
+       Details:
+       <a id="detailsshow" href="#" class="showAll">Show all</a>
+       <a id="detailshide" href="#" class="hideAll">Hide all</a></td>
+     <td>
+     [include "../framework/artifact-list-pagination-part.ezt"]
+     </td>
+     </tr>
+     </tbody>
+    </table>
+  </div>
+
+  <table cellspacing="0" cellpadding="0" border="0" width="100%" id="resultstable" class="results" style="table-layout:fixed; width:100%">
+  <tbody>
+  <tr>
+  <td style="padding:0px" width="100%">
+
+  <div id='activity-streams-list' class='activity-stream-list'>
+    [if-any updates_data.today]
+      <h4>Today</h4>
+      <ul class='activity-stream'>
+      [for updates_data.today]
+        [include "updates-entry-part.ezt" updates_data.today]
+      [end]
+      </ul>
+    [end]
+
+    [if-any updates_data.yesterday]
+      <h4>Yesterday</h4>
+      <ul class='activity-stream'>
+      [for updates_data.yesterday]
+        [include "updates-entry-part.ezt" updates_data.yesterday]
+      [end]
+      </ul>
+    [end]
+
+    [if-any updates_data.pastweek]
+      <h4>Last 7 days</h4>
+      <ul class='activity-stream'>
+      [for updates_data.pastweek]
+        [include "updates-entry-part.ezt" updates_data.pastweek]
+      [end]
+      </ul>
+    [end]
+
+    [if-any updates_data.pastmonth]
+      <h4>Last 30 days</h4>
+      <ul class='activity-stream'>
+      [for updates_data.pastmonth]
+        [include "updates-entry-part.ezt" updates_data.pastmonth]
+      [end]
+      </ul>
+    [end]
+
+    [if-any updates_data.thisyear]
+      <h4>Earlier this year</h4>
+      <ul class='activity-stream'>
+      [for updates_data.thisyear]
+        [include "updates-entry-part.ezt" updates_data.thisyear]
+      [end]
+      </ul>
+    [end]
+
+    [if-any updates_data.older]
+      <h4>Older</h4>
+      <ul class='activity-stream'>
+      [for updates_data.older]
+        [include "updates-entry-part.ezt" updates_data.older]
+      [end]
+      </ul>
+    [end]
+  </div>
+
+  </td></tr></tbody></table>
+
+  <div class="list-foot">
+    [include "../framework/artifact-list-pagination-part.ezt"]
+  </div>
+</div>
+
+[else]
+
+  [if-any no_stars]
+    [is user_updates_tab_mode "st2"]
+      <div class="display-error">There are no starred projects.</div>
+    [else][is user_updates_tab_mode "st3"]
+      <div class="display-error">There are no starred developers.</div>
+    [end][end]
+  [else][if-any no_activities]
+    <div class="display-error">There are no updates yet.</div>
+  [end][end]
+
+[end]
+
+[if-any updates_data]
+<script type="text/javascript" nonce="[nonce]">
+runOnLoad(function() {
+
+  /**
+   * Shows the activity detail for the particular activity selected.
+   */
+  function handleActivityLinkClick(e) {
+    var targetEl;
+
+    if (!e) {
+      var e = window.event;
+    }
+    if (e.target) {
+      targetEl = e.target;
+
+    } else if (e.srcElement) {
+      targetEl = e.srcElement;
+    }
+    if (targetEl.nodeType == 3) {
+      targetEl = targetEl.parentNode;
+    }
+
+    while (targetEl.tagName.toLowerCase() != 'li') {
+      targetEl = targetEl.parentNode;
+    }
+    if (targetEl.className.indexOf('click') != -1) {
+      targetEl.className = targetEl.className.replace(/click/, '');
+    } else {
+      targetEl.className += ' click';
+    }
+
+    e.preventDefault();
+  }
+
+  /**
+   * Array of <li> elements for activity streams
+   */
+  var _CS_asElemList = document.getElementById('activity-streams-list').
+      getElementsByTagName('li');
+
+  /**
+   * Shows all activity details
+   */
+  function expandAll(event) {
+    for (var i=0; i < _CS_asElemList.length; i++) {
+      _CS_asElemList[[]i].className = 'click';
+    }
+    event.preventDefault();
+  }
+
+  /**
+   * Hides all activity details
+   */
+  function closeAll(event) {
+    for (var i=0; i < _CS_asElemList.length; i++) {
+      _CS_asElemList[[]i].className = '';
+    }
+    event.preventDefault();
+  }
+
+  if ($("detailsshow"))
+    $("detailsshow").addEventListener("click", expandAll);
+  if ($("detailshide"))
+    $("detailshide").addEventListener("click", closeAll);
+
+  var activityLinks = document.getElementsByClassName("activity");
+  for (var i = 0; i < activityLinks.length; ++i) {
+    var link = activityLinks[[]i];
+    link.addEventListener("click", handleActivityLinkClick);
+  }
+});
+</script>
+[end]
diff --git a/templates/features/updates-profile-link.ezt b/templates/features/updates-profile-link.ezt
new file mode 100644
index 0000000..722dbae
--- /dev/null
+++ b/templates/features/updates-profile-link.ezt
@@ -0,0 +1 @@
+<a class="ot-profile-link-[arg0]" href="[user_profile_url]">[user_display_name]</a>
diff --git a/templates/features/updates-project-link.ezt b/templates/features/updates-project-link.ezt
new file mode 100644
index 0000000..b1a0ec2
--- /dev/null
+++ b/templates/features/updates-project-link.ezt
@@ -0,0 +1 @@
+<a class="ot-project-link-[arg0]" href="/p/[project.project_name]/">[project.project_name]</a>
diff --git a/templates/features/updates-staractivity-body.ezt b/templates/features/updates-staractivity-body.ezt
new file mode 100644
index 0000000..a016c4d
--- /dev/null
+++ b/templates/features/updates-staractivity-body.ezt
@@ -0,0 +1 @@
+[# Placeholder for star activity]
diff --git a/templates/features/updates-staractivity-title.ezt b/templates/features/updates-staractivity-title.ezt
new file mode 100644
index 0000000..93673ad
--- /dev/null
+++ b/templates/features/updates-staractivity-title.ezt
@@ -0,0 +1,5 @@
+[is scope "projects"]
+[is starred "yes"]Starred[else]Unstarred[end] project [include "updates-project-link.ezt" "1"]
+[else][is scope "users"]
+[is starred "yes"]Starred[else]Unstarred[end] <a class="ot-profile-link-1" href="[starred_user_profile_url]">[starred_user_display_name]</a>
+[end][end]
diff --git a/templates/features/user-hotlists.ezt b/templates/features/user-hotlists.ezt
new file mode 100644
index 0000000..438e7b1
--- /dev/null
+++ b/templates/features/user-hotlists.ezt
@@ -0,0 +1,130 @@
+[define title][if-any viewing_self]My[else][viewed_user_display_name][end] hotlists[end]
+[define category_css]css/ph_detail.css[end]
+
+[include "../framework/header.ezt" "showusertabs" "t5"]
+
+
+<h3>Hotlists</h3>
+
+<div class="section">
+
+  <div class="closed">
+    <div>Hotlists allow you to group and rank issues independently of projects and with other users.</div><br>
+    [if-any viewing_self]
+    <div>
+      <a href="/hosting/createHotlist" title="Create a new hotlist">
+        <input type="button" class="primary" value="Create hotlist">
+      </a>
+    </div><br>
+    [end]
+
+    <div class="list">
+      <table style="width:100%;" cellspacing="0" cellpadding="0">
+        <tr>
+          <th style="text-align:left;">Hotlists</th>
+        </tr>
+      </table>
+    </div>
+    <table cellspacing="0" cellpadding="2" border="0" class="results striped" width="100%">
+      <tr id="headingrow">
+        [if-any logged_in_user]<th style="white-space:nowrap; width:3%;">&nbsp;</th>[end]
+        <th style="white-space:nowrap; width:15%;">Role</th>
+        <th style="white-space:nowrap; width:25%">Hotlist</th>
+        <th style="white-space:nowrap; width:10%;">Issues</th>
+        <th style="white-space:nowrap; width:[if-any viewing_self]50[else]47[end]%;">Summary</th>
+      </tr>
+    [if-any owner_of_hotlists editor_of_hotlists]
+      [for owner_of_hotlists]
+        <tr data-url="[owner_of_hotlists.url]">
+          [if-any logged_in_user]
+            <td class="rowwidgets">
+              <a class="star"
+                 style="color:[if-any owner_of_hotlists.is_starred]cornflowerblue[else]gray[end]"
+                 title="[if-any owner_of_hotlists.is_starred]Un-s][else]S[end]tar this hotlist"
+                 data-hotlist-id="[owner_of_hotlists.hotlist_id]">
+             [if-any owner_of_hotlists.is_starred]&#9733;[else]&#9734;[end]
+              </a>
+            </td>
+          [end]
+          <td>Owner</td>
+          <td class="id" name="owner">
+            <a href="[owner_of_hotlists.url]">[owner_of_hotlists.name]</a></td>
+          <td>[owner_of_hotlists.num_issues]</td>
+          <td>[owner_of_hotlists.summary]</td>
+        </tr>
+      [end]
+      [for editor_of_hotlists]
+        <tr data-url="[editor_of_hotlists.url]">
+          [if-any logged_in_user]
+            <td class="rowwidgets">
+              <a class="star"
+                 style="color:[if-any editor_of_hotlists.is_starred]cornflowerblue[else]gray[end]"
+                 title="[if-any editor_of_hotlists.is_starred]Un-s][else]S[end]tar this hotlist"
+                 data-hotlist-id="[editor_of_hotlists.hotlist_id]">
+             [if-any editor_of_hotlists.is_starred]&#9733;[else]&#9734;[end]
+            </td>
+          [end]
+          <td>Editor</td>
+          <td class="id" name="editor">
+            <a href="[editor_of_hotlists.url]">[editor_of_hotlists.name]</a></td>
+          <td>[editor_of_hotlists.num_issues]</td>
+          <td>[editor_of_hotlists.summary]</td>
+        </tr>
+      [end]
+    [else]
+      <td colspan="4"><i>No hotlists.</i></td>
+    [end]
+    </table>
+    [if-any starred_hotlists]
+      <div class="list">
+        <table style="width:100%;" cellspacing="0" cellpadding="0">
+          <tr>
+            <th style="text-align:left;">Hotlists starred by [if-any viewing_self]you[else][viewed_user_display_name][end]</th>
+          </tr>
+        </table>
+      </div>
+      <table cellspacing="0" cellpadding="2" border="0" class="results striped" width="100%">
+        <tr>
+          <th style="white-space:nowrap; width:3%;">&nbsp;</th>
+          <th style="white-space:nowrap; width:30%;">Hotlist</th>
+          <th style="white-space:nowrap; width:10%;">Issues</th>
+          <th style="white-space:nowrap; width:57%;">Summary</th>
+        </tr>
+        [for starred_hotlists]
+          <tr data-url="[starred_hotlists.url]">
+            <td class="rowwidgets">
+              <a class="star"
+                 style="color:[if-any starred_hotlists.is_starred]cornflowerblue[else]gray[end]"
+                 title="[if-any starred_hotlists.is_starred]Un-s][else]S[end]tar this hotlist"
+                 data-hotlist-id="[starred_hotlists.hotlist_id]">
+             [if-any starred_hotlists.is_starred]&#9733;[else]&#9734;[end]
+            </td>
+            <td class="id" name="follower">
+              <a href="[starred_hotlists.url]">[starred_hotlists.name]</a></td>
+            </td>
+            <td>[starred_hotlists.num_issues]</td>
+            <td>[starred_hotlists.summary]</td>
+          </tr>
+        [end]
+      </table>
+    [end]
+
+  </div>
+</div>
+
+<script type="text/javascript" nonce="[nonce]">
+runOnLoad(function() {
+
+ var stars = document.getElementsByClassName("star");
+  for (var i = 0; i < stars.length; ++i) {
+    var star = stars[[]i];
+    star.addEventListener("click", function (event) {
+        var hotlistID = event.target.getAttribute("data-hotlist-id");
+        _TKR_toggleStar(event.target, null, null, null, hotlistID);
+    });
+  }
+
+});
+</script>
+
+[include "../framework/footer.ezt"]
