diff --git a/.mailmap b/.mailmap
index 81e31ea2a1..42f74158ab 100644
--- a/.mailmap
+++ b/.mailmap
@@ -8,7 +8,10 @@
 # For any emails that show up in the shortlog that aren't in one of
 # these lists, figure out their GitHub username and add them.
 
+GITHUB: aldeed <eric@dairystatedesigns.com>
 GITHUB: AlexeyMK <alexey@alexeymk.com>
+GITHUB: apendua <apendua@gmail.com>
+GITHUB: arbesfeld <arbesfeld@gmail.com>
 GITHUB: DenisGorbachev <Denis.Gorbachev@faster-than-wind.ru>
 GITHUB: EOT <eot@gmx.at>
 GITHUB: FooBarWidget <honglilai@gmail.com>
@@ -17,13 +20,17 @@ GITHUB: OyoKooN <nathan@sxnlabs.com>
 GITHUB: RobertLowe <robert@iblargz.com>
 GITHUB: ansman <nicklas@ansman.se>
 GITHUB: awwx <andrew.wilcox@gmail.com>
+GITHUB: cmather <mather.chris@gmail.com>
 GITHUB: codeinthehole <david.winterbottom@gmail.com>
 GITHUB: dandv <ddascalescu+github@gmail.com>
+GITHUB: davegonzalez <gonzalez.dalex@gmail.com>
 GITHUB: emgee3 <hello@gravitronic.com>
 GITHUB: icellan <icellan@icellan.com>
 GITHUB: jacott <geoffjacobsen@gmail.com>
 GITHUB: jfhamlin <jfhamlin@gmail.com>
+GITHUB: justinsb <justin@fathomdb.com>
 GITHUB: marcandre <github@marc-andre.ca>
+GITHUB: mart-jansink <m.jansink@gmail.com>
 GITHUB: meawoppl <meawoppl@gmail.com>
 GITHUB: michaelbishop <michael@michaelsplace.net>
 GITHUB: mitar <mitar.git@tnode.com>
@@ -31,7 +38,9 @@ GITHUB: mitar <mitar.github@tnode.com>
 GITHUB: mizzao <mizzao@gmail.com>
 GITHUB: mquandalle <maxime.quandalle@gmail.com>
 GITHUB: nathan-muir <ndmuir@gmail.com>
+GITHUB: Neftedollar <oildollar@gmail.com>
 GITHUB: paulswartz <paulswartz@gmail.com>
+GITHUB: Pent <jon@empire5design.com>
 GITHUB: queso <joshua.owens@gmail.com>
 GITHUB: rdickert <robert.dickert@gmail.com>
 GITHUB: rgould <rwgould@gmail.com>
@@ -48,6 +57,7 @@ METEOR: dgreensp <dgreenspan@alum.mit.edu>
 METEOR: estark37 <emily@meteor.com>
 METEOR: estark37 <estark37@gmail.com>
 METEOR: glasser <glasser@meteor.com>
+METEOR: glasser <glasser@davidglasser.net>
 METEOR: gschmidt <geoff@geoffschmidt.com>
 METEOR: karayu <lele.yu@gmail.com>
 METEOR: n1mmy <nim@meteor.com>
@@ -55,3 +65,4 @@ METEOR: sixolet <naomi@meteor.com>
 METEOR: Slava <slava@meteor.com>
 METEOR: stubailo <sashko@mit.edu>
 METEOR: ekatek <ekate@meteor.com>
+
diff --git a/History.md b/History.md
index a067d9aec4..8338651266 100644
--- a/History.md
+++ b/History.md
@@ -1,7 +1,190 @@
 ## v.NEXT
 
+#### Meteor Accounts
+
 * Log out a user's other sessions when they change their password.
 
+* Store pending OAuth login results in the database instead of
+  in-memory, so that an OAuth flow succeeds even if different requests
+  go to different server processes.
+
+* When validateLoginAttempt callbacks return false, don't override a more
+  specific error message.
+
+* Add `Random.secret()` for generating security-critical secrets like
+  login tokens.
+
+* `Meteor.logoutOtherClients` now calls the user callback when other
+  login tokens have actually been removed from the database, not when
+  they have been marked for eventual removal. Fixes #1915.
+
+* Rename `Oauth` to `OAuth`.  `Oauth` is now an alias for backwards
+  compatibility.
+
+* Add `oauth-encryption` package for encrypting sensitive account
+  credentials in the database.
+
+* A validate login hook can now override the exception thrown from
+  `beginPasswordExchange` like it can for other login methods.
+
+* Remove an expensive observe over all users in the `accounts-base`
+  package.
+
+
+#### Blaze
+
+* Blaze no longer renders javascript: URLs in attribute values by
+  default, to help prevent cross-site scripting bugs. Use
+  `UI._allowJavascriptUrls()` to allow them.
+
+* Fix `UI.toHTML` on templates containing `{{#with}}`
+
+* Fix {{#with}} over a data context that is mutated
+
+* Properly clean up autoruns on `UI.toHTML`
+
+* Add support for `{{!-- block comments --}}` in Spacebars. Block comments may
+  contain `}}`, so they are more useful than `{{! normal comments}}` for
+  commenting out sections of Spacebars templates.
+  XXX shouldn't this be in spacebars/README.md?
+
+* Kill TBODY special case in DomRange (XXX 45ac9b1a6d needs a better
+  description)
+
+* Do not ignore jquery-event extra parameters (? XXX b2193f5)
+
+
+#### DDP and Mongo
+
+* DDP heartbeats XXX
+
+* Generalize the mechanism by which client-side inserts generated IDs to support
+  latency compensation of generation of multiple random values. For example,
+  calling `insert` inside a method body will now return consistent IDs on the
+  client and the server.  Code that wants a random stream that is consistent
+  between method stub and real method execution can get one with
+  `DDP.randomStream`.
+
+* The oplog observe driver handles errors communicating with Mongo better and
+  knows to re-poll all queries during Mongo failovers.
+
+* Fix bugs involving mutating DDP method arguments.
+
+
+#### meteor command-line tool
+
+* Move boilerplate HTML from tools to webapp. Changes internal
+  Webapp.addHtmlAttributeHook API incompatibly.
+
+* Add `meteor list-sites` command for listing the sites that you have
+  deployed to meteor.com with your Meteor developer account.
+
+* Third-party template languages can request that their generated source loads
+  before other JavaScript files, just like *.html files, by passing the
+  isTemplate option to Plugin.registerSourceHandler.
+
+* You can specify a particular interface for the dev mode runner to bind to with
+  `meteor -p host:port`.
+
+* Don't include proprietary tar tags in bundle tarballs.
+
+* Convert relative urls to absolute url when merging CSS files
+
+
+#### Upgraded dependencies
+
+* Node.js from 0.10.25 to 0.10.26.
+* MongoDB driver from 1.3.19 to 1.4.1
+* stylus: 0.42.3 (from 0.42.2)
+* showdown: XXX (from XXX)
+* css-parse: an unreleased version (from 1.7.0)
+* css-stringify: an unreleased version (from 1.4.1)
+
+
+Patches contributed by GitHub users aldeed, apendua, arbesfeld, awwx, dandv,
+davegonzalez, emgee3, justinsb, mquandalle, Neftedollar, Pent, sdarnell,
+and timhaines.
+
+
+## v0.8.0.1
+
+* Fix security flaw in OAuth1 implementation. Clients can no longer
+  choose the callback_url for OAuth1 logins.
+
+
+## v0.8.0
+
+Meteor 0.8.0 introduces Blaze, a total rewrite of our live templating engine,
+replacing Spark. Advantages of Blaze include:
+
+  * Better interoperability with jQuery plugins and other techniques which
+    directly manipulate the DOM
+  * More fine-grained updates: only the specific elements or attributes that
+    change are touched rather than the entire template
+  * A fully documented templating language
+  * No need for the confusing `{{#constant}}`, `{{#isolate}}`, and `preserve`
+    directives
+  * Uses standard jQuery delegation (`.on`) instead of our custom implementation
+  * Blaze supports live SVG templates that work just like HTML templates
+
+See
+[the Using Blaze wiki page](https://github.com/meteor/meteor/wiki/Using-Blaze)
+for full details on upgrading your app to 0.8.0.  This includes:
+
+* The `Template.foo.rendered` callback is now only called once when the template
+  is rendered, rather than repeatedly as it is "re-rendered", because templates
+  now directly update changed data instead of fully re-rendering.
+
+* The `accounts-ui` login buttons are now invoked as a `{{> loginButtons}}`
+  rather than as `{{loginButtons}}`.
+
+* Previous versions of Meteor used a heavily modified version of the Handlebars
+  templating language. In 0.8.0, we've given it its own name: Spacebars!
+  Spacebars has an
+  [explicit specification](https://github.com/meteor/meteor/blob/devel/packages/spacebars/README.md)
+  instead of being defined as a series of changes to Handlebars. There are some
+  incompatibilities with our previous Handlebars fork, such as a
+  [different way of specifying dynamic element attributes](https://github.com/meteor/meteor/blob/devel/packages/spacebars/README.md#in-attribute-values)
+  and a
+  [new way of defining custom block helpers](https://github.com/meteor/meteor/blob/devel/packages/spacebars/README.md#custom-block-helpers).
+
+* Your template files must consist of
+  [well-formed HTML](https://github.com/meteor/meteor/blob/devel/packages/spacebars/README.md#html-dialect). Invalid
+  HTML is now a compilation failure.  (There is a current limitation in our HTML
+  parser such that it does not support
+  [omitting end tags](http://www.w3.org/TR/html5/syntax.html#syntax-tag-omission)
+  on elements such as `<P>` and `<LI>`.)
+
+* `Template.foo` is no longer a function. It is instead a
+  "component". Components render to an intermediate representation of an HTML
+  tree, not a string, so there is no longer an easy way to render a component to
+  a static HTML string.
+
+* `Meteor.render` and `Spark.render` have been removed. Use `UI.render` and
+  `UI.insert` instead.
+
+* The `<body>` tag now defines a template just like the `<template>` tag, which
+  can have helpers and event handlers.  Define them directly on the object
+  `UI.body`.
+
+* Previous versions of Meteor shipped with a synthesized `tap` event,
+  implementing a zero-delay click event on mobile browsers. Unfortunately, this
+  event never worked very well. We're eliminating it. Instead, use one of the
+  excellent third party solutions.
+
+* The `madewith` package (which supported adding a badge to your website
+  displaying its score from http://madewith.meteor.com/) has been removed, as it
+  is not compatible with the new version of that site.
+
+* The internal `spark`, `liverange`, `universal-events`, and `domutils` packages
+  have been removed.
+
+* The `Handlebars` namespace has been deprecated.  `Handlebars.SafeString` is
+  now `Spacebars.SafeString`, and `Handlebars.registerHelper` is now
+  `UI.registerHelper`.
+
+Patches contributed by GitHub users cmather and mart-jansink.
+
 
 ## v0.7.2
 
diff --git a/LICENSE.txt b/LICENSE.txt
index 082c5e26ce..afa98ec4df 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -554,6 +554,14 @@ bcrypt: https://github.com/ncb000gt/node.bcrypt.js
 Copyright (c) 2010 Nicholas Campbell
 
 
+----------
+html5: https://github.com/aredridel/html5
+----------
+
+Copyright (c) 2010 Aria Stewart <aredridel@nbtsc.org>
+
+
+
 ==============
 Apache License
 ==============
diff --git a/docs/.meteor/packages b/docs/.meteor/packages
index f4302d6960..46c52f81e7 100644
--- a/docs/.meteor/packages
+++ b/docs/.meteor/packages
@@ -12,4 +12,3 @@ jquery-waypoints
 less
 spiderable
 appcache
-handlebars
diff --git a/docs/.meteor/release b/docs/.meteor/release
index 7486fdbc50..4b324f2d8f 100644
--- a/docs/.meteor/release
+++ b/docs/.meteor/release
@@ -1 +1 @@
-0.7.2
+0.8.0.1
diff --git a/docs/client/api.html b/docs/client/api.html
index 62991b5167..ff1f70e001 100644
--- a/docs/client/api.html
+++ b/docs/client/api.html
@@ -1,5 +1,5 @@
 <template name="api">
-{{#better_markdown}}
+{{#markdown}}
 
 <h1 id="api">The Meteor API</h1>
 
@@ -455,7 +455,7 @@ the server. The return value is an object with the following fields:
 
 Instead of using callbacks to notify you on changes, this is
 a [reactive](#reactivity) data source. You can use it in a
-[template](#templates) or [computation](#deps_autorun)
+[template](#livehtmltemplates) or [computation](#deps_autorun)
 to get realtime updates.
 
 {{> api_box reconnect}}
@@ -1109,15 +1109,6 @@ the matching documents.
 
 {{> api_box cursor_count}}
 
-    // Display a count of posts matching certain criteria. Automatically
-    // keep it updated as the database changes.
-    var frag = Meteor.render(function () {
-      var highScoring = Posts.find({score: {$gt: 10}});
-      return "<p>There are " + highScoring.count() + " posts with " +
-        "scores greater than 10</p>";
-    });
-    document.body.appendChild(frag);
-
 Unlike the other functions, `count` registers a dependency only on the
 number of matching documents.  (Updates that just change or reorder the
 documents in the result set will not trigger a recomputation.)
@@ -1142,31 +1133,31 @@ applicable. If you only need to receive the fields that changed, see
 <dt><span class="name">added(document)</span> <span class="or">or</span></dt>
 <dt><span class="name">addedAt(document, atIndex, before)</span></dt>
 <dd>
-{{#better_markdown}}
+{{#markdown}}
 A new document `document` entered the result set. The new document
 appears at position `atIndex`. It is immediately before the document
 whose `_id` is `before`. `before` will be `null` if the new document
 is at the end of the results.
-{{/better_markdown}}
+{{/markdown}}
 </dd>
 
 <dt><span class="name">changed(newDocument, oldDocument)
     <span class="or">or</span></span></dt>
 <dt><span class="name">changedAt(newDocument, oldDocument, atIndex)</span></dt>
 <dd>
-{{#better_markdown}}
+{{#markdown}}
 The contents of a document were previously `oldDocument` and are now
 `newDocument`. The position of the changed document is `atIndex`.
-{{/better_markdown}}
+{{/markdown}}
 </dd>
 
 <dt><span class="name">removed(oldDocument)</span>
   <span class="or">or</span></dt>
 <dt><span class="name">removedAt(oldDocument, atIndex)</span></dt>
 <dd>
-{{#better_markdown}}
+{{#markdown}}
 The document `oldDocument` is no longer in the result set. It used to be at position `atIndex`.
-{{/better_markdown}}
+{{/markdown}}
 </dd>
 
 {{#dtdd "movedTo(document, fromIndex, toIndex, before)"}}
@@ -1207,12 +1198,12 @@ result set, not the entire contents of the document that changed.
   <span class="or">or</span></dt>
 <dt><span class="name">addedBefore(id, fields, before)</span></dt>
 <dd>
-{{#better_markdown}}
+{{#markdown}}
 A new document entered the result set. It has the `id` and `fields`
 specified. `fields` contains all fields of the document excluding the
 `_id` field. The new document is before the document identified by
 `before`, or at the end if `before` is `null`.
-{{/better_markdown}}
+{{/markdown}}
 </dd>
 
 {{#dtdd "changed(id, fields)"}}
@@ -1287,7 +1278,7 @@ that needs to deal with `_id` fields that may be either strings or `ObjectID`s,
   method, since Meteor currently constructs them fully randomly.
 {{/note}}
 
-{{#api_box_inline selectors}}
+{{#api_box selectors}}
 
 The simplest selectors are just a string or
 [`Meteor.Collection.ObjectID`](#collection_object_id). These selectors match the
@@ -1319,9 +1310,9 @@ But they can also contain more complicated tests:
 See the [complete
 documentation](http://docs.mongodb.org/manual/reference/operator/).
 
-{{/api_box_inline}}
+{{/api_box}}
 
-{{#api_box_inline modifiers}}
+{{#api_box modifiers}}
 
 A modifier is an object that describes how to update a document in
 place by changing some of its fields. Some examples:
@@ -1344,9 +1335,9 @@ supported by [validated updates](#allow).)
 See the [full list of
 modifiers](http://www.mongodb.org/display/DOCS/Updating#Updating-ModifierOperations).
 
-{{/api_box_inline}}
+{{/api_box}}
 
-{{#api_box_inline sortspecifiers}}
+{{#api_box sortspecifiers}}
 
 Sorts may be specified using your choice of several syntaxes:
 
@@ -1361,9 +1352,9 @@ The last form will only work if your JavaScript implementation
 preserves the order of keys in objects. Most do, most of the time, but
 it's up to you to be sure.
 
-{{/api_box_inline}}
+{{/api_box}}
 
-{{#api_box_inline fieldspecifiers}}
+{{#api_box fieldspecifiers}}
 
 Queries can specify a particular set of fields to include or exclude from the
 result object.
@@ -1406,7 +1397,7 @@ A more advanced example:
 See <a href="http://docs.mongodb.org/manual/tutorial/project-fields-from-query-results/#projection">
 the MongoDB docs</a> for details of the nested field rules and array behavior.
 
-{{/api_box_inline}}
+{{/api_box}}
 
 <h2 id="session"><span>Session</span></h2>
 
@@ -1419,7 +1410,7 @@ you call [`Session.get`](#session_get)`("currentList")`
 from inside a template, the template will automatically be rerendered
 whenever [`Session.set`](#session_set)`("currentList", x)` is called.
 
-{{> api_box set}}
+{{> api_box session_set}}
 
 Example:
 
@@ -1436,21 +1427,28 @@ Example:
 This is useful in initialization code, to avoid re-initializing a session
 variable every time a new version of your app is loaded.
 
-{{> api_box get}}
+{{> api_box session_get}}
 
 Example:
 
-    Session.set("enemy", "Eastasia");
-    var frag = Meteor.render(function () {
-      return "<p>We've always been at war with " +
-        Session.get("enemy") + "</p>";
+    // in main.html
+    {{lt}}template name="main">
+      <p>We've always been at war with {{dstache}}theEnemy}}.</p>
+    {{lt}}/template>
+
+    // in main.js
+    Template.main.helpers({
+      theEnemy: function () {
+        return Session.get("enemy");
+      }
     });
 
+    Session.set("enemy", "Eastasia");
     // Page will say "We've always been at war with Eastasia"
-    document.body.append(frag);
 
-    // Page will change to say "We've always been at war with Eurasia"
     Session.set("enemy", "Eurasia");
+    // Page will change to say "We've always been at war with Eurasia"
+
 
 {{> api_box equals}}
 
@@ -1464,7 +1462,7 @@ If value is a scalar, then these two expressions do the same thing:
 
 Example:
 
-    <template name="postsView">
+    {{lt}}template name="postsView">
     {{dstache}}! Show a dynamically updating list of items. Let the user click on an
         item to select it. The selected item is given a CSS class so it
         can be rendered differently. }}
@@ -1472,11 +1470,11 @@ Example:
     {{dstache}}#each posts}}
       {{dstache}}> postItem }}
     {{dstache}}/each}}
-    </{{! }}template>
+    {{lt}}/template>
 
-    <template name="postItem">
+    {{lt}}template name="postItem">
       <div class="{{dstache}}postClass}}">{{dstache}}title}}</div>
-    </{{! }}template>
+    {{lt}}/template>
 
     ///// in JS file
     Template.postsView.posts = function() {
@@ -1712,6 +1710,11 @@ example, to support GitHub login, run `$ meteor add accounts-github` and use the
         Session.set('errorMessage', err.reason || 'Unknown error');
     });
 
+Login service configuration is sent from the server to the client over DDP when
+your app starts up; you may not call the login function until the configuration
+is loaded. The function `Accounts.loginServicesConfigured()` is a reactive data
+source that will return true once the login service is configured; you should
+not make login buttons visible or active until it is true.
 
 
 {{> api_box currentUser}}
@@ -1850,10 +1853,18 @@ proceed.  If the callback returns a falsy value or throws an
 exception, the login is aborted.  Throwing a `Meteor.Error` will
 report the error reason to the user.
 
-All registered validate login callbacks are called, even if one of the
-callbacks aborts the login.  The later callbacks will see the
-`allowed` field set to `false` since the login will now not be
-successful.
+All registered validate login callbacks are called, even if one of the callbacks
+aborts the login.  The later callbacks will see the `allowed` field set to
+`false` since the login will now not be successful.  This allows later callbacks
+to override an error from a previous callback; for example, you could override
+the "Incorrect password" error with a different message.
+
+Validate login callbacks that aren't explicitly trying to override a previous
+error generally have no need to run if the attempt has already been determined
+to fail, and should start with
+
+    if (!attempt.allowed)
+      return false;
 
 
 {{> api_box accounts_onLogin}}
@@ -2011,11 +2022,19 @@ Example:
 
 <h2 id="templates_api"><span>Templates</span></h2>
 
-A template that you declare as `<{{! }}template name="foo"> ... </{{!
-}}template>` can be accessed as the function `Template.foo`, which
-returns a string of HTML when called.
 
-The same template may occur many times on the page, and these
+When you write a template as `<{{! }}template name="foo"> ... <{{!
+}}/template>` in an HTML file in your app, Meteor generates a
+"component object" named `Template.foo`.
+
+{{#note}}
+   Meteor's component API is currently in flux. This section documents a few
+   features of the component object that are useful for writing apps; a future
+   release will elaborate more about how components work and about how to build
+   components that aren't just template.
+{{/note}}
+
+The same template may occur many times on a page, and these
 occurrences are called template instances.  Template instances have a
 life cycle of being created, put into the document, and later taken
 out of the document and destroyed.  Meteor manages these stages for
@@ -2024,61 +2043,6 @@ or replaced and should be cleaned up.  You can associate data with a
 template instance, and you can access its DOM nodes when it is in the
 document.
 
-Additionally, Meteor will maintain a template instance and its state
-even if its surrounding HTML is re-rendered into new DOM nodes.  As
-long as the structure of template invocations is the same, Meteor will
-not consider any instances to have been created or destroyed.  You can
-request that the same DOM nodes be retained as well using `preserve`
-and `constant`.
-
-There are a number of callbacks and directives that you can specify on
-a named template and that apply to all instances of the template.
-They are described below.
-
-{{> api_box template_call}}
-
-When called inside a template helper, the body of `Meteor.render`, or
-other settings where reactive HTML is being generated, the resulting
-HTML is annotated so that it renders as reactive DOM elements.
-Otherwise, the HTML is unadorned and static.
-
-
-{{> api_box template_rendered}}
-
-This callback is called once when an instance of Template.*myTemplate* is
-rendered into DOM nodes and put into the document for the first time, and again
-each time any part of the template is re-rendered.
-
-In the body of the callback, `this` is a [template
-instance](#template_inst) object that is unique to this occurrence of
-the template and persists across re-renderings.  Use the `created` and
-`destroyed` callbacks to perform initialization or clean-up on the
-object.
-
-{{> api_box template_created}}
-
-This callback is called when an invocation of *myTemplate* represents
-a new occurrence of the template and not a re-rendering of an existing
-template instance.  Inside the callback, `this` is the new [template
-instance](#template_inst) object.  Properties you set on this object
-will be visible from the `rendered` and `destroyed` callbacks and from
-event handlers.
-
-This callback fires once and is the first callback to fire.  Every
-`created` has a corresponding `destroyed`; that is, if you get a
-`created` callback with a certain template instance object in `this`,
-you will eventually get a `destroyed` callback for the same object.
-
-{{> api_box template_destroyed}}
-
-This callback is called when an occurrence of a template is taken off
-the page for any reason and not replaced with a re-rendering.  Inside
-the callback, `this` is the [template instance](#template_inst) object
-being destroyed.
-
-This callback is most useful for cleaning up or undoing any external
-effects of `created`.  It fires once and is the last callback to fire.
-
 
 {{> api_box template_events}}
 
@@ -2101,104 +2065,83 @@ Example:
       }
     });
 
-In Handlebars, this helper would then be invoked as `{{dstache}}foo}}`.
+Now you can invoke this helper with `{{dstache}}foo}}` in the template defined
+with `<{{! }}template name="myTemplate">`.
 
-The following syntax is equivalent, but won't work for reserved property
-names:
+The following syntax is a shorthand for when you only have one helper to define:
 
     Template.myTemplate.foo = function () {
       return Session.get("foo");
     };
 
-{{> api_box template_preserve}}
+To create a helper that can be used in any template, use
+[`UI.registerHelper`](#ui_registerhelper).
 
-You can "preserve" a DOM element during re-rendering, leaving the
-existing element in place in the document while replacing the
-surrounding HTML.  This means that re-rendering a template need not
-disturb text fields, iframes, and other sensitive elements it
-contains.  The elements to preserve must be present both as nodes in
-the old DOM and as tags in the new HTML.  Meteor will patch the DOM
-around the preserved elements.
+
+{{> api_box template_rendered}}
+
+This callback is called once when an instance of Template.*myTemplate* is
+rendered into DOM nodes and put into the document for the first time.
+
+In the body of the callback, `this` is a [template
+instance](#template_inst) object that is unique to this occurrence of
+the template and persists across re-renderings.  Use the `created` and
+`destroyed` callbacks to perform initialization or clean-up on the
+object.
+
+Because your template has been rendered, you can use functions like
+`this.findAll` which look at its DOM nodes.
+
+{{> api_box template_created}}
+
+This callback is called before your template's logic is evaluated for the first
+time.  Inside the callback, `this` is the new [template
+instance](#template_inst) object.  Properties you set on this object will be
+visible from the `rendered` and `destroyed` callbacks and from event handlers.
+
+This callback fires once and is the first callback to fire.  Every
+`created` has a corresponding `destroyed`; that is, if you get a
+`created` callback with a certain template instance object in `this`,
+you will eventually get a `destroyed` callback for the same object.
 
 {{#note}}
-By default, new Meteor apps automatically include the
-`preserve-inputs` package.  This preserves all elements of type
-`input`, `textarea`, `button`, `select`, and `option` that have unique
-`id` attributes or that have `name` attributes that are unique within
-an enclosing element with an `id` attribute.  To turn off this default
-behavior, simply remove the `preserve-inputs` package.
+  The `created` callback is not currently very useful. In a later release, the
+  template instance object (or something like it) will be visible from helper
+  functions, and `created` will be a useful way to set up values that are read
+  from helpers. For now, you probably just want to use `rendered`.
 {{/note}}
 
-Preservation is useful in a variety of cases where replacing a DOM
-element with an identical or modified element would not have the same
-effect as retaining the original element.  These include:
+{{> api_box template_destroyed}}
 
-* Input text fields and other form controls
-* Elements with CSS animations
-* Iframes
-* Nodes with references kept in JavaScript code
+This callback is called when an occurrence of a template is taken off
+the page for any reason and not replaced with a re-rendering.  Inside
+the callback, `this` is the [template instance](#template_inst) object
+being destroyed.
 
-If you want to preserve a whole region of the DOM, an element and its
-children, or nodes not rendered by Meteor, use a [constant
-region](#constant) instead.
-
-To preserve nodes, pass a list of selectors, each of which should match
-at most one element in the template.  When the template is re-rendered,
-the selector is run on the old DOM and the new DOM, and Meteor will
-reuse the old element in place while working in any HTML changes around
-it.
-
-A second form of `preserve` takes a labeling function for each selector
-and allows the selectors to match multiple nodes. The node-labeling
-function takes a node and returns a label string that is unique for each
-node, or `false` to exclude the node from preservation.
-
-For example, to preserve all `<input>` elements with ids in template 'foo', use:
-
-    Template.foo.preserve({
-      'input[id]': function (node) { return node.id; }
-    });
-
-Selectors are interpreted as rooted at the top level of the template.
-Each occurrence of the template operates independently, so the selectors
-do not have to be unique on the entire page, only within one occurrence
-of the template.  Selectors will match nodes even if they are in
-sub-templates.
-
-Preserving a node does *not* preserve its attributes or contents. They
-will be updated to reflect the new HTML. Text in input fields is not
-preserved unless the input field has focus, in which case the cursor and
-selection are left intact. Iframes retain their navigation state and
-animations continue to run as long as their parameters haven't changed.
-
-There are some cases where nodes can not be preserved because of
-constraints inherent in the DOM API. For example, an element's tag name
-can't be changed, and it can't be moved relative to its parent or other
-preserved nodes.  For this reason, nodes that are re-ordered or
-re-parented by an update will not be preserved.
-
-{{#note}}
-Previous versions of Meteor had an implicit page-wide `preserve`
-directive that labeled nodes by their "id" and "name" attributes.
-This has been removed in favor of the explicit, opt-in mechanism.
-{{/note}}
+This callback is most useful for cleaning up or undoing any external effects of
+`created` or `rendered`.  It fires once and is the last callback to fire.
 
 
 <h2 id="template_inst"><span>Template instances</span></h2>
 
 A template instance object represents an occurrence of a template in
 the document.  It can be used to access the DOM and it can be
-assigned properties that persist across page re-renderings.
+assigned properties that persist as the template is reactively updated.
 
 Template instance objects are found as the value of `this` in the
-`created`, `rendered`, and `destroyed` template callbacks and as an
+`created`, `rendered`, and `destroyed` template callbacks, and as an
 argument to event handlers.
 
-In addition to the properties and functions described below, you can
-assign additional properties of your choice to the object.  Property names
-starting with `_` are guaranteed to be available for your use.  Use
-the `created` and `destroyed` callbacks to perform initialization or
-clean-up on the object.
+{{#note}}
+  You cannot currently access the template instance object from helpers.
+  We plan to refactor how template instances work and make them more
+  universally accessible.
+{{/note}}
+
+In addition to the properties and functions described below, you can assign
+additional properties of your choice to the object. Use the
+[`created`](#template_created) and [`destroyed`](#template_destroyed) callbacks
+to perform initialization or clean-up on the object.
 
 You can only access `findAll`, `find`, `firstNode`, and `lastNode`
 from the `rendered` callback and event handlers, not from `created`
@@ -2207,7 +2150,11 @@ in the DOM.
 
 {{> api_box template_findAll}}
 
-Returns an array of DOM elements matching `selector`.
+Returns a [jQuery object](http://api.jquery.com/Types/#jQuery) of DOM elements
+matching `selector`. This object is similar to an array but has other methods
+defined by the jQuery library.
+
+You can also call this function as `this.$(selector)`.
 
 The template instance serves as the document root for the selector. Only
 elements inside the template and its sub-templates can match parts of
@@ -2239,88 +2186,50 @@ the template.  It is updated each time the template is re-rendered.
 Access is read-only and non-reactive.
 
 
-{{> api_box render}}
+<h2 id="ui"><span>Template utilities</span></h2>
 
-`Meteor.render` creates a `DocumentFragment` (a sequence of DOM nodes)
-that automatically updates in realtime. Most Meteor apps don't need to
-call this directly; they use templates and Meteor handles the rendering.
+The `UI` namespace contains several utilities that are helpful when writing your
+user interface.  `UI.registerHelper` allows you to define helper functions which
+you can use in every template.  `UI.render`, `UI.renderWithData`, and
+`UI.insert` allow you to manually render templates and insert them directly into
+any part of the DOM for finer control than just using template inclusions.
 
-Pass in `htmlFunc`, a function that returns an HTML
-string. `Meteor.render` calls the function and turns the output into
-DOM nodes. Meanwhile, it tracks the data that was used when `htmlFunc`
-ran, and automatically wires up callbacks so that whenever any of the
-data changes, `htmlFunc` is re-run and the DOM nodes are updated in
-place.
+{{> api_box ui_registerhelper}}
 
-You may insert the returned `DocumentFragment` directly into the DOM
-wherever you would like it to appear. The inserted nodes will continue
-to update until they are taken off the screen. Then they will be
-automatically cleaned up. For more details about clean-up, see
-[`Deps.flush`](#deps_flush).
+{{> api_box ui_body}}
 
-`Meteor.render` tracks the data dependencies of `htmlFunc` by running
-it in a reactive computation, so it can respond to changes in any reactive
-data sources used by that function. For more information, or to learn
-how to make your own reactive data sources, see
-[Reactivity](#reactivity).
+You can define helpers and event maps on `UI.body` just like on any
+`Template.myTemplate` object.
 
-Example:
+{{> api_box ui_render}}
 
-    // Client side: show the number of players online.
-    var frag = Meteor.render(function () {
-      return "<p>There are " + Players.find({online: true}).count() +
-        " players online.</p>";
-    });
-    document.body.appendChild(frag);
+This returns an "instantiated component" object, which can be passed to
+[`UI.insert`](#ui_insert). The template's [`created`](#template_created) callback
+will be invoked.  The component will continue to be updated reactively as the
+data used changes.
 
-    // Server side: find all players that have been idle for a while,
-    // and mark them as offline. The count on the screen will
-    // automatically update on all clients.
-    Players.update({idleTime: {$gt: 30}}, {$set: {online: false}});
+{{#warning}}
+  Future releases will provide a richer API for "instantiated components"
+  (probably unifying them with "template instances"). For now, all you can
+  do with them is pass them to `UI.insert`.
 
-{{> api_box renderList}}
+  Most users will not need to manually render components or manually insert them
+  into the DOM at all.  As of 0.8.0, if you call `UI.render` and never insert
+  the result into the DOM, the logic to keep the instantiated component updated
+  will continue running in your browser forever. Additionally, if you remove any
+  part of your DOM using any mechanism other than jQuery, the logic to keep that
+  part of the the DOM updated will continue running.  To avoid these issues,
+  either avoid directly updating the DOM or ensure that any removals go through
+  jQuery.
+{{/warning}}
 
-Creates a `DocumentFragment` that automatically updates as the results
-of a database query change. Most Meteor apps use `{{dstache}}#each}}` in
-a template instead of calling this directly.
+{{> api_box ui_renderwithdata}}
 
-`renderList` is more efficient than using `Meteor.render` to render HTML
-for a list of documents.  For example, if a new document is created in
-the database that matches the query, a new item will be rendered and
-inserted at the appropriate place in the DOM without re-rendering the
-other elements.  Similarly, if a document changes position in a sorted
-query, the DOM nodes will simply be moved and not re-rendered.
-
-`docFunc` is called as needed to generate HTML for each document.  If
-you provide `elseFunc`, then whenever the query returns no results, it
-will be called to render alternate content. You might use this to show
-a message like "No records match your query."
-
-Each call to `docFunc` or `elseFunc` is run in its own reactive
-computation so that if it has other external data dependencies, it will be
-individually re-run when the data changes.
-
-Example:
-
-    // List the titles of all of the posts that have the tag
-    // "frontpage". Keep the list updated as new posts are made, as tags
-    // change, etc.  Display the selected post differently.
-    var frag = Meteor.renderList(
-      Posts.find({tags: "frontpage"}),
-      function(post) {
-        var style = Session.equals("selectedId", post._id) ? "selected" : "";
-        // A real app would need to quote/sanitize post.name
-        return '<div class="' + style + '">' + post.name + '</div>';
-      });
-    document.body.appendChild(frag);
-
-    // Select a post.  This will cause only the selected item and the
-    // previously selected item to update.
-    var somePost = Posts.findOne({tags: "frontpage"});
-    Session.set("selectedId", somePost._id);
+{{> api_box ui_insert}}
 
 
-{{#api_box_inline eventmaps}}
+
+{{#api_box eventmaps}}
 
 Several functions take event maps. An event map is an object where
 the properties specify a set of events to handle, and the values are
@@ -2348,8 +2257,8 @@ information about the event, and `template`, a [template
 instance](#template_inst) for the template where the handler is
 defined.  The handler also receives some additional context data in
 `this`, depending on the context of the current element handling the
-event.  In a Handlebars template, an element's context is the
-Handlebars data context where that element occurs, which is set by
+event.  In a template, an element's context is the
+data context where that element occurs, which is set by
 block helpers such as `#with` and `#each`.
 
 Example:
@@ -2481,72 +2390,15 @@ catching typing in text fields, while `keydown` and `keyup` can be
 used for arrow keys or modifier keys.
 {{/dtdd}}
 
-{{#dtdd "<code>tap</code>"}} Tap on an element.  On touch-enabled
-devices, this is a replacement to `click` that fires immediately.
-These events are synthesized from `touchmove` and `touchend`.
-{{/dtdd}}
-
 </dl>
 
 Other DOM events are available as well, but for the events above,
 Meteor has taken some care to ensure that they work uniformly in all
 browsers.
 
-{{/api_box_inline}}
+{{/api_box}}
 
 
-
-{{#api_box_inline constant}}
-
-You can mark a region of a template as "constant" and not subject to
-re-rendering using the
-`{{dstache}}#constant}}...{{dstache}}/constant}}` block helper.
-Content inside the `#constant` block helper is preserved exactly as-is
-even if the enclosing template is re-rendered.  Changes to other parts
-of the template are patched in around it in the same manner as
-`preserve`.  Unlike individual node preservation, a constant region
-retains not only the identities of its nodes but also their attributes
-and contents.  The contents of the block will only be evaluated once
-per occurrence of the enclosing template.
-
-Constant regions allow non-Meteor content to be embedded in a Meteor
-template.  Many third-party widgets create and manage their own DOM
-nodes programmatically. Typically, you put an empty element in your
-template, which the widget or library will then populate with
-children. Normally, when Meteor re-renders the enclosing template it
-would remove the new children, since the template says it should be
-empty. If the container is wrapped in a `#constant` block, however, it
-is left alone; whatever content is currently in the DOM remains.
-
-{{#note}}
-Constant regions are intended for embedding non-Meteor content.
-Event handlers and reactive dependencies don't currently work
-correctly inside constant regions.
-{{/note}}
-
-
-{{/api_box_inline}}
-
-{{#api_box_inline isolate}}
-
-Each template runs as its own reactive computation.  When the template
-accesses a reactive data source, such as by calling `Session.get` or
-making a database query, this establishes a data dependency that will
-cause the whole template to be re-rendered when the data changes.
-This means that the amount of re-rendering for a particular change
-is affected by how you've divided your HTML into templates.
-
-Typically, the exact extent of re-rendering is not crucial, but if you
-want more control, such as for performance reasons, you can use the
-`{{dstache}}#isolate}}...{{dstache}}/isolate}}` helper.  Data
-dependencies established inside an `#isolate` block are localized to
-the block and will not in themselves cause the parent template to be
-re-rendered.  This block helper essentially conveys the reactivity
-benefits you would get by pulling the content out into a new
-sub-template.
-
-{{/api_box_inline}}
-
 <h2 id="match"><span>Match</span></h2>
 
 Meteor methods and publish functions take arbitrary [EJSON](#ejson) types as
@@ -2581,7 +2433,7 @@ server logs but not revealed to the client.
 
 {{> api_box match_test}}
 
-{{#api_box_inline matchpatterns}}
+{{#api_box matchpatterns}}
 
 The following patterns can be used as pattern arguments to `check` and `Match.test`:
 
@@ -2661,7 +2513,7 @@ from the call to `check` or `Match.test`. Examples:
 {{/dtdd}}
 </dl>
 
-{{/api_box_inline}}
+{{/api_box}}
 
 <h2 id="timers"><span>Timers</span></h2>
 
@@ -2780,14 +2632,6 @@ same flush until there is no more work to be done.  Callbacks
 registered with [`Deps.afterFlush`](#deps_afterflush) are called
 after processing outstanding invalidations.
 
-Any auto-updating DOM elements that are found to not be in the
-document during a flush may be cleaned up by Meteor (meaning that
-Meteor will stop tracking and updating the elements, so that the
-browser's garbage collector can delete them).  So, if you manually
-call `flush`, you need to make sure that any auto-updating elements
-that you have created by calling [`Meteor.render`](#meteor_render)
-have already been inserted in the main DOM tree.
-
 It is illegal to call `flush` from inside a `flush` or from a running
 computation.
 
@@ -3243,11 +3087,11 @@ by spammers.)
                 'Hello from Meteor!',
                 'This is a test of Email.send.');
 
-{{/better_markdown}}
+{{/markdown}}
 
 <h2 id="assets"><span>Assets</span></h2>
 
-{{#better_markdown}}
+{{#markdown}}
 `Assets` allows server code in a Meteor application to access static server
 assets, which are located in the `private` subdirectory of an application's
 tree.
@@ -3261,7 +3105,7 @@ directory called `nested` with a file called `data.txt` inside it, then server
 code can read `data.txt` by running:
 
     var data = Assets.getText('nested/data.txt');
-{{/better_markdown}}
+{{/markdown}}
 
 </template>
 
@@ -3272,6 +3116,7 @@ code can read `data.txt` by running:
 
 <template name="api_box">
 <div class="api {{bare}}">
+
 <h3 id="{{id}}">
   <a class="name selflink" href="#{{id}}">{{{name}}}</a>
 {{#if locus}}
@@ -3280,7 +3125,7 @@ code can read `data.txt` by running:
 </h3>
 
 <div class="desc">
-{{#each descr}}{{#better_markdown}}{{{this}}}{{/better_markdown}}{{/each}}
+{{#each descr}}{{#markdown}}{{{this}}}{{/markdown}}{{/each}}
 </div>
 
 {{#if args}}
@@ -3293,8 +3138,8 @@ code can read `data.txt` by running:
 {{> api_box_args options}}
 {{/if}}
 
-{{#if body}}
-{{#better_markdown}}{{{body}}}{{/better_markdown}}
+{{#if UI.contentBlock}}
+{{#markdown}}{{> UI.contentBlock}}{{/markdown}}
 {{/if}}
 
 </div>
@@ -3314,12 +3159,12 @@ code can read `data.txt` by running:
       {{{type}}}
     {{/if}}
   </span></dt>
-<dd>{{#better_markdown}}{{{descr}}}{{/better_markdown}}</dd>
+<dd>{{#markdown}}{{{descr}}}{{/markdown}}</dd>
 {{/each}}
 </dl>
 </template>
 
 
-<template name="api_section_helper">
+<template name="api_section">
 <h2 id="{{id}}"><a href="#{{id}}" class="selflink"><span>{{name}}</span></a></h2>
 </template>
diff --git a/docs/client/api.js b/docs/client/api.js
index ab028551c9..4bffbeb556 100644
--- a/docs/client/api.js
+++ b/docs/client/api.js
@@ -58,12 +58,18 @@ Template.api.settings = {
   id: "meteor_settings",
   name: "Meteor.settings",
   locus: "Anywhere",
-  descr: ["`Meteor.settings` contains deployment-specific configuration options. " +
-          "You can initialize settings by passing the `--settings` option (which takes a file containing JSON data) to " +
-          "`meteor run` or `meteor deploy`, " +
-          "or by setting your server process's `METEOR_SETTINGS` environment variable to a JSON string. " +
-          "If you don't provide any settings, `Meteor.settings` will be an empty object.  If the settings object contains a key named `public`, then " +
-          "`Meteor.settings.public` will be available on the client as well as the server.  All other properties of `Meteor.settings` are only defined on the server."]
+  descr: ["`Meteor.settings` contains deployment-specific configuration " +
+          "options. You can initialize settings by passing the `--settings` " +
+          "option (which takes the name of a file containing JSON data) to " +
+          "`meteor run` or `meteor deploy`. When running your server " +
+          "directly (e.g. from a bundle), you instead specify settings by " +
+          "putting the JSON directly into the `METEOR_SETTINGS` environment " +
+          "variable. " +
+          "If you don't provide any settings, `Meteor.settings` will be an " +
+          "empty object.  If the settings object contains a key named " +
+          "`public`, then `Meteor.settings.public` will be available on the " +
+          "client as well as the server.  All other properties of " +
+          "`Meteor.settings` are only defined on the server."]
 };
 
 Template.api.release = {
@@ -805,7 +811,7 @@ Template.api.cursor_observe_changes = {
   ]
 };
 
-Template.api.id = {
+Template.api.random_id = {
   id: "meteor_id",
   name: "Random.id()",
   locus: "Anywhere",
@@ -994,54 +1000,12 @@ Template.api.dependency_hasdependents = {
 // writeFence
 // invalidationCrossbar
 
-Template.api.render = {
-  id: "meteor_render",
-  name: "Meteor.render(htmlFunc)",
-  locus: "Client",
-  descr: ["Create DOM nodes that automatically update themselves as data changes."],
-  args: [
-    {name: "htmlFunc",
-     type: "Function returning a string of HTML",
-     descr: "Function that generates HTML to be rendered.  Called immediately and re-run whenever data changes.  May also be a string of HTML instead of a function."}
-  ]
-};
-
-Template.api.renderList = {
-  id: "meteor_renderlist",
-  name: "Meteor.renderList(observable, docFunc, [elseFunc])",
-  locus: "Client",
-  descr: ["Create DOM nodes that automatically update themselves based on the results of a database query."],
-  args: [
-    {name: "observable",
-     type: "Cursor",
-     type_link: "meteor_collection_cursor",
-     descr: "Query cursor to observe as a reactive source of ordered documents."},
-    {name: "docFunc",
-     type: "Function taking a document and returning HTML",
-     descr: "Render function to be called for each document."},
-    {name: "elseFunc",
-     type: "Function returning HTML",
-     descr: "Optional.  Render function to be called when query is empty."}
-  ]
-};
-
 
 Template.api.eventmaps = {
   id: "eventmaps",
   name: "Event Maps"
 };
 
-Template.api.constant = {
-  id: "constant",
-  name: "Constant regions"
-};
-
-Template.api.isolate = {
-  id: "isolate",
-  name: "Reactivity isolation"
-};
-
-
 
 Template.api.user = {
   id: "meteor_user",
@@ -1053,7 +1017,7 @@ Template.api.user = {
 Template.api.currentUser = {
   id: "template_currentuser",
   name: "{{currentUser}}",
-  locus: "Handlebars templates",
+  locus: "Templates",
   descr: ["Calls [Meteor.user()](#meteor_user). Use `{{#if currentUser}}` to check whether the user is logged in."]
 };
 
@@ -1082,7 +1046,7 @@ Template.api.loggingIn = {
 Template.api.loggingInTemplate = {
   id: "template_loggingin",
   name: "{{loggingIn}}",
-  locus: "Handlebars templates",
+  locus: "Templates",
   descr: ["Calls [Meteor.loggingIn()](#meteor_loggingin)."]
 };
 
@@ -1200,6 +1164,11 @@ Template.api.accounts_config = {
       name: "loginExpirationInDays",
       type: "Number",
       descr: "The number of days from when a user logs in until their token expires and they are logged out. Defaults to 90. Set to `null` to disable login expiration."
+    },
+    {
+      name: "oauthSecretKey",
+      type: "String",
+      descr: "When using the `oauth-encryption` package, the 16 byte key using to encrypt sensitive account credentials in the database, encoded in base64.  This option may only be specifed on the server.  See packages/oauth-encryption/README.md for details."
     }
   ]
 };
@@ -1208,7 +1177,7 @@ Template.api.accounts_ui_config = {
   id: "accounts_ui_config",
   name: "Accounts.ui.config(options)",
   locus: "Client",
-  descr: ["Configure the behavior of [`{{loginButtons}}`](#accountsui)."],
+  descr: ["Configure the behavior of [`{{> loginButtons}}`](#accountsui)."],
   options: [
     {
       name: "requestPermissions",
@@ -1653,7 +1622,8 @@ Template.api.bindEnvironment = {
   ]
 };
 
-Template.api.set = {
+// Can't name this '.set', since that's a method on components.
+Template.api.session_set = {
   id: "session_set",
   name: "Session.set(key, value)",
   locus: "Client",
@@ -1683,7 +1653,8 @@ Template.api.setDefault = {
   ]
 };
 
-Template.api.get = {
+// Can't name this '.get', since that's a method on components.
+Template.api.session_get = {
   id: "session_get",
   name: "Session.get(key)",
   locus: "Client",
@@ -1718,7 +1689,7 @@ Template.api.httpcall = {
   args: [
     {name: "method",
      type: "String",
-     descr: 'The HTTP method to use: "`GET`", "`POST`", "`PUT`", or "`DELETE`".'},
+     descr: 'The [HTTP method](http://en.wikipedia.org/wiki/HTTP_method) to use, such as "`GET`", "`POST`", or "`HEAD`".'},
     {name: "url",
      type: "String",
      descr: 'The URL to retrieve.'},
@@ -1753,7 +1724,7 @@ Template.api.httpcall = {
      descr: "Maximum time in milliseconds to wait for the request before failing.  There is no timeout by default."},
     {name: "followRedirects",
      type: "Boolean",
-     descr: "If true, transparently follow HTTP redirects.  Cannot be set to false on the client."}
+     descr: "If `true`, transparently follow HTTP redirects. Cannot be set to `false` on the client. Default `true`."}
   ]
 };
 
@@ -1786,19 +1757,6 @@ Template.api.http_del = {
 };
 
 
-// XXX move these up to right place
-Template.api.template_call = {
-  id: "template_call",
-  name: "Template.<em>myTemplate</em>([data])",
-  locus: "Client",
-  descr: ["Call a template function by name to produce HTML."],
-  args: [
-    {name: "data",
-     type: "Object",
-     descr: 'Optional. The data context object with which to call the template.'}
-  ]
-};
-
 Template.api.template_rendered = {
   id: "template_rendered",
   name: "Template.<em>myTemplate</em>.rendered = function ( ) { ... }",
@@ -1845,18 +1803,6 @@ Template.api.template_helpers = {
   ]
 };
 
-Template.api.template_preserve = {
-  id: "template_preserve",
-  name: "Template.<em>myTemplate</em>.preserve(selectors)",
-  locus: "Client",
-  descr: ["Specify rules for preserving individual DOM elements on re-render."],
-  args: [
-    {name: "selectors",
-     type: "Array or Object",
-     descr: "Array of CSS selectors that each match at most one element, such as `['.thing1', '.thing2']`, or, alternatively, a dictionary of selectors and node-labeling functions (see below)."}
-  ]
-};
-
 Template.api.template_findAll = {
   id: "template_findAll",
   name: "<em>this</em>.findAll(selector)",
@@ -1902,6 +1848,80 @@ Template.api.template_data = {
   descr: ["The data context of this instance's latest invocation."]
 };
 
+
+Template.api.ui_registerhelper = {
+  id: "ui_registerhelper",
+  name: "UI.registerHelper(name, function)",
+  locus: "Client",
+  descr: ["Defines a [helper function](#template_helpers) which can be used from all templates."],
+  args: [
+    {name: "name",
+     type: "String",
+     descr: "The name of the helper function you are defining."
+    },
+    {name: "function",
+     type: "Function",
+     descr: "The helper function itself."
+    }]
+};
+
+Template.api.ui_body = {
+  id: "ui_body",
+  name: "UI.body",
+  locus: "Client",
+  descr: ["The [component object](#templates_api) representing your `<body>` tag."]
+};
+
+Template.api.ui_render = {
+  id: "ui_render",
+  name: "UI.render(Template.<em>myTemplate</em>)",
+  locus: "Client",
+  descr: ["Executes a template's logic."],
+  args: [
+    {name: "template",
+     type: "Template",
+     descr: "The particular template to evaluate."
+    }]
+};
+
+Template.api.ui_renderwithdata = {
+  id: "ui_renderwithdata",
+  name: "UI.renderWithData(Template.<em>myTemplate</em>, data)",
+  locus: "Client",
+  descr: ["Executes a template's logic with a data context. Otherwise identical to `UI.render`."],
+  args: [
+    {name: "template",
+     type: "Template",
+     descr: "The particular template to evaluate."
+    },
+    {name: "data",
+     type: "Object",
+     descr: "The data context that will be used when evaluating the template."
+    }]
+};
+
+Template.api.ui_insert = {
+  id: "ui_insert",
+  name: "UI.insert(instantiatedComponent, parentNode[, nextNode])",
+  locus: "Client",
+  descr: ["Inserts an instantiated component into the DOM and calls its [`rendered`](#template_rendered) callback."],
+  args: [
+    {name: "instantiatedComponent",
+     type: "Instantiated component object",
+     descr: "The return value from `UI.render` or `UI.renderWithData`."
+    },
+    {name: "parentNode",
+     type: "DOM Node",
+     descr: "The node that will be the parent of the rendered template."
+    },
+    {name: "nextNode",
+     type: "DOM Node",
+     descr: "If provided, must be a child of <em>parentNode</em>; the template will be inserted before this node. If not provided, the template will be inserted as the last child."
+    }]
+};
+
+
+
 var rfc = function (descr) {
   return '[RFC5322](http://tools.ietf.org/html/rfc5322) ' + descr;
 };
diff --git a/docs/client/commandline.html b/docs/client/commandline.html
index e14a342b9d..fb642598e6 100644
--- a/docs/client/commandline.html
+++ b/docs/client/commandline.html
@@ -1,6 +1,6 @@
 <template name="commandline">
 <div>
-{{#better_markdown}}
+{{#markdown}}
 
 {{#api_section "commandline"}}Command line{{/api_section}}
 
@@ -188,6 +188,6 @@ instead of deploying to Meteor's servers.  You will have to deal with
 logging, monitoring, backups, load-balancing, etc, all of which we
 handle for you if you use `meteor deploy`.
 
-{{/better_markdown}}
+{{/markdown}}
 </div>
 </template>
diff --git a/docs/client/concepts.html b/docs/client/concepts.html
index 8bcac1bfa1..6edef8e354 100644
--- a/docs/client/concepts.html
+++ b/docs/client/concepts.html
@@ -11,8 +11,7 @@ when writing those apps.
 {{> structure }}
 {{> data }}
 {{> reactivity }}
-{{> livehtml }}
-{{> templates }}
+{{> livehtmltemplates }}
 {{> packages_concept }}
 {{> namespacing }}
 {{> deploying }}
@@ -21,7 +20,7 @@ when writing those apps.
 
 <template name="whatismeteor">
 
-{{#better_markdown}}
+{{#markdown}}
 
 <h2 id="whatismeteor">What is Meteor?</h2>
 
@@ -69,11 +68,11 @@ In Meteor 1.0, the `meteor` build tool will have full support for
 Atmosphere.
 {{/note}}
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
 
 <template name="structure">
-{{#better_markdown}}
+{{#markdown}}
 
 <h2 id="structuringyourapp">Structuring your application</h2>
 
@@ -139,7 +138,7 @@ initial page load.
 Template sections, on the other hand, are converted into JavaScript
 functions, available under the `Template` namespace.  It's
 a really convenient way to ship HTML templates to the client.
-See the [templates](#templates) section for more.
+See the [templates](#livehtmltemplates) section for more.
 
 Lastly, the Meteor server will serve any files under the `public`
 directory, just like in a Rails or Django project.  This is the place
@@ -167,11 +166,11 @@ application are loaded according to these rules:
 * Finally, all files that match `main.*` are moved after everything else
   (preserving their order).
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
 
 <template name="data">
-{{#better_markdown}}
+{{#markdown}}
 
 <h2 id="dataandsecurity">Data and security</h2>
 
@@ -347,11 +346,11 @@ and publish functions validate all of their arguments. Just run
 method or publish function which skips `check`ing any of its arguments will fail
 with an exception.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
 
 <template name="reactivity">
-{{#better_markdown}}
+{{#markdown}}
 
 <h2 id="reactivity">Reactivity</h2>
 
@@ -387,9 +386,9 @@ error-prone logic.
 
 These Meteor functions run your code as a reactive computation:
 
-* [Templates](#templates)
-* [`Meteor.render`](#meteor_render) and [`Meteor.renderList`](#meteor_renderlist)
+* [Templates](#livehtmltemplates)
 * [`Deps.autorun`](#deps_autorun)
+* [`UI.render`](#ui_render) and [`UI.renderWithData`](#ui_renderwithdata)
 
 And the reactive data sources that can trigger changes are:
 
@@ -414,150 +413,98 @@ Meteor's
 is a package called [`Deps`](#deps) that is fairly short and straightforward.
 You can use it yourself to implement new reactive data sources.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
 
-<template name="livehtml">
-{{#better_markdown}}
+<template name="livehtmltemplates">
+{{#markdown}}
 
-<h2 id="livehtml">Live HTML</h2>
+<h2 id="livehtmltemplates">Live HTML templates</h2>
 
-HTML templating is central to web applications. With Meteor's live
+HTML templating is central to web applications. With Blaze, Meteor's live
 page update technology, you can render your HTML _reactively_, meaning
 that it will update automatically to track changes in the data used to
 generate it.
 
-This optional feature works with any HTML templating library, or even
-with HTML you generate manually from JavaScript. Here's an example:
+Meteor makes it easy to use your favorite HTML templating language along with
+Meteor's live page update technology. Just write your template as you normally
+would, and Meteor will take care of making it update in realtime.
 
-    var fragment = Meteor.render(
-      function () {
-        var name = Session.get("name") || "Anonymous";
-        return "<div>Hello, " + name + "</div>";
-      });
-    document.body.appendChild(fragment);
+Meteor ships with a templating language called
+[Spacebars](https://github.com/meteor/meteor/blob/devel/packages/spacebars/README.md),
+inspired by [Handlebars](http://handlebarsjs.com/).  It shares some of the
+spirit and syntax of Handlebars, but it has been tailored to produce reactive
+Meteor templates when compiled.
 
-    Session.set("name", "Bob"); // page updates automatically!
+{{#note}}
+  Today, the only templating system that ships with Meteor is Spacebars, though
+  our community has created packages for other languages such as
+  [Jade](https://atmospherejs.com/package/jade).
+{{/note}}
 
-[`Meteor.render`](#meteor_render) takes a rendering function, that is, a
-function that returns some HTML as a string. It returns an auto-updating
-`DocumentFragment`. When there is a change to data used by the rendering
-function, it is re-run. The DOM nodes in the `DocumentFragment` then
-update themselves in-place, no matter where they were inserted on the
-page. It's completely automatic. [`Meteor.render`](#meteor_render) uses
-a [reactive computation](#reactivity) to discover what data is used by the
-rendering function.
-
-Most of the time, though, you won't call these functions directly
-&mdash; you'll just use your favorite templating package, such as
-Handlebars or Jade. The `render` and `renderList` functions are intended
-for people that are implementing new templating systems.
-
-Meteor normally batches up any needed updates and executes them only
-when your code isn't running. That way, you can be sure that the DOM
-won't change out from underneath you. Sometimes you want the opposite
-behavior. For example, if you've just inserted a record in the
-database, you might want to force the DOM to update so you can find
-the new elements using a library like jQuery. In that case, call
-[`Deps.flush`](#deps_flush) to bring the DOM up to date
-immediately.
-
-When live-updating DOM elements are taken off the screen, they are automatically
-cleaned up &mdash; their callbacks are torn down, any associated database
-queries are stopped, and they stop updating. For this reason, you never have to
-worry about the [zombie
-templates](http://lostechies.com/derickbailey/2011/09/15/zombies-run-managing-page-transitions-in-backbone-apps/)
-that plague hand-written update logic. To protect your elements from cleanup,
-just make sure that they are on-screen before your code returns to the event loop,
-or before any call you make to [`Deps.flush`](#deps_flush).
-
-Another thorny problem in hand-written applications is element
-preservation. Suppose the user is typing text into an `<input>`
-element, and then the area of the page that includes that element is
-redrawn. The user could be in for a bumpy ride, as the focus, the
-cursor position, the partially entered text, and the accented
-character input state will be lost when the `<input>` is recreated.
-
-This is another problem that Meteor solves for you. You can specify
-elements to preserve when templates are re-rendered with the
-[`preserve`](#template_preserve) directive on the template. Meteor will
-preserve these elements even when their enclosing template is
-rerendered, but will still update their children and copy over any
-attribute changes.
-
-{{/better_markdown}}
-</template>
-
-<template name="templates">
-{{#better_markdown}}
-
-<h2 id="templates">Templates</h2>
-
-Meteor makes it easy to use your favorite HTML templating language,
-such as Handlebars or Jade, along with Meteor's live page update
-technology. Just write your template as you normally would, and Meteor
-will take care of making it update in realtime.
-
-To use this feature, create a file in your project with the `.html`
+To define templates, create a file in your project with the `.html`
 extension. In the file, make a `<template>` tag and give it a
 `name` attribute. Put the template contents inside the tag. Meteor
 will precompile the template, ship it down to the client, and make it
-available as a function on the global `Template` object.
+available as on the global `Template` object.
 
-{{#note}}
-Today, the only templating system that has been packaged for Meteor is
-Handlebars. Let us know what templating systems you'd like to use with
-Meteor. Meanwhile, see the [Handlebars
-documentation](http://www.handlebarsjs.com/) and [Meteor Handlebars
-extensions](https://github.com/meteor/meteor/wiki/Handlebars).
-{{/note}}
-
-A template with a `name` of `hello` is rendered by calling the
-function `Template.hello`, passing any data for the template:
-
-    <!-- in myapp.html -->
-    <template name="hello">
-      <div class="greeting">Hello there, {{dstache}}first}} {{dstache}}last}}!</div>
-    </{{! }}template>
-
-    // in the JavaScript console
-    > Template.hello({first: "Alyssa", last: "Hacker"});
-     => "<div class="greeting">Hello there, Alyssa Hacker!</div>"
-
-This returns a string. To use the template along with the [`Live
-HTML`](#livehtml) system, and get DOM elements that update
-automatically in place, use [`Meteor.render`](#meteor_render):
-
-    Meteor.render(function () {
-      return Template.hello({first: "Alyssa", last: "Hacker"});
-    })
-      => automatically updating DOM elements
+When you app is loaded, it automatically renders the special template called
+`<body>`, which is written using the `<body>` element instead of a
+`<template>`. You insert a template inside another template by using the
+`{{dstache}}> inclusion}}` operator.
 
 The easiest way to get data into templates is by defining helper
 functions in JavaScript. Just add the helper functions directly on the
-`Template.[template name]` object. For example, in this template:
+`Template.`*templateName* object. Putting it all together:
 
+
+    <!-- in myapp.html -->
+    <body>
+      <h1>Today's weather!</h1>
+      {{dstache}}> forecast}}
+    </body>
+
+    <template name="forecast">
+      <div>It'll be {{dstache}}prediction}} tonight</div>
+    {{lt}}/template>
+
+    // in client/myapp.js: reactive helper function
+    Template.forecast.prediction = function () {
+      return Session.get("weather");
+    };
+
+    // in the JavaScript console
+    > Session.set("weather", "cloudy");
+    > document.body.innerHTML
+     => "<h1>Today's weather!</h1> <div>It'll be cloudy tonight</div>"
+
+    > Session.set("weather", "cool and dry");
+    > document.body.innerHTML
+     => "<h1>Today's weather!</h1> <div>It'll be cool and dry tonight</div>"
+
+
+To iterate over an array or database cursor, use `{{dstache}}#each}}`:
+
+    <!-- in myapp.html -->
     <template name="players">
       {{dstache}}#each topScorers}}
         <div>{{dstache}}name}}</div>
       {{dstache}}/each}}
-    </{{! }}template>
-
-instead of passing in `topScorers` as data when we call the
-template function, we could define a function on `Template.players`:
+    {{lt}}/template>
 
+    // in myapp.js
     Template.players.topScorers = function () {
       return Users.find({score: {$gt: 100}}, {sort: {score: -1}});
     };
 
 In this case, the data is coming from a database query. When the
-database cursor is passed to `#each`, it will wire up all of the
+database cursor is passed to `{{dstache}}#each}}`, it will wire up all of the
 machinery to efficiently add and move DOM nodes as new results enter
 the query.
 
 Helpers can take arguments, and they receive the current template context data
 in `this`. Note that some block helpers change the current context (notably
-`each` and `with`):
+`{{dstache}}#each}}` and `{{dstache}}#with}}`):
 
     // in a JavaScript file
     Template.players.leagueIs = function (league) {
@@ -574,15 +521,7 @@ in `this`. Note that some block helpers change the current context (notably
           <div>Senior: {{dstache}}name}}</div>
         {{dstache}}/if}}
       {{dstache}}/each}}
-    </{{! }}template>
-
-{{#note}}
-Handlebars note: `{{dstache}}#if leagueIs "junior"}}` is
-allowed because of a Meteor extension that allows nesting a helper
-in a block helper. (Both `if` and `leagueIs` are
-technically helpers, and stock Handlebars would not invoke
-`leagueIs` here.)
-{{/note}}
+    {{lt}}/template>
 
 Helpers can also be used to pass in constant data.
 
@@ -599,13 +538,13 @@ the data context of the element that triggered the event.
       {{dstache}}#each player}}
         {{dstache}}> playerScore}}
       {{dstache}}/each}}
-    </{{! }}template>
+    {{lt}}/template>
 
     <template name="playerScore">
       <div>{{dstache}}name}}: {{dstache}}score}}
         <span class="givePoints">Give points</span>
       </div>
-    </{{! }}template>
+    {{lt}}/template>
 
     <!-- myapp.js -->
     Template.playerScore.events({
@@ -614,35 +553,14 @@ the data context of the element that triggered the event.
       }
     });
 
-Putting it all together, here's an example of how you can inject
-arbitrary data into your templates, and have them update automatically
-whenever that data changes. See [Live HTML](#livehtml) for further
-discussion.
+For more details about Spacebars, read [the Spacebars
+README](https://github.com/meteor/meteor/blob/devel/packages/spacebars/README.md).
 
-    <!-- in myapp.html -->
-    <template name="forecast">
-      <div>It'll be {{dstache}}prediction}} tonight</div>
-    </{{! }}template>
-
-    <!-- in myapp.js -->
-    // JavaScript: reactive helper function
-    Template.forecast.prediction = function () {
-      return Session.get("weather");
-    };
-
-    <!-- in the console -->
-    > Session.set("weather", "cloudy");
-    > document.body.appendChild(Meteor.render(Template.forecast));
-    In DOM:  <div>It'll be cloudy tonight</div>
-
-    > Session.set("weather", "cool and dry");
-    In DOM:  <div>It'll be cool and dry tonight</div>
-
-{{/better_markdown}}
+{{/markdown}}
 </template>
 
 <template name="packages_concept">
-{{#better_markdown}}
+{{#markdown}}
 
   <h2 id="usingpackages">Using packages</h2>
 
@@ -679,12 +597,12 @@ are willing to brave the fact that the Meteor package format is not
 documented yet and will change significantly before Meteor 1.0. See
 [Writing Packages](#writingpackages).
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
 
 
 <template name="namespacing">
-{{#better_markdown}}
+{{#markdown}}
 
   <h2 id="namespacing">Namespacing</h2>
 
@@ -773,12 +691,12 @@ certainly shouldn't depend on this quirk, and in the future Meteor may
 check for it and throw an error if you do.
 {{/note}}
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
 
 
 <template name="deploying">
-{{#better_markdown}}
+{{#markdown}}
 
 <h2 id="deploying">Deploying</h2>
 
@@ -823,7 +741,7 @@ To get started, run
 This command will generate a fully-contained Node.js application in the form of
 a tarball.  To run this application, you need to provide Node.js 0.10 and a
 MongoDB server.  (The current release of Meteor has been tested with Node
-0.10.25; older versions contain a serious bug that can cause production servers
+0.10.26; older versions contain a serious bug that can cause production servers
 to stall.) You can then run the application by invoking node, specifying the
 HTTP port for the application to listen on, and the MongoDB endpoint.  If
 you don't already have a MongoDB server, we can recommend our friends at
@@ -845,12 +763,12 @@ have `npm` available, and run the following:
     $ npm install fibers@1.0.1
 {{/warning}}
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
 
 
 <template name="packages_writing">
-{{#better_markdown}}
+{{#markdown}}
 
   <h2 id="writingpackages">Writing packages</h2>
 
@@ -949,5 +867,5 @@ quick tips:
   machine architecture, but if not your built Meteor package will be
   portable.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/docs.css b/docs/client/docs.css
index 70afcfd9cd..5240351084 100644
--- a/docs/client/docs.css
+++ b/docs/client/docs.css
@@ -173,7 +173,7 @@ a:hover {
 /** Main pane **/
 
 #main {
-    margin: 10px;
+    margin: 10px 10px 10px 60px;
     line-height: 1.3;
     color: #333333;
 }
@@ -407,10 +407,34 @@ dl.callbacks {
 
 /** layout control **/
 
-/* default to no sidebar */
-#nav {
+#menu-ico {
+    font-size: 30px;
+    float: right;
+    position: fixed;
+    top: 3px;
+    left: 6px;
+}
+
+#menu-ico.hidden {
     display: none;
 }
+
+/* default to no sidebar */
+#nav {
+    display: block;
+    background: #FFF;
+    position: fixed;
+    width: 260px;
+    height: 100%;
+    top: 0;
+    left: -220px;
+}
+
+#nav.show {
+    left: 0;
+    overflow: auto;
+}
+
 .github-ribbon {
     display: none;
 }
@@ -419,37 +443,44 @@ pre {
 }
 
 @media (min-width: 768px) {
-/* ipad portrait or better */
-#main {
-    width: 440px;
-    height: 100%;
-    margin-left: 260px; /* nav width + padding */
-    padding: 30px;
-}
-#nav {
-    display: block;
-    width: 200px;
-    position: fixed;
-    overflow: auto;
-    height: 100%;
-    top: 0;
-    left: 0;
-}
-.main-headline {
-    display: none;
-}
+    /* ipad portrait or better */
+    #main {
+        width: 440px;
+        height: 100%;
+        margin-left: 260px; /* nav width + padding */
+        padding: 30px;
+    }
+    #nav {
+        display: block;
+        width: 200px;
+        position: fixed;
+        overflow: auto;
+        height: 100%;
+        top: 0;
+        left: 0;
+    }
+    .main-headline {
+        display: none;
+    }
+
+    #menu-ico {
+        display: none;
+    }
 }
 
 @media (min-width: 1024px) {
-/* ipad landscape and desktop */
-#main {
-    width: 610px;
-    margin-left: 330px; /* nav width + padding */
-}
-#nav {
-    width: 270px;
-}
-.github-ribbon {
-    display: block;
-}
+    /* ipad landscape and desktop */
+    #main {
+        width: 610px;
+        margin-left: 330px; /* nav width + padding */
+    }
+    #nav {
+        width: 270px;
+    }
+    .github-ribbon {
+        display: block;
+    }
+    #menu-ico {
+        display: none;
+    }
 }
diff --git a/docs/client/docs.html b/docs/client/docs.html
index 77d03ee492..b2bcfe2f78 100644
--- a/docs/client/docs.html
+++ b/docs/client/docs.html
@@ -8,7 +8,7 @@
 </head>
 
 <body>
-  <div id="nav">
+  <div id="nav" class="hide">
     {{> nav }}
   </div>
   <div id="main">
@@ -23,18 +23,42 @@
 </body>
 
 <template name="nav">
-<div id="nav-inner">
-  {{#each sections}}
-  {{#if type "spacer"}}
-    <div class="spacer"> </div>
+  <div id="menu-ico"><a href="#">&#9776;</a></div>
+  <div id="nav-inner">
+    {{#each sections}}
+      {{#if type "spacer"}}
+        <div class="spacer"> </div>
+      {{/if}}
+      {{#if type "section"}}
+        {{#nav_section}}
+          <a href="#{{id}}" class="{{maybe_current}} {{style}}">
+            {{#if prefix}}{{prefix}}.{{/if}}{{#if instance}}<i>{{instance}}</i>.{{/if}}{{name}}
+          </a>
+        {{/nav_section}}
+      {{/if}}
+    {{/each}}
+  </div>
+</template>
+
+<template name="nav_section">
+  {{#if depthIs 1}}
+    <h1>{{> UI.contentBlock}}</h1>
   {{/if}}
-  {{#if type "section"}}
-    <h{{depth}}><a href="#{{id}}" class="{{maybe_current}} {{style}}">
-        {{#if prefix}}{{prefix}}.{{/if}}{{#if instance}}<i>{{instance}}</i>.{{/if}}{{name}}
-    </a></h{{depth}}>
+  {{#if depthIs 2}}
+    <h2>{{> UI.contentBlock}}</h2>
+  {{/if}}
+  {{#if depthIs 3}}
+    <h3>{{> UI.contentBlock}}</h3>
+  {{/if}}
+  {{#if depthIs 4}}
+    <h4>{{> UI.contentBlock}}</h4>
+  {{/if}}
+  {{#if depthIs 5}}
+    <h5>{{> UI.contentBlock}}</h5>
+  {{/if}}
+  {{#if depthIs 6}}
+    <h6>{{> UI.contentBlock}}</h6>
   {{/if}}
-  {{/each}}
-</div>
 </template>
 
 <!-- This only is displayed on narrow displays (eg phone) -->
@@ -43,24 +67,35 @@
 </template>
 
 
-<template name="dtdd_helper">
-<dt><span class="name">{{{name}}}</span>
-  {{#if type}}<span class="type">{{type}}</span>{{/if}}
-</dt>
-<dd>{{#better_markdown}}{{{descr}}}{{/better_markdown}}</dd>
+<template name="dtdd">
+  {{! can be used with either one argument (which ends up in the data
+      context, or with both name and type }}
+
+  {{#if name}}
+    <dt><span class="name">{{{name}}}</span>
+      {{#if type}}<span class="type">{{type}}</span>{{/if}}
+    </dt>
+  {{else}}
+    <dt><span class="name">{{{.}}}</span></dt>
+  {{/if}}
+  <dd>{{#markdown}}{{> UI.contentBlock}}{{/markdown}}</dd>
 </template>
 
 
 
-<template name="warning_helper">
-  <div class="warning">
-    {{#better_markdown}}{{{this}}}{{/better_markdown}}
-  </div>
+<!-- this is used within {{#markdown}}. <div> must be unindented.
+     http://daringfireball.net/projects/markdown/syntax#html -->
+<template name="warning">
+<div class="warning">
+  {{#markdown}}{{> UI.contentBlock}}{{/markdown}}
+</div>
 </template>
 
-<template name="note_helper">
-  <div class="note">
-    {{#better_markdown}}{{{this}}}{{/better_markdown}}
-  </div>
+<!-- this is used within {{#markdown}}. <div> must be unindented.
+     http://daringfireball.net/projects/markdown/syntax#html -->
+<template name="note">
+<div class="note">
+  {{#markdown}}{{> UI.contentBlock}}{{/markdown}}
+</div>
 </template>
 
diff --git a/docs/client/docs.js b/docs/client/docs.js
index 75d09ea0c5..5873bc04b7 100644
--- a/docs/client/docs.js
+++ b/docs/client/docs.js
@@ -2,7 +2,6 @@ Template.headline.release = function () {
   return Meteor.release || "(checkout)";
 };
 
-
 Meteor.startup(function () {
   // XXX this is broken by the new multi-page layout.  Also, it was
   // broken before the multi-page layout because it had illegible
@@ -89,8 +88,18 @@ Meteor.startup(function () {
 
   // Make external links open in a new tab.
   $('a:not([href^="#"])').attr('target', '_blank');
+
+  // Hide menu by tapping on background
+  $('#main').on('click', function () {
+    hideMenu();
+  });
 });
 
+var hideMenu = function () {
+  $('#nav').removeClass('show');
+  $('#menu-ico').removeClass('hidden');
+};
+
 var toc = [
   {name: "Meteor " + Template.headline.release(), id: "top"}, [
     "Quick start",
@@ -102,8 +111,7 @@ var toc = [
     "Structuring your app",
     "Data and security",
     "Reactivity",
-    "Live HTML",
-    "Templates",
+    "Live HTML templates",
     "Using packages",
     "Namespacing",
     "Deploying",
@@ -214,7 +222,7 @@ var toc = [
       "Accounts.onCreateUser",
       "Accounts.validateLoginAttempt",
       "Accounts.onLogin",
-      {name: "Accounts.onLoginFailure", id: "accounts_onlogin"},
+      {name: "Accounts.onLoginFailure", id: "accounts_onlogin"}
     ],
 
     {name: "Passwords", id: "accounts_passwords"}, [
@@ -233,13 +241,12 @@ var toc = [
     ],
 
     {name: "Templates", id: "templates_api"}, [
-      {prefix: "Template", instance: "myTemplate", id: "template_call"}, [
-        {name: "rendered", id: "template_rendered"},
-        {name: "created", id: "template_created"},
-        {name: "destroyed", id: "template_destroyed"},
+      {prefix: "Template", instance: "myTemplate", id: "templates_api"}, [
         {name: "events", id: "template_events"},
         {name: "helpers", id: "template_helpers"},
-        {name: "preserve", id: "template_preserve"}
+        {name: "rendered", id: "template_rendered"},
+        {name: "created", id: "template_created"},
+        {name: "destroyed", id: "template_destroyed"}
       ],
       {name: "Template instances", id: "template_inst"}, [
         {instance: "this", name: "findAll", id: "template_findAll"},
@@ -248,12 +255,15 @@ var toc = [
         {instance: "this", name: "lastNode", id: "template_lastNode"},
         {instance: "this", name: "data", id: "template_data"}
       ],
-      "Meteor.render",
-      "Meteor.renderList",
+      "UI", [
+        "UI.registerHelper",
+        "UI.body",
+        "UI.render",
+        "UI.renderWithData",
+        "UI.insert"
+      ],
       {type: "spacer"},
-      {name: "Event maps", style: "noncode"},
-      {name: "Constant regions", style: "noncode", id: "constant"},
-      {name: "Reactivity isolation", style: "noncode", id: "isolate"}
+      {name: "Event maps", style: "noncode"}
      ],
 
     "Match", [
@@ -348,6 +358,7 @@ var toc = [
     "force-ssl",
     "jquery",
     "less",
+    "oauth-encryption",
     "random",
     "spiderable",
     "stylus",
@@ -380,6 +391,10 @@ Template.nav.sections = function () {
   var ret = [];
   var walk = function (items, depth) {
     _.each(items, function (item) {
+      // Work around (eg) accidental trailing commas leading to spurious holes
+      // in IE8.
+      if (!item)
+        return;
       if (item instanceof Array)
         walk(item, depth + 1);
       else {
@@ -401,159 +416,38 @@ Template.nav.sections = function () {
 
 Template.nav.type = function (what) {
   return this.type === what;
-}
+};
 
 Template.nav.maybe_current = function () {
   return Session.equals("section", this.id) ? "current" : "";
 };
 
-Handlebars.registerHelper('warning', function(fn) {
-  return Template.warning_helper(fn(this));
-});
+Template.nav_section.depthIs = function (n) {
+  return this.depth === n;
+};
 
-Handlebars.registerHelper('note', function(fn) {
-  return Template.note_helper(fn(this));
-});
-
-// "name" argument may be provided as part of options.hash instead.
-Handlebars.registerHelper('dtdd', function(name, options) {
-  if (options && options.hash) {
-    // {{#dtdd name}}
-    options.hash.name = name;
-  } else {
-    // {{#dtdd name="foo" type="bar"}}
-    options = name;
+// Show hidden TOC when menu icon is tapped
+Template.nav.events({
+  'click #menu-ico' : function () {
+    $('#nav').addClass('show');
+    $('#menu-ico').addClass('hidden');
+  },
+  // Hide TOC when selecting an item
+  'click a' : function () {
+    hideMenu();
   }
-
-  return Template.dtdd_helper({descr: options.fn(this),
-                               name: options.hash.name,
-                               type: options.hash.type});
 });
 
-Handlebars.registerHelper('better_markdown', function(fn) {
-  var converter = new Showdown.converter();
-  var input = fn(this);
-
-  ///////
-  // Make Markdown *actually* skip over block-level elements when
-  // processing a string.
-  //
-  // Official Markdown doesn't descend into
-  // block elements written out as HTML (divs, tables, etc.), BUT
-  // it doesn't skip them properly either.  It assumes they are
-  // either pretty-printed with their contents indented, or, failing
-  // that, it just scans for a close tag with the same name, and takes
-  // it regardless of whether it is the right one.  As a hack to work
-  // around Markdown's hacks, we find the block-level elements
-  // using a proper recursive method and rewrite them to be indented
-  // with the final close tag on its own line.
-  ///////
-
-  // Open-block tag should be at beginning of line,
-  // and not, say, in a string literal in example code, or in a pre block.
-  // Tag must be followed by a non-word-char so that we match whole tag, not
-  // eg P for PRE.  All regexes we wish to use when scanning must have
-  // 'g' flag so that they respect (and set) lastIndex.
-  // Assume all tags are lowercase.
-  var rOpenBlockTag = /^\s{0,2}<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del)(?=\W)/mg;
-  var rTag = /<(\/?\w+)/g;
-  var idx = 0;
-  var newParts = [];
-  var blockBuf = [];
-  // helper function to execute regex `r` starting at idx and putting
-  // the end index back into idx; accumulate the intervening string
-  // into an array; and return the regex's first capturing group.
-  var rcall = function(r, inBlock) {
-    var lastIndex = idx;
-    r.lastIndex = lastIndex;
-    var match = r.exec(input);
-    var result = null;
-    if (! match) {
-      idx = input.length;
-    } else {
-      idx = r.lastIndex;
-      result = match[1];
-    }
-    (inBlock ? blockBuf : newParts).push(input.substring(lastIndex, idx));
-    return result;
-  };
-
-  // This is a tower of terrible hacks.
-  // Replace Spark annotations <$...> ... </$...> with HTML comments, and
-  // space out the comments on their own lines.  This keeps them from
-  // interfering with Markdown's paragraph parsing.
-  // Really, running Markdown multiple times on the same string is just a
-  // bad idea.
-  input = input.replace(/<(\/?\$.*?)>/g, '<!--$1-->');
-  input = input.replace(/<!--.*?-->/g, '\n\n$&\n\n');
-
-  var hashedBlocks = {};
-  var numHashedBlocks = 0;
-
-  var nestedTags = [];
-  while (idx < input.length) {
-    var blockTag = rcall(rOpenBlockTag, false);
-    if (blockTag) {
-      nestedTags.push(blockTag);
-      while (nestedTags.length) {
-        var tag = rcall(rTag, true);
-        if (! tag) {
-          throw new Error("Expected </"+nestedTags[nestedTags.length-1]+
-                          "> but found end of string");
-        } else if (tag.charAt(0) === '/') {
-          // close tag
-          var tagToPop = tag.substring(1);
-          var tagPopped = nestedTags.pop();
-          if (tagPopped !== tagToPop)
-            throw new Error(("Mismatched close tag, expected </"+tagPopped+
-                             "> but found </"+tagToPop+">: "+
-                             input.substr(idx-50,50)+"{HERE}"+
-                             input.substr(idx,50)).replace(/\n/g,'\\n'));
-        } else {
-          // open tag
-          nestedTags.push(tag);
-        }
-      }
-      var newBlock = blockBuf.join('');
-      var openTagFinish = newBlock.indexOf('>') + 1;
-      var closeTagLoc = newBlock.lastIndexOf('<');
-
-      var key = ++numHashedBlocks;
-      hashedBlocks[key] = newBlock.slice(openTagFinish, closeTagLoc);
-      newParts.push(newBlock.slice(0, openTagFinish),
-                    '!!!!HTML:'+key+'!!!!',
-                    newBlock.slice(closeTagLoc));
-      blockBuf.length = 0;
-    }
-  }
-
-  var newInput = newParts.join('');
-  var output = converter.makeHtml(newInput);
-
-  output = output.replace(/!!!!HTML:(.*?)!!!!/g, function(z, a) {
-    return hashedBlocks[a];
-  });
-
-  output = output.replace(/<!--(\/?\$.*?)-->/g, '<$1>');
-
-  return output;
-});
-
-Handlebars.registerHelper('dstache', function() {
+UI.registerHelper('dstache', function() {
   return '{{';
 });
 
-Handlebars.registerHelper('tstache', function() {
+UI.registerHelper('tstache', function() {
   return '{{{';
 });
 
-Handlebars.registerHelper('api_section', function(id, nameFn) {
-  return Template.api_section_helper(
-    {name: nameFn(this), id:id}, true);
-});
-
-Handlebars.registerHelper('api_box_inline', function(box, fn) {
-  return Template.api_box(_.extend(box, {body: fn(this)}), true);
+UI.registerHelper('lt', function () {
+  return '<';
 });
 
 Template.api_box.bare = function() {
@@ -562,7 +456,7 @@ Template.api_box.bare = function() {
           (this.options && this.options.length)) ? "" : "bareapi";
 };
 
-var check_links = function() {
+check_links = function() {
   var body = document.body.innerHTML;
 
   var id_set = {};
diff --git a/docs/client/packages.html b/docs/client/packages.html
index 077e4f1cd1..a638d180aa 100644
--- a/docs/client/packages.html
+++ b/docs/client/packages.html
@@ -1,5 +1,5 @@
 <template name="packages">
-{{#better_markdown}}
+{{#markdown}}
 
 <h1 id="packages">Packages</h1>
 
@@ -28,11 +28,12 @@ and removed with:
 {{> pkg_force_ssl}}
 {{> pkg_jquery}}
 {{> pkg_less}}
+{{> pkg_oauth_encryption}}
 {{> pkg_random}}
 {{> pkg_spiderable}}
 {{> pkg_stylus}}
 {{> pkg_showdown}}
 {{> pkg_underscore}}
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/accounts-ui.html b/docs/client/packages/accounts-ui.html
index 6d48560dc7..6dfbaf1a51 100644
--- a/docs/client/packages/accounts-ui.html
+++ b/docs/client/packages/accounts-ui.html
@@ -1,5 +1,5 @@
 <template name="pkg_accounts_ui">
-{{#better_markdown}}
+{{#markdown}}
 ## `accounts-ui`
 
 A turn-key user interface for Meteor Accounts.
@@ -9,16 +9,16 @@ To add Accounts and a set of login controls to an application, add the
 `accounts-password`, `accounts-facebook`, `accounts-github`,
 `accounts-google`, `accounts-twitter`, or `accounts-weibo`.
 
-Then simply add the `{{dstache}}loginButtons}}` helper to an HTML file. This
+Then simply add the `{{dstache}}> loginButtons}}` helper to an HTML file. This
 will place a login widget on the page. If there is only one provider configured
 and it is an external service, this will add a login/logout button. If you use
 `accounts-password` or use multiple external login services, this will add
 a "Sign in" link which opens a dropdown menu with login options. If you plan to
 position the login dropdown in the right edge of the screen, use
-`{{dstache}}loginButtons align="right"}}` in order to get the dropdown to lay
+`{{dstache}}> loginButtons align="right"}}` in order to get the dropdown to lay
 itself out without expanding off the edge of the screen.
 
-To configure the behavior of `{{dstache}}loginButtons}}`, use
+To configure the behavior of `{{dstache}}> loginButtons}}`, use
 [`Accounts.ui.config`](#accounts_ui_config).
 
 `accounts-ui` also includes modal popup dialogs to handle links from
@@ -29,5 +29,5 @@ when the URLs are loaded.
 
 
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/amplify.html b/docs/client/packages/amplify.html
index 38c50e6cf4..9e6e414c7c 100644
--- a/docs/client/packages/amplify.html
+++ b/docs/client/packages/amplify.html
@@ -1,5 +1,5 @@
 <template name="pkg_amplify">
-{{#better_markdown}}
+{{#markdown}}
 
 ## `amplify`
 
@@ -10,5 +10,5 @@ components, and several useful utility functions.
 Amplify defines a global namespace `amplify` on the client only. It does
 not run on the server.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/appcache.html b/docs/client/packages/appcache.html
index 4f2885b189..35fdf3b7aa 100644
--- a/docs/client/packages/appcache.html
+++ b/docs/client/packages/appcache.html
@@ -1,5 +1,5 @@
 <template name="pkg_appcache">
-{{#better_markdown}}
+{{#markdown}}
 
 ## `appcache`
 
@@ -89,5 +89,5 @@ cache, see the
 [AppCache page](https://github.com/meteor/meteor/wiki/AppCache)
 in the Meteor wiki.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/audit-argument-checks.html b/docs/client/packages/audit-argument-checks.html
index d2b311d927..d07d8e971d 100644
--- a/docs/client/packages/audit-argument-checks.html
+++ b/docs/client/packages/audit-argument-checks.html
@@ -1,5 +1,5 @@
 <template name="pkg_audit_argument_checks">
-{{#better_markdown}}
+{{#markdown}}
 
 ## `audit-argument-checks`
 
@@ -14,5 +14,5 @@ Methods and publish functions that do not need to validate their arguments can
 simply run `check(arguments, [Match.Any])` to satisfy the
 `audit-argument-checks` coverage checker.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/backbone.html b/docs/client/packages/backbone.html
index ab9d2d74d0..52397a2808 100644
--- a/docs/client/packages/backbone.html
+++ b/docs/client/packages/backbone.html
@@ -1,5 +1,5 @@
 <template name="pkg_backbone">
-{{#better_markdown}}
+{{#markdown}}
 ## `backbone`
 
 [Backbone](http://documentcloud.github.com/backbone/) is a popular client-side MVC framework for managing complex
@@ -7,5 +7,5 @@ data in the browser. In addition to the MVC and DOM-binding
 functionality, it also provides an API for HTML5 pushState and
 client-side URL routing.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/bootstrap.html b/docs/client/packages/bootstrap.html
index 9a017829a3..1d813fdbdb 100644
--- a/docs/client/packages/bootstrap.html
+++ b/docs/client/packages/bootstrap.html
@@ -1,5 +1,5 @@
 <template name="pkg_bootstrap">
-{{#better_markdown}}
+{{#markdown}}
 ## `bootstrap`
 
 [Twitter's Bootstrap](http://twitter.github.com/bootstrap/) package is a front-end toolkit for faster, more
@@ -9,5 +9,5 @@ interactions including typography, forms, buttons, tables, grids, and
 navigation.
 
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/browser-policy.html b/docs/client/packages/browser-policy.html
index 5bede3d5b2..8499e891c9 100644
--- a/docs/client/packages/browser-policy.html
+++ b/docs/client/packages/browser-policy.html
@@ -1,5 +1,5 @@
 <template name="pkg_browser_policy">
-{{#better_markdown}}
+{{#markdown}}
 ## `browser-policy`
 
 The `browser-policy` package lets you set security-related policies that will be
@@ -170,5 +170,5 @@ sites can frame your site, while
 sites can be loaded inside frames on your site.
 
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/coffeescript.html b/docs/client/packages/coffeescript.html
index efc55c82ab..edd0581ef1 100644
--- a/docs/client/packages/coffeescript.html
+++ b/docs/client/packages/coffeescript.html
@@ -1,5 +1,5 @@
 <template name="pkg_coffeescript">
-{{#better_markdown}}
+{{#markdown}}
 ## `coffeescript`
 
 [CoffeeScript](http://coffeescript.org/) is a little language that
@@ -48,5 +48,5 @@ Heavy CoffeeScript users, please let us know how this arrangement
 works for you, whether `share` is helpful for you, and anything else
 you'd like to see changed.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/d3.html b/docs/client/packages/d3.html
index f361fa27c8..ca999a697d 100644
--- a/docs/client/packages/d3.html
+++ b/docs/client/packages/d3.html
@@ -1,5 +1,5 @@
 <template name="pkg_d3">
-{{#better_markdown}}
+{{#markdown}}
 
 ## `d3`
 
@@ -13,5 +13,5 @@ to DOM manipulation.
 The `d3` package adds the D3 library to the client JavaScript
 bundle. It has no effect on the server.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/force-ssl.html b/docs/client/packages/force-ssl.html
index 07e4bb09eb..e5c96df358 100644
--- a/docs/client/packages/force-ssl.html
+++ b/docs/client/packages/force-ssl.html
@@ -1,5 +1,5 @@
 <template name="pkg_force_ssl">
-{{#better_markdown}}
+{{#markdown}}
 ## `force-ssl`
 
 This package causes Meteor to redirect insecure connections (HTTP) to a
@@ -19,5 +19,5 @@ Applications deployed to `meteor.com` subdomains with
 `meteor deploy` are automatically served via HTTPS using Meteor's
 certificate.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/jquery.html b/docs/client/packages/jquery.html
index b7998a3155..37958d9b23 100644
--- a/docs/client/packages/jquery.html
+++ b/docs/client/packages/jquery.html
@@ -1,5 +1,5 @@
 <template name="pkg_jquery">
-{{#better_markdown}}
+{{#markdown}}
 
 ## `jquery`
 
@@ -17,5 +17,5 @@ plugins as separate packages. These include:
 * [`jquery-layout`](http://layout.jquery-dev.net/)
 * [`jquery-waypoints`](http://imakewebthings.com/jquery-waypoints/)
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/less.html b/docs/client/packages/less.html
index a4da2ec02f..88583f6ee4 100644
--- a/docs/client/packages/less.html
+++ b/docs/client/packages/less.html
@@ -1,5 +1,5 @@
 <template name="pkg_less">
-{{#better_markdown}}
+{{#markdown}}
 ## `less`
 
 [LESS](http://lesscss.org/) extends CSS with dynamic behavior such as variables, mixins,
@@ -15,5 +15,5 @@ If you want to `@import` a file, give it the extension `.import.less`
 to prevent Meteor from processing it independently.
 {{/note}}
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/oauth-encryption.html b/docs/client/packages/oauth-encryption.html
new file mode 100644
index 0000000000..1678bebf93
--- /dev/null
+++ b/docs/client/packages/oauth-encryption.html
@@ -0,0 +1,9 @@
+<template name="pkg_oauth_encryption">
+{{#markdown}}
+## `oauth-encryption`
+
+Encrypts sensitive account credential information stored in the
+database.  See packages/oauth-encryption/README.md for details.
+
+{{/markdown}}
+</template>
diff --git a/docs/client/packages/random.html b/docs/client/packages/random.html
index 72c7ce9f51..1b85ccd4bf 100644
--- a/docs/client/packages/random.html
+++ b/docs/client/packages/random.html
@@ -1,5 +1,5 @@
 <template name="pkg_random">
-{{#better_markdown}}
+{{#markdown}}
 ## `random`
 
 The `random` package provides several functions for generating random
@@ -10,9 +10,18 @@ servers that don't have enough entropy to seed the cryptographically strong
 generator).
 
 <dl class="callbacks">
-{{#dtdd "Random.id()"}}
-Returns a unique identifier, such as `"Jjwjg6gouWLXhMGKW"`, that is likely to
-be unique in the whole world.
+{{#dtdd "Random.id([n])"}}
+Returns a unique identifier, such as `"Jjwjg6gouWLXhMGKW"`, that is
+likely to be unique in the whole world. The optional argument `n`
+specifies the length of the identifier in characters and defaults to 17.
+{{/dtdd}}
+
+{{#dtdd "Random.secret([n])"}}
+Returns a random string of printable characters with 6 bits of
+entropy per character. The optional argument `n` specifies the length of
+the secret string and defaults to 43 characters, or 256 bits of
+entropy. Use `Random.secret` for security-critical secrets that are
+intended for machine, rather than human, consumption.
 {{/dtdd}}
 
 {{#dtdd "Random.fraction()"}}
@@ -28,5 +37,5 @@ Returns a random string of `n` hexadecimal digits.
 {{/dtdd}}
 </dl>
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/spiderable.html b/docs/client/packages/spiderable.html
index 3bd785c4d4..d3adbd6339 100644
--- a/docs/client/packages/spiderable.html
+++ b/docs/client/packages/spiderable.html
@@ -1,5 +1,5 @@
 <template name="pkg_spiderable">
-{{#better_markdown}}
+{{#markdown}}
 ## `spiderable`
 
 
@@ -33,6 +33,14 @@ If you deploy your application with `meteor bundle`, you must install
 `$PATH`. If you use `meteor deploy` this is already taken care of.
 {{/warning}}
 
+{{#warning}}
+When running your page, `spiderable` will wait for all publications
+to be ready. Make sure that all of your [`publish functions`](#meteor_publish)
+either return a cursor (or an array of cursors), or eventually call
+[`this.ready()`](#publish_ready). Otherwise, the `phantomjs` executions
+will fail.
+{{/warning}}
 
-{{/better_markdown}}
+
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/stylus.html b/docs/client/packages/stylus.html
index 2752de11a9..c26aee668f 100644
--- a/docs/client/packages/stylus.html
+++ b/docs/client/packages/stylus.html
@@ -1,5 +1,5 @@
 <template name="pkg_stylus">
-{{#better_markdown}}
+{{#markdown}}
 ## `stylus`
 
 [Stylus](http://learnboost.github.com/stylus/) is a CSS pre-processor with a simple syntax and expressive
@@ -21,5 +21,5 @@ to prevent Meteor from processing it independently.
 
 See <http://visionmedia.github.com/nib> for documentation of the nib extensions of Stylus.
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/client/packages/underscore.html b/docs/client/packages/underscore.html
index cdf2fc1d33..ce5a59e77b 100644
--- a/docs/client/packages/underscore.html
+++ b/docs/client/packages/underscore.html
@@ -1,5 +1,5 @@
 <template name="pkg_underscore">
-{{#better_markdown}}
+{{#markdown}}
 ## `underscore`
 
 [Underscore](http://underscorejs.org/) is a utility-belt library for 
@@ -30,5 +30,5 @@ are treated as objects if they have no prototype (specifically, if
 {{/warning}}
 
 
-{{/better_markdown}}
+{{/markdown}}
 </template>
diff --git a/docs/lib/release-override.js b/docs/lib/release-override.js
index b99159cbf3..6ca2e658be 100644
--- a/docs/lib/release-override.js
+++ b/docs/lib/release-override.js
@@ -1,5 +1,5 @@
 // While galaxy apps are on their own special meteor releases, override
 // Meteor.release here.
 if (Meteor.isClient) {
-  Meteor.release = Meteor.release ? "0.7.2" : undefined;
+  Meteor.release = Meteor.release ? "0.8.0.1" : undefined;
 }
diff --git a/examples/clock/.meteor/.gitignore b/examples/clock/.meteor/.gitignore
new file mode 100644
index 0000000000..4083037423
--- /dev/null
+++ b/examples/clock/.meteor/.gitignore
@@ -0,0 +1 @@
+local
diff --git a/examples/clock/.meteor/packages b/examples/clock/.meteor/packages
new file mode 100644
index 0000000000..1826f1fa52
--- /dev/null
+++ b/examples/clock/.meteor/packages
@@ -0,0 +1,9 @@
+# Meteor packages used by this project, one per line.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+standard-app-packages
+autopublish
+insecure
+underscore
diff --git a/examples/clock/.meteor/release b/examples/clock/.meteor/release
new file mode 100644
index 0000000000..4b324f2d8f
--- /dev/null
+++ b/examples/clock/.meteor/release
@@ -0,0 +1 @@
+0.8.0.1
diff --git a/examples/clock/client/clock.html b/examples/clock/client/clock.html
new file mode 100644
index 0000000000..1a5e5d8ee9
--- /dev/null
+++ b/examples/clock/client/clock.html
@@ -0,0 +1,37 @@
+<head>
+  <title>SVG Clock Demo</title>
+</head>
+
+<body>
+  <svg xmlns="http://www.w3.org/2000/svg"
+       width="400" height="400"
+       viewBox="-110 -110 220 220">
+
+    <!-- bounding circle -->
+    <circle style="stroke: black; fill: #eee;"
+            cx="0" cy="0" r="100"/>
+
+    <!-- hour, minute and second hands -->
+    {{#with handData}}
+      <line {{radial hourDegrees 0 .55}}
+            style="stroke-width: 6px;
+                   stroke: green;" />
+      <line {{radial minuteDegrees 0 .85}}
+            style="stroke-width: 4px;
+                   stroke: blue;" />
+      <line {{radial secondDegrees 0 .95}}
+            style="stroke-width: 2px;
+                   stroke: red;" />
+    {{/with}}
+
+    <!-- tick marks -->
+    {{#each hours}}
+      <line {{radial degrees 0.9 1}}
+            style="stroke-width: 3px;
+                   stroke: black;" />
+    {{/each}}
+  </svg>
+</body>
+
+<!-- Adapted from David Basoko's SVG clock demo -->
+
diff --git a/examples/clock/client/clock.js b/examples/clock/client/clock.js
new file mode 100644
index 0000000000..4468819b08
--- /dev/null
+++ b/examples/clock/client/clock.js
@@ -0,0 +1,33 @@
+Meteor.setInterval(function () {
+  Session.set('time', new Date);
+}, 1000);
+
+UI.body.helpers({
+
+  hours: _.range(0, 12),
+
+  degrees: function () {
+    return 30 * this;
+  },
+
+  handData: function () {
+    var time = Session.get('time') || new Date;
+    return { hourDegrees: time.getHours() * 30,
+             minuteDegrees: time.getMinutes() * 6,
+             secondDegrees: time.getSeconds() * 6 };
+  },
+
+  radial: function (angleDegrees,
+                    startFraction,
+                    endFraction) {
+    var r = 100;
+    var radians = (angleDegrees-90) / 180 * Math.PI;
+
+    return {
+      x1: r * startFraction * Math.cos(radians),
+      y1: r * startFraction * Math.sin(radians),
+      x2: r * endFraction * Math.cos(radians),
+      y2: r * endFraction * Math.sin(radians)
+    };
+  }
+});
diff --git a/examples/leaderboard/.meteor/packages b/examples/leaderboard/.meteor/packages
index 240f048420..e442b00306 100644
--- a/examples/leaderboard/.meteor/packages
+++ b/examples/leaderboard/.meteor/packages
@@ -6,4 +6,3 @@
 standard-app-packages
 autopublish
 insecure
-preserve-inputs
diff --git a/examples/leaderboard/.meteor/release b/examples/leaderboard/.meteor/release
index 7486fdbc50..4b324f2d8f 100644
--- a/examples/leaderboard/.meteor/release
+++ b/examples/leaderboard/.meteor/release
@@ -1 +1 @@
-0.7.2
+0.8.0.1
diff --git a/examples/leaderboard/leaderboard.css b/examples/leaderboard/leaderboard.css
index d3f41060dc..5008a6fd10 100644
--- a/examples/leaderboard/leaderboard.css
+++ b/examples/leaderboard/leaderboard.css
@@ -12,7 +12,7 @@ body {
 
 #outer {
     width: 600px;
-    margin: 0 auto;    
+    margin: 0 auto;
 }
 
 .player {
diff --git a/examples/other/domrange-grid/.meteor/.gitignore b/examples/other/domrange-grid/.meteor/.gitignore
new file mode 100644
index 0000000000..4083037423
--- /dev/null
+++ b/examples/other/domrange-grid/.meteor/.gitignore
@@ -0,0 +1 @@
+local
diff --git a/examples/other/domrange-grid/.meteor/packages b/examples/other/domrange-grid/.meteor/packages
new file mode 100644
index 0000000000..f2b45cff30
--- /dev/null
+++ b/examples/other/domrange-grid/.meteor/packages
@@ -0,0 +1,10 @@
+# Meteor packages used by this project, one per line.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+standard-app-packages
+autopublish
+insecure
+preserve-inputs
+ui
diff --git a/examples/other/domrange-grid/.meteor/release b/examples/other/domrange-grid/.meteor/release
new file mode 100644
index 0000000000..621e94f0ec
--- /dev/null
+++ b/examples/other/domrange-grid/.meteor/release
@@ -0,0 +1 @@
+none
diff --git a/examples/other/domrange-grid/domrange-grid.css b/examples/other/domrange-grid/domrange-grid.css
new file mode 100644
index 0000000000..0cbc882454
--- /dev/null
+++ b/examples/other/domrange-grid/domrange-grid.css
@@ -0,0 +1,18 @@
+/* CSS declarations go here */
+
+
+* { margin: 0; padding: 0 }
+
+#grid td {
+  width: 20px;
+  height: 20px;
+  vertical-align: middle;
+  text-align: center;
+}
+
+.color0 { background: #eee; }
+.color1 { background: #d8f; }
+.color2 { background: #8c3; }
+.color3 { background: #39d; }
+.color4 { background: #d96; }
+.color5 { background: #a95; }
diff --git a/examples/other/domrange-grid/domrange-grid.html b/examples/other/domrange-grid/domrange-grid.html
new file mode 100644
index 0000000000..cf3a65f0b2
--- /dev/null
+++ b/examples/other/domrange-grid/domrange-grid.html
@@ -0,0 +1,7 @@
+<head>
+  <title>domrange-grid</title>
+</head>
+
+<body>
+
+</body>
diff --git a/examples/other/domrange-grid/domrange-grid.js b/examples/other/domrange-grid/domrange-grid.js
new file mode 100644
index 0000000000..6956fb0b5f
--- /dev/null
+++ b/examples/other/domrange-grid/domrange-grid.js
@@ -0,0 +1,105 @@
+if (Meteor.isClient) {
+  Meteor.startup(function () {
+    var N = 10;
+    var numColors = 6;
+    var colors = [];
+    for(var z = 0; z < numColors; z++)
+      colors[z] = z;
+
+    var guid = 1;
+
+    var table = $('<table id="grid"></table>');
+    $(table).appendTo("body");
+    var rows = [];
+    var tableContent = new UI.DomRange;
+    var makeCell = function (row) {
+      var cells = row.cells;
+      var tr = row.dom.elements()[0];
+      var cell = {color: Random.choice(colors),
+                  guid: String(guid++)};
+      cell.dom = new UI.DomRange(cell);
+      cells.push(cell);
+      cell.dom.add(cell.guid, $('<td class="color' +
+                                cell.color + '">' +
+                                cell.color + '</td>'));
+      row.content.add(cell.guid, cell);
+    };
+    var makeRow = function () {
+      var row = {cells: [], guid: String(guid++),
+                 content: new UI.DomRange};
+      row.dom = new UI.DomRange(row);
+      rows.push(row);
+      tableContent.add(row.guid, row);
+      var tr = $("<tr></tr>")[0];
+      row.dom.add(tr);
+      UI.DomRange.insert(row.content, tr);
+      var cells = row.cells;
+      for(var c = 0; c < N; c++)
+        makeCell(row);
+    };
+    for (var r = 0; r < N; r++)
+      makeRow();
+
+    UI.DomRange.insert(tableContent, table[0]);
+
+    $(document).on('keydown', function (evt) {
+      var deltaN = 0;
+      var deltaC = 0;
+      if (evt.which === 38) {
+        deltaN = 1; // up
+      } else if (evt.which === 40) {
+        deltaN = -1; // down
+      } else if (evt.which === 37) {
+        deltaC = -1; // left
+      } else if (evt.which === 39) {
+        deltaC = 1; // right
+      } else if (evt.which === 32) {
+        // spacebar
+        var row0 = rows.shift();
+        rows.push(row0);
+        tableContent.moveBefore(row0.guid, null);
+        for (var i = 0; i < rows.length; i++) {
+          var row = rows[i];
+          var cell0 = row.cells.shift();
+          row.cells.push(cell0);
+          row.content.moveBefore(cell0.guid, null);
+        }
+      }
+
+      if (deltaN === 1) {
+        N += 1;
+        for (var i = 0; i < N - 1; i++)
+          // lengthen old rows
+          makeCell(rows[i]);
+        makeRow();
+      } else if (deltaN === -1) {
+        if (N === 0)
+          return;
+        N -= 1;
+        tableContent.remove(rows[N].guid);
+        rows.length = N;
+        for (var i = 0; i < N; i++) {
+          var row = rows[i];
+          row.content.remove(row.cells[N].guid);
+          rows[i].cells.length = N;
+        }
+      }
+
+      if (deltaC) {
+        for (var r = 0; r < N; r++) {
+          var row = rows[r];
+          for (var c = 0; c < N; c++) {
+            var cell = row.cells[c];
+            var td = cell.dom.elements()[0];
+            var color =
+                  (cell.color =
+                   (cell.color + deltaC + numColors)
+                   % numColors);
+            td.innerHTML = color;
+            td.className = 'color' + color;
+          }
+        }
+      }
+    });
+  });
+}
diff --git a/examples/other/login-demo/login-demo.html b/examples/other/login-demo/login-demo.html
index ec70105bfb..c888074559 100644
--- a/examples/other/login-demo/login-demo.html
+++ b/examples/other/login-demo/login-demo.html
@@ -15,7 +15,7 @@
       <li>Logged out &mdash; otherwise</li>
     </ul>
     <p>If you reload the page while logged in, you'll start in the "logging in" state and see the "Loading..." message until the data loads.  Because logging in doesn't complete until all subscriptions have been rerun and finished loading, and the app only serves data when you're logged in, the "logging in" state encompasses loading the initial data for all subscriptions and is the only loading screen we need.</p>
-    <p>To configure this app for Google auth, the easiest way is to add the <code>accounts-ui</code> package, add <code>&#123;{loginButtons}}</code> to the end of the body, and use the configuration wizard.</p>
+    <p>To configure this app for Google auth, the easiest way is to add the <code>accounts-ui</code> package, add <code>&#123;{> loginButtons}}</code> to the end of the body, and use the configuration wizard.</p>
   </div>
 </body>
 
diff --git a/examples/other/template-demo/client/template-demo.html b/examples/other/template-demo/client/template-demo.html
index bb3293b1a7..1aa79e51f9 100644
--- a/examples/other/template-demo/client/template-demo.html
+++ b/examples/other/template-demo/client/template-demo.html
@@ -176,7 +176,7 @@ X={{x}}<br>
     <br>
     {{count}} circles<br>
     <input type="button" value="Add" class="add">
-    <input type="button" value="Remove" class="remove" {{{disabled}}}>
+    <input type="button" value="Remove" class="remove" {{disabled}}>
     <input type="button" value="Scram" class="scram">
     <input type="button" value="Clear" class="clear">
   </div>
diff --git a/examples/other/template-demo/client/template-demo.js b/examples/other/template-demo/client/template-demo.js
index 35a5a85763..3147a137c0 100644
--- a/examples/other/template-demo/client/template-demo.js
+++ b/examples/other/template-demo/client/template-demo.js
@@ -53,7 +53,7 @@ if (typeof Session.get("spinForward") !== 'boolean') {
 Template.preserveDemo.preserve([ '.spinner', '.spinforward' ]);
 
 Template.preserveDemo.spinForwardChecked = function () {
-  return Session.get('spinForward') ? 'checked="checked"' : '';
+  return Session.get('spinForward') ? 'checked' : '';
 };
 
 Template.preserveDemo.spinAnim = function () {
@@ -69,7 +69,7 @@ Template.preserveDemo.events({
 ///////////////////////////////////////////////////////////////////////////////
 
 Template.constantDemo.checked = function (which) {
-  return Session.get('mapchecked' + which) ? 'checked="checked"' : '';
+  return Session.get('mapchecked' + which) ? 'checked' : '';
 };
 
 Template.constantDemo.show = function (which) {
@@ -193,7 +193,7 @@ Template.circles.count = function () {
 
 Template.circles.disabled = function () {
   return Session.get("selectedCircle:" + this.group) ?
-    '' : 'disabled="disabled"';
+    '' : 'disabled';
 };
 
 Template.circles.created = function () {
diff --git a/examples/parties/.meteor/packages b/examples/parties/.meteor/packages
index 985d19f9fe..91e110ecf0 100644
--- a/examples/parties/.meteor/packages
+++ b/examples/parties/.meteor/packages
@@ -4,7 +4,6 @@
 # but you can also edit it by hand.
 
 standard-app-packages
-preserve-inputs
 accounts-ui
 accounts-password
 d3
diff --git a/examples/parties/.meteor/release b/examples/parties/.meteor/release
index 7486fdbc50..4b324f2d8f 100644
--- a/examples/parties/.meteor/release
+++ b/examples/parties/.meteor/release
@@ -1 +1 @@
-0.7.2
+0.8.0.1
diff --git a/examples/parties/client/parties.html b/examples/parties/client/parties.html
index 1a0e47191c..aa95f9bdae 100644
--- a/examples/parties/client/parties.html
+++ b/examples/parties/client/parties.html
@@ -27,7 +27,7 @@
           </div>
           <div class="span5">
             <div style="float: right">
-              {{loginButtons align="right"}}
+              {{> loginButtons align="right"}}
             </div>
           </div>
         </div>
@@ -54,13 +54,11 @@
 
 <template name="map">
   <div class="map">
-    {{#constant}}
-      <svg width="500" height="500">
-        <circle class="callout" cx=-100 cy=-100></circle>
-        <g class="circles"></g>
-        <g class="labels"></g>
-      </svg>
-    {{/constant}}
+    <svg width="500" height="500">
+      <circle class="callout" cx=-100 cy=-100></circle>
+      <g class="circles"></g>
+      <g class="labels"></g>
+    </svg>
     <div>
       <small class="attribution muted">&copy;
         <a href="http://www.openstreetmap.org/?lat=37.78212&lon=-122.40146&zoom=15&layers=M"
diff --git a/examples/todos/.meteor/packages b/examples/todos/.meteor/packages
index 001db3bdc2..c54e9c7ac9 100644
--- a/examples/todos/.meteor/packages
+++ b/examples/todos/.meteor/packages
@@ -8,5 +8,4 @@ underscore
 backbone
 spiderable
 jquery
-preserve-inputs
 insecure
diff --git a/examples/todos/.meteor/release b/examples/todos/.meteor/release
index 7486fdbc50..4b324f2d8f 100644
--- a/examples/todos/.meteor/release
+++ b/examples/todos/.meteor/release
@@ -1 +1 @@
-0.7.2
+0.8.0.1
diff --git a/examples/todos/client/todos.html b/examples/todos/client/todos.html
index f03e83b860..015363d2a1 100644
--- a/examples/todos/client/todos.html
+++ b/examples/todos/client/todos.html
@@ -72,7 +72,7 @@
     {{else}}
       <div class="destroy"></div>
       <div class="display">
-        <input class="check" name="markdone" type="checkbox" {{{done_checkbox}}} />
+        <input class="check" name="markdone" type="checkbox" checked={{done}} />
         <div class="todo-text">{{text}}</div>
       </div>
     {{/if}}
diff --git a/examples/todos/client/todos.js b/examples/todos/client/todos.js
index c5ea099eca..1d9ed49e4d 100644
--- a/examples/todos/client/todos.js
+++ b/examples/todos/client/todos.js
@@ -188,10 +188,6 @@ Template.todo_item.done_class = function () {
   return this.done ? 'done' : '';
 };
 
-Template.todo_item.done_checkbox = function () {
-  return this.done ? 'checked="checked"' : '';
-};
-
 Template.todo_item.editing = function () {
   return Session.equals('editing_itemname', this._id);
 };
diff --git a/examples/unfinished/accounts-ui-viewer/accounts-ui-viewer.html b/examples/unfinished/accounts-ui-viewer/accounts-ui-viewer.html
index 87d4b8a881..0d6b0e33e1 100644
--- a/examples/unfinished/accounts-ui-viewer/accounts-ui-viewer.html
+++ b/examples/unfinished/accounts-ui-viewer/accounts-ui-viewer.html
@@ -7,7 +7,10 @@
 </body>
 
 <template name="radio">
-  <span class="radio"><input id="{{key}}:{{value}}" {{{maybeChecked}}} type="radio" name="{{key}}" value="{{value}}" />{{! no whitespace}}<label for="{{key}}:{{value}}">{{label}}</label></span>
+  <span class="radio">
+    <input id="{{key}}:{{value}}" {{maybeChecked}} type="radio" name="{{key}}" value="{{value}}" />
+    <label for="{{key}}:{{value}}">{{label}}</label>
+  </span>
 </template>
 
 <template name="button">
@@ -18,92 +21,92 @@
   <div id="controlpane">
     <div class="group">
       <h3>Dropdown align edge:</h3>
-      {{radio "alignRight" "false" "Left"}}
-      {{radio "alignRight" "true" "Right"}}
+      {{> radio key="alignRight" value="false" label="Left"}}
+      {{> radio key="alignRight" value="true" label="Right"}}
     </div>
     <div class="group">
       <h3>Positioning:</h3>
-      {{radio "positioning" "relative" "Relative"}}
-      {{radio "positioning" "absolute" "Absolute"}}
-      {{radio "positioning" "floatRight" "Float:right"}}
-      {{radio "positioning" "inline" "Inline"}}
+      {{> radio key="positioning" value="relative" label="Relative"}}
+      {{> radio key="positioning" value="absolute" label="Absolute"}}
+      {{> radio key="positioning" value="floatRight" label="Float:right"}}
+      {{> radio key="positioning" value="inline" label="Inline"}}
     </div>
     <div class="group">
       <h3>How many third-party services?</h3>
-      {{radio "numServices" "0" "0"}}
-      {{radio "numServices" "1" "1"}}
-      {{radio "numServices" "2" "2"}}
-      {{radio "numServices" "3" "3"}}
+      {{> radio key="numServices" value="0" label="0"}}
+      {{> radio key="numServices" value="1" label="1"}}
+      {{> radio key="numServices" value="2" label="2"}}
+      {{> radio key="numServices" value="3" label="3"}}
     </div>
     <div class="group">
       <h3>Has password accounts?</h3>
-      {{radio "hasPasswords" "false" "No"}}
-      {{radio "hasPasswords" "true" "Yes"}}
+      {{> radio key="hasPasswords" value="false" label="No"}}
+      {{> radio key="hasPasswords" value="true" label="Yes"}}
     </div>
     <div class="group">
       <h3>Password sign-up fields:</h3>
-      {{radio "signupFields" "EMAIL_ONLY" "Email"}}
-      {{radio "signupFields" "USERNAME_ONLY" "Username"}}
-      {{radio "signupFields" "USERNAME_AND_EMAIL" "Username & Email"}}
-      {{radio "signupFields" "USERNAME_AND_OPTIONAL_EMAIL" "Username & Optional Email"}}
+      {{> radio key="signupFields" value="EMAIL_ONLY" label="Email"}}
+      {{> radio key="signupFields" value="USERNAME_ONLY" label="Username"}}
+      {{> radio key="signupFields" value="USERNAME_AND_EMAIL" label="Username & Email"}}
+      {{> radio key="signupFields" value="USERNAME_AND_OPTIONAL_EMAIL" label="Username & Optional Email"}}
     </div>
     <div class="group">
       <h3>Fake-Configure:</h3>
-      {{button "fakeConfig" "facebook" "Facebook"}}
-      {{button "fakeConfig" "github" "GitHub"}}
-      {{button "fakeConfig" "google" "Google"}}
+      {{> button key="fakeConfig" value="facebook" label="Facebook"}}
+      {{> button key="fakeConfig" value="github" label="GitHub"}}
+      {{> button key="fakeConfig" value="google" label="Google"}}
     </div>
     <div class="group">
       <h3>Show Configure Dialog:</h3>
-      {{button "showConfig" "facebook" "Facebook"}}
-      {{button "showConfig" "github" "GitHub"}}
-      {{button "showConfig" "google" "Google"}}
+      {{> button key="showConfig" value="facebook" label="Facebook"}}
+      {{> button key="showConfig" value="github" label="GitHub"}}
+      {{> button key="showConfig" value="google" label="Google"}}
     </div>
     <div class="group">
       <h3>Unconfigure:</h3>
-      {{button "unconfig" "facebook" "Facebook"}}
-      {{button "unconfig" "github" "GitHub"}}
-      {{button "unconfig" "google" "Google"}}
+      {{> button key="unconfig" value="facebook" label="Facebook"}}
+      {{> button key="unconfig" value="github" label="GitHub"}}
+      {{> button key="unconfig" value="google" label="Google"}}
     </div>
     <div class="group">
       <h3>Messages:</h3>
-      {{button "messages" "error" "Error"}}
-      {{button "messages" "info" "Info"}}
-      {{button "messages" "clear" "Clear"}}
+      {{> button key="messages" value="error" label="Error"}}
+      {{> button key="messages" value="info" label="Info"}}
+      {{> button key="messages" value="clear" label="Clear"}}
     </div>
     <div class="group">
       <h3>Signing in/out</h3>
-      {{button "sign" "in" "Fake sign-in"}}
-      {{button "sign" "out" "Sign out"}}
+      {{> button key="sign" value="in" label="Fake sign-in"}}
+      {{> button key="sign" value="out" label="Sign out"}}
     </div>
     <div class="group">
       <h3>Logged-out Views</h3>
-      {{button "lov" "signIn" "Sign In"}}
-      {{button "lov" "createAccount" "Create Account"}}
-      {{button "lov" "forgotPassword" "Forgot Password"}}
+      {{> button key="lov" value="signIn" label="Sign In"}}
+      {{> button key="lov" value="createAccount" label="Create Account"}}
+      {{> button key="lov" value="forgotPassword" label="Forgot Password"}}
     </div>
     <div class="group">
       <h3>Logged-in Views</h3>
-      {{button "liv" "accountButtons" "Account Buttons"}}
-      {{button "liv" "changePassword" "Change Password"}}
-      {{button "liv" "messageOnly" "Message Only"}}
+      {{> button key="liv" value="accountButtons" label="Account Buttons"}}
+      {{> button key="liv" value="changePassword" label="Change Password"}}
+      {{> button key="liv" value="messageOnly" label="Message Only"}}
     </div>
     <div class="group">
       <h3>Other Modals</h3>
-      {{button "modals" "resetPassword" "Reset Password"}}
-      {{button "modals" "enrollAccount" "Enroll Account"}}
-      {{button "modals" "justVerifiedEmail" "Verified Email"}}
+      {{> button key="modals" value="resetPassword" label="Reset Password"}}
+      {{> button key="modals" value="enrollAccount" label="Enroll Account"}}
+      {{> button key="modals" value="justVerifiedEmail" label="Verified Email"}}
     </div>
     <div class="group">
       <h3>Logging-in Spinner</h3>
-      {{radio "fakeLoggingIn" "false" "Off"}}
-      {{radio "fakeLoggingIn" "true" "Pretend loggingIn=true"}}
+      {{> radio key="fakeLoggingIn" value="false" label="Off"}}
+      {{> radio key="fakeLoggingIn" value="true" label="Pretend loggingIn=true"}}
     </div>
     <div class="group">
       <h3>Background Color</h3>
-      {{radio "bgcolor" "white" "White"}}
-      {{radio "bgcolor" "black" "Black"}}
-      {{radio "bgcolor" "red" "Red"}}
+      {{> radio key="bgcolor" value="white" label="White"}}
+      {{> radio key="bgcolor" value="black" label="Black"}}
+      {{> radio key="bgcolor" value="red" label="Red"}}
     </div>
   </div>
   {{#with settings}}
@@ -112,7 +115,7 @@
       {{#if match "positioning:inline"}}
         Here is a place to sign in, yay!
       {{/if}}
-      {{loginButtons align=dropdownAlign}}
+      {{> loginButtons align=dropdownAlign}}
       {{#if match "positioning:inline"}}
         Isn't that great?
       {{/if}}
diff --git a/examples/unfinished/accounts-ui-viewer/accounts-ui-viewer.js b/examples/unfinished/accounts-ui-viewer/accounts-ui-viewer.js
index cdd2bbefbf..ebde65defc 100644
--- a/examples/unfinished/accounts-ui-viewer/accounts-ui-viewer.js
+++ b/examples/unfinished/accounts-ui-viewer/accounts-ui-viewer.js
@@ -87,20 +87,10 @@ if (Meteor.isClient) {
   Template.radio.maybeChecked = function () {
     var curValue = Session.get('settings')[this.key];
     if (castValue(this.value) === curValue)
-      return 'checked="checked"';
+      return 'checked';
     return '';
   };
 
-  Template.page.radio = function (key, value, label) {
-    return new Handlebars.SafeString(
-      Template.radio({key: key, value: value, label: label}));
-  };
-
-  Template.page.button = function (key, value, label) {
-    return new Handlebars.SafeString(
-      Template.button({key: key, value: value, label: label}));
-  };
-
   Template.page.match = function (kv) {
     kv = keyValueFromId(kv);
     if (! kv)
@@ -218,4 +208,4 @@ if (Meteor.isClient) {
     }
   });
 
-}
\ No newline at end of file
+}
diff --git a/examples/unfinished/atoms/.meteor/.gitignore b/examples/unfinished/atoms/.meteor/.gitignore
new file mode 100644
index 0000000000..4083037423
--- /dev/null
+++ b/examples/unfinished/atoms/.meteor/.gitignore
@@ -0,0 +1 @@
+local
diff --git a/examples/unfinished/atoms/.meteor/packages b/examples/unfinished/atoms/.meteor/packages
new file mode 100644
index 0000000000..1826f1fa52
--- /dev/null
+++ b/examples/unfinished/atoms/.meteor/packages
@@ -0,0 +1,9 @@
+# Meteor packages used by this project, one per line.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+standard-app-packages
+autopublish
+insecure
+underscore
diff --git a/examples/unfinished/atoms/.meteor/release b/examples/unfinished/atoms/.meteor/release
new file mode 100644
index 0000000000..621e94f0ec
--- /dev/null
+++ b/examples/unfinished/atoms/.meteor/release
@@ -0,0 +1 @@
+none
diff --git a/examples/unfinished/atoms/atoms.css b/examples/unfinished/atoms/atoms.css
new file mode 100644
index 0000000000..038920b4ab
--- /dev/null
+++ b/examples/unfinished/atoms/atoms.css
@@ -0,0 +1,12 @@
+g[class=atom] circle {
+  stroke: black;
+  stroke-width: 3px;
+}
+
+g[class=atom] text {
+  font-family: Arial, sans-serif;
+  font-size: 24px;
+  fill: black;
+  font-weight: bold;
+  text-anchor: middle;
+}
\ No newline at end of file
diff --git a/examples/unfinished/atoms/atoms.html b/examples/unfinished/atoms/atoms.html
new file mode 100644
index 0000000000..2accd2c8ad
--- /dev/null
+++ b/examples/unfinished/atoms/atoms.html
@@ -0,0 +1,28 @@
+<head>
+  <title>Atoms</title>
+</head>
+
+<body>
+  <div id="atoms">
+    <svg xmlns="http://www.w3.org/2000/svg" width="500" height="500" viewBox="0 0 500 500">
+      {{#atom x=100 y=100 color="#ffff00"}}O{{/atom}}
+      {{> hydrogen x=150 y=100}}
+      {{#giantatom x=250 y=100 color="#ff9999"}}My{{/giantatom}}
+    </svg>
+  </div>
+</body>
+
+<template name="atom">
+  <g class="atom">
+    <circle style="fill: {{#if color}}{{color}}{{else}}white{{/if}}" cx={{x}} cy={{y}} r={{#if r}}{{r}}{{else}}20{{/if}} />
+    <text x={{x}} y={{textY}}>{{> UI.contentBlock}}</text>
+  </g>
+</template>
+
+<template name="hydrogen">
+  {{#atom x=x y=y r=r color="#00ffff"}}H{{/atom}}
+</template>
+
+<template name="giantatom">
+  {{#atom x=x y=y r=50 color=color}}{{> UI.contentBlock}}{{/atom}}
+</template>
diff --git a/examples/unfinished/atoms/atoms.js b/examples/unfinished/atoms/atoms.js
new file mode 100644
index 0000000000..d6cbcb9c39
--- /dev/null
+++ b/examples/unfinished/atoms/atoms.js
@@ -0,0 +1,5 @@
+if (Meteor.isClient) {
+  Template.atom.textY = function () {
+    return this.y + 8;
+  };
+}
\ No newline at end of file
diff --git a/examples/unfinished/movers/.meteor/.gitignore b/examples/unfinished/movers/.meteor/.gitignore
new file mode 100644
index 0000000000..4083037423
--- /dev/null
+++ b/examples/unfinished/movers/.meteor/.gitignore
@@ -0,0 +1 @@
+local
diff --git a/examples/unfinished/movers/.meteor/packages b/examples/unfinished/movers/.meteor/packages
new file mode 100644
index 0000000000..85521b15a9
--- /dev/null
+++ b/examples/unfinished/movers/.meteor/packages
@@ -0,0 +1,10 @@
+# Meteor packages used by this project, one per line.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+standard-app-packages
+autopublish
+insecure
+preserve-inputs
+less
diff --git a/examples/unfinished/movers/.meteor/release b/examples/unfinished/movers/.meteor/release
new file mode 100644
index 0000000000..621e94f0ec
--- /dev/null
+++ b/examples/unfinished/movers/.meteor/release
@@ -0,0 +1 @@
+none
diff --git a/examples/unfinished/movers/client/jquery-ui-sortable.js b/examples/unfinished/movers/client/jquery-ui-sortable.js
new file mode 100755
index 0000000000..0d85cfa365
--- /dev/null
+++ b/examples/unfinished/movers/client/jquery-ui-sortable.js
@@ -0,0 +1,2252 @@
+/*! jQuery UI - v1.10.3 - 2013-07-30
+* http://jqueryui.com
+* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.sortable.js
+* Copyright 2013 jQuery Foundation and other contributors Licensed MIT */
+
+(function( $, undefined ) {
+
+var uuid = 0,
+	runiqueId = /^ui-id-\d+$/;
+
+// $.ui might exist from components with no dependencies, e.g., $.ui.position
+$.ui = $.ui || {};
+
+$.extend( $.ui, {
+	version: "1.10.3",
+
+	keyCode: {
+		BACKSPACE: 8,
+		COMMA: 188,
+		DELETE: 46,
+		DOWN: 40,
+		END: 35,
+		ENTER: 13,
+		ESCAPE: 27,
+		HOME: 36,
+		LEFT: 37,
+		NUMPAD_ADD: 107,
+		NUMPAD_DECIMAL: 110,
+		NUMPAD_DIVIDE: 111,
+		NUMPAD_ENTER: 108,
+		NUMPAD_MULTIPLY: 106,
+		NUMPAD_SUBTRACT: 109,
+		PAGE_DOWN: 34,
+		PAGE_UP: 33,
+		PERIOD: 190,
+		RIGHT: 39,
+		SPACE: 32,
+		TAB: 9,
+		UP: 38
+	}
+});
+
+// plugins
+$.fn.extend({
+	focus: (function( orig ) {
+		return function( delay, fn ) {
+			return typeof delay === "number" ?
+				this.each(function() {
+					var elem = this;
+					setTimeout(function() {
+						$( elem ).focus();
+						if ( fn ) {
+							fn.call( elem );
+						}
+					}, delay );
+				}) :
+				orig.apply( this, arguments );
+		};
+	})( $.fn.focus ),
+
+	scrollParent: function() {
+		var scrollParent;
+		if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
+			scrollParent = this.parents().filter(function() {
+				return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
+			}).eq(0);
+		} else {
+			scrollParent = this.parents().filter(function() {
+				return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
+			}).eq(0);
+		}
+
+		return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
+	},
+
+	zIndex: function( zIndex ) {
+		if ( zIndex !== undefined ) {
+			return this.css( "zIndex", zIndex );
+		}
+
+		if ( this.length ) {
+			var elem = $( this[ 0 ] ), position, value;
+			while ( elem.length && elem[ 0 ] !== document ) {
+				// Ignore z-index if position is set to a value where z-index is ignored by the browser
+				// This makes behavior of this function consistent across browsers
+				// WebKit always returns auto if the element is positioned
+				position = elem.css( "position" );
+				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
+					// IE returns 0 when zIndex is not specified
+					// other browsers return a string
+					// we ignore the case of nested elements with an explicit value of 0
+					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
+					value = parseInt( elem.css( "zIndex" ), 10 );
+					if ( !isNaN( value ) && value !== 0 ) {
+						return value;
+					}
+				}
+				elem = elem.parent();
+			}
+		}
+
+		return 0;
+	},
+
+	uniqueId: function() {
+		return this.each(function() {
+			if ( !this.id ) {
+				this.id = "ui-id-" + (++uuid);
+			}
+		});
+	},
+
+	removeUniqueId: function() {
+		return this.each(function() {
+			if ( runiqueId.test( this.id ) ) {
+				$( this ).removeAttr( "id" );
+			}
+		});
+	}
+});
+
+// selectors
+function focusable( element, isTabIndexNotNaN ) {
+	var map, mapName, img,
+		nodeName = element.nodeName.toLowerCase();
+	if ( "area" === nodeName ) {
+		map = element.parentNode;
+		mapName = map.name;
+		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
+			return false;
+		}
+		img = $( "img[usemap=#" + mapName + "]" )[0];
+		return !!img && visible( img );
+	}
+	return ( /input|select|textarea|button|object/.test( nodeName ) ?
+		!element.disabled :
+		"a" === nodeName ?
+			element.href || isTabIndexNotNaN :
+			isTabIndexNotNaN) &&
+		// the element and all of its ancestors must be visible
+		visible( element );
+}
+
+function visible( element ) {
+	return $.expr.filters.visible( element ) &&
+		!$( element ).parents().addBack().filter(function() {
+			return $.css( this, "visibility" ) === "hidden";
+		}).length;
+}
+
+$.extend( $.expr[ ":" ], {
+	data: $.expr.createPseudo ?
+		$.expr.createPseudo(function( dataName ) {
+			return function( elem ) {
+				return !!$.data( elem, dataName );
+			};
+		}) :
+		// support: jQuery <1.8
+		function( elem, i, match ) {
+			return !!$.data( elem, match[ 3 ] );
+		},
+
+	focusable: function( element ) {
+		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
+	},
+
+	tabbable: function( element ) {
+		var tabIndex = $.attr( element, "tabindex" ),
+			isTabIndexNaN = isNaN( tabIndex );
+		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
+	}
+});
+
+// support: jQuery <1.8
+if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
+	$.each( [ "Width", "Height" ], function( i, name ) {
+		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
+			type = name.toLowerCase(),
+			orig = {
+				innerWidth: $.fn.innerWidth,
+				innerHeight: $.fn.innerHeight,
+				outerWidth: $.fn.outerWidth,
+				outerHeight: $.fn.outerHeight
+			};
+
+		function reduce( elem, size, border, margin ) {
+			$.each( side, function() {
+				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
+				if ( border ) {
+					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
+				}
+				if ( margin ) {
+					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
+				}
+			});
+			return size;
+		}
+
+		$.fn[ "inner" + name ] = function( size ) {
+			if ( size === undefined ) {
+				return orig[ "inner" + name ].call( this );
+			}
+
+			return this.each(function() {
+				$( this ).css( type, reduce( this, size ) + "px" );
+			});
+		};
+
+		$.fn[ "outer" + name] = function( size, margin ) {
+			if ( typeof size !== "number" ) {
+				return orig[ "outer" + name ].call( this, size );
+			}
+
+			return this.each(function() {
+				$( this).css( type, reduce( this, size, true, margin ) + "px" );
+			});
+		};
+	});
+}
+
+// support: jQuery <1.8
+if ( !$.fn.addBack ) {
+	$.fn.addBack = function( selector ) {
+		return this.add( selector == null ?
+			this.prevObject : this.prevObject.filter( selector )
+		);
+	};
+}
+
+// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
+if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
+	$.fn.removeData = (function( removeData ) {
+		return function( key ) {
+			if ( arguments.length ) {
+				return removeData.call( this, $.camelCase( key ) );
+			} else {
+				return removeData.call( this );
+			}
+		};
+	})( $.fn.removeData );
+}
+
+
+
+
+
+// deprecated
+$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
+
+$.support.selectstart = "onselectstart" in document.createElement( "div" );
+$.fn.extend({
+	disableSelection: function() {
+		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
+			".ui-disableSelection", function( event ) {
+				event.preventDefault();
+			});
+	},
+
+	enableSelection: function() {
+		return this.unbind( ".ui-disableSelection" );
+	}
+});
+
+$.extend( $.ui, {
+	// $.ui.plugin is deprecated. Use $.widget() extensions instead.
+	plugin: {
+		add: function( module, option, set ) {
+			var i,
+				proto = $.ui[ module ].prototype;
+			for ( i in set ) {
+				proto.plugins[ i ] = proto.plugins[ i ] || [];
+				proto.plugins[ i ].push( [ option, set[ i ] ] );
+			}
+		},
+		call: function( instance, name, args ) {
+			var i,
+				set = instance.plugins[ name ];
+			if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
+				return;
+			}
+
+			for ( i = 0; i < set.length; i++ ) {
+				if ( instance.options[ set[ i ][ 0 ] ] ) {
+					set[ i ][ 1 ].apply( instance.element, args );
+				}
+			}
+		}
+	},
+
+	// only used by resizable
+	hasScroll: function( el, a ) {
+
+		//If overflow is hidden, the element might have extra content, but the user wants to hide it
+		if ( $( el ).css( "overflow" ) === "hidden") {
+			return false;
+		}
+
+		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
+			has = false;
+
+		if ( el[ scroll ] > 0 ) {
+			return true;
+		}
+
+		// TODO: determine which cases actually cause this to happen
+		// if the element doesn't have the scroll set, see if it's possible to
+		// set the scroll
+		el[ scroll ] = 1;
+		has = ( el[ scroll ] > 0 );
+		el[ scroll ] = 0;
+		return has;
+	}
+});
+
+})( jQuery );
+(function( $, undefined ) {
+
+var uuid = 0,
+	slice = Array.prototype.slice,
+	_cleanData = $.cleanData;
+$.cleanData = function( elems ) {
+	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
+		try {
+			$( elem ).triggerHandler( "remove" );
+		// http://bugs.jquery.com/ticket/8235
+		} catch( e ) {}
+	}
+	_cleanData( elems );
+};
+
+$.widget = function( name, base, prototype ) {
+	var fullName, existingConstructor, constructor, basePrototype,
+		// proxiedPrototype allows the provided prototype to remain unmodified
+		// so that it can be used as a mixin for multiple widgets (#8876)
+		proxiedPrototype = {},
+		namespace = name.split( "." )[ 0 ];
+
+	name = name.split( "." )[ 1 ];
+	fullName = namespace + "-" + name;
+
+	if ( !prototype ) {
+		prototype = base;
+		base = $.Widget;
+	}
+
+	// create selector for plugin
+	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
+		return !!$.data( elem, fullName );
+	};
+
+	$[ namespace ] = $[ namespace ] || {};
+	existingConstructor = $[ namespace ][ name ];
+	constructor = $[ namespace ][ name ] = function( options, element ) {
+		// allow instantiation without "new" keyword
+		if ( !this._createWidget ) {
+			return new constructor( options, element );
+		}
+
+		// allow instantiation without initializing for simple inheritance
+		// must use "new" keyword (the code above always passes args)
+		if ( arguments.length ) {
+			this._createWidget( options, element );
+		}
+	};
+	// extend with the existing constructor to carry over any static properties
+	$.extend( constructor, existingConstructor, {
+		version: prototype.version,
+		// copy the object used to create the prototype in case we need to
+		// redefine the widget later
+		_proto: $.extend( {}, prototype ),
+		// track widgets that inherit from this widget in case this widget is
+		// redefined after a widget inherits from it
+		_childConstructors: []
+	});
+
+	basePrototype = new base();
+	// we need to make the options hash a property directly on the new instance
+	// otherwise we'll modify the options hash on the prototype that we're
+	// inheriting from
+	basePrototype.options = $.widget.extend( {}, basePrototype.options );
+	$.each( prototype, function( prop, value ) {
+		if ( !$.isFunction( value ) ) {
+			proxiedPrototype[ prop ] = value;
+			return;
+		}
+		proxiedPrototype[ prop ] = (function() {
+			var _super = function() {
+					return base.prototype[ prop ].apply( this, arguments );
+				},
+				_superApply = function( args ) {
+					return base.prototype[ prop ].apply( this, args );
+				};
+			return function() {
+				var __super = this._super,
+					__superApply = this._superApply,
+					returnValue;
+
+				this._super = _super;
+				this._superApply = _superApply;
+
+				returnValue = value.apply( this, arguments );
+
+				this._super = __super;
+				this._superApply = __superApply;
+
+				return returnValue;
+			};
+		})();
+	});
+	constructor.prototype = $.widget.extend( basePrototype, {
+		// TODO: remove support for widgetEventPrefix
+		// always use the name + a colon as the prefix, e.g., draggable:start
+		// don't prefix for widgets that aren't DOM-based
+		widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
+	}, proxiedPrototype, {
+		constructor: constructor,
+		namespace: namespace,
+		widgetName: name,
+		widgetFullName: fullName
+	});
+
+	// If this widget is being redefined then we need to find all widgets that
+	// are inheriting from it and redefine all of them so that they inherit from
+	// the new version of this widget. We're essentially trying to replace one
+	// level in the prototype chain.
+	if ( existingConstructor ) {
+		$.each( existingConstructor._childConstructors, function( i, child ) {
+			var childPrototype = child.prototype;
+
+			// redefine the child widget using the same prototype that was
+			// originally used, but inherit from the new version of the base
+			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
+		});
+		// remove the list of existing child constructors from the old constructor
+		// so the old child constructors can be garbage collected
+		delete existingConstructor._childConstructors;
+	} else {
+		base._childConstructors.push( constructor );
+	}
+
+	$.widget.bridge( name, constructor );
+};
+
+$.widget.extend = function( target ) {
+	var input = slice.call( arguments, 1 ),
+		inputIndex = 0,
+		inputLength = input.length,
+		key,
+		value;
+	for ( ; inputIndex < inputLength; inputIndex++ ) {
+		for ( key in input[ inputIndex ] ) {
+			value = input[ inputIndex ][ key ];
+			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
+				// Clone objects
+				if ( $.isPlainObject( value ) ) {
+					target[ key ] = $.isPlainObject( target[ key ] ) ?
+						$.widget.extend( {}, target[ key ], value ) :
+						// Don't extend strings, arrays, etc. with objects
+						$.widget.extend( {}, value );
+				// Copy everything else by reference
+				} else {
+					target[ key ] = value;
+				}
+			}
+		}
+	}
+	return target;
+};
+
+$.widget.bridge = function( name, object ) {
+	var fullName = object.prototype.widgetFullName || name;
+	$.fn[ name ] = function( options ) {
+		var isMethodCall = typeof options === "string",
+			args = slice.call( arguments, 1 ),
+			returnValue = this;
+
+		// allow multiple hashes to be passed on init
+		options = !isMethodCall && args.length ?
+			$.widget.extend.apply( null, [ options ].concat(args) ) :
+			options;
+
+		if ( isMethodCall ) {
+			this.each(function() {
+				var methodValue,
+					instance = $.data( this, fullName );
+				if ( !instance ) {
+					return $.error( "cannot call methods on " + name + " prior to initialization; " +
+						"attempted to call method '" + options + "'" );
+				}
+				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
+					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
+				}
+				methodValue = instance[ options ].apply( instance, args );
+				if ( methodValue !== instance && methodValue !== undefined ) {
+					returnValue = methodValue && methodValue.jquery ?
+						returnValue.pushStack( methodValue.get() ) :
+						methodValue;
+					return false;
+				}
+			});
+		} else {
+			this.each(function() {
+				var instance = $.data( this, fullName );
+				if ( instance ) {
+					instance.option( options || {} )._init();
+				} else {
+					$.data( this, fullName, new object( options, this ) );
+				}
+			});
+		}
+
+		return returnValue;
+	};
+};
+
+$.Widget = function( /* options, element */ ) {};
+$.Widget._childConstructors = [];
+
+$.Widget.prototype = {
+	widgetName: "widget",
+	widgetEventPrefix: "",
+	defaultElement: "<div>",
+	options: {
+		disabled: false,
+
+		// callbacks
+		create: null
+	},
+	_createWidget: function( options, element ) {
+		element = $( element || this.defaultElement || this )[ 0 ];
+		this.element = $( element );
+		this.uuid = uuid++;
+		this.eventNamespace = "." + this.widgetName + this.uuid;
+		this.options = $.widget.extend( {},
+			this.options,
+			this._getCreateOptions(),
+			options );
+
+		this.bindings = $();
+		this.hoverable = $();
+		this.focusable = $();
+
+		if ( element !== this ) {
+			$.data( element, this.widgetFullName, this );
+			this._on( true, this.element, {
+				remove: function( event ) {
+					if ( event.target === element ) {
+						this.destroy();
+					}
+				}
+			});
+			this.document = $( element.style ?
+				// element within the document
+				element.ownerDocument :
+				// element is window or document
+				element.document || element );
+			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
+		}
+
+		this._create();
+		this._trigger( "create", null, this._getCreateEventData() );
+		this._init();
+	},
+	_getCreateOptions: $.noop,
+	_getCreateEventData: $.noop,
+	_create: $.noop,
+	_init: $.noop,
+
+	destroy: function() {
+		this._destroy();
+		// we can probably remove the unbind calls in 2.0
+		// all event bindings should go through this._on()
+		this.element
+			.unbind( this.eventNamespace )
+			// 1.9 BC for #7810
+			// TODO remove dual storage
+			.removeData( this.widgetName )
+			.removeData( this.widgetFullName )
+			// support: jquery <1.6.3
+			// http://bugs.jquery.com/ticket/9413
+			.removeData( $.camelCase( this.widgetFullName ) );
+		this.widget()
+			.unbind( this.eventNamespace )
+			.removeAttr( "aria-disabled" )
+			.removeClass(
+				this.widgetFullName + "-disabled " +
+				"ui-state-disabled" );
+
+		// clean up events and states
+		this.bindings.unbind( this.eventNamespace );
+		this.hoverable.removeClass( "ui-state-hover" );
+		this.focusable.removeClass( "ui-state-focus" );
+	},
+	_destroy: $.noop,
+
+	widget: function() {
+		return this.element;
+	},
+
+	option: function( key, value ) {
+		var options = key,
+			parts,
+			curOption,
+			i;
+
+		if ( arguments.length === 0 ) {
+			// don't return a reference to the internal hash
+			return $.widget.extend( {}, this.options );
+		}
+
+		if ( typeof key === "string" ) {
+			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
+			options = {};
+			parts = key.split( "." );
+			key = parts.shift();
+			if ( parts.length ) {
+				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
+				for ( i = 0; i < parts.length - 1; i++ ) {
+					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
+					curOption = curOption[ parts[ i ] ];
+				}
+				key = parts.pop();
+				if ( value === undefined ) {
+					return curOption[ key ] === undefined ? null : curOption[ key ];
+				}
+				curOption[ key ] = value;
+			} else {
+				if ( value === undefined ) {
+					return this.options[ key ] === undefined ? null : this.options[ key ];
+				}
+				options[ key ] = value;
+			}
+		}
+
+		this._setOptions( options );
+
+		return this;
+	},
+	_setOptions: function( options ) {
+		var key;
+
+		for ( key in options ) {
+			this._setOption( key, options[ key ] );
+		}
+
+		return this;
+	},
+	_setOption: function( key, value ) {
+		this.options[ key ] = value;
+
+		if ( key === "disabled" ) {
+			this.widget()
+				.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
+				.attr( "aria-disabled", value );
+			this.hoverable.removeClass( "ui-state-hover" );
+			this.focusable.removeClass( "ui-state-focus" );
+		}
+
+		return this;
+	},
+
+	enable: function() {
+		return this._setOption( "disabled", false );
+	},
+	disable: function() {
+		return this._setOption( "disabled", true );
+	},
+
+	_on: function( suppressDisabledCheck, element, handlers ) {
+		var delegateElement,
+			instance = this;
+
+		// no suppressDisabledCheck flag, shuffle arguments
+		if ( typeof suppressDisabledCheck !== "boolean" ) {
+			handlers = element;
+			element = suppressDisabledCheck;
+			suppressDisabledCheck = false;
+		}
+
+		// no element argument, shuffle and use this.element
+		if ( !handlers ) {
+			handlers = element;
+			element = this.element;
+			delegateElement = this.widget();
+		} else {
+			// accept selectors, DOM elements
+			element = delegateElement = $( element );
+			this.bindings = this.bindings.add( element );
+		}
+
+		$.each( handlers, function( event, handler ) {
+			function handlerProxy() {
+				// allow widgets to customize the disabled handling
+				// - disabled as an array instead of boolean
+				// - disabled class as method for disabling individual parts
+				if ( !suppressDisabledCheck &&
+						( instance.options.disabled === true ||
+							$( this ).hasClass( "ui-state-disabled" ) ) ) {
+					return;
+				}
+				return ( typeof handler === "string" ? instance[ handler ] : handler )
+					.apply( instance, arguments );
+			}
+
+			// copy the guid so direct unbinding works
+			if ( typeof handler !== "string" ) {
+				handlerProxy.guid = handler.guid =
+					handler.guid || handlerProxy.guid || $.guid++;
+			}
+
+			var match = event.match( /^(\w+)\s*(.*)$/ ),
+				eventName = match[1] + instance.eventNamespace,
+				selector = match[2];
+			if ( selector ) {
+				delegateElement.delegate( selector, eventName, handlerProxy );
+			} else {
+				element.bind( eventName, handlerProxy );
+			}
+		});
+	},
+
+	_off: function( element, eventName ) {
+		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
+		element.unbind( eventName ).undelegate( eventName );
+	},
+
+	_delay: function( handler, delay ) {
+		function handlerProxy() {
+			return ( typeof handler === "string" ? instance[ handler ] : handler )
+				.apply( instance, arguments );
+		}
+		var instance = this;
+		return setTimeout( handlerProxy, delay || 0 );
+	},
+
+	_hoverable: function( element ) {
+		this.hoverable = this.hoverable.add( element );
+		this._on( element, {
+			mouseenter: function( event ) {
+				$( event.currentTarget ).addClass( "ui-state-hover" );
+			},
+			mouseleave: function( event ) {
+				$( event.currentTarget ).removeClass( "ui-state-hover" );
+			}
+		});
+	},
+
+	_focusable: function( element ) {
+		this.focusable = this.focusable.add( element );
+		this._on( element, {
+			focusin: function( event ) {
+				$( event.currentTarget ).addClass( "ui-state-focus" );
+			},
+			focusout: function( event ) {
+				$( event.currentTarget ).removeClass( "ui-state-focus" );
+			}
+		});
+	},
+
+	_trigger: function( type, event, data ) {
+		var prop, orig,
+			callback = this.options[ type ];
+
+		data = data || {};
+		event = $.Event( event );
+		event.type = ( type === this.widgetEventPrefix ?
+			type :
+			this.widgetEventPrefix + type ).toLowerCase();
+		// the original event may come from any element
+		// so we need to reset the target on the new event
+		event.target = this.element[ 0 ];
+
+		// copy original event properties over to the new event
+		orig = event.originalEvent;
+		if ( orig ) {
+			for ( prop in orig ) {
+				if ( !( prop in event ) ) {
+					event[ prop ] = orig[ prop ];
+				}
+			}
+		}
+
+		this.element.trigger( event, data );
+		return !( $.isFunction( callback ) &&
+			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
+			event.isDefaultPrevented() );
+	}
+};
+
+$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
+	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
+		if ( typeof options === "string" ) {
+			options = { effect: options };
+		}
+		var hasOptions,
+			effectName = !options ?
+				method :
+				options === true || typeof options === "number" ?
+					defaultEffect :
+					options.effect || defaultEffect;
+		options = options || {};
+		if ( typeof options === "number" ) {
+			options = { duration: options };
+		}
+		hasOptions = !$.isEmptyObject( options );
+		options.complete = callback;
+		if ( options.delay ) {
+			element.delay( options.delay );
+		}
+		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
+			element[ method ]( options );
+		} else if ( effectName !== method && element[ effectName ] ) {
+			element[ effectName ]( options.duration, options.easing, callback );
+		} else {
+			element.queue(function( next ) {
+				$( this )[ method ]();
+				if ( callback ) {
+					callback.call( element[ 0 ] );
+				}
+				next();
+			});
+		}
+	};
+});
+
+})( jQuery );
+(function( $, undefined ) {
+
+var mouseHandled = false;
+$( document ).mouseup( function() {
+	mouseHandled = false;
+});
+
+$.widget("ui.mouse", {
+	version: "1.10.3",
+	options: {
+		cancel: "input,textarea,button,select,option",
+		distance: 1,
+		delay: 0
+	},
+	_mouseInit: function() {
+		var that = this;
+
+		this.element
+			.bind("mousedown."+this.widgetName, function(event) {
+				return that._mouseDown(event);
+			})
+			.bind("click."+this.widgetName, function(event) {
+				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
+					$.removeData(event.target, that.widgetName + ".preventClickEvent");
+					event.stopImmediatePropagation();
+					return false;
+				}
+			});
+
+		this.started = false;
+	},
+
+	// TODO: make sure destroying one instance of mouse doesn't mess with
+	// other instances of mouse
+	_mouseDestroy: function() {
+		this.element.unbind("."+this.widgetName);
+		if ( this._mouseMoveDelegate ) {
+			$(document)
+				.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
+				.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
+		}
+	},
+
+	_mouseDown: function(event) {
+		// don't let more than one widget handle mouseStart
+		if( mouseHandled ) { return; }
+
+		// we may have missed mouseup (out of window)
+		(this._mouseStarted && this._mouseUp(event));
+
+		this._mouseDownEvent = event;
+
+		var that = this,
+			btnIsLeft = (event.which === 1),
+			// event.target.nodeName works around a bug in IE 8 with
+			// disabled inputs (#7620)
+			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
+		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
+			return true;
+		}
+
+		this.mouseDelayMet = !this.options.delay;
+		if (!this.mouseDelayMet) {
+			this._mouseDelayTimer = setTimeout(function() {
+				that.mouseDelayMet = true;
+			}, this.options.delay);
+		}
+
+		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
+			this._mouseStarted = (this._mouseStart(event) !== false);
+			if (!this._mouseStarted) {
+				event.preventDefault();
+				return true;
+			}
+		}
+
+		// Click event may never have fired (Gecko & Opera)
+		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
+			$.removeData(event.target, this.widgetName + ".preventClickEvent");
+		}
+
+		// these delegates are required to keep context
+		this._mouseMoveDelegate = function(event) {
+			return that._mouseMove(event);
+		};
+		this._mouseUpDelegate = function(event) {
+			return that._mouseUp(event);
+		};
+		$(document)
+			.bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
+			.bind("mouseup."+this.widgetName, this._mouseUpDelegate);
+
+		event.preventDefault();
+
+		mouseHandled = true;
+		return true;
+	},
+
+	_mouseMove: function(event) {
+		// IE mouseup check - mouseup happened when mouse was out of window
+		if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
+			return this._mouseUp(event);
+		}
+
+		if (this._mouseStarted) {
+			this._mouseDrag(event);
+			return event.preventDefault();
+		}
+
+		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
+			this._mouseStarted =
+				(this._mouseStart(this._mouseDownEvent, event) !== false);
+			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
+		}
+
+		return !this._mouseStarted;
+	},
+
+	_mouseUp: function(event) {
+		$(document)
+			.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
+			.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
+
+		if (this._mouseStarted) {
+			this._mouseStarted = false;
+
+			if (event.target === this._mouseDownEvent.target) {
+				$.data(event.target, this.widgetName + ".preventClickEvent", true);
+			}
+
+			this._mouseStop(event);
+		}
+
+		return false;
+	},
+
+	_mouseDistanceMet: function(event) {
+		return (Math.max(
+				Math.abs(this._mouseDownEvent.pageX - event.pageX),
+				Math.abs(this._mouseDownEvent.pageY - event.pageY)
+			) >= this.options.distance
+		);
+	},
+
+	_mouseDelayMet: function(/* event */) {
+		return this.mouseDelayMet;
+	},
+
+	// These are placeholder methods, to be overriden by extending plugin
+	_mouseStart: function(/* event */) {},
+	_mouseDrag: function(/* event */) {},
+	_mouseStop: function(/* event */) {},
+	_mouseCapture: function(/* event */) { return true; }
+});
+
+})(jQuery);
+(function( $, undefined ) {
+
+/*jshint loopfunc: true */
+
+function isOverAxis( x, reference, size ) {
+	return ( x > reference ) && ( x < ( reference + size ) );
+}
+
+function isFloating(item) {
+	return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
+}
+
+$.widget("ui.sortable", $.ui.mouse, {
+	version: "1.10.3",
+	widgetEventPrefix: "sort",
+	ready: false,
+	options: {
+		appendTo: "parent",
+		axis: false,
+		connectWith: false,
+		containment: false,
+		cursor: "auto",
+		cursorAt: false,
+		dropOnEmpty: true,
+		forcePlaceholderSize: false,
+		forceHelperSize: false,
+		grid: false,
+		handle: false,
+		helper: "original",
+		items: "> *",
+		opacity: false,
+		placeholder: false,
+		revert: false,
+		scroll: true,
+		scrollSensitivity: 20,
+		scrollSpeed: 20,
+		scope: "default",
+		tolerance: "intersect",
+		zIndex: 1000,
+
+		// callbacks
+		activate: null,
+		beforeStop: null,
+		change: null,
+		deactivate: null,
+		out: null,
+		over: null,
+		receive: null,
+		remove: null,
+		sort: null,
+		start: null,
+		stop: null,
+		update: null
+	},
+	_create: function() {
+
+		var o = this.options;
+		this.containerCache = {};
+		this.element.addClass("ui-sortable");
+
+		//Get the items
+		this.refresh();
+
+		//Let's determine if the items are being displayed horizontally
+		this.floating = this.items.length ? o.axis === "x" || isFloating(this.items[0].item) : false;
+
+		//Let's determine the parent's offset
+		this.offset = this.element.offset();
+
+		//Initialize mouse events for interaction
+		this._mouseInit();
+
+		//We're ready to go
+		this.ready = true;
+
+	},
+
+	_destroy: function() {
+		this.element
+			.removeClass("ui-sortable ui-sortable-disabled");
+		this._mouseDestroy();
+
+		for ( var i = this.items.length - 1; i >= 0; i-- ) {
+			this.items[i].item.removeData(this.widgetName + "-item");
+		}
+
+		return this;
+	},
+
+	_setOption: function(key, value){
+		if ( key === "disabled" ) {
+			this.options[ key ] = value;
+
+			this.widget().toggleClass( "ui-sortable-disabled", !!value );
+		} else {
+			// Don't call widget base _setOption for disable as it adds ui-state-disabled class
+			$.Widget.prototype._setOption.apply(this, arguments);
+		}
+	},
+
+	_mouseCapture: function(event, overrideHandle) {
+		var currentItem = null,
+			validHandle = false,
+			that = this;
+
+		if (this.reverting) {
+			return false;
+		}
+
+		if(this.options.disabled || this.options.type === "static") {
+			return false;
+		}
+
+		//We have to refresh the items data once first
+		this._refreshItems(event);
+
+		//Find out if the clicked node (or one of its parents) is a actual item in this.items
+		$(event.target).parents().each(function() {
+			if($.data(this, that.widgetName + "-item") === that) {
+				currentItem = $(this);
+				return false;
+			}
+		});
+		if($.data(event.target, that.widgetName + "-item") === that) {
+			currentItem = $(event.target);
+		}
+
+		if(!currentItem) {
+			return false;
+		}
+		if(this.options.handle && !overrideHandle) {
+			$(this.options.handle, currentItem).find("*").addBack().each(function() {
+				if(this === event.target) {
+					validHandle = true;
+				}
+			});
+			if(!validHandle) {
+				return false;
+			}
+		}
+
+		this.currentItem = currentItem;
+		this._removeCurrentsFromItems();
+		return true;
+
+	},
+
+	_mouseStart: function(event, overrideHandle, noActivation) {
+
+		var i, body,
+			o = this.options;
+
+		this.currentContainer = this;
+
+		//We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
+		this.refreshPositions();
+
+		//Create and append the visible helper
+		this.helper = this._createHelper(event);
+
+		//Cache the helper size
+		this._cacheHelperProportions();
+
+		/*
+		 * - Position generation -
+		 * This block generates everything position related - it's the core of draggables.
+		 */
+
+		//Cache the margins of the original element
+		this._cacheMargins();
+
+		//Get the next scrolling parent
+		this.scrollParent = this.helper.scrollParent();
+
+		//The element's absolute position on the page minus margins
+		this.offset = this.currentItem.offset();
+		this.offset = {
+			top: this.offset.top - this.margins.top,
+			left: this.offset.left - this.margins.left
+		};
+
+		$.extend(this.offset, {
+			click: { //Where the click happened, relative to the element
+				left: event.pageX - this.offset.left,
+				top: event.pageY - this.offset.top
+			},
+			parent: this._getParentOffset(),
+			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
+		});
+
+		// Only after we got the offset, we can change the helper's position to absolute
+		// TODO: Still need to figure out a way to make relative sorting possible
+		this.helper.css("position", "absolute");
+		this.cssPosition = this.helper.css("position");
+
+		//Generate the original position
+		this.originalPosition = this._generatePosition(event);
+		this.originalPageX = event.pageX;
+		this.originalPageY = event.pageY;
+
+		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
+		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
+
+		//Cache the former DOM position
+		this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
+
+		//If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
+		if(this.helper[0] !== this.currentItem[0]) {
+			this.currentItem.hide();
+		}
+
+		//Create the placeholder
+		this._createPlaceholder();
+
+		//Set a containment if given in the options
+		if(o.containment) {
+			this._setContainment();
+		}
+
+		if( o.cursor && o.cursor !== "auto" ) { // cursor option
+			body = this.document.find( "body" );
+
+			// support: IE
+			this.storedCursor = body.css( "cursor" );
+			body.css( "cursor", o.cursor );
+
+			this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
+		}
+
+		if(o.opacity) { // opacity option
+			if (this.helper.css("opacity")) {
+				this._storedOpacity = this.helper.css("opacity");
+			}
+			this.helper.css("opacity", o.opacity);
+		}
+
+		if(o.zIndex) { // zIndex option
+			if (this.helper.css("zIndex")) {
+				this._storedZIndex = this.helper.css("zIndex");
+			}
+			this.helper.css("zIndex", o.zIndex);
+		}
+
+		//Prepare scrolling
+		if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
+			this.overflowOffset = this.scrollParent.offset();
+		}
+
+		//Call callbacks
+		this._trigger("start", event, this._uiHash());
+
+		//Recache the helper size
+		if(!this._preserveHelperProportions) {
+			this._cacheHelperProportions();
+		}
+
+
+		//Post "activate" events to possible containers
+		if( !noActivation ) {
+			for ( i = this.containers.length - 1; i >= 0; i-- ) {
+				this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
+			}
+		}
+
+		//Prepare possible droppables
+		if($.ui.ddmanager) {
+			$.ui.ddmanager.current = this;
+		}
+
+		if ($.ui.ddmanager && !o.dropBehaviour) {
+			$.ui.ddmanager.prepareOffsets(this, event);
+		}
+
+		this.dragging = true;
+
+		this.helper.addClass("ui-sortable-helper");
+		this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
+		return true;
+
+	},
+
+	_mouseDrag: function(event) {
+		var i, item, itemElement, intersection,
+			o = this.options,
+			scrolled = false;
+
+		//Compute the helpers position
+		this.position = this._generatePosition(event);
+		this.positionAbs = this._convertPositionTo("absolute");
+
+		if (!this.lastPositionAbs) {
+			this.lastPositionAbs = this.positionAbs;
+		}
+
+		//Do scrolling
+		if(this.options.scroll) {
+			if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
+
+				if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
+					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
+				} else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
+					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
+				}
+
+				if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
+					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
+				} else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
+					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
+				}
+
+			} else {
+
+				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
+					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
+				} else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
+					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
+				}
+
+				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
+					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
+				} else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
+					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
+				}
+
+			}
+
+			if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
+				$.ui.ddmanager.prepareOffsets(this, event);
+			}
+		}
+
+		//Regenerate the absolute position used for position checks
+		this.positionAbs = this._convertPositionTo("absolute");
+
+		//Set the helper position
+		if(!this.options.axis || this.options.axis !== "y") {
+			this.helper[0].style.left = this.position.left+"px";
+		}
+		if(!this.options.axis || this.options.axis !== "x") {
+			this.helper[0].style.top = this.position.top+"px";
+		}
+
+		//Rearrange
+		for (i = this.items.length - 1; i >= 0; i--) {
+
+			//Cache variables and intersection, continue if no intersection
+			item = this.items[i];
+			itemElement = item.item[0];
+			intersection = this._intersectsWithPointer(item);
+			if (!intersection) {
+				continue;
+			}
+
+			// Only put the placeholder inside the current Container, skip all
+			// items form other containers. This works because when moving
+			// an item from one container to another the
+			// currentContainer is switched before the placeholder is moved.
+			//
+			// Without this moving items in "sub-sortables" can cause the placeholder to jitter
+			// beetween the outer and inner container.
+			if (item.instance !== this.currentContainer) {
+				continue;
+			}
+
+			// cannot intersect with itself
+			// no useless actions that have been done before
+			// no action if the item moved is the parent of the item checked
+			if (itemElement !== this.currentItem[0] &&
+				this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
+				!$.contains(this.placeholder[0], itemElement) &&
+				(this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
+			) {
+
+				this.direction = intersection === 1 ? "down" : "up";
+
+				if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
+					this._rearrange(event, item);
+				} else {
+					break;
+				}
+
+				this._trigger("change", event, this._uiHash());
+				break;
+			}
+		}
+
+		//Post events to containers
+		this._contactContainers(event);
+
+		//Interconnect with droppables
+		if($.ui.ddmanager) {
+			$.ui.ddmanager.drag(this, event);
+		}
+
+		//Call callbacks
+		this._trigger("sort", event, this._uiHash());
+
+		this.lastPositionAbs = this.positionAbs;
+		return false;
+
+	},
+
+	_mouseStop: function(event, noPropagation) {
+
+		if(!event) {
+			return;
+		}
+
+		//If we are using droppables, inform the manager about the drop
+		if ($.ui.ddmanager && !this.options.dropBehaviour) {
+			$.ui.ddmanager.drop(this, event);
+		}
+
+		if(this.options.revert) {
+			var that = this,
+				cur = this.placeholder.offset(),
+				axis = this.options.axis,
+				animation = {};
+
+			if ( !axis || axis === "x" ) {
+				animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft);
+			}
+			if ( !axis || axis === "y" ) {
+				animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop);
+			}
+			this.reverting = true;
+			$(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
+				that._clear(event);
+			});
+		} else {
+			this._clear(event, noPropagation);
+		}
+
+		return false;
+
+	},
+
+	cancel: function() {
+
+		if(this.dragging) {
+
+			this._mouseUp({ target: null });
+
+			if(this.options.helper === "original") {
+				this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
+			} else {
+				this.currentItem.show();
+			}
+
+			//Post deactivating events to containers
+			for (var i = this.containers.length - 1; i >= 0; i--){
+				this.containers[i]._trigger("deactivate", null, this._uiHash(this));
+				if(this.containers[i].containerCache.over) {
+					this.containers[i]._trigger("out", null, this._uiHash(this));
+					this.containers[i].containerCache.over = 0;
+				}
+			}
+
+		}
+
+		if (this.placeholder) {
+			//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
+			if(this.placeholder[0].parentNode) {
+				this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+			}
+			if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
+				this.helper.remove();
+			}
+
+			$.extend(this, {
+				helper: null,
+				dragging: false,
+				reverting: false,
+				_noFinalSort: null
+			});
+
+			if(this.domPosition.prev) {
+				$(this.domPosition.prev).after(this.currentItem);
+			} else {
+				$(this.domPosition.parent).prepend(this.currentItem);
+			}
+		}
+
+		return this;
+
+	},
+
+	serialize: function(o) {
+
+		var items = this._getItemsAsjQuery(o && o.connected),
+			str = [];
+		o = o || {};
+
+		$(items).each(function() {
+			var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
+			if (res) {
+				str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
+			}
+		});
+
+		if(!str.length && o.key) {
+			str.push(o.key + "=");
+		}
+
+		return str.join("&");
+
+	},
+
+	toArray: function(o) {
+
+		var items = this._getItemsAsjQuery(o && o.connected),
+			ret = [];
+
+		o = o || {};
+
+		items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
+		return ret;
+
+	},
+
+	/* Be careful with the following core functions */
+	_intersectsWith: function(item) {
+
+		var x1 = this.positionAbs.left,
+			x2 = x1 + this.helperProportions.width,
+			y1 = this.positionAbs.top,
+			y2 = y1 + this.helperProportions.height,
+			l = item.left,
+			r = l + item.width,
+			t = item.top,
+			b = t + item.height,
+			dyClick = this.offset.click.top,
+			dxClick = this.offset.click.left,
+			isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
+			isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
+			isOverElement = isOverElementHeight && isOverElementWidth;
+
+		if ( this.options.tolerance === "pointer" ||
+			this.options.forcePointerForContainers ||
+			(this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
+		) {
+			return isOverElement;
+		} else {
+
+			return (l < x1 + (this.helperProportions.width / 2) && // Right Half
+				x2 - (this.helperProportions.width / 2) < r && // Left Half
+				t < y1 + (this.helperProportions.height / 2) && // Bottom Half
+				y2 - (this.helperProportions.height / 2) < b ); // Top Half
+
+		}
+	},
+
+	_intersectsWithPointer: function(item) {
+
+		var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
+			isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
+			isOverElement = isOverElementHeight && isOverElementWidth,
+			verticalDirection = this._getDragVerticalDirection(),
+			horizontalDirection = this._getDragHorizontalDirection();
+
+		if (!isOverElement) {
+			return false;
+		}
+
+		return this.floating ?
+			( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
+			: ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
+
+	},
+
+	_intersectsWithSides: function(item) {
+
+		var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
+			isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
+			verticalDirection = this._getDragVerticalDirection(),
+			horizontalDirection = this._getDragHorizontalDirection();
+
+		if (this.floating && horizontalDirection) {
+			return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
+		} else {
+			return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
+		}
+
+	},
+
+	_getDragVerticalDirection: function() {
+		var delta = this.positionAbs.top - this.lastPositionAbs.top;
+		return delta !== 0 && (delta > 0 ? "down" : "up");
+	},
+
+	_getDragHorizontalDirection: function() {
+		var delta = this.positionAbs.left - this.lastPositionAbs.left;
+		return delta !== 0 && (delta > 0 ? "right" : "left");
+	},
+
+	refresh: function(event) {
+		this._refreshItems(event);
+		this.refreshPositions();
+		return this;
+	},
+
+	_connectWith: function() {
+		var options = this.options;
+		return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
+	},
+
+	_getItemsAsjQuery: function(connected) {
+
+		var i, j, cur, inst,
+			items = [],
+			queries = [],
+			connectWith = this._connectWith();
+
+		if(connectWith && connected) {
+			for (i = connectWith.length - 1; i >= 0; i--){
+				cur = $(connectWith[i]);
+				for ( j = cur.length - 1; j >= 0; j--){
+					inst = $.data(cur[j], this.widgetFullName);
+					if(inst && inst !== this && !inst.options.disabled) {
+						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), inst]);
+					}
+				}
+			}
+		}
+
+		queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), this]);
+
+		for (i = queries.length - 1; i >= 0; i--){
+			queries[i][0].each(function() {
+				items.push(this);
+			});
+		}
+
+		return $(items);
+
+	},
+
+	_removeCurrentsFromItems: function() {
+
+		var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
+
+		this.items = $.grep(this.items, function (item) {
+			for (var j=0; j < list.length; j++) {
+				if(list[j] === item.item[0]) {
+					return false;
+				}
+			}
+			return true;
+		});
+
+	},
+
+	_refreshItems: function(event) {
+
+		this.items = [];
+		this.containers = [this];
+
+		var i, j, cur, inst, targetData, _queries, item, queriesLength,
+			items = this.items,
+			queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
+			connectWith = this._connectWith();
+
+		if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
+			for (i = connectWith.length - 1; i >= 0; i--){
+				cur = $(connectWith[i]);
+				for (j = cur.length - 1; j >= 0; j--){
+					inst = $.data(cur[j], this.widgetFullName);
+					if(inst && inst !== this && !inst.options.disabled) {
+						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
+						this.containers.push(inst);
+					}
+				}
+			}
+		}
+
+		for (i = queries.length - 1; i >= 0; i--) {
+			targetData = queries[i][1];
+			_queries = queries[i][0];
+
+			for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
+				item = $(_queries[j]);
+
+				item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
+
+				items.push({
+					item: item,
+					instance: targetData,
+					width: 0, height: 0,
+					left: 0, top: 0
+				});
+			}
+		}
+
+	},
+
+	refreshPositions: function(fast) {
+
+		//This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
+		if(this.offsetParent && this.helper) {
+			this.offset.parent = this._getParentOffset();
+		}
+
+		var i, item, t, p;
+
+		for (i = this.items.length - 1; i >= 0; i--){
+			item = this.items[i];
+
+			//We ignore calculating positions of all connected containers when we're not over them
+			if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
+				continue;
+			}
+
+			t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
+
+			if (!fast) {
+				item.width = t.outerWidth();
+				item.height = t.outerHeight();
+			}
+
+			p = t.offset();
+			item.left = p.left;
+			item.top = p.top;
+		}
+
+		if(this.options.custom && this.options.custom.refreshContainers) {
+			this.options.custom.refreshContainers.call(this);
+		} else {
+			for (i = this.containers.length - 1; i >= 0; i--){
+				p = this.containers[i].element.offset();
+				this.containers[i].containerCache.left = p.left;
+				this.containers[i].containerCache.top = p.top;
+				this.containers[i].containerCache.width	= this.containers[i].element.outerWidth();
+				this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
+			}
+		}
+
+		return this;
+	},
+
+	_createPlaceholder: function(that) {
+		that = that || this;
+		var className,
+			o = that.options;
+
+		if(!o.placeholder || o.placeholder.constructor === String) {
+			className = o.placeholder;
+			o.placeholder = {
+				element: function() {
+
+					var nodeName = that.currentItem[0].nodeName.toLowerCase(),
+						element = $( "<" + nodeName + ">", that.document[0] )
+							.addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
+							.removeClass("ui-sortable-helper");
+
+					if ( nodeName === "tr" ) {
+						that.currentItem.children().each(function() {
+							$( "<td>&#160;</td>", that.document[0] )
+								.attr( "colspan", $( this ).attr( "colspan" ) || 1 )
+								.appendTo( element );
+						});
+					} else if ( nodeName === "img" ) {
+						element.attr( "src", that.currentItem.attr( "src" ) );
+					}
+
+					if ( !className ) {
+						element.css( "visibility", "hidden" );
+					}
+
+					return element;
+				},
+				update: function(container, p) {
+
+					// 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
+					// 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
+					if(className && !o.forcePlaceholderSize) {
+						return;
+					}
+
+					//If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
+					if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
+					if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
+				}
+			};
+		}
+
+		//Create the placeholder
+		that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
+
+		//Append it after the actual current item
+		that.currentItem.after(that.placeholder);
+
+		//Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
+		o.placeholder.update(that, that.placeholder);
+
+	},
+
+	_contactContainers: function(event) {
+		var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, base, cur, nearBottom, floating,
+			innermostContainer = null,
+			innermostIndex = null;
+
+		// get innermost container that intersects with item
+		for (i = this.containers.length - 1; i >= 0; i--) {
+
+			// never consider a container that's located within the item itself
+			if($.contains(this.currentItem[0], this.containers[i].element[0])) {
+				continue;
+			}
+
+			if(this._intersectsWith(this.containers[i].containerCache)) {
+
+				// if we've already found a container and it's more "inner" than this, then continue
+				if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
+					continue;
+				}
+
+				innermostContainer = this.containers[i];
+				innermostIndex = i;
+
+			} else {
+				// container doesn't intersect. trigger "out" event if necessary
+				if(this.containers[i].containerCache.over) {
+					this.containers[i]._trigger("out", event, this._uiHash(this));
+					this.containers[i].containerCache.over = 0;
+				}
+			}
+
+		}
+
+		// if no intersecting containers found, return
+		if(!innermostContainer) {
+			return;
+		}
+
+		// move the item into the container if it's not there already
+		if(this.containers.length === 1) {
+			if (!this.containers[innermostIndex].containerCache.over) {
+				this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
+				this.containers[innermostIndex].containerCache.over = 1;
+			}
+		} else {
+
+			//When entering a new container, we will find the item with the least distance and append our item near it
+			dist = 10000;
+			itemWithLeastDistance = null;
+			floating = innermostContainer.floating || isFloating(this.currentItem);
+			posProperty = floating ? "left" : "top";
+			sizeProperty = floating ? "width" : "height";
+			base = this.positionAbs[posProperty] + this.offset.click[posProperty];
+			for (j = this.items.length - 1; j >= 0; j--) {
+				if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
+					continue;
+				}
+				if(this.items[j].item[0] === this.currentItem[0]) {
+					continue;
+				}
+				if (floating && !isOverAxis(this.positionAbs.top + this.offset.click.top, this.items[j].top, this.items[j].height)) {
+					continue;
+				}
+				cur = this.items[j].item.offset()[posProperty];
+				nearBottom = false;
+				if(Math.abs(cur - base) > Math.abs(cur + this.items[j][sizeProperty] - base)){
+					nearBottom = true;
+					cur += this.items[j][sizeProperty];
+				}
+
+				if(Math.abs(cur - base) < dist) {
+					dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
+					this.direction = nearBottom ? "up": "down";
+				}
+			}
+
+			//Check if dropOnEmpty is enabled
+			if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
+				return;
+			}
+
+			if(this.currentContainer === this.containers[innermostIndex]) {
+				return;
+			}
+
+			itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
+			this._trigger("change", event, this._uiHash());
+			this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
+			this.currentContainer = this.containers[innermostIndex];
+
+			//Update the placeholder
+			this.options.placeholder.update(this.currentContainer, this.placeholder);
+
+			this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
+			this.containers[innermostIndex].containerCache.over = 1;
+		}
+
+
+	},
+
+	_createHelper: function(event) {
+
+		var o = this.options,
+			helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
+
+		//Add the helper to the DOM if that didn't happen already
+		if(!helper.parents("body").length) {
+			$(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
+		}
+
+		if(helper[0] === this.currentItem[0]) {
+			this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
+		}
+
+		if(!helper[0].style.width || o.forceHelperSize) {
+			helper.width(this.currentItem.width());
+		}
+		if(!helper[0].style.height || o.forceHelperSize) {
+			helper.height(this.currentItem.height());
+		}
+
+		return helper;
+
+	},
+
+	_adjustOffsetFromHelper: function(obj) {
+		if (typeof obj === "string") {
+			obj = obj.split(" ");
+		}
+		if ($.isArray(obj)) {
+			obj = {left: +obj[0], top: +obj[1] || 0};
+		}
+		if ("left" in obj) {
+			this.offset.click.left = obj.left + this.margins.left;
+		}
+		if ("right" in obj) {
+			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
+		}
+		if ("top" in obj) {
+			this.offset.click.top = obj.top + this.margins.top;
+		}
+		if ("bottom" in obj) {
+			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
+		}
+	},
+
+	_getParentOffset: function() {
+
+
+		//Get the offsetParent and cache its position
+		this.offsetParent = this.helper.offsetParent();
+		var po = this.offsetParent.offset();
+
+		// This is a special case where we need to modify a offset calculated on start, since the following happened:
+		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
+		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
+		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
+		if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
+			po.left += this.scrollParent.scrollLeft();
+			po.top += this.scrollParent.scrollTop();
+		}
+
+		// This needs to be actually done for all browsers, since pageX/pageY includes this information
+		// with an ugly IE fix
+		if( this.offsetParent[0] === document.body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
+			po = { top: 0, left: 0 };
+		}
+
+		return {
+			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
+			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
+		};
+
+	},
+
+	_getRelativeOffset: function() {
+
+		if(this.cssPosition === "relative") {
+			var p = this.currentItem.position();
+			return {
+				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
+				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
+			};
+		} else {
+			return { top: 0, left: 0 };
+		}
+
+	},
+
+	_cacheMargins: function() {
+		this.margins = {
+			left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
+			top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
+		};
+	},
+
+	_cacheHelperProportions: function() {
+		this.helperProportions = {
+			width: this.helper.outerWidth(),
+			height: this.helper.outerHeight()
+		};
+	},
+
+	_setContainment: function() {
+
+		var ce, co, over,
+			o = this.options;
+		if(o.containment === "parent") {
+			o.containment = this.helper[0].parentNode;
+		}
+		if(o.containment === "document" || o.containment === "window") {
+			this.containment = [
+				0 - this.offset.relative.left - this.offset.parent.left,
+				0 - this.offset.relative.top - this.offset.parent.top,
+				$(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
+				($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
+			];
+		}
+
+		if(!(/^(document|window|parent)$/).test(o.containment)) {
+			ce = $(o.containment)[0];
+			co = $(o.containment).offset();
+			over = ($(ce).css("overflow") !== "hidden");
+
+			this.containment = [
+				co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
+				co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
+				co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
+				co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
+			];
+		}
+
+	},
+
+	_convertPositionTo: function(d, pos) {
+
+		if(!pos) {
+			pos = this.position;
+		}
+		var mod = d === "absolute" ? 1 : -1,
+			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
+			scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+		return {
+			top: (
+				pos.top	+																// The absolute mouse position
+				this.offset.relative.top * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.top * mod -											// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
+			),
+			left: (
+				pos.left +																// The absolute mouse position
+				this.offset.relative.left * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.left * mod	-										// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
+			)
+		};
+
+	},
+
+	_generatePosition: function(event) {
+
+		var top, left,
+			o = this.options,
+			pageX = event.pageX,
+			pageY = event.pageY,
+			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+		// This is another very weird special case that only happens for relative elements:
+		// 1. If the css position is relative
+		// 2. and the scroll parent is the document or similar to the offset parent
+		// we have to refresh the relative offset during the scroll so there are no jumps
+		if(this.cssPosition === "relative" && !(this.scrollParent[0] !== document && this.scrollParent[0] !== this.offsetParent[0])) {
+			this.offset.relative = this._getRelativeOffset();
+		}
+
+		/*
+		 * - Position constraining -
+		 * Constrain the position to a mix of grid, containment.
+		 */
+
+		if(this.originalPosition) { //If we are not dragging yet, we won't check for options
+
+			if(this.containment) {
+				if(event.pageX - this.offset.click.left < this.containment[0]) {
+					pageX = this.containment[0] + this.offset.click.left;
+				}
+				if(event.pageY - this.offset.click.top < this.containment[1]) {
+					pageY = this.containment[1] + this.offset.click.top;
+				}
+				if(event.pageX - this.offset.click.left > this.containment[2]) {
+					pageX = this.containment[2] + this.offset.click.left;
+				}
+				if(event.pageY - this.offset.click.top > this.containment[3]) {
+					pageY = this.containment[3] + this.offset.click.top;
+				}
+			}
+
+			if(o.grid) {
+				top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
+				pageY = this.containment ? ( (top - this.offset.click.top >= this.containment[1] && top - this.offset.click.top <= this.containment[3]) ? top : ((top - this.offset.click.top >= this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
+
+				left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
+				pageX = this.containment ? ( (left - this.offset.click.left >= this.containment[0] && left - this.offset.click.left <= this.containment[2]) ? left : ((left - this.offset.click.left >= this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
+			}
+
+		}
+
+		return {
+			top: (
+				pageY -																// The absolute mouse position
+				this.offset.click.top -													// Click offset (relative to the element)
+				this.offset.relative.top	-											// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.top +												// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
+			),
+			left: (
+				pageX -																// The absolute mouse position
+				this.offset.click.left -												// Click offset (relative to the element)
+				this.offset.relative.left	-											// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.left +												// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
+			)
+		};
+
+	},
+
+	_rearrange: function(event, i, a, hardRefresh) {
+
+		a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
+
+		//Various things done here to improve the performance:
+		// 1. we create a setTimeout, that calls refreshPositions
+		// 2. on the instance, we have a counter variable, that get's higher after every append
+		// 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
+		// 4. this lets only the last addition to the timeout stack through
+		this.counter = this.counter ? ++this.counter : 1;
+		var counter = this.counter;
+
+		this._delay(function() {
+			if(counter === this.counter) {
+				this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
+			}
+		});
+
+	},
+
+	_clear: function(event, noPropagation) {
+
+		this.reverting = false;
+		// We delay all events that have to be triggered to after the point where the placeholder has been removed and
+		// everything else normalized again
+		var i,
+			delayedTriggers = [];
+
+		// We first have to update the dom position of the actual currentItem
+		// Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
+		if(!this._noFinalSort && this.currentItem.parent().length) {
+			this.placeholder.before(this.currentItem);
+		}
+		this._noFinalSort = null;
+
+		if(this.helper[0] === this.currentItem[0]) {
+			for(i in this._storedCSS) {
+				if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
+					this._storedCSS[i] = "";
+				}
+			}
+			this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
+		} else {
+			this.currentItem.show();
+		}
+
+		if(this.fromOutside && !noPropagation) {
+			delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
+		}
+		if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
+			delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
+		}
+
+		// Check if the items Container has Changed and trigger appropriate
+		// events.
+		if (this !== this.currentContainer) {
+			if(!noPropagation) {
+				delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.currentContainer));
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.currentContainer));
+			}
+		}
+
+
+		//Post events to containers
+		for (i = this.containers.length - 1; i >= 0; i--){
+			if(!noPropagation) {
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
+			}
+			if(this.containers[i].containerCache.over) {
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
+				this.containers[i].containerCache.over = 0;
+			}
+		}
+
+		//Do what was originally in plugins
+		if ( this.storedCursor ) {
+			this.document.find( "body" ).css( "cursor", this.storedCursor );
+			this.storedStylesheet.remove();
+		}
+		if(this._storedOpacity) {
+			this.helper.css("opacity", this._storedOpacity);
+		}
+		if(this._storedZIndex) {
+			this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
+		}
+
+		this.dragging = false;
+		if(this.cancelHelperRemoval) {
+			if(!noPropagation) {
+				this._trigger("beforeStop", event, this._uiHash());
+				for (i=0; i < delayedTriggers.length; i++) {
+					delayedTriggers[i].call(this, event);
+				} //Trigger all delayed events
+				this._trigger("stop", event, this._uiHash());
+			}
+
+			this.fromOutside = false;
+			return false;
+		}
+
+		if(!noPropagation) {
+			this._trigger("beforeStop", event, this._uiHash());
+		}
+
+		//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
+		this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+
+		if(this.helper[0] !== this.currentItem[0]) {
+			this.helper.remove();
+		}
+		this.helper = null;
+
+		if(!noPropagation) {
+			for (i=0; i < delayedTriggers.length; i++) {
+				delayedTriggers[i].call(this, event);
+			} //Trigger all delayed events
+			this._trigger("stop", event, this._uiHash());
+		}
+
+		this.fromOutside = false;
+		return true;
+
+	},
+
+	_trigger: function() {
+		if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
+			this.cancel();
+		}
+	},
+
+	_uiHash: function(_inst) {
+		var inst = _inst || this;
+		return {
+			helper: inst.helper,
+			placeholder: inst.placeholder || $([]),
+			position: inst.position,
+			originalPosition: inst.originalPosition,
+			offset: inst.positionAbs,
+			item: inst.currentItem,
+			sender: _inst ? _inst.element : null
+		};
+	}
+
+});
+
+})(jQuery);
diff --git a/examples/unfinished/movers/movers.html b/examples/unfinished/movers/movers.html
new file mode 100644
index 0000000000..08efb197ec
--- /dev/null
+++ b/examples/unfinished/movers/movers.html
@@ -0,0 +1,16 @@
+<head>
+  <title>movers</title>
+</head>
+
+<body>
+  {{> main}}
+</body>
+
+<template name="main">
+<div class="container">
+  <div class="item red">Red</div>
+  <div class="item green">Green</div>
+  <div class="item blue">Blue</div>
+  <div class="item yellow">Yellow</div>
+</div>
+</template>
diff --git a/examples/unfinished/movers/movers.js b/examples/unfinished/movers/movers.js
new file mode 100644
index 0000000000..8fe890660e
--- /dev/null
+++ b/examples/unfinished/movers/movers.js
@@ -0,0 +1,92 @@
+if (Meteor.isClient) {
+  var moveCount = 0;
+  var MOVE_INTERVAL = 3000;
+  var MOVE_DURATION = 2000;
+
+  doMove = function () {
+    moveCount++;
+    if (moveCount % 2 === 1) {
+      animateToBefore($('.green'), $('.yellow'));
+      animateToBefore($('.red'), null);
+      animateToBefore($('.blue'), null);
+    } else {
+      animateToBefore($('.red'), null);
+      animateToBefore($('.green'), null);
+      animateToBefore($('.blue'), null);
+      animateToBefore($('.yellow'), null);
+    }
+  };
+
+  Meteor.startup(function () {
+    doMove();
+    window.setInterval(doMove, MOVE_INTERVAL);
+  });
+
+
+  animateToBefore = function ($n, $newNext) {
+    // we don't use jQuery's `.css()` for these because we want the
+    // element's own style, not the computed style
+    var oldTop = $n[0].style.top;
+    var oldPosition = $n[0].style.position;
+    var oldZIndex = $n[0].style.zIndex;
+    var oldMarginBottom = $n[0].style.marginBottom;
+
+    var outerHeight = $n.outerHeight(); // not margin
+    var marginBottom = parseInt($n.css('margin-bottom'));
+
+    // TODO: test interesting elements like table rows, etc.
+    var placeholder = $(document.createElement($n[0].nodeName));
+    var placeholderHeight = outerHeight + marginBottom;
+    placeholder.css('height', placeholderHeight);
+    // insert placeholder
+    $n.before(placeholder);
+
+    // move node
+    if ($newNext)
+      $newNext.before($n);
+    else
+      $n.parent().append($n);
+
+    // XXX would tracking "left" as well as "top" magically get us
+    // horizontal re-ordering?
+    $n.css({marginBottom: -outerHeight,
+            position: 'relative',
+            zIndex: 2,
+            top: 0});
+    var vOffset = placeholder.offset().top - $n.offset().top;
+    $n.css('top', vOffset);
+
+    $({t:0}).animate({t:1}, {
+      duration: MOVE_DURATION,
+      step: function (t, fx) {
+        var curPlaceholderHeight = Math.round(placeholderHeight * (1-t));
+        var curMarginBottom = marginBottom - curPlaceholderHeight;
+        var curTop = (-curPlaceholderHeight +
+                      Math.round((1-t) * (vOffset + placeholderHeight)));
+        $n.css({marginBottom: curMarginBottom,
+                top: curTop});
+        placeholder.css('height', curPlaceholderHeight);
+      },
+      progress: function (a, t) {
+        //          if (t >= 0.5) {
+        //            console.log(a);
+        //            a.stop();
+        //          }
+      },
+      complete: function () {
+        placeholder.remove();
+        $n[0].style.top = oldTop;
+        $n[0].style.position = oldPosition;
+        $n[0].style.zIndex = oldZIndex;
+        $n[0].style.marginBottom = oldMarginBottom;
+      }
+    });
+  };
+
+}
+
+if (Meteor.isServer) {
+  Meteor.startup(function () {
+    // code to run on server at startup
+  });
+}
diff --git a/examples/unfinished/movers/movers.less b/examples/unfinished/movers/movers.less
new file mode 100644
index 0000000000..0b08028c37
--- /dev/null
+++ b/examples/unfinished/movers/movers.less
@@ -0,0 +1,12 @@
+.item {
+  border: 1px solid black;
+  padding: 10px;
+  font-size: 18px;
+  margin-bottom: 10px;
+  font-weight: bold;
+  position: relative;
+}
+.red { background: #fcc; }
+.blue { background: #ccf; }
+.green { background: #cfc; }
+.yellow { background: #ffc; }
diff --git a/examples/unfinished/reorderable-list/.meteor/.gitignore b/examples/unfinished/reorderable-list/.meteor/.gitignore
new file mode 100644
index 0000000000..4083037423
--- /dev/null
+++ b/examples/unfinished/reorderable-list/.meteor/.gitignore
@@ -0,0 +1 @@
+local
diff --git a/examples/unfinished/reorderable-list/.meteor/packages b/examples/unfinished/reorderable-list/.meteor/packages
new file mode 100644
index 0000000000..e442b00306
--- /dev/null
+++ b/examples/unfinished/reorderable-list/.meteor/packages
@@ -0,0 +1,8 @@
+# Meteor packages used by this project, one per line.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+standard-app-packages
+autopublish
+insecure
diff --git a/examples/unfinished/reorderable-list/.meteor/release b/examples/unfinished/reorderable-list/.meteor/release
new file mode 100644
index 0000000000..621e94f0ec
--- /dev/null
+++ b/examples/unfinished/reorderable-list/.meteor/release
@@ -0,0 +1 @@
+none
diff --git a/examples/unfinished/reorderable-list/client/jquery-ui-sortable.js b/examples/unfinished/reorderable-list/client/jquery-ui-sortable.js
new file mode 100755
index 0000000000..0d85cfa365
--- /dev/null
+++ b/examples/unfinished/reorderable-list/client/jquery-ui-sortable.js
@@ -0,0 +1,2252 @@
+/*! jQuery UI - v1.10.3 - 2013-07-30
+* http://jqueryui.com
+* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.sortable.js
+* Copyright 2013 jQuery Foundation and other contributors Licensed MIT */
+
+(function( $, undefined ) {
+
+var uuid = 0,
+	runiqueId = /^ui-id-\d+$/;
+
+// $.ui might exist from components with no dependencies, e.g., $.ui.position
+$.ui = $.ui || {};
+
+$.extend( $.ui, {
+	version: "1.10.3",
+
+	keyCode: {
+		BACKSPACE: 8,
+		COMMA: 188,
+		DELETE: 46,
+		DOWN: 40,
+		END: 35,
+		ENTER: 13,
+		ESCAPE: 27,
+		HOME: 36,
+		LEFT: 37,
+		NUMPAD_ADD: 107,
+		NUMPAD_DECIMAL: 110,
+		NUMPAD_DIVIDE: 111,
+		NUMPAD_ENTER: 108,
+		NUMPAD_MULTIPLY: 106,
+		NUMPAD_SUBTRACT: 109,
+		PAGE_DOWN: 34,
+		PAGE_UP: 33,
+		PERIOD: 190,
+		RIGHT: 39,
+		SPACE: 32,
+		TAB: 9,
+		UP: 38
+	}
+});
+
+// plugins
+$.fn.extend({
+	focus: (function( orig ) {
+		return function( delay, fn ) {
+			return typeof delay === "number" ?
+				this.each(function() {
+					var elem = this;
+					setTimeout(function() {
+						$( elem ).focus();
+						if ( fn ) {
+							fn.call( elem );
+						}
+					}, delay );
+				}) :
+				orig.apply( this, arguments );
+		};
+	})( $.fn.focus ),
+
+	scrollParent: function() {
+		var scrollParent;
+		if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
+			scrollParent = this.parents().filter(function() {
+				return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
+			}).eq(0);
+		} else {
+			scrollParent = this.parents().filter(function() {
+				return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
+			}).eq(0);
+		}
+
+		return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
+	},
+
+	zIndex: function( zIndex ) {
+		if ( zIndex !== undefined ) {
+			return this.css( "zIndex", zIndex );
+		}
+
+		if ( this.length ) {
+			var elem = $( this[ 0 ] ), position, value;
+			while ( elem.length && elem[ 0 ] !== document ) {
+				// Ignore z-index if position is set to a value where z-index is ignored by the browser
+				// This makes behavior of this function consistent across browsers
+				// WebKit always returns auto if the element is positioned
+				position = elem.css( "position" );
+				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
+					// IE returns 0 when zIndex is not specified
+					// other browsers return a string
+					// we ignore the case of nested elements with an explicit value of 0
+					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
+					value = parseInt( elem.css( "zIndex" ), 10 );
+					if ( !isNaN( value ) && value !== 0 ) {
+						return value;
+					}
+				}
+				elem = elem.parent();
+			}
+		}
+
+		return 0;
+	},
+
+	uniqueId: function() {
+		return this.each(function() {
+			if ( !this.id ) {
+				this.id = "ui-id-" + (++uuid);
+			}
+		});
+	},
+
+	removeUniqueId: function() {
+		return this.each(function() {
+			if ( runiqueId.test( this.id ) ) {
+				$( this ).removeAttr( "id" );
+			}
+		});
+	}
+});
+
+// selectors
+function focusable( element, isTabIndexNotNaN ) {
+	var map, mapName, img,
+		nodeName = element.nodeName.toLowerCase();
+	if ( "area" === nodeName ) {
+		map = element.parentNode;
+		mapName = map.name;
+		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
+			return false;
+		}
+		img = $( "img[usemap=#" + mapName + "]" )[0];
+		return !!img && visible( img );
+	}
+	return ( /input|select|textarea|button|object/.test( nodeName ) ?
+		!element.disabled :
+		"a" === nodeName ?
+			element.href || isTabIndexNotNaN :
+			isTabIndexNotNaN) &&
+		// the element and all of its ancestors must be visible
+		visible( element );
+}
+
+function visible( element ) {
+	return $.expr.filters.visible( element ) &&
+		!$( element ).parents().addBack().filter(function() {
+			return $.css( this, "visibility" ) === "hidden";
+		}).length;
+}
+
+$.extend( $.expr[ ":" ], {
+	data: $.expr.createPseudo ?
+		$.expr.createPseudo(function( dataName ) {
+			return function( elem ) {
+				return !!$.data( elem, dataName );
+			};
+		}) :
+		// support: jQuery <1.8
+		function( elem, i, match ) {
+			return !!$.data( elem, match[ 3 ] );
+		},
+
+	focusable: function( element ) {
+		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
+	},
+
+	tabbable: function( element ) {
+		var tabIndex = $.attr( element, "tabindex" ),
+			isTabIndexNaN = isNaN( tabIndex );
+		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
+	}
+});
+
+// support: jQuery <1.8
+if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
+	$.each( [ "Width", "Height" ], function( i, name ) {
+		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
+			type = name.toLowerCase(),
+			orig = {
+				innerWidth: $.fn.innerWidth,
+				innerHeight: $.fn.innerHeight,
+				outerWidth: $.fn.outerWidth,
+				outerHeight: $.fn.outerHeight
+			};
+
+		function reduce( elem, size, border, margin ) {
+			$.each( side, function() {
+				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
+				if ( border ) {
+					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
+				}
+				if ( margin ) {
+					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
+				}
+			});
+			return size;
+		}
+
+		$.fn[ "inner" + name ] = function( size ) {
+			if ( size === undefined ) {
+				return orig[ "inner" + name ].call( this );
+			}
+
+			return this.each(function() {
+				$( this ).css( type, reduce( this, size ) + "px" );
+			});
+		};
+
+		$.fn[ "outer" + name] = function( size, margin ) {
+			if ( typeof size !== "number" ) {
+				return orig[ "outer" + name ].call( this, size );
+			}
+
+			return this.each(function() {
+				$( this).css( type, reduce( this, size, true, margin ) + "px" );
+			});
+		};
+	});
+}
+
+// support: jQuery <1.8
+if ( !$.fn.addBack ) {
+	$.fn.addBack = function( selector ) {
+		return this.add( selector == null ?
+			this.prevObject : this.prevObject.filter( selector )
+		);
+	};
+}
+
+// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
+if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
+	$.fn.removeData = (function( removeData ) {
+		return function( key ) {
+			if ( arguments.length ) {
+				return removeData.call( this, $.camelCase( key ) );
+			} else {
+				return removeData.call( this );
+			}
+		};
+	})( $.fn.removeData );
+}
+
+
+
+
+
+// deprecated
+$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
+
+$.support.selectstart = "onselectstart" in document.createElement( "div" );
+$.fn.extend({
+	disableSelection: function() {
+		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
+			".ui-disableSelection", function( event ) {
+				event.preventDefault();
+			});
+	},
+
+	enableSelection: function() {
+		return this.unbind( ".ui-disableSelection" );
+	}
+});
+
+$.extend( $.ui, {
+	// $.ui.plugin is deprecated. Use $.widget() extensions instead.
+	plugin: {
+		add: function( module, option, set ) {
+			var i,
+				proto = $.ui[ module ].prototype;
+			for ( i in set ) {
+				proto.plugins[ i ] = proto.plugins[ i ] || [];
+				proto.plugins[ i ].push( [ option, set[ i ] ] );
+			}
+		},
+		call: function( instance, name, args ) {
+			var i,
+				set = instance.plugins[ name ];
+			if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
+				return;
+			}
+
+			for ( i = 0; i < set.length; i++ ) {
+				if ( instance.options[ set[ i ][ 0 ] ] ) {
+					set[ i ][ 1 ].apply( instance.element, args );
+				}
+			}
+		}
+	},
+
+	// only used by resizable
+	hasScroll: function( el, a ) {
+
+		//If overflow is hidden, the element might have extra content, but the user wants to hide it
+		if ( $( el ).css( "overflow" ) === "hidden") {
+			return false;
+		}
+
+		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
+			has = false;
+
+		if ( el[ scroll ] > 0 ) {
+			return true;
+		}
+
+		// TODO: determine which cases actually cause this to happen
+		// if the element doesn't have the scroll set, see if it's possible to
+		// set the scroll
+		el[ scroll ] = 1;
+		has = ( el[ scroll ] > 0 );
+		el[ scroll ] = 0;
+		return has;
+	}
+});
+
+})( jQuery );
+(function( $, undefined ) {
+
+var uuid = 0,
+	slice = Array.prototype.slice,
+	_cleanData = $.cleanData;
+$.cleanData = function( elems ) {
+	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
+		try {
+			$( elem ).triggerHandler( "remove" );
+		// http://bugs.jquery.com/ticket/8235
+		} catch( e ) {}
+	}
+	_cleanData( elems );
+};
+
+$.widget = function( name, base, prototype ) {
+	var fullName, existingConstructor, constructor, basePrototype,
+		// proxiedPrototype allows the provided prototype to remain unmodified
+		// so that it can be used as a mixin for multiple widgets (#8876)
+		proxiedPrototype = {},
+		namespace = name.split( "." )[ 0 ];
+
+	name = name.split( "." )[ 1 ];
+	fullName = namespace + "-" + name;
+
+	if ( !prototype ) {
+		prototype = base;
+		base = $.Widget;
+	}
+
+	// create selector for plugin
+	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
+		return !!$.data( elem, fullName );
+	};
+
+	$[ namespace ] = $[ namespace ] || {};
+	existingConstructor = $[ namespace ][ name ];
+	constructor = $[ namespace ][ name ] = function( options, element ) {
+		// allow instantiation without "new" keyword
+		if ( !this._createWidget ) {
+			return new constructor( options, element );
+		}
+
+		// allow instantiation without initializing for simple inheritance
+		// must use "new" keyword (the code above always passes args)
+		if ( arguments.length ) {
+			this._createWidget( options, element );
+		}
+	};
+	// extend with the existing constructor to carry over any static properties
+	$.extend( constructor, existingConstructor, {
+		version: prototype.version,
+		// copy the object used to create the prototype in case we need to
+		// redefine the widget later
+		_proto: $.extend( {}, prototype ),
+		// track widgets that inherit from this widget in case this widget is
+		// redefined after a widget inherits from it
+		_childConstructors: []
+	});
+
+	basePrototype = new base();
+	// we need to make the options hash a property directly on the new instance
+	// otherwise we'll modify the options hash on the prototype that we're
+	// inheriting from
+	basePrototype.options = $.widget.extend( {}, basePrototype.options );
+	$.each( prototype, function( prop, value ) {
+		if ( !$.isFunction( value ) ) {
+			proxiedPrototype[ prop ] = value;
+			return;
+		}
+		proxiedPrototype[ prop ] = (function() {
+			var _super = function() {
+					return base.prototype[ prop ].apply( this, arguments );
+				},
+				_superApply = function( args ) {
+					return base.prototype[ prop ].apply( this, args );
+				};
+			return function() {
+				var __super = this._super,
+					__superApply = this._superApply,
+					returnValue;
+
+				this._super = _super;
+				this._superApply = _superApply;
+
+				returnValue = value.apply( this, arguments );
+
+				this._super = __super;
+				this._superApply = __superApply;
+
+				return returnValue;
+			};
+		})();
+	});
+	constructor.prototype = $.widget.extend( basePrototype, {
+		// TODO: remove support for widgetEventPrefix
+		// always use the name + a colon as the prefix, e.g., draggable:start
+		// don't prefix for widgets that aren't DOM-based
+		widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
+	}, proxiedPrototype, {
+		constructor: constructor,
+		namespace: namespace,
+		widgetName: name,
+		widgetFullName: fullName
+	});
+
+	// If this widget is being redefined then we need to find all widgets that
+	// are inheriting from it and redefine all of them so that they inherit from
+	// the new version of this widget. We're essentially trying to replace one
+	// level in the prototype chain.
+	if ( existingConstructor ) {
+		$.each( existingConstructor._childConstructors, function( i, child ) {
+			var childPrototype = child.prototype;
+
+			// redefine the child widget using the same prototype that was
+			// originally used, but inherit from the new version of the base
+			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
+		});
+		// remove the list of existing child constructors from the old constructor
+		// so the old child constructors can be garbage collected
+		delete existingConstructor._childConstructors;
+	} else {
+		base._childConstructors.push( constructor );
+	}
+
+	$.widget.bridge( name, constructor );
+};
+
+$.widget.extend = function( target ) {
+	var input = slice.call( arguments, 1 ),
+		inputIndex = 0,
+		inputLength = input.length,
+		key,
+		value;
+	for ( ; inputIndex < inputLength; inputIndex++ ) {
+		for ( key in input[ inputIndex ] ) {
+			value = input[ inputIndex ][ key ];
+			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
+				// Clone objects
+				if ( $.isPlainObject( value ) ) {
+					target[ key ] = $.isPlainObject( target[ key ] ) ?
+						$.widget.extend( {}, target[ key ], value ) :
+						// Don't extend strings, arrays, etc. with objects
+						$.widget.extend( {}, value );
+				// Copy everything else by reference
+				} else {
+					target[ key ] = value;
+				}
+			}
+		}
+	}
+	return target;
+};
+
+$.widget.bridge = function( name, object ) {
+	var fullName = object.prototype.widgetFullName || name;
+	$.fn[ name ] = function( options ) {
+		var isMethodCall = typeof options === "string",
+			args = slice.call( arguments, 1 ),
+			returnValue = this;
+
+		// allow multiple hashes to be passed on init
+		options = !isMethodCall && args.length ?
+			$.widget.extend.apply( null, [ options ].concat(args) ) :
+			options;
+
+		if ( isMethodCall ) {
+			this.each(function() {
+				var methodValue,
+					instance = $.data( this, fullName );
+				if ( !instance ) {
+					return $.error( "cannot call methods on " + name + " prior to initialization; " +
+						"attempted to call method '" + options + "'" );
+				}
+				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
+					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
+				}
+				methodValue = instance[ options ].apply( instance, args );
+				if ( methodValue !== instance && methodValue !== undefined ) {
+					returnValue = methodValue && methodValue.jquery ?
+						returnValue.pushStack( methodValue.get() ) :
+						methodValue;
+					return false;
+				}
+			});
+		} else {
+			this.each(function() {
+				var instance = $.data( this, fullName );
+				if ( instance ) {
+					instance.option( options || {} )._init();
+				} else {
+					$.data( this, fullName, new object( options, this ) );
+				}
+			});
+		}
+
+		return returnValue;
+	};
+};
+
+$.Widget = function( /* options, element */ ) {};
+$.Widget._childConstructors = [];
+
+$.Widget.prototype = {
+	widgetName: "widget",
+	widgetEventPrefix: "",
+	defaultElement: "<div>",
+	options: {
+		disabled: false,
+
+		// callbacks
+		create: null
+	},
+	_createWidget: function( options, element ) {
+		element = $( element || this.defaultElement || this )[ 0 ];
+		this.element = $( element );
+		this.uuid = uuid++;
+		this.eventNamespace = "." + this.widgetName + this.uuid;
+		this.options = $.widget.extend( {},
+			this.options,
+			this._getCreateOptions(),
+			options );
+
+		this.bindings = $();
+		this.hoverable = $();
+		this.focusable = $();
+
+		if ( element !== this ) {
+			$.data( element, this.widgetFullName, this );
+			this._on( true, this.element, {
+				remove: function( event ) {
+					if ( event.target === element ) {
+						this.destroy();
+					}
+				}
+			});
+			this.document = $( element.style ?
+				// element within the document
+				element.ownerDocument :
+				// element is window or document
+				element.document || element );
+			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
+		}
+
+		this._create();
+		this._trigger( "create", null, this._getCreateEventData() );
+		this._init();
+	},
+	_getCreateOptions: $.noop,
+	_getCreateEventData: $.noop,
+	_create: $.noop,
+	_init: $.noop,
+
+	destroy: function() {
+		this._destroy();
+		// we can probably remove the unbind calls in 2.0
+		// all event bindings should go through this._on()
+		this.element
+			.unbind( this.eventNamespace )
+			// 1.9 BC for #7810
+			// TODO remove dual storage
+			.removeData( this.widgetName )
+			.removeData( this.widgetFullName )
+			// support: jquery <1.6.3
+			// http://bugs.jquery.com/ticket/9413
+			.removeData( $.camelCase( this.widgetFullName ) );
+		this.widget()
+			.unbind( this.eventNamespace )
+			.removeAttr( "aria-disabled" )
+			.removeClass(
+				this.widgetFullName + "-disabled " +
+				"ui-state-disabled" );
+
+		// clean up events and states
+		this.bindings.unbind( this.eventNamespace );
+		this.hoverable.removeClass( "ui-state-hover" );
+		this.focusable.removeClass( "ui-state-focus" );
+	},
+	_destroy: $.noop,
+
+	widget: function() {
+		return this.element;
+	},
+
+	option: function( key, value ) {
+		var options = key,
+			parts,
+			curOption,
+			i;
+
+		if ( arguments.length === 0 ) {
+			// don't return a reference to the internal hash
+			return $.widget.extend( {}, this.options );
+		}
+
+		if ( typeof key === "string" ) {
+			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
+			options = {};
+			parts = key.split( "." );
+			key = parts.shift();
+			if ( parts.length ) {
+				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
+				for ( i = 0; i < parts.length - 1; i++ ) {
+					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
+					curOption = curOption[ parts[ i ] ];
+				}
+				key = parts.pop();
+				if ( value === undefined ) {
+					return curOption[ key ] === undefined ? null : curOption[ key ];
+				}
+				curOption[ key ] = value;
+			} else {
+				if ( value === undefined ) {
+					return this.options[ key ] === undefined ? null : this.options[ key ];
+				}
+				options[ key ] = value;
+			}
+		}
+
+		this._setOptions( options );
+
+		return this;
+	},
+	_setOptions: function( options ) {
+		var key;
+
+		for ( key in options ) {
+			this._setOption( key, options[ key ] );
+		}
+
+		return this;
+	},
+	_setOption: function( key, value ) {
+		this.options[ key ] = value;
+
+		if ( key === "disabled" ) {
+			this.widget()
+				.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
+				.attr( "aria-disabled", value );
+			this.hoverable.removeClass( "ui-state-hover" );
+			this.focusable.removeClass( "ui-state-focus" );
+		}
+
+		return this;
+	},
+
+	enable: function() {
+		return this._setOption( "disabled", false );
+	},
+	disable: function() {
+		return this._setOption( "disabled", true );
+	},
+
+	_on: function( suppressDisabledCheck, element, handlers ) {
+		var delegateElement,
+			instance = this;
+
+		// no suppressDisabledCheck flag, shuffle arguments
+		if ( typeof suppressDisabledCheck !== "boolean" ) {
+			handlers = element;
+			element = suppressDisabledCheck;
+			suppressDisabledCheck = false;
+		}
+
+		// no element argument, shuffle and use this.element
+		if ( !handlers ) {
+			handlers = element;
+			element = this.element;
+			delegateElement = this.widget();
+		} else {
+			// accept selectors, DOM elements
+			element = delegateElement = $( element );
+			this.bindings = this.bindings.add( element );
+		}
+
+		$.each( handlers, function( event, handler ) {
+			function handlerProxy() {
+				// allow widgets to customize the disabled handling
+				// - disabled as an array instead of boolean
+				// - disabled class as method for disabling individual parts
+				if ( !suppressDisabledCheck &&
+						( instance.options.disabled === true ||
+							$( this ).hasClass( "ui-state-disabled" ) ) ) {
+					return;
+				}
+				return ( typeof handler === "string" ? instance[ handler ] : handler )
+					.apply( instance, arguments );
+			}
+
+			// copy the guid so direct unbinding works
+			if ( typeof handler !== "string" ) {
+				handlerProxy.guid = handler.guid =
+					handler.guid || handlerProxy.guid || $.guid++;
+			}
+
+			var match = event.match( /^(\w+)\s*(.*)$/ ),
+				eventName = match[1] + instance.eventNamespace,
+				selector = match[2];
+			if ( selector ) {
+				delegateElement.delegate( selector, eventName, handlerProxy );
+			} else {
+				element.bind( eventName, handlerProxy );
+			}
+		});
+	},
+
+	_off: function( element, eventName ) {
+		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
+		element.unbind( eventName ).undelegate( eventName );
+	},
+
+	_delay: function( handler, delay ) {
+		function handlerProxy() {
+			return ( typeof handler === "string" ? instance[ handler ] : handler )
+				.apply( instance, arguments );
+		}
+		var instance = this;
+		return setTimeout( handlerProxy, delay || 0 );
+	},
+
+	_hoverable: function( element ) {
+		this.hoverable = this.hoverable.add( element );
+		this._on( element, {
+			mouseenter: function( event ) {
+				$( event.currentTarget ).addClass( "ui-state-hover" );
+			},
+			mouseleave: function( event ) {
+				$( event.currentTarget ).removeClass( "ui-state-hover" );
+			}
+		});
+	},
+
+	_focusable: function( element ) {
+		this.focusable = this.focusable.add( element );
+		this._on( element, {
+			focusin: function( event ) {
+				$( event.currentTarget ).addClass( "ui-state-focus" );
+			},
+			focusout: function( event ) {
+				$( event.currentTarget ).removeClass( "ui-state-focus" );
+			}
+		});
+	},
+
+	_trigger: function( type, event, data ) {
+		var prop, orig,
+			callback = this.options[ type ];
+
+		data = data || {};
+		event = $.Event( event );
+		event.type = ( type === this.widgetEventPrefix ?
+			type :
+			this.widgetEventPrefix + type ).toLowerCase();
+		// the original event may come from any element
+		// so we need to reset the target on the new event
+		event.target = this.element[ 0 ];
+
+		// copy original event properties over to the new event
+		orig = event.originalEvent;
+		if ( orig ) {
+			for ( prop in orig ) {
+				if ( !( prop in event ) ) {
+					event[ prop ] = orig[ prop ];
+				}
+			}
+		}
+
+		this.element.trigger( event, data );
+		return !( $.isFunction( callback ) &&
+			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
+			event.isDefaultPrevented() );
+	}
+};
+
+$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
+	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
+		if ( typeof options === "string" ) {
+			options = { effect: options };
+		}
+		var hasOptions,
+			effectName = !options ?
+				method :
+				options === true || typeof options === "number" ?
+					defaultEffect :
+					options.effect || defaultEffect;
+		options = options || {};
+		if ( typeof options === "number" ) {
+			options = { duration: options };
+		}
+		hasOptions = !$.isEmptyObject( options );
+		options.complete = callback;
+		if ( options.delay ) {
+			element.delay( options.delay );
+		}
+		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
+			element[ method ]( options );
+		} else if ( effectName !== method && element[ effectName ] ) {
+			element[ effectName ]( options.duration, options.easing, callback );
+		} else {
+			element.queue(function( next ) {
+				$( this )[ method ]();
+				if ( callback ) {
+					callback.call( element[ 0 ] );
+				}
+				next();
+			});
+		}
+	};
+});
+
+})( jQuery );
+(function( $, undefined ) {
+
+var mouseHandled = false;
+$( document ).mouseup( function() {
+	mouseHandled = false;
+});
+
+$.widget("ui.mouse", {
+	version: "1.10.3",
+	options: {
+		cancel: "input,textarea,button,select,option",
+		distance: 1,
+		delay: 0
+	},
+	_mouseInit: function() {
+		var that = this;
+
+		this.element
+			.bind("mousedown."+this.widgetName, function(event) {
+				return that._mouseDown(event);
+			})
+			.bind("click."+this.widgetName, function(event) {
+				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
+					$.removeData(event.target, that.widgetName + ".preventClickEvent");
+					event.stopImmediatePropagation();
+					return false;
+				}
+			});
+
+		this.started = false;
+	},
+
+	// TODO: make sure destroying one instance of mouse doesn't mess with
+	// other instances of mouse
+	_mouseDestroy: function() {
+		this.element.unbind("."+this.widgetName);
+		if ( this._mouseMoveDelegate ) {
+			$(document)
+				.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
+				.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
+		}
+	},
+
+	_mouseDown: function(event) {
+		// don't let more than one widget handle mouseStart
+		if( mouseHandled ) { return; }
+
+		// we may have missed mouseup (out of window)
+		(this._mouseStarted && this._mouseUp(event));
+
+		this._mouseDownEvent = event;
+
+		var that = this,
+			btnIsLeft = (event.which === 1),
+			// event.target.nodeName works around a bug in IE 8 with
+			// disabled inputs (#7620)
+			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
+		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
+			return true;
+		}
+
+		this.mouseDelayMet = !this.options.delay;
+		if (!this.mouseDelayMet) {
+			this._mouseDelayTimer = setTimeout(function() {
+				that.mouseDelayMet = true;
+			}, this.options.delay);
+		}
+
+		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
+			this._mouseStarted = (this._mouseStart(event) !== false);
+			if (!this._mouseStarted) {
+				event.preventDefault();
+				return true;
+			}
+		}
+
+		// Click event may never have fired (Gecko & Opera)
+		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
+			$.removeData(event.target, this.widgetName + ".preventClickEvent");
+		}
+
+		// these delegates are required to keep context
+		this._mouseMoveDelegate = function(event) {
+			return that._mouseMove(event);
+		};
+		this._mouseUpDelegate = function(event) {
+			return that._mouseUp(event);
+		};
+		$(document)
+			.bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
+			.bind("mouseup."+this.widgetName, this._mouseUpDelegate);
+
+		event.preventDefault();
+
+		mouseHandled = true;
+		return true;
+	},
+
+	_mouseMove: function(event) {
+		// IE mouseup check - mouseup happened when mouse was out of window
+		if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
+			return this._mouseUp(event);
+		}
+
+		if (this._mouseStarted) {
+			this._mouseDrag(event);
+			return event.preventDefault();
+		}
+
+		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
+			this._mouseStarted =
+				(this._mouseStart(this._mouseDownEvent, event) !== false);
+			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
+		}
+
+		return !this._mouseStarted;
+	},
+
+	_mouseUp: function(event) {
+		$(document)
+			.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
+			.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
+
+		if (this._mouseStarted) {
+			this._mouseStarted = false;
+
+			if (event.target === this._mouseDownEvent.target) {
+				$.data(event.target, this.widgetName + ".preventClickEvent", true);
+			}
+
+			this._mouseStop(event);
+		}
+
+		return false;
+	},
+
+	_mouseDistanceMet: function(event) {
+		return (Math.max(
+				Math.abs(this._mouseDownEvent.pageX - event.pageX),
+				Math.abs(this._mouseDownEvent.pageY - event.pageY)
+			) >= this.options.distance
+		);
+	},
+
+	_mouseDelayMet: function(/* event */) {
+		return this.mouseDelayMet;
+	},
+
+	// These are placeholder methods, to be overriden by extending plugin
+	_mouseStart: function(/* event */) {},
+	_mouseDrag: function(/* event */) {},
+	_mouseStop: function(/* event */) {},
+	_mouseCapture: function(/* event */) { return true; }
+});
+
+})(jQuery);
+(function( $, undefined ) {
+
+/*jshint loopfunc: true */
+
+function isOverAxis( x, reference, size ) {
+	return ( x > reference ) && ( x < ( reference + size ) );
+}
+
+function isFloating(item) {
+	return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
+}
+
+$.widget("ui.sortable", $.ui.mouse, {
+	version: "1.10.3",
+	widgetEventPrefix: "sort",
+	ready: false,
+	options: {
+		appendTo: "parent",
+		axis: false,
+		connectWith: false,
+		containment: false,
+		cursor: "auto",
+		cursorAt: false,
+		dropOnEmpty: true,
+		forcePlaceholderSize: false,
+		forceHelperSize: false,
+		grid: false,
+		handle: false,
+		helper: "original",
+		items: "> *",
+		opacity: false,
+		placeholder: false,
+		revert: false,
+		scroll: true,
+		scrollSensitivity: 20,
+		scrollSpeed: 20,
+		scope: "default",
+		tolerance: "intersect",
+		zIndex: 1000,
+
+		// callbacks
+		activate: null,
+		beforeStop: null,
+		change: null,
+		deactivate: null,
+		out: null,
+		over: null,
+		receive: null,
+		remove: null,
+		sort: null,
+		start: null,
+		stop: null,
+		update: null
+	},
+	_create: function() {
+
+		var o = this.options;
+		this.containerCache = {};
+		this.element.addClass("ui-sortable");
+
+		//Get the items
+		this.refresh();
+
+		//Let's determine if the items are being displayed horizontally
+		this.floating = this.items.length ? o.axis === "x" || isFloating(this.items[0].item) : false;
+
+		//Let's determine the parent's offset
+		this.offset = this.element.offset();
+
+		//Initialize mouse events for interaction
+		this._mouseInit();
+
+		//We're ready to go
+		this.ready = true;
+
+	},
+
+	_destroy: function() {
+		this.element
+			.removeClass("ui-sortable ui-sortable-disabled");
+		this._mouseDestroy();
+
+		for ( var i = this.items.length - 1; i >= 0; i-- ) {
+			this.items[i].item.removeData(this.widgetName + "-item");
+		}
+
+		return this;
+	},
+
+	_setOption: function(key, value){
+		if ( key === "disabled" ) {
+			this.options[ key ] = value;
+
+			this.widget().toggleClass( "ui-sortable-disabled", !!value );
+		} else {
+			// Don't call widget base _setOption for disable as it adds ui-state-disabled class
+			$.Widget.prototype._setOption.apply(this, arguments);
+		}
+	},
+
+	_mouseCapture: function(event, overrideHandle) {
+		var currentItem = null,
+			validHandle = false,
+			that = this;
+
+		if (this.reverting) {
+			return false;
+		}
+
+		if(this.options.disabled || this.options.type === "static") {
+			return false;
+		}
+
+		//We have to refresh the items data once first
+		this._refreshItems(event);
+
+		//Find out if the clicked node (or one of its parents) is a actual item in this.items
+		$(event.target).parents().each(function() {
+			if($.data(this, that.widgetName + "-item") === that) {
+				currentItem = $(this);
+				return false;
+			}
+		});
+		if($.data(event.target, that.widgetName + "-item") === that) {
+			currentItem = $(event.target);
+		}
+
+		if(!currentItem) {
+			return false;
+		}
+		if(this.options.handle && !overrideHandle) {
+			$(this.options.handle, currentItem).find("*").addBack().each(function() {
+				if(this === event.target) {
+					validHandle = true;
+				}
+			});
+			if(!validHandle) {
+				return false;
+			}
+		}
+
+		this.currentItem = currentItem;
+		this._removeCurrentsFromItems();
+		return true;
+
+	},
+
+	_mouseStart: function(event, overrideHandle, noActivation) {
+
+		var i, body,
+			o = this.options;
+
+		this.currentContainer = this;
+
+		//We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
+		this.refreshPositions();
+
+		//Create and append the visible helper
+		this.helper = this._createHelper(event);
+
+		//Cache the helper size
+		this._cacheHelperProportions();
+
+		/*
+		 * - Position generation -
+		 * This block generates everything position related - it's the core of draggables.
+		 */
+
+		//Cache the margins of the original element
+		this._cacheMargins();
+
+		//Get the next scrolling parent
+		this.scrollParent = this.helper.scrollParent();
+
+		//The element's absolute position on the page minus margins
+		this.offset = this.currentItem.offset();
+		this.offset = {
+			top: this.offset.top - this.margins.top,
+			left: this.offset.left - this.margins.left
+		};
+
+		$.extend(this.offset, {
+			click: { //Where the click happened, relative to the element
+				left: event.pageX - this.offset.left,
+				top: event.pageY - this.offset.top
+			},
+			parent: this._getParentOffset(),
+			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
+		});
+
+		// Only after we got the offset, we can change the helper's position to absolute
+		// TODO: Still need to figure out a way to make relative sorting possible
+		this.helper.css("position", "absolute");
+		this.cssPosition = this.helper.css("position");
+
+		//Generate the original position
+		this.originalPosition = this._generatePosition(event);
+		this.originalPageX = event.pageX;
+		this.originalPageY = event.pageY;
+
+		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
+		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
+
+		//Cache the former DOM position
+		this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
+
+		//If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
+		if(this.helper[0] !== this.currentItem[0]) {
+			this.currentItem.hide();
+		}
+
+		//Create the placeholder
+		this._createPlaceholder();
+
+		//Set a containment if given in the options
+		if(o.containment) {
+			this._setContainment();
+		}
+
+		if( o.cursor && o.cursor !== "auto" ) { // cursor option
+			body = this.document.find( "body" );
+
+			// support: IE
+			this.storedCursor = body.css( "cursor" );
+			body.css( "cursor", o.cursor );
+
+			this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
+		}
+
+		if(o.opacity) { // opacity option
+			if (this.helper.css("opacity")) {
+				this._storedOpacity = this.helper.css("opacity");
+			}
+			this.helper.css("opacity", o.opacity);
+		}
+
+		if(o.zIndex) { // zIndex option
+			if (this.helper.css("zIndex")) {
+				this._storedZIndex = this.helper.css("zIndex");
+			}
+			this.helper.css("zIndex", o.zIndex);
+		}
+
+		//Prepare scrolling
+		if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
+			this.overflowOffset = this.scrollParent.offset();
+		}
+
+		//Call callbacks
+		this._trigger("start", event, this._uiHash());
+
+		//Recache the helper size
+		if(!this._preserveHelperProportions) {
+			this._cacheHelperProportions();
+		}
+
+
+		//Post "activate" events to possible containers
+		if( !noActivation ) {
+			for ( i = this.containers.length - 1; i >= 0; i-- ) {
+				this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
+			}
+		}
+
+		//Prepare possible droppables
+		if($.ui.ddmanager) {
+			$.ui.ddmanager.current = this;
+		}
+
+		if ($.ui.ddmanager && !o.dropBehaviour) {
+			$.ui.ddmanager.prepareOffsets(this, event);
+		}
+
+		this.dragging = true;
+
+		this.helper.addClass("ui-sortable-helper");
+		this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
+		return true;
+
+	},
+
+	_mouseDrag: function(event) {
+		var i, item, itemElement, intersection,
+			o = this.options,
+			scrolled = false;
+
+		//Compute the helpers position
+		this.position = this._generatePosition(event);
+		this.positionAbs = this._convertPositionTo("absolute");
+
+		if (!this.lastPositionAbs) {
+			this.lastPositionAbs = this.positionAbs;
+		}
+
+		//Do scrolling
+		if(this.options.scroll) {
+			if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
+
+				if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
+					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
+				} else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
+					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
+				}
+
+				if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
+					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
+				} else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
+					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
+				}
+
+			} else {
+
+				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
+					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
+				} else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
+					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
+				}
+
+				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
+					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
+				} else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
+					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
+				}
+
+			}
+
+			if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
+				$.ui.ddmanager.prepareOffsets(this, event);
+			}
+		}
+
+		//Regenerate the absolute position used for position checks
+		this.positionAbs = this._convertPositionTo("absolute");
+
+		//Set the helper position
+		if(!this.options.axis || this.options.axis !== "y") {
+			this.helper[0].style.left = this.position.left+"px";
+		}
+		if(!this.options.axis || this.options.axis !== "x") {
+			this.helper[0].style.top = this.position.top+"px";
+		}
+
+		//Rearrange
+		for (i = this.items.length - 1; i >= 0; i--) {
+
+			//Cache variables and intersection, continue if no intersection
+			item = this.items[i];
+			itemElement = item.item[0];
+			intersection = this._intersectsWithPointer(item);
+			if (!intersection) {
+				continue;
+			}
+
+			// Only put the placeholder inside the current Container, skip all
+			// items form other containers. This works because when moving
+			// an item from one container to another the
+			// currentContainer is switched before the placeholder is moved.
+			//
+			// Without this moving items in "sub-sortables" can cause the placeholder to jitter
+			// beetween the outer and inner container.
+			if (item.instance !== this.currentContainer) {
+				continue;
+			}
+
+			// cannot intersect with itself
+			// no useless actions that have been done before
+			// no action if the item moved is the parent of the item checked
+			if (itemElement !== this.currentItem[0] &&
+				this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
+				!$.contains(this.placeholder[0], itemElement) &&
+				(this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
+			) {
+
+				this.direction = intersection === 1 ? "down" : "up";
+
+				if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
+					this._rearrange(event, item);
+				} else {
+					break;
+				}
+
+				this._trigger("change", event, this._uiHash());
+				break;
+			}
+		}
+
+		//Post events to containers
+		this._contactContainers(event);
+
+		//Interconnect with droppables
+		if($.ui.ddmanager) {
+			$.ui.ddmanager.drag(this, event);
+		}
+
+		//Call callbacks
+		this._trigger("sort", event, this._uiHash());
+
+		this.lastPositionAbs = this.positionAbs;
+		return false;
+
+	},
+
+	_mouseStop: function(event, noPropagation) {
+
+		if(!event) {
+			return;
+		}
+
+		//If we are using droppables, inform the manager about the drop
+		if ($.ui.ddmanager && !this.options.dropBehaviour) {
+			$.ui.ddmanager.drop(this, event);
+		}
+
+		if(this.options.revert) {
+			var that = this,
+				cur = this.placeholder.offset(),
+				axis = this.options.axis,
+				animation = {};
+
+			if ( !axis || axis === "x" ) {
+				animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft);
+			}
+			if ( !axis || axis === "y" ) {
+				animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop);
+			}
+			this.reverting = true;
+			$(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
+				that._clear(event);
+			});
+		} else {
+			this._clear(event, noPropagation);
+		}
+
+		return false;
+
+	},
+
+	cancel: function() {
+
+		if(this.dragging) {
+
+			this._mouseUp({ target: null });
+
+			if(this.options.helper === "original") {
+				this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
+			} else {
+				this.currentItem.show();
+			}
+
+			//Post deactivating events to containers
+			for (var i = this.containers.length - 1; i >= 0; i--){
+				this.containers[i]._trigger("deactivate", null, this._uiHash(this));
+				if(this.containers[i].containerCache.over) {
+					this.containers[i]._trigger("out", null, this._uiHash(this));
+					this.containers[i].containerCache.over = 0;
+				}
+			}
+
+		}
+
+		if (this.placeholder) {
+			//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
+			if(this.placeholder[0].parentNode) {
+				this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+			}
+			if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
+				this.helper.remove();
+			}
+
+			$.extend(this, {
+				helper: null,
+				dragging: false,
+				reverting: false,
+				_noFinalSort: null
+			});
+
+			if(this.domPosition.prev) {
+				$(this.domPosition.prev).after(this.currentItem);
+			} else {
+				$(this.domPosition.parent).prepend(this.currentItem);
+			}
+		}
+
+		return this;
+
+	},
+
+	serialize: function(o) {
+
+		var items = this._getItemsAsjQuery(o && o.connected),
+			str = [];
+		o = o || {};
+
+		$(items).each(function() {
+			var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
+			if (res) {
+				str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
+			}
+		});
+
+		if(!str.length && o.key) {
+			str.push(o.key + "=");
+		}
+
+		return str.join("&");
+
+	},
+
+	toArray: function(o) {
+
+		var items = this._getItemsAsjQuery(o && o.connected),
+			ret = [];
+
+		o = o || {};
+
+		items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
+		return ret;
+
+	},
+
+	/* Be careful with the following core functions */
+	_intersectsWith: function(item) {
+
+		var x1 = this.positionAbs.left,
+			x2 = x1 + this.helperProportions.width,
+			y1 = this.positionAbs.top,
+			y2 = y1 + this.helperProportions.height,
+			l = item.left,
+			r = l + item.width,
+			t = item.top,
+			b = t + item.height,
+			dyClick = this.offset.click.top,
+			dxClick = this.offset.click.left,
+			isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
+			isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
+			isOverElement = isOverElementHeight && isOverElementWidth;
+
+		if ( this.options.tolerance === "pointer" ||
+			this.options.forcePointerForContainers ||
+			(this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
+		) {
+			return isOverElement;
+		} else {
+
+			return (l < x1 + (this.helperProportions.width / 2) && // Right Half
+				x2 - (this.helperProportions.width / 2) < r && // Left Half
+				t < y1 + (this.helperProportions.height / 2) && // Bottom Half
+				y2 - (this.helperProportions.height / 2) < b ); // Top Half
+
+		}
+	},
+
+	_intersectsWithPointer: function(item) {
+
+		var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
+			isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
+			isOverElement = isOverElementHeight && isOverElementWidth,
+			verticalDirection = this._getDragVerticalDirection(),
+			horizontalDirection = this._getDragHorizontalDirection();
+
+		if (!isOverElement) {
+			return false;
+		}
+
+		return this.floating ?
+			( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
+			: ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
+
+	},
+
+	_intersectsWithSides: function(item) {
+
+		var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
+			isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
+			verticalDirection = this._getDragVerticalDirection(),
+			horizontalDirection = this._getDragHorizontalDirection();
+
+		if (this.floating && horizontalDirection) {
+			return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
+		} else {
+			return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
+		}
+
+	},
+
+	_getDragVerticalDirection: function() {
+		var delta = this.positionAbs.top - this.lastPositionAbs.top;
+		return delta !== 0 && (delta > 0 ? "down" : "up");
+	},
+
+	_getDragHorizontalDirection: function() {
+		var delta = this.positionAbs.left - this.lastPositionAbs.left;
+		return delta !== 0 && (delta > 0 ? "right" : "left");
+	},
+
+	refresh: function(event) {
+		this._refreshItems(event);
+		this.refreshPositions();
+		return this;
+	},
+
+	_connectWith: function() {
+		var options = this.options;
+		return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
+	},
+
+	_getItemsAsjQuery: function(connected) {
+
+		var i, j, cur, inst,
+			items = [],
+			queries = [],
+			connectWith = this._connectWith();
+
+		if(connectWith && connected) {
+			for (i = connectWith.length - 1; i >= 0; i--){
+				cur = $(connectWith[i]);
+				for ( j = cur.length - 1; j >= 0; j--){
+					inst = $.data(cur[j], this.widgetFullName);
+					if(inst && inst !== this && !inst.options.disabled) {
+						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), inst]);
+					}
+				}
+			}
+		}
+
+		queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), this]);
+
+		for (i = queries.length - 1; i >= 0; i--){
+			queries[i][0].each(function() {
+				items.push(this);
+			});
+		}
+
+		return $(items);
+
+	},
+
+	_removeCurrentsFromItems: function() {
+
+		var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
+
+		this.items = $.grep(this.items, function (item) {
+			for (var j=0; j < list.length; j++) {
+				if(list[j] === item.item[0]) {
+					return false;
+				}
+			}
+			return true;
+		});
+
+	},
+
+	_refreshItems: function(event) {
+
+		this.items = [];
+		this.containers = [this];
+
+		var i, j, cur, inst, targetData, _queries, item, queriesLength,
+			items = this.items,
+			queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
+			connectWith = this._connectWith();
+
+		if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
+			for (i = connectWith.length - 1; i >= 0; i--){
+				cur = $(connectWith[i]);
+				for (j = cur.length - 1; j >= 0; j--){
+					inst = $.data(cur[j], this.widgetFullName);
+					if(inst && inst !== this && !inst.options.disabled) {
+						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
+						this.containers.push(inst);
+					}
+				}
+			}
+		}
+
+		for (i = queries.length - 1; i >= 0; i--) {
+			targetData = queries[i][1];
+			_queries = queries[i][0];
+
+			for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
+				item = $(_queries[j]);
+
+				item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
+
+				items.push({
+					item: item,
+					instance: targetData,
+					width: 0, height: 0,
+					left: 0, top: 0
+				});
+			}
+		}
+
+	},
+
+	refreshPositions: function(fast) {
+
+		//This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
+		if(this.offsetParent && this.helper) {
+			this.offset.parent = this._getParentOffset();
+		}
+
+		var i, item, t, p;
+
+		for (i = this.items.length - 1; i >= 0; i--){
+			item = this.items[i];
+
+			//We ignore calculating positions of all connected containers when we're not over them
+			if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
+				continue;
+			}
+
+			t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
+
+			if (!fast) {
+				item.width = t.outerWidth();
+				item.height = t.outerHeight();
+			}
+
+			p = t.offset();
+			item.left = p.left;
+			item.top = p.top;
+		}
+
+		if(this.options.custom && this.options.custom.refreshContainers) {
+			this.options.custom.refreshContainers.call(this);
+		} else {
+			for (i = this.containers.length - 1; i >= 0; i--){
+				p = this.containers[i].element.offset();
+				this.containers[i].containerCache.left = p.left;
+				this.containers[i].containerCache.top = p.top;
+				this.containers[i].containerCache.width	= this.containers[i].element.outerWidth();
+				this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
+			}
+		}
+
+		return this;
+	},
+
+	_createPlaceholder: function(that) {
+		that = that || this;
+		var className,
+			o = that.options;
+
+		if(!o.placeholder || o.placeholder.constructor === String) {
+			className = o.placeholder;
+			o.placeholder = {
+				element: function() {
+
+					var nodeName = that.currentItem[0].nodeName.toLowerCase(),
+						element = $( "<" + nodeName + ">", that.document[0] )
+							.addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
+							.removeClass("ui-sortable-helper");
+
+					if ( nodeName === "tr" ) {
+						that.currentItem.children().each(function() {
+							$( "<td>&#160;</td>", that.document[0] )
+								.attr( "colspan", $( this ).attr( "colspan" ) || 1 )
+								.appendTo( element );
+						});
+					} else if ( nodeName === "img" ) {
+						element.attr( "src", that.currentItem.attr( "src" ) );
+					}
+
+					if ( !className ) {
+						element.css( "visibility", "hidden" );
+					}
+
+					return element;
+				},
+				update: function(container, p) {
+
+					// 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
+					// 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
+					if(className && !o.forcePlaceholderSize) {
+						return;
+					}
+
+					//If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
+					if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
+					if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
+				}
+			};
+		}
+
+		//Create the placeholder
+		that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
+
+		//Append it after the actual current item
+		that.currentItem.after(that.placeholder);
+
+		//Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
+		o.placeholder.update(that, that.placeholder);
+
+	},
+
+	_contactContainers: function(event) {
+		var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, base, cur, nearBottom, floating,
+			innermostContainer = null,
+			innermostIndex = null;
+
+		// get innermost container that intersects with item
+		for (i = this.containers.length - 1; i >= 0; i--) {
+
+			// never consider a container that's located within the item itself
+			if($.contains(this.currentItem[0], this.containers[i].element[0])) {
+				continue;
+			}
+
+			if(this._intersectsWith(this.containers[i].containerCache)) {
+
+				// if we've already found a container and it's more "inner" than this, then continue
+				if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
+					continue;
+				}
+
+				innermostContainer = this.containers[i];
+				innermostIndex = i;
+
+			} else {
+				// container doesn't intersect. trigger "out" event if necessary
+				if(this.containers[i].containerCache.over) {
+					this.containers[i]._trigger("out", event, this._uiHash(this));
+					this.containers[i].containerCache.over = 0;
+				}
+			}
+
+		}
+
+		// if no intersecting containers found, return
+		if(!innermostContainer) {
+			return;
+		}
+
+		// move the item into the container if it's not there already
+		if(this.containers.length === 1) {
+			if (!this.containers[innermostIndex].containerCache.over) {
+				this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
+				this.containers[innermostIndex].containerCache.over = 1;
+			}
+		} else {
+
+			//When entering a new container, we will find the item with the least distance and append our item near it
+			dist = 10000;
+			itemWithLeastDistance = null;
+			floating = innermostContainer.floating || isFloating(this.currentItem);
+			posProperty = floating ? "left" : "top";
+			sizeProperty = floating ? "width" : "height";
+			base = this.positionAbs[posProperty] + this.offset.click[posProperty];
+			for (j = this.items.length - 1; j >= 0; j--) {
+				if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
+					continue;
+				}
+				if(this.items[j].item[0] === this.currentItem[0]) {
+					continue;
+				}
+				if (floating && !isOverAxis(this.positionAbs.top + this.offset.click.top, this.items[j].top, this.items[j].height)) {
+					continue;
+				}
+				cur = this.items[j].item.offset()[posProperty];
+				nearBottom = false;
+				if(Math.abs(cur - base) > Math.abs(cur + this.items[j][sizeProperty] - base)){
+					nearBottom = true;
+					cur += this.items[j][sizeProperty];
+				}
+
+				if(Math.abs(cur - base) < dist) {
+					dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
+					this.direction = nearBottom ? "up": "down";
+				}
+			}
+
+			//Check if dropOnEmpty is enabled
+			if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
+				return;
+			}
+
+			if(this.currentContainer === this.containers[innermostIndex]) {
+				return;
+			}
+
+			itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
+			this._trigger("change", event, this._uiHash());
+			this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
+			this.currentContainer = this.containers[innermostIndex];
+
+			//Update the placeholder
+			this.options.placeholder.update(this.currentContainer, this.placeholder);
+
+			this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
+			this.containers[innermostIndex].containerCache.over = 1;
+		}
+
+
+	},
+
+	_createHelper: function(event) {
+
+		var o = this.options,
+			helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
+
+		//Add the helper to the DOM if that didn't happen already
+		if(!helper.parents("body").length) {
+			$(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
+		}
+
+		if(helper[0] === this.currentItem[0]) {
+			this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
+		}
+
+		if(!helper[0].style.width || o.forceHelperSize) {
+			helper.width(this.currentItem.width());
+		}
+		if(!helper[0].style.height || o.forceHelperSize) {
+			helper.height(this.currentItem.height());
+		}
+
+		return helper;
+
+	},
+
+	_adjustOffsetFromHelper: function(obj) {
+		if (typeof obj === "string") {
+			obj = obj.split(" ");
+		}
+		if ($.isArray(obj)) {
+			obj = {left: +obj[0], top: +obj[1] || 0};
+		}
+		if ("left" in obj) {
+			this.offset.click.left = obj.left + this.margins.left;
+		}
+		if ("right" in obj) {
+			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
+		}
+		if ("top" in obj) {
+			this.offset.click.top = obj.top + this.margins.top;
+		}
+		if ("bottom" in obj) {
+			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
+		}
+	},
+
+	_getParentOffset: function() {
+
+
+		//Get the offsetParent and cache its position
+		this.offsetParent = this.helper.offsetParent();
+		var po = this.offsetParent.offset();
+
+		// This is a special case where we need to modify a offset calculated on start, since the following happened:
+		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
+		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
+		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
+		if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
+			po.left += this.scrollParent.scrollLeft();
+			po.top += this.scrollParent.scrollTop();
+		}
+
+		// This needs to be actually done for all browsers, since pageX/pageY includes this information
+		// with an ugly IE fix
+		if( this.offsetParent[0] === document.body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
+			po = { top: 0, left: 0 };
+		}
+
+		return {
+			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
+			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
+		};
+
+	},
+
+	_getRelativeOffset: function() {
+
+		if(this.cssPosition === "relative") {
+			var p = this.currentItem.position();
+			return {
+				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
+				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
+			};
+		} else {
+			return { top: 0, left: 0 };
+		}
+
+	},
+
+	_cacheMargins: function() {
+		this.margins = {
+			left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
+			top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
+		};
+	},
+
+	_cacheHelperProportions: function() {
+		this.helperProportions = {
+			width: this.helper.outerWidth(),
+			height: this.helper.outerHeight()
+		};
+	},
+
+	_setContainment: function() {
+
+		var ce, co, over,
+			o = this.options;
+		if(o.containment === "parent") {
+			o.containment = this.helper[0].parentNode;
+		}
+		if(o.containment === "document" || o.containment === "window") {
+			this.containment = [
+				0 - this.offset.relative.left - this.offset.parent.left,
+				0 - this.offset.relative.top - this.offset.parent.top,
+				$(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
+				($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
+			];
+		}
+
+		if(!(/^(document|window|parent)$/).test(o.containment)) {
+			ce = $(o.containment)[0];
+			co = $(o.containment).offset();
+			over = ($(ce).css("overflow") !== "hidden");
+
+			this.containment = [
+				co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
+				co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
+				co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
+				co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
+			];
+		}
+
+	},
+
+	_convertPositionTo: function(d, pos) {
+
+		if(!pos) {
+			pos = this.position;
+		}
+		var mod = d === "absolute" ? 1 : -1,
+			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
+			scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+		return {
+			top: (
+				pos.top	+																// The absolute mouse position
+				this.offset.relative.top * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.top * mod -											// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
+			),
+			left: (
+				pos.left +																// The absolute mouse position
+				this.offset.relative.left * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.left * mod	-										// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
+			)
+		};
+
+	},
+
+	_generatePosition: function(event) {
+
+		var top, left,
+			o = this.options,
+			pageX = event.pageX,
+			pageY = event.pageY,
+			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+		// This is another very weird special case that only happens for relative elements:
+		// 1. If the css position is relative
+		// 2. and the scroll parent is the document or similar to the offset parent
+		// we have to refresh the relative offset during the scroll so there are no jumps
+		if(this.cssPosition === "relative" && !(this.scrollParent[0] !== document && this.scrollParent[0] !== this.offsetParent[0])) {
+			this.offset.relative = this._getRelativeOffset();
+		}
+
+		/*
+		 * - Position constraining -
+		 * Constrain the position to a mix of grid, containment.
+		 */
+
+		if(this.originalPosition) { //If we are not dragging yet, we won't check for options
+
+			if(this.containment) {
+				if(event.pageX - this.offset.click.left < this.containment[0]) {
+					pageX = this.containment[0] + this.offset.click.left;
+				}
+				if(event.pageY - this.offset.click.top < this.containment[1]) {
+					pageY = this.containment[1] + this.offset.click.top;
+				}
+				if(event.pageX - this.offset.click.left > this.containment[2]) {
+					pageX = this.containment[2] + this.offset.click.left;
+				}
+				if(event.pageY - this.offset.click.top > this.containment[3]) {
+					pageY = this.containment[3] + this.offset.click.top;
+				}
+			}
+
+			if(o.grid) {
+				top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
+				pageY = this.containment ? ( (top - this.offset.click.top >= this.containment[1] && top - this.offset.click.top <= this.containment[3]) ? top : ((top - this.offset.click.top >= this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
+
+				left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
+				pageX = this.containment ? ( (left - this.offset.click.left >= this.containment[0] && left - this.offset.click.left <= this.containment[2]) ? left : ((left - this.offset.click.left >= this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
+			}
+
+		}
+
+		return {
+			top: (
+				pageY -																// The absolute mouse position
+				this.offset.click.top -													// Click offset (relative to the element)
+				this.offset.relative.top	-											// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.top +												// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
+			),
+			left: (
+				pageX -																// The absolute mouse position
+				this.offset.click.left -												// Click offset (relative to the element)
+				this.offset.relative.left	-											// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.left +												// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
+			)
+		};
+
+	},
+
+	_rearrange: function(event, i, a, hardRefresh) {
+
+		a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
+
+		//Various things done here to improve the performance:
+		// 1. we create a setTimeout, that calls refreshPositions
+		// 2. on the instance, we have a counter variable, that get's higher after every append
+		// 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
+		// 4. this lets only the last addition to the timeout stack through
+		this.counter = this.counter ? ++this.counter : 1;
+		var counter = this.counter;
+
+		this._delay(function() {
+			if(counter === this.counter) {
+				this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
+			}
+		});
+
+	},
+
+	_clear: function(event, noPropagation) {
+
+		this.reverting = false;
+		// We delay all events that have to be triggered to after the point where the placeholder has been removed and
+		// everything else normalized again
+		var i,
+			delayedTriggers = [];
+
+		// We first have to update the dom position of the actual currentItem
+		// Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
+		if(!this._noFinalSort && this.currentItem.parent().length) {
+			this.placeholder.before(this.currentItem);
+		}
+		this._noFinalSort = null;
+
+		if(this.helper[0] === this.currentItem[0]) {
+			for(i in this._storedCSS) {
+				if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
+					this._storedCSS[i] = "";
+				}
+			}
+			this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
+		} else {
+			this.currentItem.show();
+		}
+
+		if(this.fromOutside && !noPropagation) {
+			delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
+		}
+		if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
+			delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
+		}
+
+		// Check if the items Container has Changed and trigger appropriate
+		// events.
+		if (this !== this.currentContainer) {
+			if(!noPropagation) {
+				delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.currentContainer));
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.currentContainer));
+			}
+		}
+
+
+		//Post events to containers
+		for (i = this.containers.length - 1; i >= 0; i--){
+			if(!noPropagation) {
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
+			}
+			if(this.containers[i].containerCache.over) {
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
+				this.containers[i].containerCache.over = 0;
+			}
+		}
+
+		//Do what was originally in plugins
+		if ( this.storedCursor ) {
+			this.document.find( "body" ).css( "cursor", this.storedCursor );
+			this.storedStylesheet.remove();
+		}
+		if(this._storedOpacity) {
+			this.helper.css("opacity", this._storedOpacity);
+		}
+		if(this._storedZIndex) {
+			this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
+		}
+
+		this.dragging = false;
+		if(this.cancelHelperRemoval) {
+			if(!noPropagation) {
+				this._trigger("beforeStop", event, this._uiHash());
+				for (i=0; i < delayedTriggers.length; i++) {
+					delayedTriggers[i].call(this, event);
+				} //Trigger all delayed events
+				this._trigger("stop", event, this._uiHash());
+			}
+
+			this.fromOutside = false;
+			return false;
+		}
+
+		if(!noPropagation) {
+			this._trigger("beforeStop", event, this._uiHash());
+		}
+
+		//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
+		this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+
+		if(this.helper[0] !== this.currentItem[0]) {
+			this.helper.remove();
+		}
+		this.helper = null;
+
+		if(!noPropagation) {
+			for (i=0; i < delayedTriggers.length; i++) {
+				delayedTriggers[i].call(this, event);
+			} //Trigger all delayed events
+			this._trigger("stop", event, this._uiHash());
+		}
+
+		this.fromOutside = false;
+		return true;
+
+	},
+
+	_trigger: function() {
+		if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
+			this.cancel();
+		}
+	},
+
+	_uiHash: function(_inst) {
+		var inst = _inst || this;
+		return {
+			helper: inst.helper,
+			placeholder: inst.placeholder || $([]),
+			position: inst.position,
+			originalPosition: inst.originalPosition,
+			offset: inst.positionAbs,
+			item: inst.currentItem,
+			sender: _inst ? _inst.element : null
+		};
+	}
+
+});
+
+})(jQuery);
diff --git a/examples/unfinished/reorderable-list/client/shark.css b/examples/unfinished/reorderable-list/client/shark.css
new file mode 100644
index 0000000000..c6a9f2e7f5
--- /dev/null
+++ b/examples/unfinished/reorderable-list/client/shark.css
@@ -0,0 +1,10 @@
+#list div {
+  padding: 10px;
+  height: 19px;
+  border: 1px solid #bbb;
+  margin: 8px;
+  font-weight: bold;
+  cursor: move;
+  width: 400px;
+  background: #eee; }
+
diff --git a/examples/unfinished/reorderable-list/client/shark.html b/examples/unfinished/reorderable-list/client/shark.html
new file mode 100644
index 0000000000..e65e597c2d
--- /dev/null
+++ b/examples/unfinished/reorderable-list/client/shark.html
@@ -0,0 +1,9 @@
+<body>
+  <div id="list">
+    {{#each items}}
+      <div class="item">
+        {{text}}
+      </div>
+    {{/each}}
+  </div>
+</body>
diff --git a/examples/unfinished/reorderable-list/client/shark.js b/examples/unfinished/reorderable-list/client/shark.js
new file mode 100644
index 0000000000..2ae26b746c
--- /dev/null
+++ b/examples/unfinished/reorderable-list/client/shark.js
@@ -0,0 +1,30 @@
+UI.body.items = Items.find({}, { sort: { rank: 1 } });
+
+SimpleRationalRanks = {
+  beforeFirst: function (firstRank) { return firstRank - 1; },
+  between: function (beforeRank, afterRank) { return (beforeRank + afterRank) / 2; },
+  afterLast: function (lastRank) { return lastRank + 1; }
+};
+
+UI.body.rendered = function () {
+  $(this.find('#list')).sortable({ // uses the 'sortable' interaction from jquery ui
+    stop: function (event, ui) { // fired when an item is dropped
+      var el = ui.item.get(0), before = ui.item.prev().get(0), after = ui.item.next().get(0);
+
+      var newRank;
+      if (!before) { // moving to the top of the list
+        newRank = SimpleRationalRanks.beforeFirst(UI.getElementData(after).rank);
+
+      } else if (!after) { // moving to the bottom of the list
+        newRank = SimpleRationalRanks.afterLast(UI.getElementData(before).rank);
+
+      } else {
+        newRank = SimpleRationalRanks.between(
+          UI.getElementData(before).rank,
+          UI.getElementData(after).rank);
+      }
+
+      Items.update(UI.getElementData(el)._id, {$set: {rank: newRank}});
+    }
+  });
+};
diff --git a/examples/unfinished/reorderable-list/lib/items.js b/examples/unfinished/reorderable-list/lib/items.js
new file mode 100644
index 0000000000..11b6f7951c
--- /dev/null
+++ b/examples/unfinished/reorderable-list/lib/items.js
@@ -0,0 +1,9 @@
+Items = new Meteor.Collection("items");
+
+if (Meteor.isServer) {
+  if (Items.find().count() === 0) {
+    _.each(
+      ["violet", "unicorn", "flask", "jar", "leitmotif", "rearrange", "right", "ethereal"],
+      function (text, index) { Items.insert({text: text, rank: index}); });
+  }
+}
\ No newline at end of file
diff --git a/examples/wordplay/.meteor/packages b/examples/wordplay/.meteor/packages
index e695b93a6f..5facf43e33 100644
--- a/examples/wordplay/.meteor/packages
+++ b/examples/wordplay/.meteor/packages
@@ -6,4 +6,3 @@
 standard-app-packages
 insecure
 jquery
-preserve-inputs
diff --git a/examples/wordplay/.meteor/release b/examples/wordplay/.meteor/release
index 7486fdbc50..4b324f2d8f 100644
--- a/examples/wordplay/.meteor/release
+++ b/examples/wordplay/.meteor/release
@@ -1 +1 @@
-0.7.2
+0.8.0.1
diff --git a/examples/wordplay/client/wordplay.html b/examples/wordplay/client/wordplay.html
index 90fb54aefc..c286df6634 100644
--- a/examples/wordplay/client/wordplay.html
+++ b/examples/wordplay/client/wordplay.html
@@ -65,7 +65,7 @@
       {{/each}}
       {{/if}}
       <div>
-        <button id="startgame" class="startgame" {{{disabled}}}>
+        <button id="startgame" class="startgame" {{disabled}}>
           {{#if count}} It's on! {{else}} Play solo {{/if}}
         </button>
       </div>
diff --git a/examples/wordplay/client/wordplay.js b/examples/wordplay/client/wordplay.js
index acff55aaeb..64440a6e70 100644
--- a/examples/wordplay/client/wordplay.js
+++ b/examples/wordplay/client/wordplay.js
@@ -24,9 +24,9 @@ var set_selected_positions = function (word) {
   }
 
   for (var pos = 0; pos < 16; pos++) {
-    if (last_in_a_path.indexOf(pos) !== -1)
+    if (_.indexOf(last_in_a_path, pos) !== -1)
       Session.set('selected_' + pos, 'last_in_path');
-    else if (in_a_path.indexOf(pos) !== -1)
+    else if (_.indexOf(in_a_path, pos) !== -1)
       Session.set('selected_' + pos, 'in_path');
     else
       Session.set('selected_' + pos, false);
@@ -68,13 +68,14 @@ Template.lobby.disabled = function () {
   var me = player();
   if (me && me.name)
     return '';
-  return 'disabled="disabled"';
+  return 'disabled';
 };
 
+var trim = function (string) { return string.replace(/^\s+|\s+$/g, ''); };
 
 Template.lobby.events({
   'keyup input#myname': function (evt) {
-    var name = $('#lobby input#myname').val().trim();
+    var name = trim($('#lobby input#myname').val());
     Players.update(Session.get('player_id'), {$set: {name: name}});
   },
   'click button.startgame': function () {
@@ -115,7 +116,9 @@ Template.board.clock = function () {
 Template.board.events({
   'click .square': function (evt) {
     var textbox = $('#scratchpad input');
-    textbox.val(textbox.val() + evt.target.innerHTML);
+    // Note: Getting the letter out of the DOM is kind of a hack
+    var letter = evt.target.textContent || evt.target.innerText;
+    textbox.val(textbox.val() + letter);
     textbox.focus();
   }
 });
diff --git a/examples/wordplay/model.js b/examples/wordplay/model.js
index 416c4db122..5b2912eaae 100644
--- a/examples/wordplay/model.js
+++ b/examples/wordplay/model.js
@@ -82,7 +82,7 @@ paths_for_word = function (board, word) {
 
     for (var i = 0; i < positions_to_try.length; i++) {
       var pos = positions_to_try[i];
-      if (board[pos] === word[0] && path.indexOf(pos) === -1)
+      if (board[pos] === word[0] && _.indexOf(path, pos) === -1)
         check_path(word.slice(1),      // cdr of word
                    path.concat([pos]), // append matching loc to path
                    ADJACENCIES[pos]);  // only look at surrounding tiles
diff --git a/meteor b/meteor
index 29fe3a330c..a89420b584 100755
--- a/meteor
+++ b/meteor
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-BUNDLE_VERSION=0.3.33
+BUNDLE_VERSION=0.3.34
 
 # OS Check. Put here because here is where we download the precompiled
 # bundles that are arch specific.
diff --git a/packages/accounts-base/accounts_client.js b/packages/accounts-base/accounts_client.js
index a74c96fe0b..140cdf1069 100644
--- a/packages/accounts-base/accounts_client.js
+++ b/packages/accounts-base/accounts_client.js
@@ -215,38 +215,40 @@ Meteor.logout = function (callback) {
 };
 
 Meteor.logoutOtherClients = function (callback) {
-  // Call the `logoutOtherClients` method. Store the login token that we get
-  // back and use it to log in again. The server is not supposed to close
-  // connections on the old token for 10 seconds, so we should have time to
-  // store our new token and log in with it before being disconnected. If we get
-  // disconnected, then we'll immediately reconnect with the new token. If for
-  // some reason we get disconnected before storing the new token, then the
-  // worst that will happen is that we'll have a flicker from trying to log in
-  // with the old token before storing and logging in with the new one.
-  Accounts.connection.apply('logoutOtherClients', [], { wait: true },
-               function (error, result) {
-                 if (error) {
-                   callback && callback(error);
-                 } else {
-                   var userId = Meteor.userId();
-                   storeLoginToken(userId, result.token, result.tokenExpires);
-                   // If the server hasn't disconnected us yet by deleting our
-                   // old token, then logging in now with the new valid token
-                   // will prevent us from getting disconnected. If the server
-                   // has already disconnected us due to our old invalid token,
-                   // then we would have already tried and failed to login with
-                   // the old token on reconnect, and we have to make sure a
-                   // login method gets sent here with the new token.
-                   Meteor.loginWithToken(result.token, function (err) {
-                     if (err &&
-                         storedLoginToken() &&
-                         storedLoginToken().token === result.token) {
-                       makeClientLoggedOut();
-                     }
-                     callback && callback(err);
-                   });
-                 }
-               });
+  // We need to make two method calls: one to replace our current token,
+  // and another to remove all tokens except the current one. We want to
+  // call these two methods one after the other, without any other
+  // methods running between them. For example, we don't want `logout`
+  // to be called in between our two method calls (otherwise the second
+  // method call would return an error). Another example: we don't want
+  // logout to be called before the callback for `getNewToken`;
+  // otherwise we would momentarily log the user out and then write a
+  // new token to localStorage.
+  //
+  // To accomplish this, we make both calls as wait methods, and queue
+  // them one after the other, without spinning off the event loop in
+  // between. Even though we queue `removeOtherTokens` before
+  // `getNewToken`, we won't actually send the `removeOtherTokens` call
+  // until the `getNewToken` callback has finished running, because they
+  // are both wait methods.
+  Accounts.connection.apply(
+    'getNewToken',
+    [],
+    { wait: true },
+    function (err, result) {
+      if (! err) {
+        storeLoginToken(Meteor.userId(), result.token, result.tokenExpires);
+      }
+    }
+  );
+  Accounts.connection.apply(
+    'removeOtherTokens',
+    [],
+    { wait: true },
+    function (err) {
+      callback && callback(err);
+    }
+  );
 };
 
 
@@ -269,13 +271,13 @@ Accounts.loginServicesConfigured = function () {
 /// HANDLEBARS HELPERS
 ///
 
-// If we're using Handlebars, register the {{currentUser}} and
-// {{loggingIn}} global helpers.
-if (Package.handlebars) {
-  Package.handlebars.Handlebars.registerHelper('currentUser', function () {
+// If our app has a UI, register the {{currentUser}} and {{loggingIn}}
+// global helpers.
+if (Package.ui) {
+  Package.ui.UI.registerHelper('currentUser', function () {
     return Meteor.user();
   });
-  Package.handlebars.Handlebars.registerHelper('loggingIn', function () {
+  Package.ui.UI.registerHelper('loggingIn', function () {
     return Meteor.loggingIn();
   });
 }
diff --git a/packages/accounts-base/accounts_common.js b/packages/accounts-base/accounts_common.js
index 34a83982f4..5fbc104e0a 100644
--- a/packages/accounts-base/accounts_common.js
+++ b/packages/accounts-base/accounts_common.js
@@ -53,6 +53,18 @@ Accounts.config = function(options) {
                   "server; some configuration options may not take effect.");
   }
 
+  // We need to validate the oauthSecretKey option at the time
+  // Accounts.config is called. We also deliberately don't store the
+  // oauthSecretKey in Accounts._options.
+  if (_.has(options, "oauthSecretKey")) {
+    if (Meteor.isClient)
+      throw new Error("The oauthSecretKey option may only be specified on the server");
+    if (! Package["oauth-encryption"])
+      throw new Error("The oauth-encryption package must be loaded to set oauthSecretKey");
+    Package["oauth-encryption"].OAuthEncryption.loadKey(options.oauthSecretKey);
+    options = _.omit(options, "oauthSecretKey");
+  }
+
   // validate option keys
   var VALID_KEYS = ["sendVerificationEmail", "forbidClientAccountCreation",
                     "restrictCreationByEmailDomain", "loginExpirationInDays"];
diff --git a/packages/accounts-base/accounts_server.js b/packages/accounts-base/accounts_server.js
index a75c70134b..5f4de80932 100644
--- a/packages/accounts-base/accounts_server.js
+++ b/packages/accounts-base/accounts_server.js
@@ -73,12 +73,19 @@ var validateLogin = function (connection, attempt) {
     }
     catch (e) {
       attempt.allowed = false;
+      // XXX this means the last thrown error overrides previous error
+      // messages. Maybe this is surprising to users and we should make
+      // overriding errors more explicit. (see
+      // https://github.com/meteor/meteor/issues/1960)
       attempt.error = e;
       return true;
     }
     if (! ret) {
       attempt.allowed = false;
-      attempt.error = new Meteor.Error(403, "Login forbidden");
+      // don't override a specific error provided by a previous
+      // validator or the initial attempt (eg "incorrect password").
+      if (!attempt.error)
+        attempt.error = new Meteor.Error(403, "Login forbidden");
     }
     return true;
   });
@@ -302,6 +309,9 @@ Accounts._reportLoginFailure = function (methodInvocation, methodName, methodArg
 
   validateLogin(methodInvocation.connection, attempt);
   failedLogin(methodInvocation.connection, attempt);
+  // validateLogin may mutate attempt to set a new error message. Return
+  // the modified version.
+  return attempt;
 };
 
 
@@ -424,6 +434,17 @@ Meteor.methods({
   // use. Tests set Accounts._noConnectionCloseDelayForTest to delete tokens
   // immediately instead of using a delay.
   //
+  // XXX COMPAT WITH 0.7.2
+  // This single `logoutOtherClients` method has been replaced with two
+  // methods, one that you call to get a new token, and another that you
+  // call to remove all tokens except your own. The new design allows
+  // clients to know when other clients have actually been logged
+  // out. (The `logoutOtherClients` method guarantees the caller that
+  // the other clients will be logged out at some point, but makes no
+  // guarantees about when.) This method is left in for backwards
+  // compatibility, especially since application code might be calling
+  // this method directly.
+  //
   // @returns {Object} Object with token and tokenExpires keys.
   logoutOtherClients: function () {
     var self = this;
@@ -441,7 +462,7 @@ Meteor.methods({
       var tokens = user.services.resume.loginTokens;
       var newToken = Accounts._generateStampedLoginToken();
       var userId = self.userId;
-      Meteor.users.update(self.userId, {
+      Meteor.users.update(userId, {
         $set: {
           "services.resume.loginTokensToDelete": tokens,
           "services.resume.haveLoginTokensToDelete": true
@@ -462,8 +483,60 @@ Meteor.methods({
         tokenExpires: Accounts._tokenExpiration(newToken.when)
       };
     } else {
-      throw new Error("You are not logged in.");
+      throw new Meteor.Error("You are not logged in.");
     }
+  },
+
+  // Generates a new login token with the same expiration as the
+  // connection's current token and saves it to the database. Associates
+  // the connection with this new token and returns it. Throws an error
+  // if called on a connection that isn't logged in.
+  //
+  // @returns Object
+  //   If successful, returns { token: <new token>, id: <user id>,
+  //   tokenExpires: <expiration date> }.
+  getNewToken: function () {
+    var self = this;
+    var user = Meteor.users.findOne(self.userId, {
+      fields: { "services.resume.loginTokens": 1 }
+    });
+    if (! self.userId || ! user) {
+      throw new Meteor.Error("You are not logged in.");
+    }
+    // Be careful not to generate a new token that has a later
+    // expiration than the curren token. Otherwise, a bad guy with a
+    // stolen token could use this method to stop his stolen token from
+    // ever expiring.
+    var currentHashedToken = Accounts._getLoginToken(self.connection.id);
+    var currentStampedToken = _.find(
+      user.services.resume.loginTokens,
+      function (stampedToken) {
+        return stampedToken.hashedToken === currentHashedToken;
+      }
+    );
+    if (! currentStampedToken) { // safety belt: this should never happen
+      throw new Meteor.Error("Invalid login token");
+    }
+    var newStampedToken = Accounts._generateStampedLoginToken();
+    newStampedToken.when = currentStampedToken.when;
+    Accounts._insertLoginToken(self.userId, newStampedToken);
+    return loginUser(self, self.userId, newStampedToken);
+  },
+
+  // Removes all tokens except the token associated with the current
+  // connection. Throws an error if the connection is not logged
+  // in. Returns nothing on success.
+  removeOtherTokens: function () {
+    var self = this;
+    if (! self.userId) {
+      throw new Meteor.Error("You are not logged in.");
+    }
+    var currentToken = Accounts._getLoginToken(self.connection.id);
+    Meteor.users.update(self.userId, {
+      $pull: {
+        "services.resume.loginTokens": { hashedToken: { $ne: currentToken } }
+      }
+    });
   }
 });
 
@@ -753,7 +826,7 @@ Accounts.registerLoginHandler("resume", function(options) {
 // (Also used by Meteor Accounts server and tests).
 //
 Accounts._generateStampedLoginToken = function () {
-  return {token: Random.id(), when: (new Date)};
+  return {token: Random.secret(), when: (new Date)};
 };
 
 ///
@@ -815,6 +888,67 @@ maybeStopExpireTokensInterval = function () {
 expireTokenInterval = Meteor.setInterval(expireTokens,
                                          EXPIRE_TOKENS_INTERVAL_MS);
 
+
+///
+/// OAuth Encryption Support
+///
+
+var OAuthEncryption = Package["oauth-encryption"] && Package["oauth-encryption"].OAuthEncryption;
+
+
+var usingOAuthEncryption = function () {
+  return OAuthEncryption && OAuthEncryption.keyIsLoaded();
+};
+
+
+// OAuth service data is temporarily stored in the pending credentials
+// collection during the oauth authentication process.  Sensitive data
+// such as access tokens are encrypted without the user id because
+// we don't know the user id yet.  We re-encrypt these fields with the
+// user id included when storing the service data permanently in
+// the users collection.
+//
+var pinEncryptedFieldsToUser = function (serviceData, userId) {
+  _.each(_.keys(serviceData), function (key) {
+    var value = serviceData[key];
+    if (OAuthEncryption && OAuthEncryption.isSealed(value))
+      value = OAuthEncryption.seal(OAuthEncryption.open(value), userId);
+    serviceData[key] = value;
+  });
+};
+
+
+// Encrypt unencrypted login service secrets when oauth-encryption is
+// added.
+//
+// XXX For the oauthSecretKey to be available here at startup, the
+// developer must call Accounts.config({oauthSecretKey: ...}) at load
+// time, instead of in a Meteor.startup block, because the startup
+// block in the app code will run after this accounts-base startup
+// block.  Perhaps we need a post-startup callback?
+
+Meteor.startup(function () {
+  if (!usingOAuthEncryption())
+    return;
+
+  var ServiceConfiguration =
+    Package['service-configuration'].ServiceConfiguration;
+
+  ServiceConfiguration.configurations.find( {$and: [
+      { secret: {$exists: true} },
+      { "secret.algorithm": {$exists: false} }
+    ] } ).
+    forEach(function (config) {
+      ServiceConfiguration.configurations.update(
+        config._id,
+        { $set: {
+          secret: OAuthEncryption.seal(config.secret)
+        } }
+      );
+    });
+});
+
+
 ///
 /// CREATE USER HOOKS
 ///
@@ -851,6 +985,11 @@ Accounts.insertUserDoc = function (options, user) {
   // collections)
   user = _.extend({createdAt: new Date(), _id: Random.id()}, user);
 
+  if (user.services)
+    _.each(user.services, function (serviceData) {
+      pinEncryptedFieldsToUser(serviceData, user._id);
+    });
+
   var fullUser;
   if (onCreateUserHook) {
     fullUser = onCreateUserHook(options, user);
@@ -986,6 +1125,8 @@ Accounts.updateOrCreateUserFromExternalService = function(
   var user = Meteor.users.findOne(selector);
 
   if (user) {
+    pinEncryptedFieldsToUser(serviceData, user._id);
+
     // We *don't* process options (eg, profile) for update, but we do replace
     // the serviceData (eg, so that we keep an unexpired access token and
     // don't cache old email addresses in serviceData.email).
@@ -1122,6 +1263,10 @@ Meteor.methods({
       Package['service-configuration'].ServiceConfiguration;
     if (ServiceConfiguration.configurations.findOne({service: options.service}))
       throw new Meteor.Error(403, "Service " + options.service + " already configured");
+
+    if (_.has(options, "secret") && usingOAuthEncryption())
+      options.secret = OAuthEncryption.seal(options.secret);
+
     ServiceConfiguration.configurations.insert(options);
   }
 });
diff --git a/packages/accounts-base/accounts_tests.js b/packages/accounts-base/accounts_tests.js
index e3eeaecd0c..1e49fd31f2 100644
--- a/packages/accounts-base/accounts_tests.js
+++ b/packages/accounts-base/accounts_tests.js
@@ -1,3 +1,9 @@
+Meteor.methods({
+  getCurrentLoginToken: function () {
+    return Accounts._getLoginToken(this.connection.id);
+  }
+});
+
 // XXX it'd be cool to also test that the right thing happens if options
 // *are* validated, but Accounts._options is global state which makes this hard
 // (impossible?)
@@ -297,3 +303,73 @@ Tinytest.addAsync(
     );
   }
 );
+
+Tinytest.add(
+  'accounts - get new token',
+  function (test) {
+    // Test that the `getNewToken` method returns us a valid token, with
+    // the same expiration as our original token.
+    var userId = Accounts.insertUserDoc({}, { username: Random.id() });
+    var stampedToken = Accounts._generateStampedLoginToken();
+    Accounts._insertLoginToken(userId, stampedToken);
+    var conn = DDP.connect(Meteor.absoluteUrl());
+    conn.call('login', { resume: stampedToken.token });
+    test.equal(conn.call('getCurrentLoginToken'),
+               Accounts._hashLoginToken(stampedToken.token));
+
+    var newTokenResult = conn.call('getNewToken');
+    test.equal(newTokenResult.tokenExpires,
+               Accounts._tokenExpiration(stampedToken.when));
+    test.equal(conn.call('getCurrentLoginToken'),
+               Accounts._hashLoginToken(newTokenResult.token));
+    conn.disconnect();
+
+    // A second connection should be able to log in with the new token
+    // we got.
+    var secondConn = DDP.connect(Meteor.absoluteUrl());
+    secondConn.call('login', { resume: newTokenResult.token });
+    secondConn.disconnect();
+  }
+);
+
+Tinytest.addAsync(
+  'accounts - remove other tokens',
+  function (test, onComplete) {
+    // Test that the `removeOtherTokens` method removes all tokens other
+    // than the caller's token, thereby logging out and closing other
+    // connections.
+    var userId = Accounts.insertUserDoc({}, { username: Random.id() });
+    var stampedTokens = [];
+    var conns = [];
+
+    _.times(2, function (i) {
+      stampedTokens.push(Accounts._generateStampedLoginToken());
+      Accounts._insertLoginToken(userId, stampedTokens[i]);
+      var conn = DDP.connect(Meteor.absoluteUrl());
+      conn.call('login', { resume: stampedTokens[i].token });
+      test.equal(conn.call('getCurrentLoginToken'),
+                 Accounts._hashLoginToken(stampedTokens[i].token));
+      conns.push(conn);
+    });
+
+    conns[0].call('removeOtherTokens');
+    simplePoll(
+      function () {
+        var tokens = _.map(conns, function (conn) {
+          return conn.call('getCurrentLoginToken');
+        });
+        return ! tokens[1] &&
+          tokens[0] === Accounts._hashLoginToken(stampedTokens[0].token);
+      },
+      function () { // success
+        _.each(conns, function (conn) {
+          conn.disconnect();
+        });
+        onComplete();
+      },
+      function () { // timed out
+        throw new Error("accounts - remove other tokens timed out");
+      }
+    );
+  }
+);
diff --git a/packages/accounts-base/package.js b/packages/accounts-base/package.js
index 63a1486d29..47d285cf01 100644
--- a/packages/accounts-base/package.js
+++ b/packages/accounts-base/package.js
@@ -25,14 +25,16 @@ Package.on_use(function (api) {
   // we'd probably want to abstract this away
   api.use('mongo-livedata', ['client', 'server']);
 
-  // If handlebars happens to be loaded, we'll define some helpers like
+  // If the 'ui' package is loaded, we'll define some helpers like
   // {{currentUser}}.  If not, no biggie.
-  api.use('handlebars', 'client', {weak: true});
+  api.use('ui', 'client', {weak: true});
 
   // Allow us to detect 'autopublish', and publish some Meteor.users fields if
   // it's loaded.
   api.use('autopublish', 'server', {weak: true});
 
+  api.use('oauth-encryption', 'server', {weak: true});
+
   api.export('Accounts');
 
   api.add_files('accounts_common.js', ['client', 'server']);
@@ -53,5 +55,6 @@ Package.on_test(function (api) {
   api.use('tinytest');
   api.use('random');
   api.use('test-helpers');
+  api.use('oauth-encryption');
   api.add_files('accounts_tests.js', 'server');
 });
diff --git a/packages/accounts-oauth/oauth_server.js b/packages/accounts-oauth/oauth_server.js
index 7854f02516..3f722fd229 100644
--- a/packages/accounts-oauth/oauth_server.js
+++ b/packages/accounts-oauth/oauth_server.js
@@ -6,7 +6,9 @@ Accounts.registerLoginHandler(function (options) {
 
   check(options.oauth, {credentialToken: String});
 
-  if (!Oauth.hasCredential(options.oauth.credentialToken)) {
+  var result = OAuth.retrieveCredential(options.oauth.credentialToken);
+
+  if (!result) {
     // OAuth credentialToken is not recognized, which could be either
     // because the popup was closed by the user before completion, or
     // some sort of error where the oauth provider didn't talk to our
@@ -26,7 +28,7 @@ Accounts.registerLoginHandler(function (options) {
                Accounts.LoginCancelledError.numericError,
                "No matching login attempt found") };
   }
-  var result = Oauth.retrieveCredential(options.oauth.credentialToken);
+
   if (result instanceof Error)
     // We tried to login, but there was a fatal error. Report it back
     // to the user.
diff --git a/packages/accounts-password/password_server.js b/packages/accounts-password/password_server.js
index 8f4b8dd862..a758da4a1c 100644
--- a/packages/accounts-password/password_server.js
+++ b/packages/accounts-password/password_server.js
@@ -73,12 +73,13 @@ Meteor.methods({beginPasswordExchange: function (request) {
     // the second step method ('login') is called. If a user calls
     // 'beginPasswordExchange' but then never calls the second step
     // 'login' method, no login hook will fire.
-    Accounts._reportLoginFailure(self, 'beginPasswordExchange', arguments, {
+    // The validate login hooks can mutate the exception to be thrown.
+    var attempt = Accounts._reportLoginFailure(self, 'beginPasswordExchange', arguments, {
       type: 'password',
       error: err,
       userId: user && user._id
     });
-    throw err;
+    throw attempt.error;
   }
 
   // Save results so we can verify them later.
@@ -263,7 +264,7 @@ Accounts.sendResetPasswordEmail = function (userId, email) {
   if (!email || !_.contains(_.pluck(user.emails || [], 'address'), email))
     throw new Error("No such email for user.");
 
-  var token = Random.id();
+  var token = Random.secret();
   var when = new Date();
   Meteor.users.update(userId, {$set: {
     "services.password.reset": {
@@ -312,7 +313,7 @@ Accounts.sendEnrollmentEmail = function (userId, email) {
     throw new Error("No such email for user.");
 
 
-  var token = Random.id();
+  var token = Random.secret();
   var when = new Date();
   Meteor.users.update(userId, {$set: {
     "services.password.reset": {
@@ -435,7 +436,7 @@ Accounts.sendVerificationEmail = function (userId, address) {
 
 
   var tokenRecord = {
-    token: Random.id(),
+    token: Random.secret(),
     address: address,
     when: new Date()};
   Meteor.users.update(
diff --git a/packages/accounts-password/password_tests.js b/packages/accounts-password/password_tests.js
index 614862502c..bd1ce9a6d1 100644
--- a/packages/accounts-password/password_tests.js
+++ b/packages/accounts-password/password_tests.js
@@ -33,7 +33,12 @@ if (Meteor.isClient) (function () {
     }, 10 * 1000, 100);
   };
   var invalidateLoginsStep = function (test, expect) {
-    Meteor.call("testInvalidateLogins", true, expect(function (error) {
+    Meteor.call("testInvalidateLogins", 'fail', expect(function (error) {
+      test.isFalse(error);
+    }));
+  };
+  var hideActualLoginErrorStep = function (test, expect) {
+    Meteor.call("testInvalidateLogins", 'hide', expect(function (error) {
       test.isFalse(error);
     }));
   };
@@ -468,13 +473,59 @@ if (Meteor.isClient) (function () {
         test.equal(Meteor.userId(), null);
       }));
     },
+    logoutStep,
+    function (test, expect) {
+      var self = this;
+      // Test that Meteor.logoutOtherClients logs out a second
+      // authentcated connection while leaving Accounts.connection
+      // logged in.
+      var secondConn = DDP.connect(Meteor.absoluteUrl());
+      var token;
+
+      var expectSecondConnLoggedOut = expect(function (err, result) {
+        test.isTrue(err);
+      });
+
+      var expectAccountsConnLoggedIn = expect(function (err, result) {
+        test.isFalse(err);
+      });
+
+      var expectSecondConnLoggedIn = expect(function (err, result) {
+        test.equal(result.token, token);
+        test.isFalse(err);
+        Meteor.logoutOtherClients(function (err) {
+          test.isFalse(err);
+          secondConn.call('login', { resume: token },
+                          expectSecondConnLoggedOut);
+          Accounts.connection.call('login', {
+            resume: Accounts._storedLoginToken()
+          }, expectAccountsConnLoggedIn);
+        });
+      });
+
+      Meteor.loginWithPassword(
+        self.username,
+        self.password,
+        expect(function (err) {
+          test.isFalse(err);
+          token = Accounts._storedLoginToken();
+          test.isTrue(token);
+          secondConn.call('login', { resume: token },
+                          expectSecondConnLoggedIn);
+        })
+      );
+    },
+    logoutStep,
+
+    // The tests below this point are for the deprecated
+    // `logoutOtherClients` method.
+
     function (test, expect) {
       var self = this;
 
       // Test that Meteor.logoutOtherClients logs out a second authenticated
       // connection while leaving Accounts.connection logged in.
       var token;
-      var userId;
       self.secondConn = DDP.connect(Meteor.absoluteUrl());
 
       var expectLoginError = expect(function (err) {
@@ -502,7 +553,6 @@ if (Meteor.isClient) (function () {
         token = Accounts._storedLoginToken();
         self.beforeLogoutOthersToken = token;
         test.isTrue(token);
-        userId = Meteor.userId();
         self.secondConn.call("login", { resume: token },
                              expectSecondConnLoggedIn);
       }));
@@ -536,41 +586,9 @@ if (Meteor.isClient) (function () {
       );
     },
     logoutStep,
-    function (test, expect) {
-      var self = this;
-      // Test that, when we call logoutOtherClients, if the server disconnects
-      // us before the logoutOtherClients callback runs, then we still end up
-      // logged in.
-      var expectServerLoggedIn = expect(function (err, result) {
-        test.isFalse(err);
-        test.isTrue(Meteor.userId());
-        test.equal(result, Meteor.userId());
-      });
 
-      Meteor.loginWithPassword(
-        self.username,
-        self.password,
-        expect(function (err) {
-          test.isFalse(err);
-          test.isTrue(Meteor.userId());
 
-          // The test is only useful if things interleave in the following order:
-          // - logoutOtherClients runs on the server
-          // - onReconnect fires and sends a login method with the old token,
-          //   which results in an error
-          // - logoutOtherClients callback runs and stores the new token and
-          //   logs in with it
-          // In practice they seem to interleave this way, but I'm not sure how
-          // to make sure that they do.
 
-          Meteor.logoutOtherClients(function (err) {
-            test.isFalse(err);
-            Meteor.call("getUserId", expectServerLoggedIn);
-          });
-        })
-      );
-    },
-    logoutStep,
     function (test, expect) {
       var self = this;
       // Test that deleting a user logs out that user's connections.
@@ -603,6 +621,28 @@ if (Meteor.isClient) (function () {
         })
       );
     },
+    validateLoginsStep,
+    function (test, expect) {
+      Meteor.loginWithPassword(
+        "no such user",
+        "some password",
+        expect(function (error) {
+          test.isTrue(error);
+          test.equal(error.reason, 'User not found');
+        })
+      );
+    },
+    hideActualLoginErrorStep,
+    function (test, expect) {
+      Meteor.loginWithPassword(
+        "no such user",
+        "some password",
+        expect(function (error) {
+          test.isTrue(error);
+          test.equal(error.reason, 'hide actual error');
+        })
+      );
+    },
     validateLoginsStep
   ]);
 
diff --git a/packages/accounts-password/password_tests_setup.js b/packages/accounts-password/password_tests_setup.js
index 8f420321f1..e9d110c936 100644
--- a/packages/accounts-password/password_tests_setup.js
+++ b/packages/accounts-password/password_tests_setup.js
@@ -15,14 +15,14 @@ Accounts.onCreateUser(function (options, user) {
 });
 
 
-// connection id -> true
+// connection id -> action
 var invalidateLogins = {};
 
 
 Meteor.methods({
-  testInvalidateLogins: function (flag) {
-    if (flag)
-      invalidateLogins[this.connection.id] = true;
+  testInvalidateLogins: function (action) {
+    if (action)
+      invalidateLogins[this.connection.id] = action;
     else
       delete invalidateLogins[this.connection.id];
   }
@@ -30,9 +30,19 @@ Meteor.methods({
 
 
 Accounts.validateLoginAttempt(function (attempt) {
-  return ! (attempt &&
-            attempt.connection &&
-            invalidateLogins[attempt.connection.id]);
+  var action =
+    attempt &&
+    attempt.connection &&
+    invalidateLogins[attempt.connection.id];
+
+  if (! action)
+    return true;
+  else if (action === 'fail')
+    return false;
+  else if (action === 'hide')
+    throw new Meteor.Error(403, 'hide actual error');
+  else
+    throw new Error('unknown action: ' + action);
 });
 
 
diff --git a/packages/accounts-ui-unstyled/login_buttons.html b/packages/accounts-ui-unstyled/login_buttons.html
index 08d2dd3a46..f5ec6afb55 100644
--- a/packages/accounts-ui-unstyled/login_buttons.html
+++ b/packages/accounts-ui-unstyled/login_buttons.html
@@ -1,10 +1,4 @@
-<!--
-    NOTE: You shouldn't use these templates directly. Instead, use the global
-    {{loginButtons}} template. For positioning on the right side of your app,
-    try {{loginButtons align="right"}}
-  -->
-
-<template name="_loginButtons">
+<template name="loginButtons">
   <div id="login-buttons" class="login-buttons-dropdown-align-{{align}}">
     {{#if currentUser}}
       {{#if loggingIn}}
@@ -86,6 +80,6 @@
     </div>
   {{else}}
     {{! just add some padding }}
-    <div class="login-buttons-padding" />
+    <div class="login-buttons-padding"></div>
   {{/unless}}
 </template>
diff --git a/packages/accounts-ui-unstyled/login_buttons.js b/packages/accounts-ui-unstyled/login_buttons.js
index d173faaeb1..9f11b5e0fe 100644
--- a/packages/accounts-ui-unstyled/login_buttons.js
+++ b/packages/accounts-ui-unstyled/login_buttons.js
@@ -1,17 +1,8 @@
 // for convenience
 var loginButtonsSession = Accounts._loginButtonsSession;
 
-Handlebars.registerHelper(
-  "loginButtons",
-  function (options) {
-    if (options.hash.align === "right")
-      return new Handlebars.SafeString(Template._loginButtons({align: "right"}));
-    else
-      return new Handlebars.SafeString(Template._loginButtons({align: "left"}));
-  });
-
 // shared between dropdown and single mode
-Template._loginButtons.events({
+Template.loginButtons.events({
   'click #login-buttons-logout': function() {
     Meteor.logout(function () {
       loginButtonsSession.closeDropdown();
@@ -19,8 +10,8 @@ Template._loginButtons.events({
   }
 });
 
-Template._loginButtons.preserve({
-  'input[id]': Spark._labelFromIdOrName
+UI.registerHelper('loginButtons', function () {
+  throw new Error("Use {{> loginButtons}} instead of {{loginButtons}}");
 });
 
 //
diff --git a/packages/accounts-ui-unstyled/login_buttons_dialogs.html b/packages/accounts-ui-unstyled/login_buttons_dialogs.html
index 8f04552269..f7ebdbffe6 100644
--- a/packages/accounts-ui-unstyled/login_buttons_dialogs.html
+++ b/packages/accounts-ui-unstyled/login_buttons_dialogs.html
@@ -68,7 +68,7 @@
 <template name="_configureLoginServiceDialog">
   {{#if visible}}
     <div id="configure-login-service-dialog" class="accounts-dialog accounts-centered-dialog">
-      {{{configurationSteps}}}
+      {{> configurationSteps}}
 
       <p>
         Now, copy over some details.
@@ -97,12 +97,10 @@
         </div>
         <a class="accounts-close configure-login-service-dismiss-button">&times;</a>
 
-        {{#isolate}}
-          <div class="login-button login-button-configure {{#if saveDisabled}}login-button-disabled{{/if}}"
+        <div class="login-button login-button-configure {{#if saveDisabled}}login-button-disabled{{/if}}"
              id="configure-login-service-dialog-save-configuration">
-            Save Configuration
-          </div>
-        {{/isolate}}
+          Save Configuration
+        </div>
       </div>
     </div>
   {{/if}}
diff --git a/packages/accounts-ui-unstyled/login_buttons_dialogs.js b/packages/accounts-ui-unstyled/login_buttons_dialogs.js
index 1ebb51c11a..cea8e9947d 100644
--- a/packages/accounts-ui-unstyled/login_buttons_dialogs.js
+++ b/packages/accounts-ui-unstyled/login_buttons_dialogs.js
@@ -231,7 +231,7 @@ Template._configureLoginServiceDialog.visible = function () {
 
 Template._configureLoginServiceDialog.configurationSteps = function () {
   // renders the appropriate template
-  return configureLoginServiceDialogTemplateForService()();
+  return configureLoginServiceDialogTemplateForService();
 };
 
 Template._configureLoginServiceDialog.saveDisabled = function () {
diff --git a/packages/accounts-ui-unstyled/login_buttons_dropdown.js b/packages/accounts-ui-unstyled/login_buttons_dropdown.js
index 5327dd055d..6c485ba99a 100644
--- a/packages/accounts-ui-unstyled/login_buttons_dropdown.js
+++ b/packages/accounts-ui-unstyled/login_buttons_dropdown.js
@@ -3,7 +3,7 @@ var loginButtonsSession = Accounts._loginButtonsSession;
 
 // events shared between loginButtonsLoggedOutDropdown and
 // loginButtonsLoggedInDropdown
-Template._loginButtons.events({
+Template.loginButtons.events({
   'click #login-name-link, click #login-sign-in-link': function () {
     loginButtonsSession.set('dropdownVisible', true);
     Deps.flush();
@@ -94,7 +94,9 @@ Template._loginButtonsLoggedOutDropdown.events({
         document.getElementById('login-username').value = usernameOrEmail;
     else
       document.getElementById('login-email').value = usernameOrEmail;
-    // "login-password" is preserved, since password fields aren't updated by Spark.
+
+    if (password !== null)
+      document.getElementById('login-password').value = password;
 
     // Force redrawing the `login-dropdown-list` element because of
     // a bizarre Chrome bug in which part of the DIV is not redrawn
@@ -134,6 +136,8 @@ Template._loginButtonsLoggedOutDropdown.events({
     var username = trimmedElementValueById('login-username');
     var email = trimmedElementValueById('login-email')
           || trimmedElementValueById('forgot-password-email'); // Ughh. Standardize on names?
+    // notably not trimmed. a password could (?) start or end with a space
+    var password = elementValueById('login-password');
 
     loginButtonsSession.set('inSignupFlow', false);
     loginButtonsSession.set('inForgotPasswordFlow', false);
@@ -144,9 +148,12 @@ Template._loginButtonsLoggedOutDropdown.events({
       document.getElementById('login-username').value = username;
     if (document.getElementById('login-email'))
       document.getElementById('login-email').value = email;
-    // "login-password" is preserved, since password fields aren't updated by Spark.
+
     if (document.getElementById('login-username-or-email'))
       document.getElementById('login-username-or-email').value = email || username;
+
+    if (password !== null)
+      document.getElementById('login-password').value = password;
   },
   'keypress #login-username, keypress #login-email, keypress #login-username-or-email, keypress #login-password, keypress #login-password-again': function (event) {
     if (event.keyCode === 13)
diff --git a/packages/accounts-ui-unstyled/package.js b/packages/accounts-ui-unstyled/package.js
index e01a709d07..4d47169183 100644
--- a/packages/accounts-ui-unstyled/package.js
+++ b/packages/accounts-ui-unstyled/package.js
@@ -7,8 +7,7 @@ Package.describe({
 
 Package.on_use(function (api) {
   api.use(['deps', 'service-configuration', 'accounts-base',
-           'underscore', 'templating',
-           'handlebars', 'spark', 'session'], 'client');
+           'underscore', 'templating', 'session'], 'client');
   // Export Accounts (etc) to packages using this one.
   api.imply('accounts-base', ['client', 'server']);
 
diff --git a/packages/appcache/appcache-server.js b/packages/appcache/appcache-server.js
index ce579583d2..3d4bec1c4c 100644
--- a/packages/appcache/appcache-server.js
+++ b/packages/appcache/appcache-server.js
@@ -57,7 +57,7 @@ var browserEnabled = function(request) {
 
 WebApp.addHtmlAttributeHook(function (request) {
   if (browserEnabled(request))
-    return 'manifest="/app.manifest"';
+    return { manifest: "/app.manifest" };
   else
     return null;
 });
diff --git a/packages/deps/deps.js b/packages/deps/deps.js
index 72d318e5fb..d05ad80052 100644
--- a/packages/deps/deps.js
+++ b/packages/deps/deps.js
@@ -15,10 +15,23 @@ var setCurrentComputation = function (c) {
   Deps.active = !! c;
 };
 
+// _assign is like _.extend or the upcoming Object.assign.
+// Copy src's own, enumerable properties onto tgt and return
+// tgt.
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+var _assign = function (tgt, src) {
+  for (var k in src) {
+    if (_hasOwnProperty.call(src, k))
+      tgt[k] = src[k];
+  }
+  return tgt;
+};
+
 var _debugFunc = function () {
   // lazy evaluation because `Meteor` does not exist right away
   return (typeof Meteor !== "undefined" ? Meteor._debug :
-          ((typeof console !== "undefined") && console.log ? console.log :
+          ((typeof console !== "undefined") && console.log ?
+           function () { console.log.apply(console, arguments); } :
            function () {}));
 };
 
@@ -31,6 +44,20 @@ var _throwOrLog = function (from, e) {
   }
 };
 
+// Like `Meteor._noYieldsAllowed(function () { f(comp); })` but shorter,
+// and doesn't clutter the stack with an extra frame on the client,
+// where `_noYieldsAllowed` is a no-op.  `f` may be a computation
+// function or an onInvalidate callback.
+var callWithNoYieldsAllowed = function (f, comp) {
+  if ((typeof Meteor === 'undefined') || Meteor.isClient) {
+    f(comp);
+  } else {
+    Meteor._noYieldsAllowed(function () {
+      f(comp);
+    });
+  }
+};
+
 var nextId = 1;
 // computations whose callbacks we should call at flush time
 var pendingComputations = [];
@@ -46,7 +73,7 @@ var inCompute = false;
 // `true` if the `_throwFirstError` option was passed in to the call
 // to Deps.flush that we are in. When set, throw rather than log the
 // first error encountered while flushing. Before throwing the error,
-// finish flushing (from a catch block), logging any subsequent
+// finish flushing (from a finally block), logging any subsequent
 // errors.
 var throwFirstError = false;
 
@@ -102,7 +129,7 @@ Deps.Computation = function (f, parent) {
   }
 };
 
-_.extend(Deps.Computation.prototype, {
+_assign(Deps.Computation.prototype, {
 
   // http://docs.meteor.com/#computation_oninvalidate
   onInvalidate: function (f) {
@@ -111,18 +138,13 @@ _.extend(Deps.Computation.prototype, {
     if (typeof f !== 'function')
       throw new Error("onInvalidate requires a function");
 
-    var g = function () {
+    if (self.invalidated) {
       Deps.nonreactive(function () {
-        return Meteor._noYieldsAllowed(function () {
-          f(self);
-        });
+        callWithNoYieldsAllowed(f, self);
       });
-    };
-
-    if (self.invalidated)
-      g();
-    else
-      self._onInvalidateCallbacks.push(g);
+    } else {
+      self._onInvalidateCallbacks.push(f);
+    }
   },
 
   // http://docs.meteor.com/#computation_invalidate
@@ -140,8 +162,11 @@ _.extend(Deps.Computation.prototype, {
 
       // callbacks can't add callbacks, because
       // self.invalidated === true.
-      for(var i = 0, f; f = self._onInvalidateCallbacks[i]; i++)
-        f(); // already bound with self as argument
+      for(var i = 0, f; f = self._onInvalidateCallbacks[i]; i++) {
+        Deps.nonreactive(function () {
+          callWithNoYieldsAllowed(f, self);
+        });
+      }
       self._onInvalidateCallbacks = [];
     }
   },
@@ -163,7 +188,7 @@ _.extend(Deps.Computation.prototype, {
     var previousInCompute = inCompute;
     inCompute = true;
     try {
-      self._func(self);
+      callWithNoYieldsAllowed(self._func, self);
     } finally {
       setCurrentComputation(previous);
       inCompute = false;
@@ -201,7 +226,7 @@ Deps.Dependency = function () {
   this._dependentsById = {};
 };
 
-_.extend(Deps.Dependency.prototype, {
+_assign(Deps.Dependency.prototype, {
   // http://docs.meteor.com/#dependency_depend
   //
   // Adds `computation` to this set if it is not already
@@ -243,9 +268,12 @@ _.extend(Deps.Dependency.prototype, {
   }
 });
 
-_.extend(Deps, {
+_assign(Deps, {
   // http://docs.meteor.com/#deps_flush
   flush: function (_opts) {
+    // XXX What part of the comment below is still true? (We no longer
+    // have Spark)
+    //
     // Nested flush could plausibly happen if, say, a flush causes
     // DOM mutation, which causes a "blur" event, which runs an
     // app event handler that calls Deps.flush.  At the moment
@@ -264,6 +292,7 @@ _.extend(Deps, {
     willFlush = true;
     throwFirstError = !! (_opts && _opts._throwFirstError);
 
+    var finishedTry = false;
     try {
       while (pendingComputations.length ||
              afterFlushCallbacks.length) {
@@ -285,11 +314,13 @@ _.extend(Deps, {
           }
         }
       }
-    } catch (e) {
-      inFlush = false; // needed before calling `Deps.flush()` again
-      Deps.flush({_throwFirstError: false}); // finish flushing
-      throw e;
+      finishedTry = true;
     } finally {
+      if (! finishedTry) {
+        // we're erroring
+        inFlush = false; // needed before calling `Deps.flush()` again
+        Deps.flush({_throwFirstError: false}); // finish flushing
+      }
       willFlush = false;
       inFlush = false;
     }
@@ -309,9 +340,7 @@ _.extend(Deps, {
       throw new Error('Deps.autorun requires a function argument');
 
     constructingComputation = true;
-    var c = new Deps.Computation(function (c) {
-      Meteor._noYieldsAllowed(function () { f(c); });
-    }, Deps.currentComputation);
+    var c = new Deps.Computation(f, Deps.currentComputation);
 
     if (Deps.active)
       Deps.onInvalidate(function () {
diff --git a/packages/domutils/domutils.js b/packages/domutils/domutils.js
deleted file mode 100644
index 118fb91e2b..0000000000
--- a/packages/domutils/domutils.js
+++ /dev/null
@@ -1,554 +0,0 @@
-DomUtils = {};
-
-var qsaFindAllBySelector = function (selector, contextNode) {
-  // If IE7 users report the following error message, you
-  // can fix it with "meteor add jquery".
-  if (! document.querySelectorAll)
-    throw new Error("This browser doesn't support querySelectorAll.");
-
-  // the search is constrained to descendants of `ancestor`,
-  // but it doesn't affect the scope of the query.
-  var ancestor = contextNode;
-
-  return withElementId(
-    contextNode, "DomUtils_findAllBySelector_scope",
-    function (idSelector) {
-      // scope the entire selector to contextNode by prepending
-      // id of contextNode to the selector.
-      var doctoredSelector = _.map(selector.split(','), function (selec) {
-        return idSelector + " " + selec;
-      }).join(',');
-      return ancestor.querySelectorAll(doctoredSelector);
-    });
-};
-
-// We have our own, querySelectorAll-based implementation of scoped
-// selector matching; it's all you need in IE 8+ and modern browsers.
-//
-// However, we use Sizzle or jQuery if it's present on the client because of:
-// - apps that want jQuery's selector extensions (:visible, :input, etc.)
-// - apps that include jQuery anyway
-// - apps that want IE 7 support
-//
-// XXX others? zepto?
-var findAllBySelector = (window.Sizzle
-                         || (window.jQuery && window.jQuery.find)
-                         || qsaFindAllBySelector);
-
-///// Common look-up tables used by htmlToFragment et al.
-
-var testDiv = document.createElement("div");
-testDiv.innerHTML = "   <link/><table></table><select><!----></select>";
-// Need to wrap in a div rather than directly creating SELECT to avoid
-// *another* IE bug.
-var testSelectDiv = document.createElement("div");
-testSelectDiv.innerHTML = "<select><option selected>Foo</option></select>";
-testSelectDiv.firstChild.setAttribute("name", "myname");
-
-// Tests that, if true, indicate browser quirks present.
-var quirks = {
-  // IE loses initial whitespace when setting innerHTML.
-  leadingWhitespaceKilled: (testDiv.firstChild.nodeType !== 3),
-
-  // IE may insert an empty tbody tag in a table.
-  tbodyInsertion: testDiv.getElementsByTagName("tbody").length > 0,
-
-  // IE loses some tags in some environments (requiring extra wrapper).
-  tagsLost: testDiv.getElementsByTagName("link").length === 0,
-
-  // IE <= 9 loses HTML comments in <select> and <option> tags.
-  commentsLost: (! testDiv.getElementsByTagName("select")[0].firstChild),
-
-  selectValueMustBeFromAttribute: (testSelectDiv.firstChild.value !== "Foo"),
-
-  // In IE7, setAttribute('name', foo) doesn't show up in rendered HTML.
-  // (In FF3, outerHTML is undefined, but it doesn't have this quirk.)
-  mustSetNameInCreateElement: (
-    testSelectDiv.firstChild.outerHTML &&
-      testSelectDiv.firstChild.outerHTML.indexOf("myname") === -1)
-};
-
-// Set up map of wrappers for different nodes.
-var wrapMap = {
-  option: [ 1, "<select multiple='multiple'>", "</select>" ],
-  legend: [ 1, "<fieldset>", "</fieldset>" ],
-  thead: [ 1, "<table>", "</table>" ],
-  tr: [ 2, "<table><tbody>", "</tbody></table>" ],
-  td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
-  col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
-  area: [ 1, "<map>", "</map>" ],
-  _default: [ 0, "", "" ]
-};
-_.extend(wrapMap, {
-  optgroup: wrapMap.option,
-  tbody: wrapMap.thead,
-  tfoot: wrapMap.thead,
-  colgroup: wrapMap.thead,
-  caption: wrapMap.thead,
-  th: wrapMap.td
-});
-if (quirks.tagsLost) {
-  // trick from jquery.  initial text is ignored when we take lastChild.
-  wrapMap._default = [ 1, "div<div>", "</div>" ];
-}
-
-var rleadingWhitespace = /^\s+/,
-    rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
-    rtagName = /<([\w:]+)/,
-    rtbody = /<tbody/i,
-    rhtml = /<|&#?\w+;/,
-    rnoInnerhtml = /<(?:script|style)/i;
-
-
-// Parse an HTML string, which may contain multiple top-level tags,
-// and return a DocumentFragment.
-DomUtils.htmlToFragment = function (html) {
-  var doc = document; // node factory
-  var frag = doc.createDocumentFragment();
-
-  if (! html.length) {
-    // empty, do nothing
-  } else if (! rhtml.test(html)) {
-    // Just text.
-    frag.appendChild(doc.createTextNode(html));
-  } else {
-    // General case.
-    // Replace self-closing tags
-    html = html.replace(rxhtmlTag, "<$1></$2>");
-    // Use first tag to determine wrapping needed.
-    var firstTagMatch = rtagName.exec(html);
-    var firstTag = (firstTagMatch ? firstTagMatch[1].toLowerCase() : "");
-    var wrapData = wrapMap[firstTag] || wrapMap._default;
-    var fullHtml = wrapData[1] + html + wrapData[2];
-    if (quirks.commentsLost) {
-      // rewrite <select> and <option> tags into fake tags
-      fullHtml = fullHtml.replace(/<\s*(select|option)\b/ig,
-                                  '<ins domutilsrealtagname="$1"');
-      fullHtml = fullHtml.replace(/<\/\s*(select|option)\b/ig,
-                                  '</ins');
-    }
-
-    var container = doc.createElement("div");
-    // insert wrapped HTML into a DIV
-    container.innerHTML = fullHtml;
-    // set "container" to inner node of wrapper
-    var unwraps = wrapData[0];
-    while (unwraps--) {
-      container = container.lastChild;
-    }
-
-    if (quirks.tbodyInsertion && ! rtbody.test(html)) {
-      // Any tbody we find was created by the browser.
-      var tbodies = container.getElementsByTagName("tbody");
-      _.each(tbodies, function (n) {
-        if (! n.firstChild) {
-          // spurious empty tbody
-          n.parentNode.removeChild(n);
-        }
-      });
-    }
-
-    if (quirks.leadingWhitespaceKilled) {
-      var wsMatch = rleadingWhitespace.exec(html);
-      if (wsMatch) {
-        container.insertBefore(doc.createTextNode(wsMatch[0]),
-                               container.firstChild);
-      }
-    }
-
-    if (quirks.commentsLost) {
-      // replace fake select tags with real <select> tags
-      var fakeTags = [];
-      // getElementsByTagName returns a "live" collection, so avoid
-      // factorings of this code that iterate over it while mutating
-      // the DOM.
-      // Here we build an array of fake tags and iterate over that.
-      _.each(container.getElementsByTagName("ins"), function (ins) {
-        if (ins.getAttribute("domutilsrealtagname")) {
-          fakeTags.push(ins);
-        }
-      });
-
-      _.each(fakeTags, function (fakeTag) {
-        var tagName = fakeTag.getAttribute('domutilsrealtagname');
-        if (quirks.mustSetNameInCreateElement &&
-            fakeTag.getAttribute('name')) {
-          // IE7 can't set 'name' with setAttribute, but it has this
-          // crazy syntax for setting it at create time.
-          // http://webbugtrack.blogspot.com/2007/10/bug-235-createelement-is-broken-in-ie.html
-          // http://msdn.microsoft.com/en-us/library/ms536389.aspx
-          tagName = "<" + tagName + " name='" +
-            _.escape(fakeTag.getAttribute('name')) + "'/>";
-        }
-        var realTag = document.createElement(tagName);
-        fakeTag.removeAttribute('domutilsrealtagname');
-        // copy all attributes. for some reason mergeAttributes doesn't work
-        // here: eg, it doesn't copy SELECTED or VALUE. (Probably because
-        // these attributes would be expando on INS?)
-        var fakeAttrs = fakeTag.attributes;
-        for (var i = 0; i < fakeAttrs.length; ++i) {
-          var fakeAttr = fakeAttrs.item(i);
-          if (fakeAttr.specified) {
-            var name = fakeAttr.name.toLowerCase();
-            var value = String(fakeAttr.value);
-            // IE7 gets confused if you try to setAttribute('selected', ''),
-            // so be a little more explicit.
-            if (name === 'selected' && value === '')
-              value = 'selected';
-            realTag.setAttribute(name, value);
-          }
-        }
-
-        // move all children
-        while (fakeTag.firstChild)
-          realTag.appendChild(fakeTag.firstChild);
-        // replace
-        fakeTag.parentNode.replaceChild(realTag, fakeTag);
-      });
-    }
-
-    // Reparent children of container to frag.
-    while (container.firstChild)
-      frag.appendChild(container.firstChild);
-  }
-
-  return frag;
-};
-
-// Return an HTML string representing the contents of frag,
-// a DocumentFragment.  (This is what innerHTML would do if
-// it were defined on DocumentFragments.)
-DomUtils.fragmentToHtml = function (frag) {
-  frag = frag.cloneNode(true); // deep copy, don't touch original!
-
-  return DomUtils.fragmentToContainer(frag).innerHTML;
-};
-
-// Given a DocumentFragment, return a node whose children are the
-// reparented contents of the DocumentFragment.  In most cases this
-// is as simple as creating a DIV, but in the case of a fragment
-// containing TRs, for example, it's necessary to create a TABLE and
-// a TBODY and return the TBODY.
-DomUtils.fragmentToContainer = function (frag) {
-  var doc = document; // node factory
-
-  var firstElement = frag.firstChild;
-  while (firstElement && firstElement.nodeType !== 1) {
-    firstElement = firstElement.nextSibling;
-  }
-
-  var container = doc.createElement("div");
-
-  if (! firstElement) {
-    // no tags!
-    container.appendChild(frag);
-  } else {
-    var firstTag = firstElement.nodeName;
-    var wrapData = wrapMap[firstTag] || wrapMap._default;
-
-    container.innerHTML = wrapData[1] + wrapData[2];
-    var unwraps = wrapData[0];
-    while (unwraps--) {
-      container = container.lastChild;
-    }
-
-    container.appendChild(frag);
-  }
-
-  return container;
-};
-
-// Returns true if element a contains node b and is not node b.
-DomUtils.elementContains = function (a, b) {
-  if (a.nodeType !== 1) /* ELEMENT */
-    return false;
-  if (a === b)
-    return false;
-
-  if (a.compareDocumentPosition) {
-    return a.compareDocumentPosition(b) & 0x10;
-  } else {
-    // Should be only old IE and maybe other old browsers here.
-    // Modern Safari has both functions but seems to get contains() wrong.
-    // IE can't handle b being a text node.  We work around this
-    // by doing a direct parent test now.
-    b = b.parentNode;
-    if (! (b && b.nodeType === 1)) /* ELEMENT */
-      return false;
-    if (a === b)
-      return true;
-
-    return a.contains(b);
-  }
-};
-
-// Returns an array containing the children of contextNode that
-// match `selector`. Unlike querySelectorAll, `selector` is
-// interpreted as if the document were rooted at `contextNode` --
-// the only nodes that can be used to match components of the
-// selector are the descendents of `contextNode`. `contextNode`
-// itself is not included (it can't be used to match a component of
-// the selector, and it can never be included in the returned
-// array.)
-//
-// `contextNode` may be either a node, a document, or a DocumentFragment.
-DomUtils.findAll = function (contextNode, selector) {
-  if (contextNode.nodeType === 11 /* DocumentFragment */) {
-    // contextNode is a DocumentFragment.
-    //
-    // We don't expect to be able to run selectors on a DocumentFragment
-    // (Sizzle won't work) but we can on a normal elements that aren't
-    // in the document.  Fortunately we can manipulate offscreen nodes
-    // as much as we want as long as we put them back the way they were
-    // when we're done.
-    var frag = contextNode;
-    var container = DomUtils.fragmentToContainer(frag);
-    var results = findAllBySelector(selector, container);
-    // put nodes back into frag
-    while (container.firstChild)
-      frag.appendChild(container.firstChild);
-    return results;
-  }
-
-  return findAllBySelector(selector, contextNode);
-};
-
-// Like `findAll` but finds one element (or returns null).
-DomUtils.find = function (contextNode, selector) {
-  var results = DomUtils.findAll(contextNode, selector);
-  return (results.length ? results[0] : null);
-};
-
-var isElementInClipRange = function (elem, clipStart, clipEnd) {
-  // elem is not in clip range if it contains the clip range
-  if (DomUtils.elementContains(elem, clipStart))
-    return false;
-  // elem is in clip range if clipStart <= elem <= clipEnd
-  return (DomUtils.compareElementIndex(clipStart, elem) <= 0) &&
-    (DomUtils.compareElementIndex(elem, clipEnd) <= 0);
-};
-
-// Like `findAll` but searches the nodes from `start` to `end`
-// inclusive. `start` and `end` must be siblings, and they participate
-// in the search (they can be used to match selector components, and
-// they can appear in the returned results). It's as if the parent of
-// `start` and `end` serves as contextNode, but matches from children
-// that aren't between `start` and `end` (inclusive) are ignored.
-//
-// If `selector` involves sibling selectors, child index selectors, or
-// the like, the results are undefined.
-//
-// precond: clipStart/clipEnd are descendents of contextNode
-// XXX document
-DomUtils.findAllClipped = function (contextNode, selector, clipStart, clipEnd) {
-
-  // Ensure the clip range starts and ends on element nodes.  This is possible
-  // to do without changing the result set because non-element nodes can't
-  // be or contain matches.
-  while (clipStart !== clipEnd && clipStart.nodeType !== 1)
-    clipStart = clipStart.nextSibling;
-  while (clipStart !== clipEnd && clipEnd.nodeType !== 1)
-    clipEnd = clipEnd.previousSibling;
-  if (clipStart.nodeType !== 1)
-    return []; // no top-level elements!  start === end and it's not an element
-
-  // resultsPlus includes matches all matches descended from contextNode,
-  // including those that aren't in the clip range.
-  var resultsPlus = DomUtils.findAll(contextNode, selector);
-
-  // Filter the list of nodes to remove nodes that occur before start
-  // or after end.
-  return _.reject(resultsPlus, function (n) {
-    return ! isElementInClipRange(n, clipStart, clipEnd);
-  });
-};
-
-// Like `findAllClipped` but finds one element (or returns null).
-DomUtils.findClipped = function (contextNode, selector, clipStart, clipEnd) {
-  var results = DomUtils.findAllClipped(
-    contextNode, selector, clipStart, clipEnd);
-  return (results.length ? results[0] : null);
-};
-
-// Executes `func` while ensuring that `element` has an ID.  If `element`
-// doesn't have an ID, it is assigned `magicId` temporarily.
-// Calls func with a selector of the form "[id='...']" as an argument.
-var withElementId = function (element, magicId, func) {
-  var didSetId = false;
-  if (! element.getAttribute('id')) {
-    element.setAttribute('id', magicId);
-    didSetId = true;
-  }
-  try {
-    var escapedNodeId = element.getAttribute('id').replace(/'/g, "\\$&");
-    return func("[id='" + escapedNodeId + "']");
-  } finally {
-    if (didSetId)
-      element.removeAttribute('id');
-  }
-};
-
-var matchesSelectorMaybeClipped = function (element, contextNode, selector,
-                                           clipStart, clipEnd) {
-  var selecs = selector.split(',');
-  for(var i = 0, N = selecs.length; i < N; i++) {
-    var matches = withElementId(
-      element, "DomUtils_matchesSelector_target",
-      function (idSelector) {
-        var trimmedSelector = selector.match(/\S.*?(?=\s*$)/)[0];
-        // appending [id='foo'] to a selector with no whitespace ought to
-        // simply restrict the set of possible outputs regardless of the
-        // form of the selector.
-        var doctoredSelector = trimmedSelector + idSelector;
-        var result;
-        if (clipStart)
-          result = DomUtils.findClipped(contextNode, doctoredSelector,
-                                        clipStart, clipEnd);
-        else
-          result = DomUtils.find(contextNode, doctoredSelector);
-        return (result === element);
-      });
-
-    if (matches)
-      return true;
-  }
-
-  return false;
-};
-
-// Check if `element` matches `selector`, scoped to `contextNode`.
-DomUtils.matchesSelector = function (element, contextNode, selector) {
-  return matchesSelectorMaybeClipped(element, contextNode, selector);
-};
-
-// Check if `element` matches `selector`, scoped to `contextNode`,
-// clipped to ordered siblings `clipStart`..`clipEnd`.
-DomUtils.matchesSelectorClipped = function (element, contextNode, selector,
-                                            clipStart, clipEnd) {
-  return matchesSelectorMaybeClipped(element, contextNode, selector,
-                                     clipStart, clipEnd);
-};
-
-// Returns 0 if the nodes are the same or either one contains the other;
-// otherwise, -1 if a comes before b, or else 1 if b comes before a in
-// document order.
-// Requires: `a` and `b` are element nodes in the same document tree.
-DomUtils.compareElementIndex = function (a, b) {
-  // See http://ejohn.org/blog/comparing-document-position/
-  if (a === b)
-    return 0;
-  if (a.compareDocumentPosition) {
-    var n = a.compareDocumentPosition(b);
-    return ((n & 0x18) ? 0 : ((n & 0x4) ? -1 : 1));
-  } else {
-    // Only old IE is known to not have compareDocumentPosition (though Safari
-    // originally lacked it).  Thankfully, IE gives us a way of comparing elements
-    // via the "sourceIndex" property.
-    if (a.contains(b) || b.contains(a))
-      return 0;
-    return (a.sourceIndex < b.sourceIndex ? -1 : 1);
-  }
-};
-
-// Wrap `frag` as necessary to prepare it for insertion in
-// `container`. For example, if `frag` has TR nodes at top level,
-// and `container` is a TABLE, then it's necessary to wrap `frag` in
-// a TBODY to avoid IE quirks.
-//
-// `frag` is a DocumentFragment and will be modified in
-// place. `container` is a DOM element.
-DomUtils.wrapFragmentForContainer = function (frag, container) {
-  if (container && container.nodeName === "TABLE" &&
-      _.any(frag.childNodes,
-            function (n) { return n.nodeName === "TR"; })) {
-    // Avoid putting a TR directly in a TABLE without an
-    // intervening TBODY, because it doesn't work in IE.  We do
-    // the same thing on all browsers for ease of testing
-    // and debugging.
-    var tbody = document.createElement("TBODY");
-    tbody.appendChild(frag);
-    frag.appendChild(tbody);
-  }
-};
-
-// Return true if `node` is part of the global DOM document. Like
-// elementContains(document, node), except (1) it works for any node
-// (eg, text nodes), not just elements; (2) it works around browser
-// quirks that would otherwise come up when passing 'document' as
-// the first argument to elementContains.
-//
-// Returns true if node === document.
-DomUtils.isInDocument = function (node) {
-  // Deal with all cases where node is not an element
-  // node descending from the body first...
-  if (node === document)
-    return true;
-
-  if (node.nodeType !== 1 /* Element */)
-    node = node.parentNode;
-  if (! (node && node.nodeType === 1))
-    return false;
-  if (node === document.body)
-    return true;
-
-  return DomUtils.elementContains(document.body, node);
-};
-
-// Return an HTML string representation of the nodes from
-// firstNode to lastNode, which must be siblings.
-// The tags representing firstNode and lastNode are included,
-// but not their parent or outer siblings.
-DomUtils.rangeToHtml = function (firstNode, lastNode) {
-  var frag = document.createDocumentFragment();
-  for(var n = firstNode, after = lastNode.nextSibling;
-      n && n !== after;
-      n = n.nextSibling)
-    frag.appendChild(n.cloneNode(true)); // deep copy
-  return DomUtils.fragmentToHtml(frag);
-};
-
-// Return an HTML string representation of node, including its
-// own open and close tag.
-DomUtils.outerHtml = function (node) {
-  return DomUtils.rangeToHtml(node, node);
-};
-
-// Sets the value of an element, portably across browsers. There's a special
-// case for SELECT elements in IE.
-DomUtils.setElementValue = function (node, value) {
-  // Try to assign the value.
-  node.value = value;
-  if (node.value === value || node.nodeName !== 'SELECT')
-    return;
-
-  // IE (all versions) appears to only let you assign SELECT values which
-  // match valid OPTION values... and moreover, the OPTION value must be
-  // explicitly given as an attribute, not just as the text. So we hunt for
-  // the OPTION and select it.
-  var options = DomUtils.findAll(node, 'option');
-  for (var i = 0; i < options.length; ++i) {
-    if (DomUtils.getElementValue(options[i]) === value) {
-      options[i].selected = true;
-      return;
-    }
-  }
-};
-
-// Gets the value of an element, portably across browsers. There's a special
-// case for SELECT elements in IE.
-DomUtils.getElementValue = function (node) {
-  if (!quirks.selectValueMustBeFromAttribute)
-    return node.value;
-
-  if (node.nodeName === 'OPTION') {
-    // Inspired by jQuery.valHooks.option.get.
-    var val = node.attributes.value;
-    return !val || val.specified ? node.value : node.text;
-  } else if (node.nodeName === 'SELECT') {
-    if (node.selectedIndex < 0)
-      return null;
-    return DomUtils.getElementValue(node.options[node.selectedIndex]);
-  } else {
-    return node.value;
-  }
-};
diff --git a/packages/domutils/domutils_tests.js b/packages/domutils/domutils_tests.js
deleted file mode 100644
index a0707f308e..0000000000
--- a/packages/domutils/domutils_tests.js
+++ /dev/null
@@ -1,31 +0,0 @@
-Tinytest.add("domutils - setElementValue", function (test) {
-  var div = OnscreenDiv();
-  div.node().appendChild(DomUtils.htmlToFragment(
-    ("<select><option>Foo</option><option value='Bar'>Baz</option>" +
-     "<option selected value='Quux'>Quux</option></select>")));
-
-  var select = DomUtils.find(div.node(), 'select');
-  test.equal(DomUtils.getElementValue(select), "Quux");
-  _.each(["Foo", "Bar", "Quux"], function (value) {
-    DomUtils.setElementValue(select, value);
-    test.equal(DomUtils.getElementValue(select), value);
-  });
-
-  div.kill();
-});
-
-Tinytest.add("domutils - form id expando", function (test) {
-  // See https://github.com/meteor/meteor/issues/604
-
-  var div = OnscreenDiv();
-  div.node().appendChild(DomUtils.htmlToFragment(
-    ('<form><input name="id"></form>')));
-  var theInput = DomUtils.find(div.node(), 'input');
-  var theForm = theInput.parentNode;
-  var theDiv = theForm.parentNode;
-
-  // test that this call doesn't throw an exception
-  test.equal(DomUtils.matchesSelector(theForm, theDiv, 'form'), true);
-
-  div.kill();
-});
diff --git a/packages/domutils/package.js b/packages/domutils/package.js
deleted file mode 100644
index 619cb9dc7b..0000000000
--- a/packages/domutils/package.js
+++ /dev/null
@@ -1,31 +0,0 @@
-Package.describe({
-  name: "domutils",
-  test: "domutils-test",
-  summary: "Utility functions for DOM manipulation",
-  version: '1.0.0',
-  internal: true
-});
-
-Package.on_use(function (api) {
-  // XXX
-  // Doesn't actually require jQuery (but uses it if available).
-  //
-  // For now we are going to keep shipping jQuery with all apps
-  // so as not to break existing apps, but any time now we will
-  // cut this dependency.
-  api.use('jquery', 'client');
-
-  api.use('underscore', 'client');
-
-  api.export('DomUtils', 'client');
-  api.add_files('domutils.js', 'client');
-});
-
-Package.on_test(function (api) {
-  api.use(['tinytest']);
-  api.use(['domutils', 'test-helpers', 'underscore'], 'client');
-
-  api.add_files([
-    'domutils_tests.js'
-  ], 'client');
-});
diff --git a/packages/ejson/ejson.js b/packages/ejson/ejson.js
index 1b8f7b704b..ec846156f9 100644
--- a/packages/ejson/ejson.js
+++ b/packages/ejson/ejson.js
@@ -114,6 +114,8 @@ var builtinConverters = [
     },
     fromJSONValue: function (obj) {
       var typeName = obj.$type;
+      if (!_.has(customTypes, typeName))
+        throw new Error("Custom EJSON type " + typeName + " is not defined");
       var converter = customTypes[typeName];
       return converter(obj.$value);
     }
diff --git a/packages/facebook/facebook_client.js b/packages/facebook/facebook_client.js
index 7eb09fe52a..f49e352e37 100644
--- a/packages/facebook/facebook_client.js
+++ b/packages/facebook/facebook_client.js
@@ -15,12 +15,13 @@ Facebook.requestCredential = function (options, credentialRequestCompleteCallbac
 
   var config = ServiceConfiguration.configurations.findOne({service: 'facebook'});
   if (!config) {
-    credentialRequestCompleteCallback && credentialRequestCompleteCallback(new ServiceConfiguration.ConfigError("Service not configured"));
+    credentialRequestCompleteCallback && credentialRequestCompleteCallback(
+      new ServiceConfiguration.ConfigError());
     return;
   }
 
-  var credentialToken = Random.id();
-  var mobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry/i.test(navigator.userAgent);
+  var credentialToken = Random.secret();
+  var mobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|Windows Phone/i.test(navigator.userAgent);
   var display = mobile ? 'touch' : 'popup';
 
   var scope = "email";
@@ -32,7 +33,7 @@ Facebook.requestCredential = function (options, credentialRequestCompleteCallbac
         '&redirect_uri=' + Meteor.absoluteUrl('_oauth/facebook?close') +
         '&display=' + display + '&scope=' + scope + '&state=' + credentialToken;
 
-  Oauth.showPopup(
+  OAuth.showPopup(
     loginUrl,
     _.bind(credentialRequestCompleteCallback, null, credentialToken)
   );
diff --git a/packages/facebook/facebook_server.js b/packages/facebook/facebook_server.js
index f9f7c1d696..6f6b0c48a8 100644
--- a/packages/facebook/facebook_server.js
+++ b/packages/facebook/facebook_server.js
@@ -3,7 +3,7 @@ Facebook = {};
 var querystring = Npm.require('querystring');
 
 
-Oauth.registerService('facebook', 2, null, function(query) {
+OAuth.registerService('facebook', 2, null, function(query) {
 
   var response = getTokenResponse(query);
   var accessToken = response.accessToken;
@@ -44,7 +44,7 @@ var isJSON = function (str) {
 var getTokenResponse = function (query) {
   var config = ServiceConfiguration.configurations.findOne({service: 'facebook'});
   if (!config)
-    throw new ServiceConfiguration.ConfigError("Service not configured");
+    throw new ServiceConfiguration.ConfigError();
 
   var responseContent;
   try {
@@ -54,7 +54,7 @@ var getTokenResponse = function (query) {
         params: {
           client_id: config.appId,
           redirect_uri: Meteor.absoluteUrl("_oauth/facebook?close"),
-          client_secret: config.secret,
+          client_secret: OAuth.openSecret(config.secret),
           code: query.code
         }
       }).content;
@@ -96,5 +96,5 @@ var getIdentity = function (accessToken) {
 };
 
 Facebook.retrieveCredential = function(credentialToken) {
-  return Oauth.retrieveCredential(credentialToken);
+  return OAuth.retrieveCredential(credentialToken);
 };
diff --git a/packages/github/github_client.js b/packages/github/github_client.js
index d335702b6e..11b43eab87 100644
--- a/packages/github/github_client.js
+++ b/packages/github/github_client.js
@@ -14,10 +14,11 @@ Github.requestCredential = function (options, credentialRequestCompleteCallback)
 
   var config = ServiceConfiguration.configurations.findOne({service: 'github'});
   if (!config) {
-    credentialRequestCompleteCallback && credentialRequestCompleteCallback(new ServiceConfiguration.ConfigError("Service not configured"));
+    credentialRequestCompleteCallback && credentialRequestCompleteCallback(
+      new ServiceConfiguration.ConfigError());
     return;
   }
-  var credentialToken = Random.id();
+  var credentialToken = Random.secret();
 
   var scope = (options && options.requestPermissions) || [];
   var flatScope = _.map(scope, encodeURIComponent).join('+');
@@ -29,8 +30,7 @@ Github.requestCredential = function (options, credentialRequestCompleteCallback)
         '&redirect_uri=' + Meteor.absoluteUrl('_oauth/github?close') +
         '&state=' + credentialToken;
 
-
-  Oauth.showPopup(
+  OAuth.showPopup(
     loginUrl,
     _.bind(credentialRequestCompleteCallback, null, credentialToken),
     {width: 900, height: 450}
diff --git a/packages/github/github_server.js b/packages/github/github_server.js
index 78e342f421..c46fd787a5 100644
--- a/packages/github/github_server.js
+++ b/packages/github/github_server.js
@@ -1,6 +1,6 @@
 Github = {};
 
-Oauth.registerService('github', 2, null, function(query) {
+OAuth.registerService('github', 2, null, function(query) {
 
   var accessToken = getAccessToken(query);
   var identity = getIdentity(accessToken);
@@ -8,7 +8,7 @@ Oauth.registerService('github', 2, null, function(query) {
   return {
     serviceData: {
       id: identity.id,
-      accessToken: accessToken,
+      accessToken: OAuth.sealSecret(accessToken),
       email: identity.email,
       username: identity.login
     },
@@ -24,7 +24,7 @@ if (Meteor.release)
 var getAccessToken = function (query) {
   var config = ServiceConfiguration.configurations.findOne({service: 'github'});
   if (!config)
-    throw new ServiceConfiguration.ConfigError("Service not configured");
+    throw new ServiceConfiguration.ConfigError();
 
   var response;
   try {
@@ -37,7 +37,7 @@ var getAccessToken = function (query) {
         params: {
           code: query.code,
           client_id: config.clientId,
-          client_secret: config.secret,
+          client_secret: OAuth.openSecret(config.secret),
           redirect_uri: Meteor.absoluteUrl("_oauth/github?close"),
           state: query.state
         }
@@ -68,5 +68,5 @@ var getIdentity = function (accessToken) {
 
 
 Github.retrieveCredential = function(credentialToken) {
-  return Oauth.retrieveCredential(credentialToken);
+  return OAuth.retrieveCredential(credentialToken);
 };
diff --git a/packages/google/google_client.js b/packages/google/google_client.js
index a828571fd6..864fa4a90a 100644
--- a/packages/google/google_client.js
+++ b/packages/google/google_client.js
@@ -16,11 +16,12 @@ Google.requestCredential = function (options, credentialRequestCompleteCallback)
 
   var config = ServiceConfiguration.configurations.findOne({service: 'google'});
   if (!config) {
-    credentialRequestCompleteCallback && credentialRequestCompleteCallback(new ServiceConfiguration.ConfigError("Service not configured"));
+    credentialRequestCompleteCallback && credentialRequestCompleteCallback(
+      new ServiceConfiguration.ConfigError());
     return;
   }
 
-  var credentialToken = Random.id();
+  var credentialToken = Random.secret();
 
   // always need this to get user id from google.
   var requiredScope = ['profile'];
@@ -53,7 +54,7 @@ Google.requestCredential = function (options, credentialRequestCompleteCallback)
     loginUrl += '&hd=' + encodeURIComponent(Accounts._options.restrictCreationByEmailDomain);
   }
 
-  Oauth.showPopup(
+  OAuth.showPopup(
     loginUrl,
     _.bind(credentialRequestCompleteCallback, null, credentialToken),
     { height: 406 }
diff --git a/packages/google/google_configure.html b/packages/google/google_configure.html
index 11a91073f5..83917941b2 100644
--- a/packages/google/google_configure.html
+++ b/packages/google/google_configure.html
@@ -8,6 +8,7 @@
     </li>
     <li>
       If necessary, "Create Project"
+    </li>
     <li>
       Click "APIs &amp; auth" and "Credentials" on the left
     </li>
diff --git a/packages/google/google_server.js b/packages/google/google_server.js
index 27c98321bb..2a4f3bc986 100644
--- a/packages/google/google_server.js
+++ b/packages/google/google_server.js
@@ -5,7 +5,7 @@ Google.whitelistedFields = ['id', 'email', 'verified_email', 'name', 'given_name
                    'family_name', 'picture', 'locale', 'timezone', 'gender'];
 
 
-Oauth.registerService('google', 2, null, function(query) {
+OAuth.registerService('google', 2, null, function(query) {
 
   var response = getTokens(query);
   var accessToken = response.accessToken;
@@ -38,7 +38,7 @@ Oauth.registerService('google', 2, null, function(query) {
 var getTokens = function (query) {
   var config = ServiceConfiguration.configurations.findOne({service: 'google'});
   if (!config)
-    throw new ServiceConfiguration.ConfigError("Service not configured");
+    throw new ServiceConfiguration.ConfigError();
 
   var response;
   try {
@@ -46,7 +46,7 @@ var getTokens = function (query) {
       "https://accounts.google.com/o/oauth2/token", {params: {
         code: query.code,
         client_id: config.clientId,
-        client_secret: config.secret,
+        client_secret: OAuth.openSecret(config.secret),
         redirect_uri: Meteor.absoluteUrl("_oauth/google?close"),
         grant_type: 'authorization_code'
       }});
@@ -79,5 +79,5 @@ var getIdentity = function (accessToken) {
 
 
 Google.retrieveCredential = function(credentialToken) {
-  return Oauth.retrieveCredential(credentialToken);
+  return OAuth.retrieveCredential(credentialToken);
 };
diff --git a/packages/handlebars/.npm/package/.gitignore b/packages/handlebars/.npm/package/.gitignore
deleted file mode 100644
index 3c3629e647..0000000000
--- a/packages/handlebars/.npm/package/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-node_modules
diff --git a/packages/handlebars/.npm/package/README b/packages/handlebars/.npm/package/README
deleted file mode 100644
index 3d492553a4..0000000000
--- a/packages/handlebars/.npm/package/README
+++ /dev/null
@@ -1,7 +0,0 @@
-This directory and the files immediately inside it are automatically generated
-when you change this package's NPM dependencies. Commit the files in this
-directory (npm-shrinkwrap.json, .gitignore, and this README) to source control
-so that others run the same versions of sub-dependencies.
-
-You should NOT check in the node_modules directory that Meteor automatically
-creates; if you are using git, the .gitignore file tells git to ignore it.
diff --git a/packages/handlebars/.npm/package/npm-shrinkwrap.json b/packages/handlebars/.npm/package/npm-shrinkwrap.json
deleted file mode 100644
index 563d2c159b..0000000000
--- a/packages/handlebars/.npm/package/npm-shrinkwrap.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "dependencies": {
-    "handlebars": {
-      "version": "https://github.com/meteor/handlebars.js/tarball/543ec6689cf663cfda2d8f26c3c27de40aad7bd5",
-      "dependencies": {
-        "optimist": {
-          "version": "0.3.7",
-          "dependencies": {
-            "wordwrap": {
-              "version": "0.0.2"
-            }
-          }
-        }
-      }
-    }
-  }
-}
diff --git a/packages/handlebars/evaluate-handlebars.js b/packages/handlebars/evaluate-handlebars.js
deleted file mode 100644
index ab895c2550..0000000000
--- a/packages/handlebars/evaluate-handlebars.js
+++ /dev/null
@@ -1,385 +0,0 @@
-Handlebars = {};
-
-// XXX we probably forgot to implement the #foo case where foo is not
-// a helper (and similarly the ^foo case)
-
-// XXX there is a ton of stuff that needs testing! like,
-// everything. including the '..' stuff.
-
-Handlebars.json_ast_to_func = function (ast) {
-  return function (data, options) {
-    return Handlebars.evaluate(ast, data, options);
-  };
-};
-
-// If minimongo is available (it's a weak dependency) use its ID stringifier to
-// label branches (so that, eg, ObjectId and strings don't overlap). Otherwise
-// just use the identity function.
-var idStringify = Package.minimongo
-  ? Package.minimongo.LocalCollection._idStringify
-  : function (id) { return id; };
-
-// block helpers take:
-// (N args), options (hash args, plus 'fn' and 'inverse')
-// and return text
-//
-// normal helpers take:
-// (N args), options (hash args)
-//
-// partials take one argument, data
-
-// XXX handlebars' format for arguments is not the clearest, likely
-// for backwards compatibility to mustache. eg, options ===
-// options.fn. take the opportunity to clean this up. treat block
-// arguments (fn, inverse) as just another kind of argument, same as
-// what is passed in via named arguments.
-Handlebars._default_helpers = {
-  'with': function (data, options) {
-    if (!data || (data instanceof Array && !data.length))
-      return options.inverse(this);
-    else
-      return options.fn(data);
-  },
-  'each': function (data, options) {
-    var parentData = this;
-    if (data && data.length > 0)
-      return _.map(data, function(x, i) {
-        // infer a branch key from the data
-        var branch = ((x && x._id && idStringify(x._id)) ||
-                      (typeof x === 'string' ? x : null) ||
-                      Spark.UNIQUE_LABEL);
-        return Spark.labelBranch(branch, function() {
-          return options.fn(x);
-        });
-      }).join('');
-    else
-      return Spark.labelBranch(
-        'else',
-        function () {
-          return options.inverse(parentData);
-        });
-  },
-  'if': function (data, options) {
-    if (!data || (data instanceof Array && !data.length))
-      return options.inverse(this);
-    else
-      return options.fn(this);
-  },
-  'unless': function (data, options) {
-    if (!data || (data instanceof Array && !data.length))
-      return options.fn(this);
-    else
-      return options.inverse(this);
-  }
-};
-
-Handlebars.registerHelper = function (name, func) {
-  if (name in Handlebars._default_helpers)
-    throw new Error("There is already a helper '" + name + "'");
-  Handlebars._default_helpers[name] = func;
-};
-
-// Utility to HTML-escape a string.
-Handlebars._escape = (function() {
-  var escape_map = {
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#x27;",
-    "`": "&#x60;", /* IE allows backtick-delimited attributes?? */
-    "&": "&amp;"
-  };
-  var escape_one = function(c) {
-    return escape_map[c];
-  };
-
-  return function (x) {
-    return x.replace(/[&<>"'`]/g, escape_one);
-  };
-})();
-
-// be able to recognize default "this", which is different in different environments
-Handlebars._defaultThis = (function() { return this; })();
-
-Handlebars.evaluate = function (ast, data, options) {
-  options = options || {};
-  var helpers = _.extend({}, Handlebars._default_helpers);
-  _.extend(helpers, options.helpers || {});
-  var partials = options.partials || {};
-
-  // re 'stack' arguments: top of stack is the current data to use for
-  // the template. higher levels are the data referenced by
-  // identifiers with one or more '..' segments. we have to keep the
-  // stack pure-functional style, with a tree rather than an array,
-  // because we want to continue to allow block helpers provided by
-  // the user to capture their subtemplate rendering functions and
-  // call them later, after we've finished running (for eg findLive.)
-  // maybe revisit later.
-
-  var eval_value = function (stack, id) {
-    if (typeof(id) !== "object")
-      return id;
-
-    // follow '..' in {{../../foo.bar}}
-    for (var i = 0; i < id[0]; i++) {
-      if (!stack.parent)
-        throw new Error("Too many '..' segments");
-      else
-        stack = stack.parent;
-    }
-
-    if (id.length === 1)
-      // no name: {{this}}, {{..}}, {{../..}}
-      return stack.data;
-
-    var scopedToContext = false;
-    if (id[1] === '') {
-      // an empty path segment is our AST's way of encoding
-      // the presence of 'this.' at the beginning of the path.
-      id = id.slice();
-      id.splice(1, 1); // remove the ''
-      scopedToContext = true;
-    }
-
-    // when calling functions (helpers/methods/getters), dataThis
-    // tracks what to use for `this`.  For helpers, it's the
-    // current data context.  For getters and methods on the data
-    // context object, and on the return value of a helper, it's
-    // the object where we got the getter or method.
-    var dataThis = stack.data;
-
-    var data;
-    if (id[0] === 0 && helpers.hasOwnProperty(id[1]) && ! scopedToContext) {
-      // first path segment is a helper
-      data = helpers[id[1]];
-    } else {
-      if ((! data instanceof Object) &&
-          (typeof (function() {})[id[1]] !== 'undefined') &&
-          ! scopedToContext) {
-        // Give a helpful error message if the user tried to name
-        // a helper 'name', 'length', or some other built-in property
-        // of function objects.  Unfortunately, this case is very
-        // hard to detect, as Template.foo.name = ... will fail silently,
-        // and {{name}} will be silently empty if the property doesn't
-        // exist (per Handlebars rules).
-        // However, if there is no data context at all, we jump in.
-        throw new Error("Can't call a helper '"+id[1]+"' because "+
-                        "it is a built-in function property in JavaScript");
-      }
-      // first path segment is property of data context
-      data = (stack.data && stack.data[id[1]]);
-    }
-
-    // handle dots, as in {{foo.bar}}
-    for (var i = 2; i < id.length; i++) {
-      // Call functions when taking the dot, to support
-      // for example currentUser.name.
-      //
-      // In the case of {{foo.bar}}, we end up returning one of:
-      // - helpers.foo.bar
-      // - helpers.foo().bar
-      // - stack.data.foo.bar
-      // - stack.data.foo().bar.
-      //
-      // The caller does the final application with any
-      // arguments, as in {{foo.bar arg1 arg2}}, and passes
-      // the current data context in `this`.  Therefore,
-      // we use the current data context (`helperThis`)
-      // for all function calls.
-      if (typeof data === 'function') {
-        data = data.call(dataThis);
-        dataThis = data;
-      }
-      if (data === undefined || data === null) {
-        // Handlebars fails silently and returns "" if
-        // we start to access properties that don't exist.
-        data = '';
-        break;
-      }
-
-      data = data[id[i]];
-    }
-
-    // ensure `this` is bound appropriately when the caller
-    // invokes `data` with any arguments.  For example,
-    // in {{foo.bar baz}}, the caller must supply `baz`,
-    // but we alone have `foo` (in `dataThis`).
-    if (typeof data === 'function')
-      return _.bind(data, dataThis);
-
-    return data;
-  };
-
-  // 'extra' will be clobbered, but not 'params'.
-  // if (isNested), evaluate params.slice(1) as a nested
-  // helper invocation if there is at least one positional
-  // argument.  This is used for block helpers.
-  var invoke = function (stack, params, extra, isNested) {
-    extra = extra || {};
-    params = params.slice(0);
-
-    // remove hash (dictionary of keyword arguments) from
-    // the end of params, if present.
-    var last = params[params.length - 1];
-    var hash = {};
-    if (typeof(last) === "object" && !(last instanceof Array)) {
-      // evaluate hash values, which are found as invocations
-      // like [0, "foo"]
-      _.each(params.pop(), function(v,k) {
-        var result = eval_value(stack, v);
-        hash[k] = (typeof result === "function" ? result() : result);
-      });
-    }
-
-    var apply = function (values, extra) {
-      var args = values.slice(1);
-      for(var i=0; i<args.length; i++)
-        if (typeof args[i] === "function")
-          args[i] = args[i](); // `this` already bound by eval_value
-      if (extra)
-        args.push(extra);
-      return values[0].apply(stack.data, args);
-    };
-
-    var values = new Array(params.length);
-    for(var i=0; i<params.length; i++)
-      values[i] = eval_value(stack, params[i]);
-
-    if (typeof(values[0]) !== "function")
-      return values[0];
-
-    if (isNested && values.length > 1) {
-      // at least one positional argument; not no args
-      // or only hash args.
-      var oneArg = values[1];
-      if (typeof oneArg === "function")
-        // invoke the positional arguments
-        // (and hash arguments) as a nested helper invocation.
-        oneArg = apply(values.slice(1), {hash:hash});
-      values = [values[0], oneArg];
-      // keyword args don't go to the block helper, then.
-      extra.hash = {};
-    } else {
-      extra.hash = hash;
-    }
-
-    return apply(values, extra);
-  };
-
-  var template = function (stack, elts, basePCKey) {
-    var buf = [];
-
-    var toString = function (x) {
-      if (typeof x === "string") return x;
-      // May want to revisit the following one day
-      if (x === null) return "null";
-      if (x === undefined) return "";
-      return x.toString();
-    };
-
-    // wrap `fn` and `inverse` blocks in chunks having `data`, if the data
-    // is different from the enclosing data, so that the data is available
-    // at runtime for events.
-    var decorateBlockFn = function(fn, old_data) {
-      return function(data) {
-        // don't create spurious annotations when data is same
-        // as before (or when transitioning between e.g. `window` and
-        // `undefined`)
-        if ((data || Handlebars._defaultThis) ===
-            (old_data || Handlebars._defaultThis))
-          return fn(data);
-        else
-          return Spark.setDataContext(data, fn(data));
-      };
-    };
-
-    // Handle the return value of a {{helper}}.
-    // Takes a:
-    //   string - escapes it
-    //   SafeString - returns the underlying string unescaped
-    //   other value - coerces to a string and escapes it
-    var maybeEscape = function(x) {
-      if (x instanceof Handlebars.SafeString)
-        return x.toString();
-      return Handlebars._escape(toString(x));
-    };
-
-    var curIndex;
-    // Construct a unique key for the current position
-    // in the AST.  Since template(...) is invoked recursively,
-    // the "PC" (program counter) key is hierarchical, consisting
-    // of one or more numbers, for example '0' or '1.3.0.1'.
-    var getPCKey = function() {
-      return (basePCKey ? basePCKey+'.' : '') + curIndex;
-    };
-    var branch = function(name, func) {
-      // Construct a unique branch identifier based on what partial
-      // we're in, what partial or helper we're calling, and our index
-      // into the template AST (essentially the program counter).
-      // If "foo" calls "bar" at index 3, it looks like: bar@foo#3.
-      return Spark.labelBranch(name + "@" + getPCKey(), func);
-    };
-
-    _.each(elts, function (elt, index) {
-      curIndex = index;
-      if (typeof(elt) === "string")
-        buf.push(elt);
-      else if (elt[0] === '{')
-        // {{double stache}}
-        buf.push(branch(elt[1], function () {
-          return maybeEscape(invoke(stack, elt[1]));
-        }));
-      else if (elt[0] === '!')
-        // {{{triple stache}}}
-        buf.push(branch(elt[1], function () {
-          return toString(invoke(stack, elt[1] || ''));
-        }));
-      else if (elt[0] === '#') {
-        // {{#block helper}}
-        var pcKey = getPCKey();
-        var block = decorateBlockFn(
-          function (data) {
-            return template({parent: stack, data: data}, elt[2], pcKey);
-          }, stack.data);
-        block.fn = block;
-        block.inverse = decorateBlockFn(
-          function (data) {
-            return template({parent: stack, data: data}, elt[3] || [], pcKey);
-          }, stack.data);
-        var html = branch(elt[1], function () {
-          return toString(invoke(stack, elt[1], block, true));
-        });
-        buf.push(html);
-      } else if (elt[0] === '>') {
-        // {{> partial}}
-        var partialName = elt[1];
-        if (!(partialName in partials))
-          // XXX why do we call these templates in docs and partials in code?
-          throw new Error("No such template '" + partialName + "'");
-        // call the partial
-        var html = branch(partialName, function () {
-          return toString(partials[partialName](stack.data));
-        });
-        buf.push(html);
-      } else
-        throw new Error("bad element in template");
-    });
-
-    return buf.join('');
-  };
-
-  // Set the prefix for PC keys, which identify call sites in the AST
-  // for the purpose of chunk matching.
-  // `options.name` will be null in the body, but otherwise have a value,
-  // assuming `options` was assembled in templating/deftemplate.js.
-  var rootPCKey = (options.name||"")+"#";
-
-  return template({data: data, parent: null}, ast, rootPCKey);
-};
-
-Handlebars.SafeString = function(string) {
-  this.string = string;
-};
-Handlebars.SafeString.prototype.toString = function() {
-  return this.string.toString();
-};
diff --git a/packages/handlebars/package.js b/packages/handlebars/package.js
index 166d7427e2..1c2fa87475 100644
--- a/packages/handlebars/package.js
+++ b/packages/handlebars/package.js
@@ -1,45 +1,17 @@
 Package.describe({
   name: "handlebars",
   test: "handlebars-test",
-  summary: "Simple semantic templating language",
+  summary: "Deprecated",
   version: '1.0.0',
   internal: true
 });
 
-Npm.depends({
-  // Fork of 1.0.7 dropping a used-only-by-bin/handlebars dependency on the very
-  // large uglify-js 1.2.6.
-  handlebars: 'https://github.com/meteor/handlebars.js/tarball/543ec6689cf663cfda2d8f26c3c27de40aad7bd5'
-});
-
 Package.on_use(function (api) {
-  api.use('underscore');
-  api.use('spark', 'client');
-
-  api.export('Handlebars');
-
-
-  // If we have minimongo available, use its idStringify function.
-  api.use('minimongo', 'client', {weak: true});
-
-  // XXX these should be split up into two different slices, not
-  // different code with totally different APIs that is sent depending
-  // on the architecture
-  api.add_files('parse-handlebars.js', 'server');
-  api.add_files('evaluate-handlebars.js', 'client');
-
-  // XXX This package has been folded into the 'templating' package
-  // for now. Historically, you could see it in your package list
-  // (because it didn't have internal: true, which it probably should
-  // have), but adding it didn't do anything (because it just
-  // contained the handlebars precompiler and runtime, not any
-  // functions you could call yourself.) So leave it around as an
-  // empty package for the moment so as to not break the projects of
-  // anyone that happened to type 'meteor add handlebars' because they
-  // thought they had to.
+// XXX we unfortunately we can't do this since `meteor test-packages`
+// tries to load all packages.
+//
+//  throw new Error(
+//    "The 'handlebars' package is deprecated. "
+//      + "`Handlebars.registerHelper` is now `UI.registerHelper` in the 'ui' package.");
 });
 
-Package.on_test(function (api) {
-  api.use('tinytest');
-  api.use('underscore');
-});
diff --git a/packages/handlebars/parse-handlebars.js b/packages/handlebars/parse-handlebars.js
deleted file mode 100644
index 90e5319bb3..0000000000
--- a/packages/handlebars/parse-handlebars.js
+++ /dev/null
@@ -1,192 +0,0 @@
-Handlebars = {};
-
-/* Our format:
- *
- * A 'template' is an array. Each element in it is either
- * - a literal string to echo
- * - an escaped substition: ['{', invocation]
- * - an unescaped substition: ['!', invocation]
- * - a (conditional or iterated) block:
- *   ['#', invocation, template_a, template_b]
- *   (the second template is optional)
- * - a partial: ['>', partial_name] (partial_name is a string)
- *
- * An 'invocation' is an array: one or more 'values', then an optional
- * hash (of which the keys are strings, and the values are 'values'.)
- *
- * An 'identifier' is:
- * - [depth, key, key, key..]
- * Eg, '../../a.b.c' would be [2, 'a', 'b', 'c']. 'a' would be [0, 'a'].
- * And 'this' or '.' would be [0].
- *
- * A 'value' is either an identifier, or a string, int, or bool.
- *
- * You should provide a block helper 'with' since we will emit calls
- * to it (if the user passes the second 'context' argument to a
- * partial.)
- */
-
-var path = Npm.require('path');
-var hbars = Npm.require('handlebars');
-
-// Has keys 'message', 'line'
-Handlebars.ParseError = function (message, line) {
-  this.message = message;
-  if (line)
-    this.line = line;
-};
-
-// Raises Handlebars.ParseError if the Handlebars parser fails. We
-// will do our best to decode the output of Handlebars into a message
-// and a line number.
-
-// If Handlebars parsing fails, the Handlebars parser error will
-// escape to the caller.
-//
-Handlebars.to_json_ast = function (code) {
-  try {
-    var ast = hbars.parse(code);
-  } catch (e) {
-    // The Handlebars parser throws Error objects with a message
-    // attribute (and nothing else) and we must do our best. Parse
-    // errors include a line number (relative to the start of 'code'
-    // of course) which we'll attempt to parse out. (Handlebars
-    // almost, but not quite copies the line number information onto
-    // the Error object.) Other than parse errors, you also see very
-    // short strings like "else doesn't match unless" (with no
-    // location information.)
-    var m = e.message.match(/^Parse error on line (\d+):([\s\S]*)$/)
-    if (m)
-      throw new Handlebars.ParseError("Parse error:" + m[2], +m[1]);
-
-    if (e.message)
-      throw new Handlebars.ParseError(e.message);
-
-    throw e;
-  }
-
-  // Recreate Handlebars.Exception to properly report error messages
-  // and stack traces. (https://github.com/wycats/handlebars.js/issues/226)
-  makeHandlebarsExceptionsVisible();
-
-  var identifier = function (node) {
-    if (node.type !== "ID")
-      throw new Error("got ast node " + node.type + " for identifier");
-    // drop node.isScoped. this is true if there was a 'this' or '.'
-    // anywhere in the path. vanilla handlebars will turn off
-    // helpers lookup if isScoped is true, but this is too restrictive
-    // for us.
-    var ret = [node.depth];
-    // we still want to turn off helper lookup if path starts with 'this.'
-    // as in {{this.foo}}, which means it has to look different from {{foo}}
-    // in our AST.  signal the presence of 'this' in our AST using an empty
-    // path segment.
-    if (/^this\./.test(node.original))
-      ret.push('');
-    return ret.concat(node.parts);
-  };
-
-  var value = function (node) {
-    // Work around handlebars.js Issue #422 - Negative integers for
-    // helpers get trapped as ID. handlebars doesn't support floating
-    // point, just integers.
-    if (node.type === 'ID' && /^-\d+$/.test(node.string)) {
-      // Reconstruct node
-      node.type = 'INTEGER';
-      node.integer = node.string;
-    }
-
-    var choices = {
-      ID: function (node) {return identifier(node);},
-      STRING: function (node) {return node.string;},
-      INTEGER: function (node) {return +node.integer;},
-      BOOLEAN: function (node) {return (node.bool === 'true');}
-    };
-    if (!(node.type in choices))
-      throw new Error("got ast node " + node.type + " for value");
-    return choices[node.type](node);
-  };
-
-  var hash = function (node) {
-    if (node.type !== "hash")
-      throw new Error("got ast node " + node.type + " for hash");
-    var ret = {};
-    _.each(node.pairs, function (p) {
-      ret[p[0]] = value(p[1]);
-    });
-    return ret;
-  };
-
-  var invocation = function (node) {
-    if (node.type !== "mustache")
-      throw new Error("got ast node " + node.type + " for invocation");
-    var ret = [node.id];
-    ret = ret.concat(node.params);
-    ret = _.map(ret, value);
-    if (node.hash)
-      ret.push(hash(node.hash));
-    return ret;
-  };
-
-  var template = function (nodes) {
-    var ret = [];
-
-    if (!nodes)
-      return [];
-
-    var choices = {
-      mustache: function (node) {
-        ret.push([node.escaped ? '{' : '!', invocation(node)]);
-      },
-      partial: function (node) {
-        var id = identifier(node.id);
-        if (id.length !== 2 || id[0] !== 0)
-          // XXX actually should just get the literal string the
-          // entered, and avoid identifier parsing
-          throw new Error("Template names shouldn't contain '.' or '/'");
-        var x = ['>', id[1]];
-        if (node.context)
-          x = ['#', [[0, 'with'], identifier(node.context)], [x]];
-        ret.push(x);
-      },
-      block: function (node) {
-        var x = ['#', invocation(node.mustache),
-                 template(node.program.statements)];
-        if (node.program.inverse)
-          x.push(template(node.program.inverse.statements));
-        ret.push(x);
-      },
-      inverse: function (node) {
-        ret.push(['#', invocation(node.mustache),
-                  node.program.inverse &&
-                  template(node.program.inverse.statements) || [],
-                  template(node.program.statements)]);
-      },
-      content: function (node) {ret.push(node.string);},
-      comment: function (node) {}
-    };
-
-    _.each(nodes, function (node) {
-      if (!(node.type in choices))
-        throw new Error("got ast node " + node.type + " in template");
-      choices[node.type](node);
-    });
-
-    return ret;
-  };
-
-  if (ast.type !== "program")
-    throw new Error("got ast node " + node.type + " at toplevel");
-  return template(ast.statements);
-};
-
-var makeHandlebarsExceptionsVisible = function () {
-  hbars.Exception = function(message) {
-    this.message = message;
-    // In Node, if we don't do this we don't see the message displayed
-    // nor the right stack trace.
-    Error.captureStackTrace(this, arguments.callee);
-  };
-  hbars.Exception.prototype = new Error();
-  hbars.Exception.prototype.name = 'Handlebars.Exception';
-};
diff --git a/packages/domutils/.gitignore b/packages/html-tools/.gitignore
similarity index 100%
rename from packages/domutils/.gitignore
rename to packages/html-tools/.gitignore
diff --git a/packages/html-tools/README.md b/packages/html-tools/README.md
new file mode 100644
index 0000000000..ce0f4e6a7f
--- /dev/null
+++ b/packages/html-tools/README.md
@@ -0,0 +1,148 @@
+# html-tools
+
+A lightweight HTML tokenizer and parser which outputs to the HTMLjs
+object representation.  Special hooks allow the syntax to be extended
+to parse an HTML-like template language like Spacebars.
+
+```
+HTML.parseFragment("<div class=greeting>Hello<br>World</div>")
+
+=> HTML.DIV({'class':'greeting'}, "Hello", HTML.BR(), "World"))
+```
+
+This package is used by the Spacebars compiler, which normally only
+runs at bundle time but can also be used at runtime on the client or
+server.
+
+## Invoking the Parser
+
+`HTML.parseFragment(input, options)` - Takes an input string or Scanner object and returns HTMLjs.
+
+In the basic case, where no options are passed, `parseFragment` will consume the entire input (the full string or the rest of the Scanner).
+
+The options are as follows:
+
+#### getSpecialTag
+
+This option extends the HTML parser to parse template tags such as `{{foo}}`.
+
+`getSpecialTag: function (scanner, templateTagPosition) { ... }` - A function for the parser to call after every HTML token and at various positions within tags.  If the function returns a non-null value, that value is wrapped in an `HTML.Special` node which is inserted into the HTMLjs tree at the appropriate location.  The function is expected to advance the scanner if it succeeds at parsing a template tag (see the section on `HTML.Scanner`).
+
+There are four possible outcomes when `getSpecialTag` is called:
+
+* Not a template tag - Leave the scanner as is, and return `null`.  A quick peek at the next character should bail to this case if the start of a template tag is not seen.
+* Bad template tag - Call `scanner.fatal`, which aborts parsing completely.  Once the beginning of a template tag is seen, `getSpecialTag` will generally want to commit, and either succeed or fail trying).
+* Good template tag - Advance the scanner to the end of the template tag and return an object.
+* Comment tag - Advance the scanner and return `null`.  For example, a Spacebars comment is `{{! foo}}`.
+
+The `templateTagPosition` argument to `getSpecialTag` is one of:
+
+* `HTML.TEMPLATE_TAG_POSITION.ELEMENT` - At "element level," meaning somewhere an HTML tag could be.
+* `HTML.TEMPLATE_TAG_POSITION.IN_START_TAG` - Inside a start tag, as in `<div {{foo}}>`, where you might otherwise find `name=value`.
+* `HTML.TEMPLATE_TAG_POSITION.IN_ATTRIBUTE` - Inside the value of an HTML attribute, as in `<div class={{foo}}>`.
+* `HTML.TEMPLATE_TAG_POSITION.IN_RCDATA` - Inside a TEXTAREA or a block helper inside an attribute, where character references are allowed ("replaced character data") but not tags.
+* `HTML.TEMPLATE_TAG_POSITION.IN_RAWTEXT` - In a context where character references are not parsed, such as a script tag, style tag, or markdown helper.
+
+It's completely normal for `getSpecialTag` to invoke `HTML.parseFragment` recursively on the same scanner (see `shouldStop`).  If it does so, the same value of `getSpecialTag` must be passed to the second invocation.
+
+At the moment, template tags must begin with `{`.  The parser does not try calling `getSpecialTag` for every character of an HTML document, only at token boundaries, and it knows to always end a token at `{`.
+
+**XXX Better error message for `<div {{k}}={{v}}>`.**
+
+**XXX Do something with `<input type=checkbox {{#if foo}}checked{{/if}}>`**
+
+**XXX Why both IN_ATTRIBUTE and IN_RCDATA?**
+
+**XXX Fix Markdown**
+
+#### textMode
+
+The `textMode` option, if present, causes the parser to parse text (such as the contents of a `<textarea>` tag or part of an attribute) instead of HTML.  In a text mode, for example, the input `"<"` is not a parse error (because a bare `<` is allowed in a textarea or attribute).
+
+The value of `textMode` must be one of:
+
+* `HTML.TEXTMODE.RCDATA` - Interpret character references (the usual case)
+* `HTML.TEXTMODE.STRING` - Don't interpret character references (the RAWTEXT case)
+
+#### shouldStop
+
+`shouldStop: function (scanner) { ... }` - A function that the parser invokes between tokens to check whether it should stop parsing.  The function should return a boolean value.
+
+The `shouldStop` function provides a way to put a "wall" in the input stream for the purpose of parsing HTML content embedded in a template tag.  For example, take the template `{{#if happy}}yay{{/if}}`.  The scanner will be advanced to the start of the word `yay` before `parseFragment` is called to parse the contents of the tag.  (Note that the caller happens to be the `getSpecialTag` function of an enclosing `parseFragment`.)  When parsing from `yay`, the `shouldStop` function is used to end the fragment at `{{/if}}`, which, like `{{/blah}}` or `{{else}}`, couldn't possibly be actual content that belongs in the fragment.  Even if HTML tags are not closed, as in the malformed template `{{#if foo}}<div>{{else}}`, the fragment stops at the `{{else}}`, and the error is an unclosed `<div>` (before the parser notices the unclosed `{{#if}}`).
+
+**XXX This option doesn't seem very elegant, or at least the way it's passed around internally isn't.**
+
+## HTML.Scanner class
+
+To write `getSpecialTag` and `shouldStop` functions, you have to
+interface with the `HTML.Scanner` class used by html-tools.  It's a
+general class that could be used by any parser/lexer/tokenizer.
+
+A Scanner has an immutable source document and a mutable pointer into
+the document.
+
+* `new Scanner(input)` - constructs a Scanner with source string `input`
+* `scanner.input` (read-only) - the entire source string
+* `scanner.pos` (read/write) - the current index into the source string
+
+Scanners provide these methods for convenience:
+
+* `scanner.rest()` - `input.slice(pos)` (the rest of the document)
+* `scanner.peek()` - `input.charAt(pos)` (the next character)
+* `scanner.isEOF()` - true if `pos` is at or beyond the end of `input`
+* `scanner.fatal(msg)` - throw an error indicating a problem at `pos`
+
+Even though `scanner.rest()` performs a substring operation, it should be considered fast and O(1), because all known JavaScript runtimes in use have constant-time substring.  It would be possible, but extremely clumsy, to avoid such a substring operation while performing the usual business of a parser, which is to try to match a regex anchored at a particular index.
+
+Functions that take scanners generally have three possible outcomes:
+
+* Success:  Advance `scanner.pos` and return some truthy value
+* Failure: Leave `scanner.pos` alone and return `null`
+* Fatal: Throw an exception via `scanner.fatal`
+
+It's particularly important that in the Failure case, the function restores the scanner to the state it found it.  This makes it possible to immediately try another parse function when one fails and form alternations such as `foo(scanner) || bar(scanner)`.
+
+It's often easiest to avoid the Failure case altogether, writing parse functions that always succeed or throw.  This requires less bookkeeping and leads to good error messages.  A Failure case may be added if it is simple to check for up front and makes the function easier to use in an alternation.  We say a function has "committed" or "will succeed or fail fatally trying" when it has reached a point where it must return a value or throw.  Any parse function that has moved the scanner position and not remembered the original position is necessarily committed.  Usually, committing is completely natural in the context of the language being parsed; for example, `{{` in a template always starts a template tag or throws an error about a malformed template tag.
+
+## HTML Dialect
+
+HTML has many dialects and potential degrees of permissiveness.  We
+use the WHATWG syntax spec and are pretty strict, failing on any
+"parse error" cases, which basically means the input has to be
+valid "HTML5" (except for the template tags).
+
+HTML syntax references:
+
+* [Human-readable syntax guide](http://developers.whatwg.org/syntax.html#syntax)
+* [Tokenization state machine](http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html)
+
+The WHATWG parser without error recovery is strict compared to
+browsers (which will recover from almost anything), but lenient
+compared to the now-defunct XHTML spec (which required lowercase tag
+names and lots more escaping of special characters).
+
+The following are examples of **errors**:
+
+* A stray or unclosed `<` character
+* An unknown character reference like `&asdf;`
+* Self-closing tags like `<div/>` (except for BR, HR, INPUT, and other "void" elements)
+* End tags for void elements (BR, HR, INPUT, etc.)
+* Missing end tags, in most cases (e.g. missing `</div>`)
+
+The following are **permitted**:
+
+* Bare `>` characters
+* Bare `&` that can't be confused with a character reference
+* Uppercase or lowercase tag and attribute names (case insensitive)
+* Unquoted and valueless attributes - `<input type=checkbox checked>`
+* Most characters in attribute values - `<img alt=x,y>`
+* Embedded SVG elements
+
+**XXX Currently you have to close your Ps, LIs, and other tags for which the spec allows the end tag to be omitted in many cases**
+
+## Character References
+
+This package contains a lookup table for all known named character references in HTML, of which there are over 2,000, from `&Aacute;` (capital A, acute accent) to `&zwnj;` (zero-width non-joiner), as well as code for interpreting numeric character entities like `&#65;`.
+
+Since character references are parsed into `HTML.CharRef` objects which contain both the raw and interpreted form, we never have to convert between the forms except at parse time.
+
diff --git a/packages/html-tools/charref.js b/packages/html-tools/charref.js
new file mode 100644
index 0000000000..ff437ee8b8
--- /dev/null
+++ b/packages/html-tools/charref.js
@@ -0,0 +1,2414 @@
+
+// http://www.whatwg.org/specs/web-apps/current-work/multipage/entities.json
+
+
+// Note that some entities don't have a final semicolon!  These are used to
+// make `&lt` (for example) with no semicolon a parse error but `&abcde` not.
+
+var ENTITIES = {
+  "&Aacute;": { "codepoints": [193], "characters": "\u00C1" },
+  "&Aacute": { "codepoints": [193], "characters": "\u00C1" },
+  "&aacute;": { "codepoints": [225], "characters": "\u00E1" },
+  "&aacute": { "codepoints": [225], "characters": "\u00E1" },
+  "&Abreve;": { "codepoints": [258], "characters": "\u0102" },
+  "&abreve;": { "codepoints": [259], "characters": "\u0103" },
+  "&ac;": { "codepoints": [8766], "characters": "\u223E" },
+  "&acd;": { "codepoints": [8767], "characters": "\u223F" },
+  "&acE;": { "codepoints": [8766, 819], "characters": "\u223E\u0333" },
+  "&Acirc;": { "codepoints": [194], "characters": "\u00C2" },
+  "&Acirc": { "codepoints": [194], "characters": "\u00C2" },
+  "&acirc;": { "codepoints": [226], "characters": "\u00E2" },
+  "&acirc": { "codepoints": [226], "characters": "\u00E2" },
+  "&acute;": { "codepoints": [180], "characters": "\u00B4" },
+  "&acute": { "codepoints": [180], "characters": "\u00B4" },
+  "&Acy;": { "codepoints": [1040], "characters": "\u0410" },
+  "&acy;": { "codepoints": [1072], "characters": "\u0430" },
+  "&AElig;": { "codepoints": [198], "characters": "\u00C6" },
+  "&AElig": { "codepoints": [198], "characters": "\u00C6" },
+  "&aelig;": { "codepoints": [230], "characters": "\u00E6" },
+  "&aelig": { "codepoints": [230], "characters": "\u00E6" },
+  "&af;": { "codepoints": [8289], "characters": "\u2061" },
+  "&Afr;": { "codepoints": [120068], "characters": "\uD835\uDD04" },
+  "&afr;": { "codepoints": [120094], "characters": "\uD835\uDD1E" },
+  "&Agrave;": { "codepoints": [192], "characters": "\u00C0" },
+  "&Agrave": { "codepoints": [192], "characters": "\u00C0" },
+  "&agrave;": { "codepoints": [224], "characters": "\u00E0" },
+  "&agrave": { "codepoints": [224], "characters": "\u00E0" },
+  "&alefsym;": { "codepoints": [8501], "characters": "\u2135" },
+  "&aleph;": { "codepoints": [8501], "characters": "\u2135" },
+  "&Alpha;": { "codepoints": [913], "characters": "\u0391" },
+  "&alpha;": { "codepoints": [945], "characters": "\u03B1" },
+  "&Amacr;": { "codepoints": [256], "characters": "\u0100" },
+  "&amacr;": { "codepoints": [257], "characters": "\u0101" },
+  "&amalg;": { "codepoints": [10815], "characters": "\u2A3F" },
+  "&amp;": { "codepoints": [38], "characters": "\u0026" },
+  "&amp": { "codepoints": [38], "characters": "\u0026" },
+  "&AMP;": { "codepoints": [38], "characters": "\u0026" },
+  "&AMP": { "codepoints": [38], "characters": "\u0026" },
+  "&andand;": { "codepoints": [10837], "characters": "\u2A55" },
+  "&And;": { "codepoints": [10835], "characters": "\u2A53" },
+  "&and;": { "codepoints": [8743], "characters": "\u2227" },
+  "&andd;": { "codepoints": [10844], "characters": "\u2A5C" },
+  "&andslope;": { "codepoints": [10840], "characters": "\u2A58" },
+  "&andv;": { "codepoints": [10842], "characters": "\u2A5A" },
+  "&ang;": { "codepoints": [8736], "characters": "\u2220" },
+  "&ange;": { "codepoints": [10660], "characters": "\u29A4" },
+  "&angle;": { "codepoints": [8736], "characters": "\u2220" },
+  "&angmsdaa;": { "codepoints": [10664], "characters": "\u29A8" },
+  "&angmsdab;": { "codepoints": [10665], "characters": "\u29A9" },
+  "&angmsdac;": { "codepoints": [10666], "characters": "\u29AA" },
+  "&angmsdad;": { "codepoints": [10667], "characters": "\u29AB" },
+  "&angmsdae;": { "codepoints": [10668], "characters": "\u29AC" },
+  "&angmsdaf;": { "codepoints": [10669], "characters": "\u29AD" },
+  "&angmsdag;": { "codepoints": [10670], "characters": "\u29AE" },
+  "&angmsdah;": { "codepoints": [10671], "characters": "\u29AF" },
+  "&angmsd;": { "codepoints": [8737], "characters": "\u2221" },
+  "&angrt;": { "codepoints": [8735], "characters": "\u221F" },
+  "&angrtvb;": { "codepoints": [8894], "characters": "\u22BE" },
+  "&angrtvbd;": { "codepoints": [10653], "characters": "\u299D" },
+  "&angsph;": { "codepoints": [8738], "characters": "\u2222" },
+  "&angst;": { "codepoints": [197], "characters": "\u00C5" },
+  "&angzarr;": { "codepoints": [9084], "characters": "\u237C" },
+  "&Aogon;": { "codepoints": [260], "characters": "\u0104" },
+  "&aogon;": { "codepoints": [261], "characters": "\u0105" },
+  "&Aopf;": { "codepoints": [120120], "characters": "\uD835\uDD38" },
+  "&aopf;": { "codepoints": [120146], "characters": "\uD835\uDD52" },
+  "&apacir;": { "codepoints": [10863], "characters": "\u2A6F" },
+  "&ap;": { "codepoints": [8776], "characters": "\u2248" },
+  "&apE;": { "codepoints": [10864], "characters": "\u2A70" },
+  "&ape;": { "codepoints": [8778], "characters": "\u224A" },
+  "&apid;": { "codepoints": [8779], "characters": "\u224B" },
+  "&apos;": { "codepoints": [39], "characters": "\u0027" },
+  "&ApplyFunction;": { "codepoints": [8289], "characters": "\u2061" },
+  "&approx;": { "codepoints": [8776], "characters": "\u2248" },
+  "&approxeq;": { "codepoints": [8778], "characters": "\u224A" },
+  "&Aring;": { "codepoints": [197], "characters": "\u00C5" },
+  "&Aring": { "codepoints": [197], "characters": "\u00C5" },
+  "&aring;": { "codepoints": [229], "characters": "\u00E5" },
+  "&aring": { "codepoints": [229], "characters": "\u00E5" },
+  "&Ascr;": { "codepoints": [119964], "characters": "\uD835\uDC9C" },
+  "&ascr;": { "codepoints": [119990], "characters": "\uD835\uDCB6" },
+  "&Assign;": { "codepoints": [8788], "characters": "\u2254" },
+  "&ast;": { "codepoints": [42], "characters": "\u002A" },
+  "&asymp;": { "codepoints": [8776], "characters": "\u2248" },
+  "&asympeq;": { "codepoints": [8781], "characters": "\u224D" },
+  "&Atilde;": { "codepoints": [195], "characters": "\u00C3" },
+  "&Atilde": { "codepoints": [195], "characters": "\u00C3" },
+  "&atilde;": { "codepoints": [227], "characters": "\u00E3" },
+  "&atilde": { "codepoints": [227], "characters": "\u00E3" },
+  "&Auml;": { "codepoints": [196], "characters": "\u00C4" },
+  "&Auml": { "codepoints": [196], "characters": "\u00C4" },
+  "&auml;": { "codepoints": [228], "characters": "\u00E4" },
+  "&auml": { "codepoints": [228], "characters": "\u00E4" },
+  "&awconint;": { "codepoints": [8755], "characters": "\u2233" },
+  "&awint;": { "codepoints": [10769], "characters": "\u2A11" },
+  "&backcong;": { "codepoints": [8780], "characters": "\u224C" },
+  "&backepsilon;": { "codepoints": [1014], "characters": "\u03F6" },
+  "&backprime;": { "codepoints": [8245], "characters": "\u2035" },
+  "&backsim;": { "codepoints": [8765], "characters": "\u223D" },
+  "&backsimeq;": { "codepoints": [8909], "characters": "\u22CD" },
+  "&Backslash;": { "codepoints": [8726], "characters": "\u2216" },
+  "&Barv;": { "codepoints": [10983], "characters": "\u2AE7" },
+  "&barvee;": { "codepoints": [8893], "characters": "\u22BD" },
+  "&barwed;": { "codepoints": [8965], "characters": "\u2305" },
+  "&Barwed;": { "codepoints": [8966], "characters": "\u2306" },
+  "&barwedge;": { "codepoints": [8965], "characters": "\u2305" },
+  "&bbrk;": { "codepoints": [9141], "characters": "\u23B5" },
+  "&bbrktbrk;": { "codepoints": [9142], "characters": "\u23B6" },
+  "&bcong;": { "codepoints": [8780], "characters": "\u224C" },
+  "&Bcy;": { "codepoints": [1041], "characters": "\u0411" },
+  "&bcy;": { "codepoints": [1073], "characters": "\u0431" },
+  "&bdquo;": { "codepoints": [8222], "characters": "\u201E" },
+  "&becaus;": { "codepoints": [8757], "characters": "\u2235" },
+  "&because;": { "codepoints": [8757], "characters": "\u2235" },
+  "&Because;": { "codepoints": [8757], "characters": "\u2235" },
+  "&bemptyv;": { "codepoints": [10672], "characters": "\u29B0" },
+  "&bepsi;": { "codepoints": [1014], "characters": "\u03F6" },
+  "&bernou;": { "codepoints": [8492], "characters": "\u212C" },
+  "&Bernoullis;": { "codepoints": [8492], "characters": "\u212C" },
+  "&Beta;": { "codepoints": [914], "characters": "\u0392" },
+  "&beta;": { "codepoints": [946], "characters": "\u03B2" },
+  "&beth;": { "codepoints": [8502], "characters": "\u2136" },
+  "&between;": { "codepoints": [8812], "characters": "\u226C" },
+  "&Bfr;": { "codepoints": [120069], "characters": "\uD835\uDD05" },
+  "&bfr;": { "codepoints": [120095], "characters": "\uD835\uDD1F" },
+  "&bigcap;": { "codepoints": [8898], "characters": "\u22C2" },
+  "&bigcirc;": { "codepoints": [9711], "characters": "\u25EF" },
+  "&bigcup;": { "codepoints": [8899], "characters": "\u22C3" },
+  "&bigodot;": { "codepoints": [10752], "characters": "\u2A00" },
+  "&bigoplus;": { "codepoints": [10753], "characters": "\u2A01" },
+  "&bigotimes;": { "codepoints": [10754], "characters": "\u2A02" },
+  "&bigsqcup;": { "codepoints": [10758], "characters": "\u2A06" },
+  "&bigstar;": { "codepoints": [9733], "characters": "\u2605" },
+  "&bigtriangledown;": { "codepoints": [9661], "characters": "\u25BD" },
+  "&bigtriangleup;": { "codepoints": [9651], "characters": "\u25B3" },
+  "&biguplus;": { "codepoints": [10756], "characters": "\u2A04" },
+  "&bigvee;": { "codepoints": [8897], "characters": "\u22C1" },
+  "&bigwedge;": { "codepoints": [8896], "characters": "\u22C0" },
+  "&bkarow;": { "codepoints": [10509], "characters": "\u290D" },
+  "&blacklozenge;": { "codepoints": [10731], "characters": "\u29EB" },
+  "&blacksquare;": { "codepoints": [9642], "characters": "\u25AA" },
+  "&blacktriangle;": { "codepoints": [9652], "characters": "\u25B4" },
+  "&blacktriangledown;": { "codepoints": [9662], "characters": "\u25BE" },
+  "&blacktriangleleft;": { "codepoints": [9666], "characters": "\u25C2" },
+  "&blacktriangleright;": { "codepoints": [9656], "characters": "\u25B8" },
+  "&blank;": { "codepoints": [9251], "characters": "\u2423" },
+  "&blk12;": { "codepoints": [9618], "characters": "\u2592" },
+  "&blk14;": { "codepoints": [9617], "characters": "\u2591" },
+  "&blk34;": { "codepoints": [9619], "characters": "\u2593" },
+  "&block;": { "codepoints": [9608], "characters": "\u2588" },
+  "&bne;": { "codepoints": [61, 8421], "characters": "\u003D\u20E5" },
+  "&bnequiv;": { "codepoints": [8801, 8421], "characters": "\u2261\u20E5" },
+  "&bNot;": { "codepoints": [10989], "characters": "\u2AED" },
+  "&bnot;": { "codepoints": [8976], "characters": "\u2310" },
+  "&Bopf;": { "codepoints": [120121], "characters": "\uD835\uDD39" },
+  "&bopf;": { "codepoints": [120147], "characters": "\uD835\uDD53" },
+  "&bot;": { "codepoints": [8869], "characters": "\u22A5" },
+  "&bottom;": { "codepoints": [8869], "characters": "\u22A5" },
+  "&bowtie;": { "codepoints": [8904], "characters": "\u22C8" },
+  "&boxbox;": { "codepoints": [10697], "characters": "\u29C9" },
+  "&boxdl;": { "codepoints": [9488], "characters": "\u2510" },
+  "&boxdL;": { "codepoints": [9557], "characters": "\u2555" },
+  "&boxDl;": { "codepoints": [9558], "characters": "\u2556" },
+  "&boxDL;": { "codepoints": [9559], "characters": "\u2557" },
+  "&boxdr;": { "codepoints": [9484], "characters": "\u250C" },
+  "&boxdR;": { "codepoints": [9554], "characters": "\u2552" },
+  "&boxDr;": { "codepoints": [9555], "characters": "\u2553" },
+  "&boxDR;": { "codepoints": [9556], "characters": "\u2554" },
+  "&boxh;": { "codepoints": [9472], "characters": "\u2500" },
+  "&boxH;": { "codepoints": [9552], "characters": "\u2550" },
+  "&boxhd;": { "codepoints": [9516], "characters": "\u252C" },
+  "&boxHd;": { "codepoints": [9572], "characters": "\u2564" },
+  "&boxhD;": { "codepoints": [9573], "characters": "\u2565" },
+  "&boxHD;": { "codepoints": [9574], "characters": "\u2566" },
+  "&boxhu;": { "codepoints": [9524], "characters": "\u2534" },
+  "&boxHu;": { "codepoints": [9575], "characters": "\u2567" },
+  "&boxhU;": { "codepoints": [9576], "characters": "\u2568" },
+  "&boxHU;": { "codepoints": [9577], "characters": "\u2569" },
+  "&boxminus;": { "codepoints": [8863], "characters": "\u229F" },
+  "&boxplus;": { "codepoints": [8862], "characters": "\u229E" },
+  "&boxtimes;": { "codepoints": [8864], "characters": "\u22A0" },
+  "&boxul;": { "codepoints": [9496], "characters": "\u2518" },
+  "&boxuL;": { "codepoints": [9563], "characters": "\u255B" },
+  "&boxUl;": { "codepoints": [9564], "characters": "\u255C" },
+  "&boxUL;": { "codepoints": [9565], "characters": "\u255D" },
+  "&boxur;": { "codepoints": [9492], "characters": "\u2514" },
+  "&boxuR;": { "codepoints": [9560], "characters": "\u2558" },
+  "&boxUr;": { "codepoints": [9561], "characters": "\u2559" },
+  "&boxUR;": { "codepoints": [9562], "characters": "\u255A" },
+  "&boxv;": { "codepoints": [9474], "characters": "\u2502" },
+  "&boxV;": { "codepoints": [9553], "characters": "\u2551" },
+  "&boxvh;": { "codepoints": [9532], "characters": "\u253C" },
+  "&boxvH;": { "codepoints": [9578], "characters": "\u256A" },
+  "&boxVh;": { "codepoints": [9579], "characters": "\u256B" },
+  "&boxVH;": { "codepoints": [9580], "characters": "\u256C" },
+  "&boxvl;": { "codepoints": [9508], "characters": "\u2524" },
+  "&boxvL;": { "codepoints": [9569], "characters": "\u2561" },
+  "&boxVl;": { "codepoints": [9570], "characters": "\u2562" },
+  "&boxVL;": { "codepoints": [9571], "characters": "\u2563" },
+  "&boxvr;": { "codepoints": [9500], "characters": "\u251C" },
+  "&boxvR;": { "codepoints": [9566], "characters": "\u255E" },
+  "&boxVr;": { "codepoints": [9567], "characters": "\u255F" },
+  "&boxVR;": { "codepoints": [9568], "characters": "\u2560" },
+  "&bprime;": { "codepoints": [8245], "characters": "\u2035" },
+  "&breve;": { "codepoints": [728], "characters": "\u02D8" },
+  "&Breve;": { "codepoints": [728], "characters": "\u02D8" },
+  "&brvbar;": { "codepoints": [166], "characters": "\u00A6" },
+  "&brvbar": { "codepoints": [166], "characters": "\u00A6" },
+  "&bscr;": { "codepoints": [119991], "characters": "\uD835\uDCB7" },
+  "&Bscr;": { "codepoints": [8492], "characters": "\u212C" },
+  "&bsemi;": { "codepoints": [8271], "characters": "\u204F" },
+  "&bsim;": { "codepoints": [8765], "characters": "\u223D" },
+  "&bsime;": { "codepoints": [8909], "characters": "\u22CD" },
+  "&bsolb;": { "codepoints": [10693], "characters": "\u29C5" },
+  "&bsol;": { "codepoints": [92], "characters": "\u005C" },
+  "&bsolhsub;": { "codepoints": [10184], "characters": "\u27C8" },
+  "&bull;": { "codepoints": [8226], "characters": "\u2022" },
+  "&bullet;": { "codepoints": [8226], "characters": "\u2022" },
+  "&bump;": { "codepoints": [8782], "characters": "\u224E" },
+  "&bumpE;": { "codepoints": [10926], "characters": "\u2AAE" },
+  "&bumpe;": { "codepoints": [8783], "characters": "\u224F" },
+  "&Bumpeq;": { "codepoints": [8782], "characters": "\u224E" },
+  "&bumpeq;": { "codepoints": [8783], "characters": "\u224F" },
+  "&Cacute;": { "codepoints": [262], "characters": "\u0106" },
+  "&cacute;": { "codepoints": [263], "characters": "\u0107" },
+  "&capand;": { "codepoints": [10820], "characters": "\u2A44" },
+  "&capbrcup;": { "codepoints": [10825], "characters": "\u2A49" },
+  "&capcap;": { "codepoints": [10827], "characters": "\u2A4B" },
+  "&cap;": { "codepoints": [8745], "characters": "\u2229" },
+  "&Cap;": { "codepoints": [8914], "characters": "\u22D2" },
+  "&capcup;": { "codepoints": [10823], "characters": "\u2A47" },
+  "&capdot;": { "codepoints": [10816], "characters": "\u2A40" },
+  "&CapitalDifferentialD;": { "codepoints": [8517], "characters": "\u2145" },
+  "&caps;": { "codepoints": [8745, 65024], "characters": "\u2229\uFE00" },
+  "&caret;": { "codepoints": [8257], "characters": "\u2041" },
+  "&caron;": { "codepoints": [711], "characters": "\u02C7" },
+  "&Cayleys;": { "codepoints": [8493], "characters": "\u212D" },
+  "&ccaps;": { "codepoints": [10829], "characters": "\u2A4D" },
+  "&Ccaron;": { "codepoints": [268], "characters": "\u010C" },
+  "&ccaron;": { "codepoints": [269], "characters": "\u010D" },
+  "&Ccedil;": { "codepoints": [199], "characters": "\u00C7" },
+  "&Ccedil": { "codepoints": [199], "characters": "\u00C7" },
+  "&ccedil;": { "codepoints": [231], "characters": "\u00E7" },
+  "&ccedil": { "codepoints": [231], "characters": "\u00E7" },
+  "&Ccirc;": { "codepoints": [264], "characters": "\u0108" },
+  "&ccirc;": { "codepoints": [265], "characters": "\u0109" },
+  "&Cconint;": { "codepoints": [8752], "characters": "\u2230" },
+  "&ccups;": { "codepoints": [10828], "characters": "\u2A4C" },
+  "&ccupssm;": { "codepoints": [10832], "characters": "\u2A50" },
+  "&Cdot;": { "codepoints": [266], "characters": "\u010A" },
+  "&cdot;": { "codepoints": [267], "characters": "\u010B" },
+  "&cedil;": { "codepoints": [184], "characters": "\u00B8" },
+  "&cedil": { "codepoints": [184], "characters": "\u00B8" },
+  "&Cedilla;": { "codepoints": [184], "characters": "\u00B8" },
+  "&cemptyv;": { "codepoints": [10674], "characters": "\u29B2" },
+  "&cent;": { "codepoints": [162], "characters": "\u00A2" },
+  "&cent": { "codepoints": [162], "characters": "\u00A2" },
+  "&centerdot;": { "codepoints": [183], "characters": "\u00B7" },
+  "&CenterDot;": { "codepoints": [183], "characters": "\u00B7" },
+  "&cfr;": { "codepoints": [120096], "characters": "\uD835\uDD20" },
+  "&Cfr;": { "codepoints": [8493], "characters": "\u212D" },
+  "&CHcy;": { "codepoints": [1063], "characters": "\u0427" },
+  "&chcy;": { "codepoints": [1095], "characters": "\u0447" },
+  "&check;": { "codepoints": [10003], "characters": "\u2713" },
+  "&checkmark;": { "codepoints": [10003], "characters": "\u2713" },
+  "&Chi;": { "codepoints": [935], "characters": "\u03A7" },
+  "&chi;": { "codepoints": [967], "characters": "\u03C7" },
+  "&circ;": { "codepoints": [710], "characters": "\u02C6" },
+  "&circeq;": { "codepoints": [8791], "characters": "\u2257" },
+  "&circlearrowleft;": { "codepoints": [8634], "characters": "\u21BA" },
+  "&circlearrowright;": { "codepoints": [8635], "characters": "\u21BB" },
+  "&circledast;": { "codepoints": [8859], "characters": "\u229B" },
+  "&circledcirc;": { "codepoints": [8858], "characters": "\u229A" },
+  "&circleddash;": { "codepoints": [8861], "characters": "\u229D" },
+  "&CircleDot;": { "codepoints": [8857], "characters": "\u2299" },
+  "&circledR;": { "codepoints": [174], "characters": "\u00AE" },
+  "&circledS;": { "codepoints": [9416], "characters": "\u24C8" },
+  "&CircleMinus;": { "codepoints": [8854], "characters": "\u2296" },
+  "&CirclePlus;": { "codepoints": [8853], "characters": "\u2295" },
+  "&CircleTimes;": { "codepoints": [8855], "characters": "\u2297" },
+  "&cir;": { "codepoints": [9675], "characters": "\u25CB" },
+  "&cirE;": { "codepoints": [10691], "characters": "\u29C3" },
+  "&cire;": { "codepoints": [8791], "characters": "\u2257" },
+  "&cirfnint;": { "codepoints": [10768], "characters": "\u2A10" },
+  "&cirmid;": { "codepoints": [10991], "characters": "\u2AEF" },
+  "&cirscir;": { "codepoints": [10690], "characters": "\u29C2" },
+  "&ClockwiseContourIntegral;": { "codepoints": [8754], "characters": "\u2232" },
+  "&CloseCurlyDoubleQuote;": { "codepoints": [8221], "characters": "\u201D" },
+  "&CloseCurlyQuote;": { "codepoints": [8217], "characters": "\u2019" },
+  "&clubs;": { "codepoints": [9827], "characters": "\u2663" },
+  "&clubsuit;": { "codepoints": [9827], "characters": "\u2663" },
+  "&colon;": { "codepoints": [58], "characters": "\u003A" },
+  "&Colon;": { "codepoints": [8759], "characters": "\u2237" },
+  "&Colone;": { "codepoints": [10868], "characters": "\u2A74" },
+  "&colone;": { "codepoints": [8788], "characters": "\u2254" },
+  "&coloneq;": { "codepoints": [8788], "characters": "\u2254" },
+  "&comma;": { "codepoints": [44], "characters": "\u002C" },
+  "&commat;": { "codepoints": [64], "characters": "\u0040" },
+  "&comp;": { "codepoints": [8705], "characters": "\u2201" },
+  "&compfn;": { "codepoints": [8728], "characters": "\u2218" },
+  "&complement;": { "codepoints": [8705], "characters": "\u2201" },
+  "&complexes;": { "codepoints": [8450], "characters": "\u2102" },
+  "&cong;": { "codepoints": [8773], "characters": "\u2245" },
+  "&congdot;": { "codepoints": [10861], "characters": "\u2A6D" },
+  "&Congruent;": { "codepoints": [8801], "characters": "\u2261" },
+  "&conint;": { "codepoints": [8750], "characters": "\u222E" },
+  "&Conint;": { "codepoints": [8751], "characters": "\u222F" },
+  "&ContourIntegral;": { "codepoints": [8750], "characters": "\u222E" },
+  "&copf;": { "codepoints": [120148], "characters": "\uD835\uDD54" },
+  "&Copf;": { "codepoints": [8450], "characters": "\u2102" },
+  "&coprod;": { "codepoints": [8720], "characters": "\u2210" },
+  "&Coproduct;": { "codepoints": [8720], "characters": "\u2210" },
+  "&copy;": { "codepoints": [169], "characters": "\u00A9" },
+  "&copy": { "codepoints": [169], "characters": "\u00A9" },
+  "&COPY;": { "codepoints": [169], "characters": "\u00A9" },
+  "&COPY": { "codepoints": [169], "characters": "\u00A9" },
+  "&copysr;": { "codepoints": [8471], "characters": "\u2117" },
+  "&CounterClockwiseContourIntegral;": { "codepoints": [8755], "characters": "\u2233" },
+  "&crarr;": { "codepoints": [8629], "characters": "\u21B5" },
+  "&cross;": { "codepoints": [10007], "characters": "\u2717" },
+  "&Cross;": { "codepoints": [10799], "characters": "\u2A2F" },
+  "&Cscr;": { "codepoints": [119966], "characters": "\uD835\uDC9E" },
+  "&cscr;": { "codepoints": [119992], "characters": "\uD835\uDCB8" },
+  "&csub;": { "codepoints": [10959], "characters": "\u2ACF" },
+  "&csube;": { "codepoints": [10961], "characters": "\u2AD1" },
+  "&csup;": { "codepoints": [10960], "characters": "\u2AD0" },
+  "&csupe;": { "codepoints": [10962], "characters": "\u2AD2" },
+  "&ctdot;": { "codepoints": [8943], "characters": "\u22EF" },
+  "&cudarrl;": { "codepoints": [10552], "characters": "\u2938" },
+  "&cudarrr;": { "codepoints": [10549], "characters": "\u2935" },
+  "&cuepr;": { "codepoints": [8926], "characters": "\u22DE" },
+  "&cuesc;": { "codepoints": [8927], "characters": "\u22DF" },
+  "&cularr;": { "codepoints": [8630], "characters": "\u21B6" },
+  "&cularrp;": { "codepoints": [10557], "characters": "\u293D" },
+  "&cupbrcap;": { "codepoints": [10824], "characters": "\u2A48" },
+  "&cupcap;": { "codepoints": [10822], "characters": "\u2A46" },
+  "&CupCap;": { "codepoints": [8781], "characters": "\u224D" },
+  "&cup;": { "codepoints": [8746], "characters": "\u222A" },
+  "&Cup;": { "codepoints": [8915], "characters": "\u22D3" },
+  "&cupcup;": { "codepoints": [10826], "characters": "\u2A4A" },
+  "&cupdot;": { "codepoints": [8845], "characters": "\u228D" },
+  "&cupor;": { "codepoints": [10821], "characters": "\u2A45" },
+  "&cups;": { "codepoints": [8746, 65024], "characters": "\u222A\uFE00" },
+  "&curarr;": { "codepoints": [8631], "characters": "\u21B7" },
+  "&curarrm;": { "codepoints": [10556], "characters": "\u293C" },
+  "&curlyeqprec;": { "codepoints": [8926], "characters": "\u22DE" },
+  "&curlyeqsucc;": { "codepoints": [8927], "characters": "\u22DF" },
+  "&curlyvee;": { "codepoints": [8910], "characters": "\u22CE" },
+  "&curlywedge;": { "codepoints": [8911], "characters": "\u22CF" },
+  "&curren;": { "codepoints": [164], "characters": "\u00A4" },
+  "&curren": { "codepoints": [164], "characters": "\u00A4" },
+  "&curvearrowleft;": { "codepoints": [8630], "characters": "\u21B6" },
+  "&curvearrowright;": { "codepoints": [8631], "characters": "\u21B7" },
+  "&cuvee;": { "codepoints": [8910], "characters": "\u22CE" },
+  "&cuwed;": { "codepoints": [8911], "characters": "\u22CF" },
+  "&cwconint;": { "codepoints": [8754], "characters": "\u2232" },
+  "&cwint;": { "codepoints": [8753], "characters": "\u2231" },
+  "&cylcty;": { "codepoints": [9005], "characters": "\u232D" },
+  "&dagger;": { "codepoints": [8224], "characters": "\u2020" },
+  "&Dagger;": { "codepoints": [8225], "characters": "\u2021" },
+  "&daleth;": { "codepoints": [8504], "characters": "\u2138" },
+  "&darr;": { "codepoints": [8595], "characters": "\u2193" },
+  "&Darr;": { "codepoints": [8609], "characters": "\u21A1" },
+  "&dArr;": { "codepoints": [8659], "characters": "\u21D3" },
+  "&dash;": { "codepoints": [8208], "characters": "\u2010" },
+  "&Dashv;": { "codepoints": [10980], "characters": "\u2AE4" },
+  "&dashv;": { "codepoints": [8867], "characters": "\u22A3" },
+  "&dbkarow;": { "codepoints": [10511], "characters": "\u290F" },
+  "&dblac;": { "codepoints": [733], "characters": "\u02DD" },
+  "&Dcaron;": { "codepoints": [270], "characters": "\u010E" },
+  "&dcaron;": { "codepoints": [271], "characters": "\u010F" },
+  "&Dcy;": { "codepoints": [1044], "characters": "\u0414" },
+  "&dcy;": { "codepoints": [1076], "characters": "\u0434" },
+  "&ddagger;": { "codepoints": [8225], "characters": "\u2021" },
+  "&ddarr;": { "codepoints": [8650], "characters": "\u21CA" },
+  "&DD;": { "codepoints": [8517], "characters": "\u2145" },
+  "&dd;": { "codepoints": [8518], "characters": "\u2146" },
+  "&DDotrahd;": { "codepoints": [10513], "characters": "\u2911" },
+  "&ddotseq;": { "codepoints": [10871], "characters": "\u2A77" },
+  "&deg;": { "codepoints": [176], "characters": "\u00B0" },
+  "&deg": { "codepoints": [176], "characters": "\u00B0" },
+  "&Del;": { "codepoints": [8711], "characters": "\u2207" },
+  "&Delta;": { "codepoints": [916], "characters": "\u0394" },
+  "&delta;": { "codepoints": [948], "characters": "\u03B4" },
+  "&demptyv;": { "codepoints": [10673], "characters": "\u29B1" },
+  "&dfisht;": { "codepoints": [10623], "characters": "\u297F" },
+  "&Dfr;": { "codepoints": [120071], "characters": "\uD835\uDD07" },
+  "&dfr;": { "codepoints": [120097], "characters": "\uD835\uDD21" },
+  "&dHar;": { "codepoints": [10597], "characters": "\u2965" },
+  "&dharl;": { "codepoints": [8643], "characters": "\u21C3" },
+  "&dharr;": { "codepoints": [8642], "characters": "\u21C2" },
+  "&DiacriticalAcute;": { "codepoints": [180], "characters": "\u00B4" },
+  "&DiacriticalDot;": { "codepoints": [729], "characters": "\u02D9" },
+  "&DiacriticalDoubleAcute;": { "codepoints": [733], "characters": "\u02DD" },
+  "&DiacriticalGrave;": { "codepoints": [96], "characters": "\u0060" },
+  "&DiacriticalTilde;": { "codepoints": [732], "characters": "\u02DC" },
+  "&diam;": { "codepoints": [8900], "characters": "\u22C4" },
+  "&diamond;": { "codepoints": [8900], "characters": "\u22C4" },
+  "&Diamond;": { "codepoints": [8900], "characters": "\u22C4" },
+  "&diamondsuit;": { "codepoints": [9830], "characters": "\u2666" },
+  "&diams;": { "codepoints": [9830], "characters": "\u2666" },
+  "&die;": { "codepoints": [168], "characters": "\u00A8" },
+  "&DifferentialD;": { "codepoints": [8518], "characters": "\u2146" },
+  "&digamma;": { "codepoints": [989], "characters": "\u03DD" },
+  "&disin;": { "codepoints": [8946], "characters": "\u22F2" },
+  "&div;": { "codepoints": [247], "characters": "\u00F7" },
+  "&divide;": { "codepoints": [247], "characters": "\u00F7" },
+  "&divide": { "codepoints": [247], "characters": "\u00F7" },
+  "&divideontimes;": { "codepoints": [8903], "characters": "\u22C7" },
+  "&divonx;": { "codepoints": [8903], "characters": "\u22C7" },
+  "&DJcy;": { "codepoints": [1026], "characters": "\u0402" },
+  "&djcy;": { "codepoints": [1106], "characters": "\u0452" },
+  "&dlcorn;": { "codepoints": [8990], "characters": "\u231E" },
+  "&dlcrop;": { "codepoints": [8973], "characters": "\u230D" },
+  "&dollar;": { "codepoints": [36], "characters": "\u0024" },
+  "&Dopf;": { "codepoints": [120123], "characters": "\uD835\uDD3B" },
+  "&dopf;": { "codepoints": [120149], "characters": "\uD835\uDD55" },
+  "&Dot;": { "codepoints": [168], "characters": "\u00A8" },
+  "&dot;": { "codepoints": [729], "characters": "\u02D9" },
+  "&DotDot;": { "codepoints": [8412], "characters": "\u20DC" },
+  "&doteq;": { "codepoints": [8784], "characters": "\u2250" },
+  "&doteqdot;": { "codepoints": [8785], "characters": "\u2251" },
+  "&DotEqual;": { "codepoints": [8784], "characters": "\u2250" },
+  "&dotminus;": { "codepoints": [8760], "characters": "\u2238" },
+  "&dotplus;": { "codepoints": [8724], "characters": "\u2214" },
+  "&dotsquare;": { "codepoints": [8865], "characters": "\u22A1" },
+  "&doublebarwedge;": { "codepoints": [8966], "characters": "\u2306" },
+  "&DoubleContourIntegral;": { "codepoints": [8751], "characters": "\u222F" },
+  "&DoubleDot;": { "codepoints": [168], "characters": "\u00A8" },
+  "&DoubleDownArrow;": { "codepoints": [8659], "characters": "\u21D3" },
+  "&DoubleLeftArrow;": { "codepoints": [8656], "characters": "\u21D0" },
+  "&DoubleLeftRightArrow;": { "codepoints": [8660], "characters": "\u21D4" },
+  "&DoubleLeftTee;": { "codepoints": [10980], "characters": "\u2AE4" },
+  "&DoubleLongLeftArrow;": { "codepoints": [10232], "characters": "\u27F8" },
+  "&DoubleLongLeftRightArrow;": { "codepoints": [10234], "characters": "\u27FA" },
+  "&DoubleLongRightArrow;": { "codepoints": [10233], "characters": "\u27F9" },
+  "&DoubleRightArrow;": { "codepoints": [8658], "characters": "\u21D2" },
+  "&DoubleRightTee;": { "codepoints": [8872], "characters": "\u22A8" },
+  "&DoubleUpArrow;": { "codepoints": [8657], "characters": "\u21D1" },
+  "&DoubleUpDownArrow;": { "codepoints": [8661], "characters": "\u21D5" },
+  "&DoubleVerticalBar;": { "codepoints": [8741], "characters": "\u2225" },
+  "&DownArrowBar;": { "codepoints": [10515], "characters": "\u2913" },
+  "&downarrow;": { "codepoints": [8595], "characters": "\u2193" },
+  "&DownArrow;": { "codepoints": [8595], "characters": "\u2193" },
+  "&Downarrow;": { "codepoints": [8659], "characters": "\u21D3" },
+  "&DownArrowUpArrow;": { "codepoints": [8693], "characters": "\u21F5" },
+  "&DownBreve;": { "codepoints": [785], "characters": "\u0311" },
+  "&downdownarrows;": { "codepoints": [8650], "characters": "\u21CA" },
+  "&downharpoonleft;": { "codepoints": [8643], "characters": "\u21C3" },
+  "&downharpoonright;": { "codepoints": [8642], "characters": "\u21C2" },
+  "&DownLeftRightVector;": { "codepoints": [10576], "characters": "\u2950" },
+  "&DownLeftTeeVector;": { "codepoints": [10590], "characters": "\u295E" },
+  "&DownLeftVectorBar;": { "codepoints": [10582], "characters": "\u2956" },
+  "&DownLeftVector;": { "codepoints": [8637], "characters": "\u21BD" },
+  "&DownRightTeeVector;": { "codepoints": [10591], "characters": "\u295F" },
+  "&DownRightVectorBar;": { "codepoints": [10583], "characters": "\u2957" },
+  "&DownRightVector;": { "codepoints": [8641], "characters": "\u21C1" },
+  "&DownTeeArrow;": { "codepoints": [8615], "characters": "\u21A7" },
+  "&DownTee;": { "codepoints": [8868], "characters": "\u22A4" },
+  "&drbkarow;": { "codepoints": [10512], "characters": "\u2910" },
+  "&drcorn;": { "codepoints": [8991], "characters": "\u231F" },
+  "&drcrop;": { "codepoints": [8972], "characters": "\u230C" },
+  "&Dscr;": { "codepoints": [119967], "characters": "\uD835\uDC9F" },
+  "&dscr;": { "codepoints": [119993], "characters": "\uD835\uDCB9" },
+  "&DScy;": { "codepoints": [1029], "characters": "\u0405" },
+  "&dscy;": { "codepoints": [1109], "characters": "\u0455" },
+  "&dsol;": { "codepoints": [10742], "characters": "\u29F6" },
+  "&Dstrok;": { "codepoints": [272], "characters": "\u0110" },
+  "&dstrok;": { "codepoints": [273], "characters": "\u0111" },
+  "&dtdot;": { "codepoints": [8945], "characters": "\u22F1" },
+  "&dtri;": { "codepoints": [9663], "characters": "\u25BF" },
+  "&dtrif;": { "codepoints": [9662], "characters": "\u25BE" },
+  "&duarr;": { "codepoints": [8693], "characters": "\u21F5" },
+  "&duhar;": { "codepoints": [10607], "characters": "\u296F" },
+  "&dwangle;": { "codepoints": [10662], "characters": "\u29A6" },
+  "&DZcy;": { "codepoints": [1039], "characters": "\u040F" },
+  "&dzcy;": { "codepoints": [1119], "characters": "\u045F" },
+  "&dzigrarr;": { "codepoints": [10239], "characters": "\u27FF" },
+  "&Eacute;": { "codepoints": [201], "characters": "\u00C9" },
+  "&Eacute": { "codepoints": [201], "characters": "\u00C9" },
+  "&eacute;": { "codepoints": [233], "characters": "\u00E9" },
+  "&eacute": { "codepoints": [233], "characters": "\u00E9" },
+  "&easter;": { "codepoints": [10862], "characters": "\u2A6E" },
+  "&Ecaron;": { "codepoints": [282], "characters": "\u011A" },
+  "&ecaron;": { "codepoints": [283], "characters": "\u011B" },
+  "&Ecirc;": { "codepoints": [202], "characters": "\u00CA" },
+  "&Ecirc": { "codepoints": [202], "characters": "\u00CA" },
+  "&ecirc;": { "codepoints": [234], "characters": "\u00EA" },
+  "&ecirc": { "codepoints": [234], "characters": "\u00EA" },
+  "&ecir;": { "codepoints": [8790], "characters": "\u2256" },
+  "&ecolon;": { "codepoints": [8789], "characters": "\u2255" },
+  "&Ecy;": { "codepoints": [1069], "characters": "\u042D" },
+  "&ecy;": { "codepoints": [1101], "characters": "\u044D" },
+  "&eDDot;": { "codepoints": [10871], "characters": "\u2A77" },
+  "&Edot;": { "codepoints": [278], "characters": "\u0116" },
+  "&edot;": { "codepoints": [279], "characters": "\u0117" },
+  "&eDot;": { "codepoints": [8785], "characters": "\u2251" },
+  "&ee;": { "codepoints": [8519], "characters": "\u2147" },
+  "&efDot;": { "codepoints": [8786], "characters": "\u2252" },
+  "&Efr;": { "codepoints": [120072], "characters": "\uD835\uDD08" },
+  "&efr;": { "codepoints": [120098], "characters": "\uD835\uDD22" },
+  "&eg;": { "codepoints": [10906], "characters": "\u2A9A" },
+  "&Egrave;": { "codepoints": [200], "characters": "\u00C8" },
+  "&Egrave": { "codepoints": [200], "characters": "\u00C8" },
+  "&egrave;": { "codepoints": [232], "characters": "\u00E8" },
+  "&egrave": { "codepoints": [232], "characters": "\u00E8" },
+  "&egs;": { "codepoints": [10902], "characters": "\u2A96" },
+  "&egsdot;": { "codepoints": [10904], "characters": "\u2A98" },
+  "&el;": { "codepoints": [10905], "characters": "\u2A99" },
+  "&Element;": { "codepoints": [8712], "characters": "\u2208" },
+  "&elinters;": { "codepoints": [9191], "characters": "\u23E7" },
+  "&ell;": { "codepoints": [8467], "characters": "\u2113" },
+  "&els;": { "codepoints": [10901], "characters": "\u2A95" },
+  "&elsdot;": { "codepoints": [10903], "characters": "\u2A97" },
+  "&Emacr;": { "codepoints": [274], "characters": "\u0112" },
+  "&emacr;": { "codepoints": [275], "characters": "\u0113" },
+  "&empty;": { "codepoints": [8709], "characters": "\u2205" },
+  "&emptyset;": { "codepoints": [8709], "characters": "\u2205" },
+  "&EmptySmallSquare;": { "codepoints": [9723], "characters": "\u25FB" },
+  "&emptyv;": { "codepoints": [8709], "characters": "\u2205" },
+  "&EmptyVerySmallSquare;": { "codepoints": [9643], "characters": "\u25AB" },
+  "&emsp13;": { "codepoints": [8196], "characters": "\u2004" },
+  "&emsp14;": { "codepoints": [8197], "characters": "\u2005" },
+  "&emsp;": { "codepoints": [8195], "characters": "\u2003" },
+  "&ENG;": { "codepoints": [330], "characters": "\u014A" },
+  "&eng;": { "codepoints": [331], "characters": "\u014B" },
+  "&ensp;": { "codepoints": [8194], "characters": "\u2002" },
+  "&Eogon;": { "codepoints": [280], "characters": "\u0118" },
+  "&eogon;": { "codepoints": [281], "characters": "\u0119" },
+  "&Eopf;": { "codepoints": [120124], "characters": "\uD835\uDD3C" },
+  "&eopf;": { "codepoints": [120150], "characters": "\uD835\uDD56" },
+  "&epar;": { "codepoints": [8917], "characters": "\u22D5" },
+  "&eparsl;": { "codepoints": [10723], "characters": "\u29E3" },
+  "&eplus;": { "codepoints": [10865], "characters": "\u2A71" },
+  "&epsi;": { "codepoints": [949], "characters": "\u03B5" },
+  "&Epsilon;": { "codepoints": [917], "characters": "\u0395" },
+  "&epsilon;": { "codepoints": [949], "characters": "\u03B5" },
+  "&epsiv;": { "codepoints": [1013], "characters": "\u03F5" },
+  "&eqcirc;": { "codepoints": [8790], "characters": "\u2256" },
+  "&eqcolon;": { "codepoints": [8789], "characters": "\u2255" },
+  "&eqsim;": { "codepoints": [8770], "characters": "\u2242" },
+  "&eqslantgtr;": { "codepoints": [10902], "characters": "\u2A96" },
+  "&eqslantless;": { "codepoints": [10901], "characters": "\u2A95" },
+  "&Equal;": { "codepoints": [10869], "characters": "\u2A75" },
+  "&equals;": { "codepoints": [61], "characters": "\u003D" },
+  "&EqualTilde;": { "codepoints": [8770], "characters": "\u2242" },
+  "&equest;": { "codepoints": [8799], "characters": "\u225F" },
+  "&Equilibrium;": { "codepoints": [8652], "characters": "\u21CC" },
+  "&equiv;": { "codepoints": [8801], "characters": "\u2261" },
+  "&equivDD;": { "codepoints": [10872], "characters": "\u2A78" },
+  "&eqvparsl;": { "codepoints": [10725], "characters": "\u29E5" },
+  "&erarr;": { "codepoints": [10609], "characters": "\u2971" },
+  "&erDot;": { "codepoints": [8787], "characters": "\u2253" },
+  "&escr;": { "codepoints": [8495], "characters": "\u212F" },
+  "&Escr;": { "codepoints": [8496], "characters": "\u2130" },
+  "&esdot;": { "codepoints": [8784], "characters": "\u2250" },
+  "&Esim;": { "codepoints": [10867], "characters": "\u2A73" },
+  "&esim;": { "codepoints": [8770], "characters": "\u2242" },
+  "&Eta;": { "codepoints": [919], "characters": "\u0397" },
+  "&eta;": { "codepoints": [951], "characters": "\u03B7" },
+  "&ETH;": { "codepoints": [208], "characters": "\u00D0" },
+  "&ETH": { "codepoints": [208], "characters": "\u00D0" },
+  "&eth;": { "codepoints": [240], "characters": "\u00F0" },
+  "&eth": { "codepoints": [240], "characters": "\u00F0" },
+  "&Euml;": { "codepoints": [203], "characters": "\u00CB" },
+  "&Euml": { "codepoints": [203], "characters": "\u00CB" },
+  "&euml;": { "codepoints": [235], "characters": "\u00EB" },
+  "&euml": { "codepoints": [235], "characters": "\u00EB" },
+  "&euro;": { "codepoints": [8364], "characters": "\u20AC" },
+  "&excl;": { "codepoints": [33], "characters": "\u0021" },
+  "&exist;": { "codepoints": [8707], "characters": "\u2203" },
+  "&Exists;": { "codepoints": [8707], "characters": "\u2203" },
+  "&expectation;": { "codepoints": [8496], "characters": "\u2130" },
+  "&exponentiale;": { "codepoints": [8519], "characters": "\u2147" },
+  "&ExponentialE;": { "codepoints": [8519], "characters": "\u2147" },
+  "&fallingdotseq;": { "codepoints": [8786], "characters": "\u2252" },
+  "&Fcy;": { "codepoints": [1060], "characters": "\u0424" },
+  "&fcy;": { "codepoints": [1092], "characters": "\u0444" },
+  "&female;": { "codepoints": [9792], "characters": "\u2640" },
+  "&ffilig;": { "codepoints": [64259], "characters": "\uFB03" },
+  "&fflig;": { "codepoints": [64256], "characters": "\uFB00" },
+  "&ffllig;": { "codepoints": [64260], "characters": "\uFB04" },
+  "&Ffr;": { "codepoints": [120073], "characters": "\uD835\uDD09" },
+  "&ffr;": { "codepoints": [120099], "characters": "\uD835\uDD23" },
+  "&filig;": { "codepoints": [64257], "characters": "\uFB01" },
+  "&FilledSmallSquare;": { "codepoints": [9724], "characters": "\u25FC" },
+  "&FilledVerySmallSquare;": { "codepoints": [9642], "characters": "\u25AA" },
+  "&fjlig;": { "codepoints": [102, 106], "characters": "\u0066\u006A" },
+  "&flat;": { "codepoints": [9837], "characters": "\u266D" },
+  "&fllig;": { "codepoints": [64258], "characters": "\uFB02" },
+  "&fltns;": { "codepoints": [9649], "characters": "\u25B1" },
+  "&fnof;": { "codepoints": [402], "characters": "\u0192" },
+  "&Fopf;": { "codepoints": [120125], "characters": "\uD835\uDD3D" },
+  "&fopf;": { "codepoints": [120151], "characters": "\uD835\uDD57" },
+  "&forall;": { "codepoints": [8704], "characters": "\u2200" },
+  "&ForAll;": { "codepoints": [8704], "characters": "\u2200" },
+  "&fork;": { "codepoints": [8916], "characters": "\u22D4" },
+  "&forkv;": { "codepoints": [10969], "characters": "\u2AD9" },
+  "&Fouriertrf;": { "codepoints": [8497], "characters": "\u2131" },
+  "&fpartint;": { "codepoints": [10765], "characters": "\u2A0D" },
+  "&frac12;": { "codepoints": [189], "characters": "\u00BD" },
+  "&frac12": { "codepoints": [189], "characters": "\u00BD" },
+  "&frac13;": { "codepoints": [8531], "characters": "\u2153" },
+  "&frac14;": { "codepoints": [188], "characters": "\u00BC" },
+  "&frac14": { "codepoints": [188], "characters": "\u00BC" },
+  "&frac15;": { "codepoints": [8533], "characters": "\u2155" },
+  "&frac16;": { "codepoints": [8537], "characters": "\u2159" },
+  "&frac18;": { "codepoints": [8539], "characters": "\u215B" },
+  "&frac23;": { "codepoints": [8532], "characters": "\u2154" },
+  "&frac25;": { "codepoints": [8534], "characters": "\u2156" },
+  "&frac34;": { "codepoints": [190], "characters": "\u00BE" },
+  "&frac34": { "codepoints": [190], "characters": "\u00BE" },
+  "&frac35;": { "codepoints": [8535], "characters": "\u2157" },
+  "&frac38;": { "codepoints": [8540], "characters": "\u215C" },
+  "&frac45;": { "codepoints": [8536], "characters": "\u2158" },
+  "&frac56;": { "codepoints": [8538], "characters": "\u215A" },
+  "&frac58;": { "codepoints": [8541], "characters": "\u215D" },
+  "&frac78;": { "codepoints": [8542], "characters": "\u215E" },
+  "&frasl;": { "codepoints": [8260], "characters": "\u2044" },
+  "&frown;": { "codepoints": [8994], "characters": "\u2322" },
+  "&fscr;": { "codepoints": [119995], "characters": "\uD835\uDCBB" },
+  "&Fscr;": { "codepoints": [8497], "characters": "\u2131" },
+  "&gacute;": { "codepoints": [501], "characters": "\u01F5" },
+  "&Gamma;": { "codepoints": [915], "characters": "\u0393" },
+  "&gamma;": { "codepoints": [947], "characters": "\u03B3" },
+  "&Gammad;": { "codepoints": [988], "characters": "\u03DC" },
+  "&gammad;": { "codepoints": [989], "characters": "\u03DD" },
+  "&gap;": { "codepoints": [10886], "characters": "\u2A86" },
+  "&Gbreve;": { "codepoints": [286], "characters": "\u011E" },
+  "&gbreve;": { "codepoints": [287], "characters": "\u011F" },
+  "&Gcedil;": { "codepoints": [290], "characters": "\u0122" },
+  "&Gcirc;": { "codepoints": [284], "characters": "\u011C" },
+  "&gcirc;": { "codepoints": [285], "characters": "\u011D" },
+  "&Gcy;": { "codepoints": [1043], "characters": "\u0413" },
+  "&gcy;": { "codepoints": [1075], "characters": "\u0433" },
+  "&Gdot;": { "codepoints": [288], "characters": "\u0120" },
+  "&gdot;": { "codepoints": [289], "characters": "\u0121" },
+  "&ge;": { "codepoints": [8805], "characters": "\u2265" },
+  "&gE;": { "codepoints": [8807], "characters": "\u2267" },
+  "&gEl;": { "codepoints": [10892], "characters": "\u2A8C" },
+  "&gel;": { "codepoints": [8923], "characters": "\u22DB" },
+  "&geq;": { "codepoints": [8805], "characters": "\u2265" },
+  "&geqq;": { "codepoints": [8807], "characters": "\u2267" },
+  "&geqslant;": { "codepoints": [10878], "characters": "\u2A7E" },
+  "&gescc;": { "codepoints": [10921], "characters": "\u2AA9" },
+  "&ges;": { "codepoints": [10878], "characters": "\u2A7E" },
+  "&gesdot;": { "codepoints": [10880], "characters": "\u2A80" },
+  "&gesdoto;": { "codepoints": [10882], "characters": "\u2A82" },
+  "&gesdotol;": { "codepoints": [10884], "characters": "\u2A84" },
+  "&gesl;": { "codepoints": [8923, 65024], "characters": "\u22DB\uFE00" },
+  "&gesles;": { "codepoints": [10900], "characters": "\u2A94" },
+  "&Gfr;": { "codepoints": [120074], "characters": "\uD835\uDD0A" },
+  "&gfr;": { "codepoints": [120100], "characters": "\uD835\uDD24" },
+  "&gg;": { "codepoints": [8811], "characters": "\u226B" },
+  "&Gg;": { "codepoints": [8921], "characters": "\u22D9" },
+  "&ggg;": { "codepoints": [8921], "characters": "\u22D9" },
+  "&gimel;": { "codepoints": [8503], "characters": "\u2137" },
+  "&GJcy;": { "codepoints": [1027], "characters": "\u0403" },
+  "&gjcy;": { "codepoints": [1107], "characters": "\u0453" },
+  "&gla;": { "codepoints": [10917], "characters": "\u2AA5" },
+  "&gl;": { "codepoints": [8823], "characters": "\u2277" },
+  "&glE;": { "codepoints": [10898], "characters": "\u2A92" },
+  "&glj;": { "codepoints": [10916], "characters": "\u2AA4" },
+  "&gnap;": { "codepoints": [10890], "characters": "\u2A8A" },
+  "&gnapprox;": { "codepoints": [10890], "characters": "\u2A8A" },
+  "&gne;": { "codepoints": [10888], "characters": "\u2A88" },
+  "&gnE;": { "codepoints": [8809], "characters": "\u2269" },
+  "&gneq;": { "codepoints": [10888], "characters": "\u2A88" },
+  "&gneqq;": { "codepoints": [8809], "characters": "\u2269" },
+  "&gnsim;": { "codepoints": [8935], "characters": "\u22E7" },
+  "&Gopf;": { "codepoints": [120126], "characters": "\uD835\uDD3E" },
+  "&gopf;": { "codepoints": [120152], "characters": "\uD835\uDD58" },
+  "&grave;": { "codepoints": [96], "characters": "\u0060" },
+  "&GreaterEqual;": { "codepoints": [8805], "characters": "\u2265" },
+  "&GreaterEqualLess;": { "codepoints": [8923], "characters": "\u22DB" },
+  "&GreaterFullEqual;": { "codepoints": [8807], "characters": "\u2267" },
+  "&GreaterGreater;": { "codepoints": [10914], "characters": "\u2AA2" },
+  "&GreaterLess;": { "codepoints": [8823], "characters": "\u2277" },
+  "&GreaterSlantEqual;": { "codepoints": [10878], "characters": "\u2A7E" },
+  "&GreaterTilde;": { "codepoints": [8819], "characters": "\u2273" },
+  "&Gscr;": { "codepoints": [119970], "characters": "\uD835\uDCA2" },
+  "&gscr;": { "codepoints": [8458], "characters": "\u210A" },
+  "&gsim;": { "codepoints": [8819], "characters": "\u2273" },
+  "&gsime;": { "codepoints": [10894], "characters": "\u2A8E" },
+  "&gsiml;": { "codepoints": [10896], "characters": "\u2A90" },
+  "&gtcc;": { "codepoints": [10919], "characters": "\u2AA7" },
+  "&gtcir;": { "codepoints": [10874], "characters": "\u2A7A" },
+  "&gt;": { "codepoints": [62], "characters": "\u003E" },
+  "&gt": { "codepoints": [62], "characters": "\u003E" },
+  "&GT;": { "codepoints": [62], "characters": "\u003E" },
+  "&GT": { "codepoints": [62], "characters": "\u003E" },
+  "&Gt;": { "codepoints": [8811], "characters": "\u226B" },
+  "&gtdot;": { "codepoints": [8919], "characters": "\u22D7" },
+  "&gtlPar;": { "codepoints": [10645], "characters": "\u2995" },
+  "&gtquest;": { "codepoints": [10876], "characters": "\u2A7C" },
+  "&gtrapprox;": { "codepoints": [10886], "characters": "\u2A86" },
+  "&gtrarr;": { "codepoints": [10616], "characters": "\u2978" },
+  "&gtrdot;": { "codepoints": [8919], "characters": "\u22D7" },
+  "&gtreqless;": { "codepoints": [8923], "characters": "\u22DB" },
+  "&gtreqqless;": { "codepoints": [10892], "characters": "\u2A8C" },
+  "&gtrless;": { "codepoints": [8823], "characters": "\u2277" },
+  "&gtrsim;": { "codepoints": [8819], "characters": "\u2273" },
+  "&gvertneqq;": { "codepoints": [8809, 65024], "characters": "\u2269\uFE00" },
+  "&gvnE;": { "codepoints": [8809, 65024], "characters": "\u2269\uFE00" },
+  "&Hacek;": { "codepoints": [711], "characters": "\u02C7" },
+  "&hairsp;": { "codepoints": [8202], "characters": "\u200A" },
+  "&half;": { "codepoints": [189], "characters": "\u00BD" },
+  "&hamilt;": { "codepoints": [8459], "characters": "\u210B" },
+  "&HARDcy;": { "codepoints": [1066], "characters": "\u042A" },
+  "&hardcy;": { "codepoints": [1098], "characters": "\u044A" },
+  "&harrcir;": { "codepoints": [10568], "characters": "\u2948" },
+  "&harr;": { "codepoints": [8596], "characters": "\u2194" },
+  "&hArr;": { "codepoints": [8660], "characters": "\u21D4" },
+  "&harrw;": { "codepoints": [8621], "characters": "\u21AD" },
+  "&Hat;": { "codepoints": [94], "characters": "\u005E" },
+  "&hbar;": { "codepoints": [8463], "characters": "\u210F" },
+  "&Hcirc;": { "codepoints": [292], "characters": "\u0124" },
+  "&hcirc;": { "codepoints": [293], "characters": "\u0125" },
+  "&hearts;": { "codepoints": [9829], "characters": "\u2665" },
+  "&heartsuit;": { "codepoints": [9829], "characters": "\u2665" },
+  "&hellip;": { "codepoints": [8230], "characters": "\u2026" },
+  "&hercon;": { "codepoints": [8889], "characters": "\u22B9" },
+  "&hfr;": { "codepoints": [120101], "characters": "\uD835\uDD25" },
+  "&Hfr;": { "codepoints": [8460], "characters": "\u210C" },
+  "&HilbertSpace;": { "codepoints": [8459], "characters": "\u210B" },
+  "&hksearow;": { "codepoints": [10533], "characters": "\u2925" },
+  "&hkswarow;": { "codepoints": [10534], "characters": "\u2926" },
+  "&hoarr;": { "codepoints": [8703], "characters": "\u21FF" },
+  "&homtht;": { "codepoints": [8763], "characters": "\u223B" },
+  "&hookleftarrow;": { "codepoints": [8617], "characters": "\u21A9" },
+  "&hookrightarrow;": { "codepoints": [8618], "characters": "\u21AA" },
+  "&hopf;": { "codepoints": [120153], "characters": "\uD835\uDD59" },
+  "&Hopf;": { "codepoints": [8461], "characters": "\u210D" },
+  "&horbar;": { "codepoints": [8213], "characters": "\u2015" },
+  "&HorizontalLine;": { "codepoints": [9472], "characters": "\u2500" },
+  "&hscr;": { "codepoints": [119997], "characters": "\uD835\uDCBD" },
+  "&Hscr;": { "codepoints": [8459], "characters": "\u210B" },
+  "&hslash;": { "codepoints": [8463], "characters": "\u210F" },
+  "&Hstrok;": { "codepoints": [294], "characters": "\u0126" },
+  "&hstrok;": { "codepoints": [295], "characters": "\u0127" },
+  "&HumpDownHump;": { "codepoints": [8782], "characters": "\u224E" },
+  "&HumpEqual;": { "codepoints": [8783], "characters": "\u224F" },
+  "&hybull;": { "codepoints": [8259], "characters": "\u2043" },
+  "&hyphen;": { "codepoints": [8208], "characters": "\u2010" },
+  "&Iacute;": { "codepoints": [205], "characters": "\u00CD" },
+  "&Iacute": { "codepoints": [205], "characters": "\u00CD" },
+  "&iacute;": { "codepoints": [237], "characters": "\u00ED" },
+  "&iacute": { "codepoints": [237], "characters": "\u00ED" },
+  "&ic;": { "codepoints": [8291], "characters": "\u2063" },
+  "&Icirc;": { "codepoints": [206], "characters": "\u00CE" },
+  "&Icirc": { "codepoints": [206], "characters": "\u00CE" },
+  "&icirc;": { "codepoints": [238], "characters": "\u00EE" },
+  "&icirc": { "codepoints": [238], "characters": "\u00EE" },
+  "&Icy;": { "codepoints": [1048], "characters": "\u0418" },
+  "&icy;": { "codepoints": [1080], "characters": "\u0438" },
+  "&Idot;": { "codepoints": [304], "characters": "\u0130" },
+  "&IEcy;": { "codepoints": [1045], "characters": "\u0415" },
+  "&iecy;": { "codepoints": [1077], "characters": "\u0435" },
+  "&iexcl;": { "codepoints": [161], "characters": "\u00A1" },
+  "&iexcl": { "codepoints": [161], "characters": "\u00A1" },
+  "&iff;": { "codepoints": [8660], "characters": "\u21D4" },
+  "&ifr;": { "codepoints": [120102], "characters": "\uD835\uDD26" },
+  "&Ifr;": { "codepoints": [8465], "characters": "\u2111" },
+  "&Igrave;": { "codepoints": [204], "characters": "\u00CC" },
+  "&Igrave": { "codepoints": [204], "characters": "\u00CC" },
+  "&igrave;": { "codepoints": [236], "characters": "\u00EC" },
+  "&igrave": { "codepoints": [236], "characters": "\u00EC" },
+  "&ii;": { "codepoints": [8520], "characters": "\u2148" },
+  "&iiiint;": { "codepoints": [10764], "characters": "\u2A0C" },
+  "&iiint;": { "codepoints": [8749], "characters": "\u222D" },
+  "&iinfin;": { "codepoints": [10716], "characters": "\u29DC" },
+  "&iiota;": { "codepoints": [8489], "characters": "\u2129" },
+  "&IJlig;": { "codepoints": [306], "characters": "\u0132" },
+  "&ijlig;": { "codepoints": [307], "characters": "\u0133" },
+  "&Imacr;": { "codepoints": [298], "characters": "\u012A" },
+  "&imacr;": { "codepoints": [299], "characters": "\u012B" },
+  "&image;": { "codepoints": [8465], "characters": "\u2111" },
+  "&ImaginaryI;": { "codepoints": [8520], "characters": "\u2148" },
+  "&imagline;": { "codepoints": [8464], "characters": "\u2110" },
+  "&imagpart;": { "codepoints": [8465], "characters": "\u2111" },
+  "&imath;": { "codepoints": [305], "characters": "\u0131" },
+  "&Im;": { "codepoints": [8465], "characters": "\u2111" },
+  "&imof;": { "codepoints": [8887], "characters": "\u22B7" },
+  "&imped;": { "codepoints": [437], "characters": "\u01B5" },
+  "&Implies;": { "codepoints": [8658], "characters": "\u21D2" },
+  "&incare;": { "codepoints": [8453], "characters": "\u2105" },
+  "&in;": { "codepoints": [8712], "characters": "\u2208" },
+  "&infin;": { "codepoints": [8734], "characters": "\u221E" },
+  "&infintie;": { "codepoints": [10717], "characters": "\u29DD" },
+  "&inodot;": { "codepoints": [305], "characters": "\u0131" },
+  "&intcal;": { "codepoints": [8890], "characters": "\u22BA" },
+  "&int;": { "codepoints": [8747], "characters": "\u222B" },
+  "&Int;": { "codepoints": [8748], "characters": "\u222C" },
+  "&integers;": { "codepoints": [8484], "characters": "\u2124" },
+  "&Integral;": { "codepoints": [8747], "characters": "\u222B" },
+  "&intercal;": { "codepoints": [8890], "characters": "\u22BA" },
+  "&Intersection;": { "codepoints": [8898], "characters": "\u22C2" },
+  "&intlarhk;": { "codepoints": [10775], "characters": "\u2A17" },
+  "&intprod;": { "codepoints": [10812], "characters": "\u2A3C" },
+  "&InvisibleComma;": { "codepoints": [8291], "characters": "\u2063" },
+  "&InvisibleTimes;": { "codepoints": [8290], "characters": "\u2062" },
+  "&IOcy;": { "codepoints": [1025], "characters": "\u0401" },
+  "&iocy;": { "codepoints": [1105], "characters": "\u0451" },
+  "&Iogon;": { "codepoints": [302], "characters": "\u012E" },
+  "&iogon;": { "codepoints": [303], "characters": "\u012F" },
+  "&Iopf;": { "codepoints": [120128], "characters": "\uD835\uDD40" },
+  "&iopf;": { "codepoints": [120154], "characters": "\uD835\uDD5A" },
+  "&Iota;": { "codepoints": [921], "characters": "\u0399" },
+  "&iota;": { "codepoints": [953], "characters": "\u03B9" },
+  "&iprod;": { "codepoints": [10812], "characters": "\u2A3C" },
+  "&iquest;": { "codepoints": [191], "characters": "\u00BF" },
+  "&iquest": { "codepoints": [191], "characters": "\u00BF" },
+  "&iscr;": { "codepoints": [119998], "characters": "\uD835\uDCBE" },
+  "&Iscr;": { "codepoints": [8464], "characters": "\u2110" },
+  "&isin;": { "codepoints": [8712], "characters": "\u2208" },
+  "&isindot;": { "codepoints": [8949], "characters": "\u22F5" },
+  "&isinE;": { "codepoints": [8953], "characters": "\u22F9" },
+  "&isins;": { "codepoints": [8948], "characters": "\u22F4" },
+  "&isinsv;": { "codepoints": [8947], "characters": "\u22F3" },
+  "&isinv;": { "codepoints": [8712], "characters": "\u2208" },
+  "&it;": { "codepoints": [8290], "characters": "\u2062" },
+  "&Itilde;": { "codepoints": [296], "characters": "\u0128" },
+  "&itilde;": { "codepoints": [297], "characters": "\u0129" },
+  "&Iukcy;": { "codepoints": [1030], "characters": "\u0406" },
+  "&iukcy;": { "codepoints": [1110], "characters": "\u0456" },
+  "&Iuml;": { "codepoints": [207], "characters": "\u00CF" },
+  "&Iuml": { "codepoints": [207], "characters": "\u00CF" },
+  "&iuml;": { "codepoints": [239], "characters": "\u00EF" },
+  "&iuml": { "codepoints": [239], "characters": "\u00EF" },
+  "&Jcirc;": { "codepoints": [308], "characters": "\u0134" },
+  "&jcirc;": { "codepoints": [309], "characters": "\u0135" },
+  "&Jcy;": { "codepoints": [1049], "characters": "\u0419" },
+  "&jcy;": { "codepoints": [1081], "characters": "\u0439" },
+  "&Jfr;": { "codepoints": [120077], "characters": "\uD835\uDD0D" },
+  "&jfr;": { "codepoints": [120103], "characters": "\uD835\uDD27" },
+  "&jmath;": { "codepoints": [567], "characters": "\u0237" },
+  "&Jopf;": { "codepoints": [120129], "characters": "\uD835\uDD41" },
+  "&jopf;": { "codepoints": [120155], "characters": "\uD835\uDD5B" },
+  "&Jscr;": { "codepoints": [119973], "characters": "\uD835\uDCA5" },
+  "&jscr;": { "codepoints": [119999], "characters": "\uD835\uDCBF" },
+  "&Jsercy;": { "codepoints": [1032], "characters": "\u0408" },
+  "&jsercy;": { "codepoints": [1112], "characters": "\u0458" },
+  "&Jukcy;": { "codepoints": [1028], "characters": "\u0404" },
+  "&jukcy;": { "codepoints": [1108], "characters": "\u0454" },
+  "&Kappa;": { "codepoints": [922], "characters": "\u039A" },
+  "&kappa;": { "codepoints": [954], "characters": "\u03BA" },
+  "&kappav;": { "codepoints": [1008], "characters": "\u03F0" },
+  "&Kcedil;": { "codepoints": [310], "characters": "\u0136" },
+  "&kcedil;": { "codepoints": [311], "characters": "\u0137" },
+  "&Kcy;": { "codepoints": [1050], "characters": "\u041A" },
+  "&kcy;": { "codepoints": [1082], "characters": "\u043A" },
+  "&Kfr;": { "codepoints": [120078], "characters": "\uD835\uDD0E" },
+  "&kfr;": { "codepoints": [120104], "characters": "\uD835\uDD28" },
+  "&kgreen;": { "codepoints": [312], "characters": "\u0138" },
+  "&KHcy;": { "codepoints": [1061], "characters": "\u0425" },
+  "&khcy;": { "codepoints": [1093], "characters": "\u0445" },
+  "&KJcy;": { "codepoints": [1036], "characters": "\u040C" },
+  "&kjcy;": { "codepoints": [1116], "characters": "\u045C" },
+  "&Kopf;": { "codepoints": [120130], "characters": "\uD835\uDD42" },
+  "&kopf;": { "codepoints": [120156], "characters": "\uD835\uDD5C" },
+  "&Kscr;": { "codepoints": [119974], "characters": "\uD835\uDCA6" },
+  "&kscr;": { "codepoints": [120000], "characters": "\uD835\uDCC0" },
+  "&lAarr;": { "codepoints": [8666], "characters": "\u21DA" },
+  "&Lacute;": { "codepoints": [313], "characters": "\u0139" },
+  "&lacute;": { "codepoints": [314], "characters": "\u013A" },
+  "&laemptyv;": { "codepoints": [10676], "characters": "\u29B4" },
+  "&lagran;": { "codepoints": [8466], "characters": "\u2112" },
+  "&Lambda;": { "codepoints": [923], "characters": "\u039B" },
+  "&lambda;": { "codepoints": [955], "characters": "\u03BB" },
+  "&lang;": { "codepoints": [10216], "characters": "\u27E8" },
+  "&Lang;": { "codepoints": [10218], "characters": "\u27EA" },
+  "&langd;": { "codepoints": [10641], "characters": "\u2991" },
+  "&langle;": { "codepoints": [10216], "characters": "\u27E8" },
+  "&lap;": { "codepoints": [10885], "characters": "\u2A85" },
+  "&Laplacetrf;": { "codepoints": [8466], "characters": "\u2112" },
+  "&laquo;": { "codepoints": [171], "characters": "\u00AB" },
+  "&laquo": { "codepoints": [171], "characters": "\u00AB" },
+  "&larrb;": { "codepoints": [8676], "characters": "\u21E4" },
+  "&larrbfs;": { "codepoints": [10527], "characters": "\u291F" },
+  "&larr;": { "codepoints": [8592], "characters": "\u2190" },
+  "&Larr;": { "codepoints": [8606], "characters": "\u219E" },
+  "&lArr;": { "codepoints": [8656], "characters": "\u21D0" },
+  "&larrfs;": { "codepoints": [10525], "characters": "\u291D" },
+  "&larrhk;": { "codepoints": [8617], "characters": "\u21A9" },
+  "&larrlp;": { "codepoints": [8619], "characters": "\u21AB" },
+  "&larrpl;": { "codepoints": [10553], "characters": "\u2939" },
+  "&larrsim;": { "codepoints": [10611], "characters": "\u2973" },
+  "&larrtl;": { "codepoints": [8610], "characters": "\u21A2" },
+  "&latail;": { "codepoints": [10521], "characters": "\u2919" },
+  "&lAtail;": { "codepoints": [10523], "characters": "\u291B" },
+  "&lat;": { "codepoints": [10923], "characters": "\u2AAB" },
+  "&late;": { "codepoints": [10925], "characters": "\u2AAD" },
+  "&lates;": { "codepoints": [10925, 65024], "characters": "\u2AAD\uFE00" },
+  "&lbarr;": { "codepoints": [10508], "characters": "\u290C" },
+  "&lBarr;": { "codepoints": [10510], "characters": "\u290E" },
+  "&lbbrk;": { "codepoints": [10098], "characters": "\u2772" },
+  "&lbrace;": { "codepoints": [123], "characters": "\u007B" },
+  "&lbrack;": { "codepoints": [91], "characters": "\u005B" },
+  "&lbrke;": { "codepoints": [10635], "characters": "\u298B" },
+  "&lbrksld;": { "codepoints": [10639], "characters": "\u298F" },
+  "&lbrkslu;": { "codepoints": [10637], "characters": "\u298D" },
+  "&Lcaron;": { "codepoints": [317], "characters": "\u013D" },
+  "&lcaron;": { "codepoints": [318], "characters": "\u013E" },
+  "&Lcedil;": { "codepoints": [315], "characters": "\u013B" },
+  "&lcedil;": { "codepoints": [316], "characters": "\u013C" },
+  "&lceil;": { "codepoints": [8968], "characters": "\u2308" },
+  "&lcub;": { "codepoints": [123], "characters": "\u007B" },
+  "&Lcy;": { "codepoints": [1051], "characters": "\u041B" },
+  "&lcy;": { "codepoints": [1083], "characters": "\u043B" },
+  "&ldca;": { "codepoints": [10550], "characters": "\u2936" },
+  "&ldquo;": { "codepoints": [8220], "characters": "\u201C" },
+  "&ldquor;": { "codepoints": [8222], "characters": "\u201E" },
+  "&ldrdhar;": { "codepoints": [10599], "characters": "\u2967" },
+  "&ldrushar;": { "codepoints": [10571], "characters": "\u294B" },
+  "&ldsh;": { "codepoints": [8626], "characters": "\u21B2" },
+  "&le;": { "codepoints": [8804], "characters": "\u2264" },
+  "&lE;": { "codepoints": [8806], "characters": "\u2266" },
+  "&LeftAngleBracket;": { "codepoints": [10216], "characters": "\u27E8" },
+  "&LeftArrowBar;": { "codepoints": [8676], "characters": "\u21E4" },
+  "&leftarrow;": { "codepoints": [8592], "characters": "\u2190" },
+  "&LeftArrow;": { "codepoints": [8592], "characters": "\u2190" },
+  "&Leftarrow;": { "codepoints": [8656], "characters": "\u21D0" },
+  "&LeftArrowRightArrow;": { "codepoints": [8646], "characters": "\u21C6" },
+  "&leftarrowtail;": { "codepoints": [8610], "characters": "\u21A2" },
+  "&LeftCeiling;": { "codepoints": [8968], "characters": "\u2308" },
+  "&LeftDoubleBracket;": { "codepoints": [10214], "characters": "\u27E6" },
+  "&LeftDownTeeVector;": { "codepoints": [10593], "characters": "\u2961" },
+  "&LeftDownVectorBar;": { "codepoints": [10585], "characters": "\u2959" },
+  "&LeftDownVector;": { "codepoints": [8643], "characters": "\u21C3" },
+  "&LeftFloor;": { "codepoints": [8970], "characters": "\u230A" },
+  "&leftharpoondown;": { "codepoints": [8637], "characters": "\u21BD" },
+  "&leftharpoonup;": { "codepoints": [8636], "characters": "\u21BC" },
+  "&leftleftarrows;": { "codepoints": [8647], "characters": "\u21C7" },
+  "&leftrightarrow;": { "codepoints": [8596], "characters": "\u2194" },
+  "&LeftRightArrow;": { "codepoints": [8596], "characters": "\u2194" },
+  "&Leftrightarrow;": { "codepoints": [8660], "characters": "\u21D4" },
+  "&leftrightarrows;": { "codepoints": [8646], "characters": "\u21C6" },
+  "&leftrightharpoons;": { "codepoints": [8651], "characters": "\u21CB" },
+  "&leftrightsquigarrow;": { "codepoints": [8621], "characters": "\u21AD" },
+  "&LeftRightVector;": { "codepoints": [10574], "characters": "\u294E" },
+  "&LeftTeeArrow;": { "codepoints": [8612], "characters": "\u21A4" },
+  "&LeftTee;": { "codepoints": [8867], "characters": "\u22A3" },
+  "&LeftTeeVector;": { "codepoints": [10586], "characters": "\u295A" },
+  "&leftthreetimes;": { "codepoints": [8907], "characters": "\u22CB" },
+  "&LeftTriangleBar;": { "codepoints": [10703], "characters": "\u29CF" },
+  "&LeftTriangle;": { "codepoints": [8882], "characters": "\u22B2" },
+  "&LeftTriangleEqual;": { "codepoints": [8884], "characters": "\u22B4" },
+  "&LeftUpDownVector;": { "codepoints": [10577], "characters": "\u2951" },
+  "&LeftUpTeeVector;": { "codepoints": [10592], "characters": "\u2960" },
+  "&LeftUpVectorBar;": { "codepoints": [10584], "characters": "\u2958" },
+  "&LeftUpVector;": { "codepoints": [8639], "characters": "\u21BF" },
+  "&LeftVectorBar;": { "codepoints": [10578], "characters": "\u2952" },
+  "&LeftVector;": { "codepoints": [8636], "characters": "\u21BC" },
+  "&lEg;": { "codepoints": [10891], "characters": "\u2A8B" },
+  "&leg;": { "codepoints": [8922], "characters": "\u22DA" },
+  "&leq;": { "codepoints": [8804], "characters": "\u2264" },
+  "&leqq;": { "codepoints": [8806], "characters": "\u2266" },
+  "&leqslant;": { "codepoints": [10877], "characters": "\u2A7D" },
+  "&lescc;": { "codepoints": [10920], "characters": "\u2AA8" },
+  "&les;": { "codepoints": [10877], "characters": "\u2A7D" },
+  "&lesdot;": { "codepoints": [10879], "characters": "\u2A7F" },
+  "&lesdoto;": { "codepoints": [10881], "characters": "\u2A81" },
+  "&lesdotor;": { "codepoints": [10883], "characters": "\u2A83" },
+  "&lesg;": { "codepoints": [8922, 65024], "characters": "\u22DA\uFE00" },
+  "&lesges;": { "codepoints": [10899], "characters": "\u2A93" },
+  "&lessapprox;": { "codepoints": [10885], "characters": "\u2A85" },
+  "&lessdot;": { "codepoints": [8918], "characters": "\u22D6" },
+  "&lesseqgtr;": { "codepoints": [8922], "characters": "\u22DA" },
+  "&lesseqqgtr;": { "codepoints": [10891], "characters": "\u2A8B" },
+  "&LessEqualGreater;": { "codepoints": [8922], "characters": "\u22DA" },
+  "&LessFullEqual;": { "codepoints": [8806], "characters": "\u2266" },
+  "&LessGreater;": { "codepoints": [8822], "characters": "\u2276" },
+  "&lessgtr;": { "codepoints": [8822], "characters": "\u2276" },
+  "&LessLess;": { "codepoints": [10913], "characters": "\u2AA1" },
+  "&lesssim;": { "codepoints": [8818], "characters": "\u2272" },
+  "&LessSlantEqual;": { "codepoints": [10877], "characters": "\u2A7D" },
+  "&LessTilde;": { "codepoints": [8818], "characters": "\u2272" },
+  "&lfisht;": { "codepoints": [10620], "characters": "\u297C" },
+  "&lfloor;": { "codepoints": [8970], "characters": "\u230A" },
+  "&Lfr;": { "codepoints": [120079], "characters": "\uD835\uDD0F" },
+  "&lfr;": { "codepoints": [120105], "characters": "\uD835\uDD29" },
+  "&lg;": { "codepoints": [8822], "characters": "\u2276" },
+  "&lgE;": { "codepoints": [10897], "characters": "\u2A91" },
+  "&lHar;": { "codepoints": [10594], "characters": "\u2962" },
+  "&lhard;": { "codepoints": [8637], "characters": "\u21BD" },
+  "&lharu;": { "codepoints": [8636], "characters": "\u21BC" },
+  "&lharul;": { "codepoints": [10602], "characters": "\u296A" },
+  "&lhblk;": { "codepoints": [9604], "characters": "\u2584" },
+  "&LJcy;": { "codepoints": [1033], "characters": "\u0409" },
+  "&ljcy;": { "codepoints": [1113], "characters": "\u0459" },
+  "&llarr;": { "codepoints": [8647], "characters": "\u21C7" },
+  "&ll;": { "codepoints": [8810], "characters": "\u226A" },
+  "&Ll;": { "codepoints": [8920], "characters": "\u22D8" },
+  "&llcorner;": { "codepoints": [8990], "characters": "\u231E" },
+  "&Lleftarrow;": { "codepoints": [8666], "characters": "\u21DA" },
+  "&llhard;": { "codepoints": [10603], "characters": "\u296B" },
+  "&lltri;": { "codepoints": [9722], "characters": "\u25FA" },
+  "&Lmidot;": { "codepoints": [319], "characters": "\u013F" },
+  "&lmidot;": { "codepoints": [320], "characters": "\u0140" },
+  "&lmoustache;": { "codepoints": [9136], "characters": "\u23B0" },
+  "&lmoust;": { "codepoints": [9136], "characters": "\u23B0" },
+  "&lnap;": { "codepoints": [10889], "characters": "\u2A89" },
+  "&lnapprox;": { "codepoints": [10889], "characters": "\u2A89" },
+  "&lne;": { "codepoints": [10887], "characters": "\u2A87" },
+  "&lnE;": { "codepoints": [8808], "characters": "\u2268" },
+  "&lneq;": { "codepoints": [10887], "characters": "\u2A87" },
+  "&lneqq;": { "codepoints": [8808], "characters": "\u2268" },
+  "&lnsim;": { "codepoints": [8934], "characters": "\u22E6" },
+  "&loang;": { "codepoints": [10220], "characters": "\u27EC" },
+  "&loarr;": { "codepoints": [8701], "characters": "\u21FD" },
+  "&lobrk;": { "codepoints": [10214], "characters": "\u27E6" },
+  "&longleftarrow;": { "codepoints": [10229], "characters": "\u27F5" },
+  "&LongLeftArrow;": { "codepoints": [10229], "characters": "\u27F5" },
+  "&Longleftarrow;": { "codepoints": [10232], "characters": "\u27F8" },
+  "&longleftrightarrow;": { "codepoints": [10231], "characters": "\u27F7" },
+  "&LongLeftRightArrow;": { "codepoints": [10231], "characters": "\u27F7" },
+  "&Longleftrightarrow;": { "codepoints": [10234], "characters": "\u27FA" },
+  "&longmapsto;": { "codepoints": [10236], "characters": "\u27FC" },
+  "&longrightarrow;": { "codepoints": [10230], "characters": "\u27F6" },
+  "&LongRightArrow;": { "codepoints": [10230], "characters": "\u27F6" },
+  "&Longrightarrow;": { "codepoints": [10233], "characters": "\u27F9" },
+  "&looparrowleft;": { "codepoints": [8619], "characters": "\u21AB" },
+  "&looparrowright;": { "codepoints": [8620], "characters": "\u21AC" },
+  "&lopar;": { "codepoints": [10629], "characters": "\u2985" },
+  "&Lopf;": { "codepoints": [120131], "characters": "\uD835\uDD43" },
+  "&lopf;": { "codepoints": [120157], "characters": "\uD835\uDD5D" },
+  "&loplus;": { "codepoints": [10797], "characters": "\u2A2D" },
+  "&lotimes;": { "codepoints": [10804], "characters": "\u2A34" },
+  "&lowast;": { "codepoints": [8727], "characters": "\u2217" },
+  "&lowbar;": { "codepoints": [95], "characters": "\u005F" },
+  "&LowerLeftArrow;": { "codepoints": [8601], "characters": "\u2199" },
+  "&LowerRightArrow;": { "codepoints": [8600], "characters": "\u2198" },
+  "&loz;": { "codepoints": [9674], "characters": "\u25CA" },
+  "&lozenge;": { "codepoints": [9674], "characters": "\u25CA" },
+  "&lozf;": { "codepoints": [10731], "characters": "\u29EB" },
+  "&lpar;": { "codepoints": [40], "characters": "\u0028" },
+  "&lparlt;": { "codepoints": [10643], "characters": "\u2993" },
+  "&lrarr;": { "codepoints": [8646], "characters": "\u21C6" },
+  "&lrcorner;": { "codepoints": [8991], "characters": "\u231F" },
+  "&lrhar;": { "codepoints": [8651], "characters": "\u21CB" },
+  "&lrhard;": { "codepoints": [10605], "characters": "\u296D" },
+  "&lrm;": { "codepoints": [8206], "characters": "\u200E" },
+  "&lrtri;": { "codepoints": [8895], "characters": "\u22BF" },
+  "&lsaquo;": { "codepoints": [8249], "characters": "\u2039" },
+  "&lscr;": { "codepoints": [120001], "characters": "\uD835\uDCC1" },
+  "&Lscr;": { "codepoints": [8466], "characters": "\u2112" },
+  "&lsh;": { "codepoints": [8624], "characters": "\u21B0" },
+  "&Lsh;": { "codepoints": [8624], "characters": "\u21B0" },
+  "&lsim;": { "codepoints": [8818], "characters": "\u2272" },
+  "&lsime;": { "codepoints": [10893], "characters": "\u2A8D" },
+  "&lsimg;": { "codepoints": [10895], "characters": "\u2A8F" },
+  "&lsqb;": { "codepoints": [91], "characters": "\u005B" },
+  "&lsquo;": { "codepoints": [8216], "characters": "\u2018" },
+  "&lsquor;": { "codepoints": [8218], "characters": "\u201A" },
+  "&Lstrok;": { "codepoints": [321], "characters": "\u0141" },
+  "&lstrok;": { "codepoints": [322], "characters": "\u0142" },
+  "&ltcc;": { "codepoints": [10918], "characters": "\u2AA6" },
+  "&ltcir;": { "codepoints": [10873], "characters": "\u2A79" },
+  "&lt;": { "codepoints": [60], "characters": "\u003C" },
+  "&lt": { "codepoints": [60], "characters": "\u003C" },
+  "&LT;": { "codepoints": [60], "characters": "\u003C" },
+  "&LT": { "codepoints": [60], "characters": "\u003C" },
+  "&Lt;": { "codepoints": [8810], "characters": "\u226A" },
+  "&ltdot;": { "codepoints": [8918], "characters": "\u22D6" },
+  "&lthree;": { "codepoints": [8907], "characters": "\u22CB" },
+  "&ltimes;": { "codepoints": [8905], "characters": "\u22C9" },
+  "&ltlarr;": { "codepoints": [10614], "characters": "\u2976" },
+  "&ltquest;": { "codepoints": [10875], "characters": "\u2A7B" },
+  "&ltri;": { "codepoints": [9667], "characters": "\u25C3" },
+  "&ltrie;": { "codepoints": [8884], "characters": "\u22B4" },
+  "&ltrif;": { "codepoints": [9666], "characters": "\u25C2" },
+  "&ltrPar;": { "codepoints": [10646], "characters": "\u2996" },
+  "&lurdshar;": { "codepoints": [10570], "characters": "\u294A" },
+  "&luruhar;": { "codepoints": [10598], "characters": "\u2966" },
+  "&lvertneqq;": { "codepoints": [8808, 65024], "characters": "\u2268\uFE00" },
+  "&lvnE;": { "codepoints": [8808, 65024], "characters": "\u2268\uFE00" },
+  "&macr;": { "codepoints": [175], "characters": "\u00AF" },
+  "&macr": { "codepoints": [175], "characters": "\u00AF" },
+  "&male;": { "codepoints": [9794], "characters": "\u2642" },
+  "&malt;": { "codepoints": [10016], "characters": "\u2720" },
+  "&maltese;": { "codepoints": [10016], "characters": "\u2720" },
+  "&Map;": { "codepoints": [10501], "characters": "\u2905" },
+  "&map;": { "codepoints": [8614], "characters": "\u21A6" },
+  "&mapsto;": { "codepoints": [8614], "characters": "\u21A6" },
+  "&mapstodown;": { "codepoints": [8615], "characters": "\u21A7" },
+  "&mapstoleft;": { "codepoints": [8612], "characters": "\u21A4" },
+  "&mapstoup;": { "codepoints": [8613], "characters": "\u21A5" },
+  "&marker;": { "codepoints": [9646], "characters": "\u25AE" },
+  "&mcomma;": { "codepoints": [10793], "characters": "\u2A29" },
+  "&Mcy;": { "codepoints": [1052], "characters": "\u041C" },
+  "&mcy;": { "codepoints": [1084], "characters": "\u043C" },
+  "&mdash;": { "codepoints": [8212], "characters": "\u2014" },
+  "&mDDot;": { "codepoints": [8762], "characters": "\u223A" },
+  "&measuredangle;": { "codepoints": [8737], "characters": "\u2221" },
+  "&MediumSpace;": { "codepoints": [8287], "characters": "\u205F" },
+  "&Mellintrf;": { "codepoints": [8499], "characters": "\u2133" },
+  "&Mfr;": { "codepoints": [120080], "characters": "\uD835\uDD10" },
+  "&mfr;": { "codepoints": [120106], "characters": "\uD835\uDD2A" },
+  "&mho;": { "codepoints": [8487], "characters": "\u2127" },
+  "&micro;": { "codepoints": [181], "characters": "\u00B5" },
+  "&micro": { "codepoints": [181], "characters": "\u00B5" },
+  "&midast;": { "codepoints": [42], "characters": "\u002A" },
+  "&midcir;": { "codepoints": [10992], "characters": "\u2AF0" },
+  "&mid;": { "codepoints": [8739], "characters": "\u2223" },
+  "&middot;": { "codepoints": [183], "characters": "\u00B7" },
+  "&middot": { "codepoints": [183], "characters": "\u00B7" },
+  "&minusb;": { "codepoints": [8863], "characters": "\u229F" },
+  "&minus;": { "codepoints": [8722], "characters": "\u2212" },
+  "&minusd;": { "codepoints": [8760], "characters": "\u2238" },
+  "&minusdu;": { "codepoints": [10794], "characters": "\u2A2A" },
+  "&MinusPlus;": { "codepoints": [8723], "characters": "\u2213" },
+  "&mlcp;": { "codepoints": [10971], "characters": "\u2ADB" },
+  "&mldr;": { "codepoints": [8230], "characters": "\u2026" },
+  "&mnplus;": { "codepoints": [8723], "characters": "\u2213" },
+  "&models;": { "codepoints": [8871], "characters": "\u22A7" },
+  "&Mopf;": { "codepoints": [120132], "characters": "\uD835\uDD44" },
+  "&mopf;": { "codepoints": [120158], "characters": "\uD835\uDD5E" },
+  "&mp;": { "codepoints": [8723], "characters": "\u2213" },
+  "&mscr;": { "codepoints": [120002], "characters": "\uD835\uDCC2" },
+  "&Mscr;": { "codepoints": [8499], "characters": "\u2133" },
+  "&mstpos;": { "codepoints": [8766], "characters": "\u223E" },
+  "&Mu;": { "codepoints": [924], "characters": "\u039C" },
+  "&mu;": { "codepoints": [956], "characters": "\u03BC" },
+  "&multimap;": { "codepoints": [8888], "characters": "\u22B8" },
+  "&mumap;": { "codepoints": [8888], "characters": "\u22B8" },
+  "&nabla;": { "codepoints": [8711], "characters": "\u2207" },
+  "&Nacute;": { "codepoints": [323], "characters": "\u0143" },
+  "&nacute;": { "codepoints": [324], "characters": "\u0144" },
+  "&nang;": { "codepoints": [8736, 8402], "characters": "\u2220\u20D2" },
+  "&nap;": { "codepoints": [8777], "characters": "\u2249" },
+  "&napE;": { "codepoints": [10864, 824], "characters": "\u2A70\u0338" },
+  "&napid;": { "codepoints": [8779, 824], "characters": "\u224B\u0338" },
+  "&napos;": { "codepoints": [329], "characters": "\u0149" },
+  "&napprox;": { "codepoints": [8777], "characters": "\u2249" },
+  "&natural;": { "codepoints": [9838], "characters": "\u266E" },
+  "&naturals;": { "codepoints": [8469], "characters": "\u2115" },
+  "&natur;": { "codepoints": [9838], "characters": "\u266E" },
+  "&nbsp;": { "codepoints": [160], "characters": "\u00A0" },
+  "&nbsp": { "codepoints": [160], "characters": "\u00A0" },
+  "&nbump;": { "codepoints": [8782, 824], "characters": "\u224E\u0338" },
+  "&nbumpe;": { "codepoints": [8783, 824], "characters": "\u224F\u0338" },
+  "&ncap;": { "codepoints": [10819], "characters": "\u2A43" },
+  "&Ncaron;": { "codepoints": [327], "characters": "\u0147" },
+  "&ncaron;": { "codepoints": [328], "characters": "\u0148" },
+  "&Ncedil;": { "codepoints": [325], "characters": "\u0145" },
+  "&ncedil;": { "codepoints": [326], "characters": "\u0146" },
+  "&ncong;": { "codepoints": [8775], "characters": "\u2247" },
+  "&ncongdot;": { "codepoints": [10861, 824], "characters": "\u2A6D\u0338" },
+  "&ncup;": { "codepoints": [10818], "characters": "\u2A42" },
+  "&Ncy;": { "codepoints": [1053], "characters": "\u041D" },
+  "&ncy;": { "codepoints": [1085], "characters": "\u043D" },
+  "&ndash;": { "codepoints": [8211], "characters": "\u2013" },
+  "&nearhk;": { "codepoints": [10532], "characters": "\u2924" },
+  "&nearr;": { "codepoints": [8599], "characters": "\u2197" },
+  "&neArr;": { "codepoints": [8663], "characters": "\u21D7" },
+  "&nearrow;": { "codepoints": [8599], "characters": "\u2197" },
+  "&ne;": { "codepoints": [8800], "characters": "\u2260" },
+  "&nedot;": { "codepoints": [8784, 824], "characters": "\u2250\u0338" },
+  "&NegativeMediumSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&NegativeThickSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&NegativeThinSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&NegativeVeryThinSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&nequiv;": { "codepoints": [8802], "characters": "\u2262" },
+  "&nesear;": { "codepoints": [10536], "characters": "\u2928" },
+  "&nesim;": { "codepoints": [8770, 824], "characters": "\u2242\u0338" },
+  "&NestedGreaterGreater;": { "codepoints": [8811], "characters": "\u226B" },
+  "&NestedLessLess;": { "codepoints": [8810], "characters": "\u226A" },
+  "&NewLine;": { "codepoints": [10], "characters": "\u000A" },
+  "&nexist;": { "codepoints": [8708], "characters": "\u2204" },
+  "&nexists;": { "codepoints": [8708], "characters": "\u2204" },
+  "&Nfr;": { "codepoints": [120081], "characters": "\uD835\uDD11" },
+  "&nfr;": { "codepoints": [120107], "characters": "\uD835\uDD2B" },
+  "&ngE;": { "codepoints": [8807, 824], "characters": "\u2267\u0338" },
+  "&nge;": { "codepoints": [8817], "characters": "\u2271" },
+  "&ngeq;": { "codepoints": [8817], "characters": "\u2271" },
+  "&ngeqq;": { "codepoints": [8807, 824], "characters": "\u2267\u0338" },
+  "&ngeqslant;": { "codepoints": [10878, 824], "characters": "\u2A7E\u0338" },
+  "&nges;": { "codepoints": [10878, 824], "characters": "\u2A7E\u0338" },
+  "&nGg;": { "codepoints": [8921, 824], "characters": "\u22D9\u0338" },
+  "&ngsim;": { "codepoints": [8821], "characters": "\u2275" },
+  "&nGt;": { "codepoints": [8811, 8402], "characters": "\u226B\u20D2" },
+  "&ngt;": { "codepoints": [8815], "characters": "\u226F" },
+  "&ngtr;": { "codepoints": [8815], "characters": "\u226F" },
+  "&nGtv;": { "codepoints": [8811, 824], "characters": "\u226B\u0338" },
+  "&nharr;": { "codepoints": [8622], "characters": "\u21AE" },
+  "&nhArr;": { "codepoints": [8654], "characters": "\u21CE" },
+  "&nhpar;": { "codepoints": [10994], "characters": "\u2AF2" },
+  "&ni;": { "codepoints": [8715], "characters": "\u220B" },
+  "&nis;": { "codepoints": [8956], "characters": "\u22FC" },
+  "&nisd;": { "codepoints": [8954], "characters": "\u22FA" },
+  "&niv;": { "codepoints": [8715], "characters": "\u220B" },
+  "&NJcy;": { "codepoints": [1034], "characters": "\u040A" },
+  "&njcy;": { "codepoints": [1114], "characters": "\u045A" },
+  "&nlarr;": { "codepoints": [8602], "characters": "\u219A" },
+  "&nlArr;": { "codepoints": [8653], "characters": "\u21CD" },
+  "&nldr;": { "codepoints": [8229], "characters": "\u2025" },
+  "&nlE;": { "codepoints": [8806, 824], "characters": "\u2266\u0338" },
+  "&nle;": { "codepoints": [8816], "characters": "\u2270" },
+  "&nleftarrow;": { "codepoints": [8602], "characters": "\u219A" },
+  "&nLeftarrow;": { "codepoints": [8653], "characters": "\u21CD" },
+  "&nleftrightarrow;": { "codepoints": [8622], "characters": "\u21AE" },
+  "&nLeftrightarrow;": { "codepoints": [8654], "characters": "\u21CE" },
+  "&nleq;": { "codepoints": [8816], "characters": "\u2270" },
+  "&nleqq;": { "codepoints": [8806, 824], "characters": "\u2266\u0338" },
+  "&nleqslant;": { "codepoints": [10877, 824], "characters": "\u2A7D\u0338" },
+  "&nles;": { "codepoints": [10877, 824], "characters": "\u2A7D\u0338" },
+  "&nless;": { "codepoints": [8814], "characters": "\u226E" },
+  "&nLl;": { "codepoints": [8920, 824], "characters": "\u22D8\u0338" },
+  "&nlsim;": { "codepoints": [8820], "characters": "\u2274" },
+  "&nLt;": { "codepoints": [8810, 8402], "characters": "\u226A\u20D2" },
+  "&nlt;": { "codepoints": [8814], "characters": "\u226E" },
+  "&nltri;": { "codepoints": [8938], "characters": "\u22EA" },
+  "&nltrie;": { "codepoints": [8940], "characters": "\u22EC" },
+  "&nLtv;": { "codepoints": [8810, 824], "characters": "\u226A\u0338" },
+  "&nmid;": { "codepoints": [8740], "characters": "\u2224" },
+  "&NoBreak;": { "codepoints": [8288], "characters": "\u2060" },
+  "&NonBreakingSpace;": { "codepoints": [160], "characters": "\u00A0" },
+  "&nopf;": { "codepoints": [120159], "characters": "\uD835\uDD5F" },
+  "&Nopf;": { "codepoints": [8469], "characters": "\u2115" },
+  "&Not;": { "codepoints": [10988], "characters": "\u2AEC" },
+  "&not;": { "codepoints": [172], "characters": "\u00AC" },
+  "&not": { "codepoints": [172], "characters": "\u00AC" },
+  "&NotCongruent;": { "codepoints": [8802], "characters": "\u2262" },
+  "&NotCupCap;": { "codepoints": [8813], "characters": "\u226D" },
+  "&NotDoubleVerticalBar;": { "codepoints": [8742], "characters": "\u2226" },
+  "&NotElement;": { "codepoints": [8713], "characters": "\u2209" },
+  "&NotEqual;": { "codepoints": [8800], "characters": "\u2260" },
+  "&NotEqualTilde;": { "codepoints": [8770, 824], "characters": "\u2242\u0338" },
+  "&NotExists;": { "codepoints": [8708], "characters": "\u2204" },
+  "&NotGreater;": { "codepoints": [8815], "characters": "\u226F" },
+  "&NotGreaterEqual;": { "codepoints": [8817], "characters": "\u2271" },
+  "&NotGreaterFullEqual;": { "codepoints": [8807, 824], "characters": "\u2267\u0338" },
+  "&NotGreaterGreater;": { "codepoints": [8811, 824], "characters": "\u226B\u0338" },
+  "&NotGreaterLess;": { "codepoints": [8825], "characters": "\u2279" },
+  "&NotGreaterSlantEqual;": { "codepoints": [10878, 824], "characters": "\u2A7E\u0338" },
+  "&NotGreaterTilde;": { "codepoints": [8821], "characters": "\u2275" },
+  "&NotHumpDownHump;": { "codepoints": [8782, 824], "characters": "\u224E\u0338" },
+  "&NotHumpEqual;": { "codepoints": [8783, 824], "characters": "\u224F\u0338" },
+  "&notin;": { "codepoints": [8713], "characters": "\u2209" },
+  "&notindot;": { "codepoints": [8949, 824], "characters": "\u22F5\u0338" },
+  "&notinE;": { "codepoints": [8953, 824], "characters": "\u22F9\u0338" },
+  "&notinva;": { "codepoints": [8713], "characters": "\u2209" },
+  "&notinvb;": { "codepoints": [8951], "characters": "\u22F7" },
+  "&notinvc;": { "codepoints": [8950], "characters": "\u22F6" },
+  "&NotLeftTriangleBar;": { "codepoints": [10703, 824], "characters": "\u29CF\u0338" },
+  "&NotLeftTriangle;": { "codepoints": [8938], "characters": "\u22EA" },
+  "&NotLeftTriangleEqual;": { "codepoints": [8940], "characters": "\u22EC" },
+  "&NotLess;": { "codepoints": [8814], "characters": "\u226E" },
+  "&NotLessEqual;": { "codepoints": [8816], "characters": "\u2270" },
+  "&NotLessGreater;": { "codepoints": [8824], "characters": "\u2278" },
+  "&NotLessLess;": { "codepoints": [8810, 824], "characters": "\u226A\u0338" },
+  "&NotLessSlantEqual;": { "codepoints": [10877, 824], "characters": "\u2A7D\u0338" },
+  "&NotLessTilde;": { "codepoints": [8820], "characters": "\u2274" },
+  "&NotNestedGreaterGreater;": { "codepoints": [10914, 824], "characters": "\u2AA2\u0338" },
+  "&NotNestedLessLess;": { "codepoints": [10913, 824], "characters": "\u2AA1\u0338" },
+  "&notni;": { "codepoints": [8716], "characters": "\u220C" },
+  "&notniva;": { "codepoints": [8716], "characters": "\u220C" },
+  "&notnivb;": { "codepoints": [8958], "characters": "\u22FE" },
+  "&notnivc;": { "codepoints": [8957], "characters": "\u22FD" },
+  "&NotPrecedes;": { "codepoints": [8832], "characters": "\u2280" },
+  "&NotPrecedesEqual;": { "codepoints": [10927, 824], "characters": "\u2AAF\u0338" },
+  "&NotPrecedesSlantEqual;": { "codepoints": [8928], "characters": "\u22E0" },
+  "&NotReverseElement;": { "codepoints": [8716], "characters": "\u220C" },
+  "&NotRightTriangleBar;": { "codepoints": [10704, 824], "characters": "\u29D0\u0338" },
+  "&NotRightTriangle;": { "codepoints": [8939], "characters": "\u22EB" },
+  "&NotRightTriangleEqual;": { "codepoints": [8941], "characters": "\u22ED" },
+  "&NotSquareSubset;": { "codepoints": [8847, 824], "characters": "\u228F\u0338" },
+  "&NotSquareSubsetEqual;": { "codepoints": [8930], "characters": "\u22E2" },
+  "&NotSquareSuperset;": { "codepoints": [8848, 824], "characters": "\u2290\u0338" },
+  "&NotSquareSupersetEqual;": { "codepoints": [8931], "characters": "\u22E3" },
+  "&NotSubset;": { "codepoints": [8834, 8402], "characters": "\u2282\u20D2" },
+  "&NotSubsetEqual;": { "codepoints": [8840], "characters": "\u2288" },
+  "&NotSucceeds;": { "codepoints": [8833], "characters": "\u2281" },
+  "&NotSucceedsEqual;": { "codepoints": [10928, 824], "characters": "\u2AB0\u0338" },
+  "&NotSucceedsSlantEqual;": { "codepoints": [8929], "characters": "\u22E1" },
+  "&NotSucceedsTilde;": { "codepoints": [8831, 824], "characters": "\u227F\u0338" },
+  "&NotSuperset;": { "codepoints": [8835, 8402], "characters": "\u2283\u20D2" },
+  "&NotSupersetEqual;": { "codepoints": [8841], "characters": "\u2289" },
+  "&NotTilde;": { "codepoints": [8769], "characters": "\u2241" },
+  "&NotTildeEqual;": { "codepoints": [8772], "characters": "\u2244" },
+  "&NotTildeFullEqual;": { "codepoints": [8775], "characters": "\u2247" },
+  "&NotTildeTilde;": { "codepoints": [8777], "characters": "\u2249" },
+  "&NotVerticalBar;": { "codepoints": [8740], "characters": "\u2224" },
+  "&nparallel;": { "codepoints": [8742], "characters": "\u2226" },
+  "&npar;": { "codepoints": [8742], "characters": "\u2226" },
+  "&nparsl;": { "codepoints": [11005, 8421], "characters": "\u2AFD\u20E5" },
+  "&npart;": { "codepoints": [8706, 824], "characters": "\u2202\u0338" },
+  "&npolint;": { "codepoints": [10772], "characters": "\u2A14" },
+  "&npr;": { "codepoints": [8832], "characters": "\u2280" },
+  "&nprcue;": { "codepoints": [8928], "characters": "\u22E0" },
+  "&nprec;": { "codepoints": [8832], "characters": "\u2280" },
+  "&npreceq;": { "codepoints": [10927, 824], "characters": "\u2AAF\u0338" },
+  "&npre;": { "codepoints": [10927, 824], "characters": "\u2AAF\u0338" },
+  "&nrarrc;": { "codepoints": [10547, 824], "characters": "\u2933\u0338" },
+  "&nrarr;": { "codepoints": [8603], "characters": "\u219B" },
+  "&nrArr;": { "codepoints": [8655], "characters": "\u21CF" },
+  "&nrarrw;": { "codepoints": [8605, 824], "characters": "\u219D\u0338" },
+  "&nrightarrow;": { "codepoints": [8603], "characters": "\u219B" },
+  "&nRightarrow;": { "codepoints": [8655], "characters": "\u21CF" },
+  "&nrtri;": { "codepoints": [8939], "characters": "\u22EB" },
+  "&nrtrie;": { "codepoints": [8941], "characters": "\u22ED" },
+  "&nsc;": { "codepoints": [8833], "characters": "\u2281" },
+  "&nsccue;": { "codepoints": [8929], "characters": "\u22E1" },
+  "&nsce;": { "codepoints": [10928, 824], "characters": "\u2AB0\u0338" },
+  "&Nscr;": { "codepoints": [119977], "characters": "\uD835\uDCA9" },
+  "&nscr;": { "codepoints": [120003], "characters": "\uD835\uDCC3" },
+  "&nshortmid;": { "codepoints": [8740], "characters": "\u2224" },
+  "&nshortparallel;": { "codepoints": [8742], "characters": "\u2226" },
+  "&nsim;": { "codepoints": [8769], "characters": "\u2241" },
+  "&nsime;": { "codepoints": [8772], "characters": "\u2244" },
+  "&nsimeq;": { "codepoints": [8772], "characters": "\u2244" },
+  "&nsmid;": { "codepoints": [8740], "characters": "\u2224" },
+  "&nspar;": { "codepoints": [8742], "characters": "\u2226" },
+  "&nsqsube;": { "codepoints": [8930], "characters": "\u22E2" },
+  "&nsqsupe;": { "codepoints": [8931], "characters": "\u22E3" },
+  "&nsub;": { "codepoints": [8836], "characters": "\u2284" },
+  "&nsubE;": { "codepoints": [10949, 824], "characters": "\u2AC5\u0338" },
+  "&nsube;": { "codepoints": [8840], "characters": "\u2288" },
+  "&nsubset;": { "codepoints": [8834, 8402], "characters": "\u2282\u20D2" },
+  "&nsubseteq;": { "codepoints": [8840], "characters": "\u2288" },
+  "&nsubseteqq;": { "codepoints": [10949, 824], "characters": "\u2AC5\u0338" },
+  "&nsucc;": { "codepoints": [8833], "characters": "\u2281" },
+  "&nsucceq;": { "codepoints": [10928, 824], "characters": "\u2AB0\u0338" },
+  "&nsup;": { "codepoints": [8837], "characters": "\u2285" },
+  "&nsupE;": { "codepoints": [10950, 824], "characters": "\u2AC6\u0338" },
+  "&nsupe;": { "codepoints": [8841], "characters": "\u2289" },
+  "&nsupset;": { "codepoints": [8835, 8402], "characters": "\u2283\u20D2" },
+  "&nsupseteq;": { "codepoints": [8841], "characters": "\u2289" },
+  "&nsupseteqq;": { "codepoints": [10950, 824], "characters": "\u2AC6\u0338" },
+  "&ntgl;": { "codepoints": [8825], "characters": "\u2279" },
+  "&Ntilde;": { "codepoints": [209], "characters": "\u00D1" },
+  "&Ntilde": { "codepoints": [209], "characters": "\u00D1" },
+  "&ntilde;": { "codepoints": [241], "characters": "\u00F1" },
+  "&ntilde": { "codepoints": [241], "characters": "\u00F1" },
+  "&ntlg;": { "codepoints": [8824], "characters": "\u2278" },
+  "&ntriangleleft;": { "codepoints": [8938], "characters": "\u22EA" },
+  "&ntrianglelefteq;": { "codepoints": [8940], "characters": "\u22EC" },
+  "&ntriangleright;": { "codepoints": [8939], "characters": "\u22EB" },
+  "&ntrianglerighteq;": { "codepoints": [8941], "characters": "\u22ED" },
+  "&Nu;": { "codepoints": [925], "characters": "\u039D" },
+  "&nu;": { "codepoints": [957], "characters": "\u03BD" },
+  "&num;": { "codepoints": [35], "characters": "\u0023" },
+  "&numero;": { "codepoints": [8470], "characters": "\u2116" },
+  "&numsp;": { "codepoints": [8199], "characters": "\u2007" },
+  "&nvap;": { "codepoints": [8781, 8402], "characters": "\u224D\u20D2" },
+  "&nvdash;": { "codepoints": [8876], "characters": "\u22AC" },
+  "&nvDash;": { "codepoints": [8877], "characters": "\u22AD" },
+  "&nVdash;": { "codepoints": [8878], "characters": "\u22AE" },
+  "&nVDash;": { "codepoints": [8879], "characters": "\u22AF" },
+  "&nvge;": { "codepoints": [8805, 8402], "characters": "\u2265\u20D2" },
+  "&nvgt;": { "codepoints": [62, 8402], "characters": "\u003E\u20D2" },
+  "&nvHarr;": { "codepoints": [10500], "characters": "\u2904" },
+  "&nvinfin;": { "codepoints": [10718], "characters": "\u29DE" },
+  "&nvlArr;": { "codepoints": [10498], "characters": "\u2902" },
+  "&nvle;": { "codepoints": [8804, 8402], "characters": "\u2264\u20D2" },
+  "&nvlt;": { "codepoints": [60, 8402], "characters": "\u003C\u20D2" },
+  "&nvltrie;": { "codepoints": [8884, 8402], "characters": "\u22B4\u20D2" },
+  "&nvrArr;": { "codepoints": [10499], "characters": "\u2903" },
+  "&nvrtrie;": { "codepoints": [8885, 8402], "characters": "\u22B5\u20D2" },
+  "&nvsim;": { "codepoints": [8764, 8402], "characters": "\u223C\u20D2" },
+  "&nwarhk;": { "codepoints": [10531], "characters": "\u2923" },
+  "&nwarr;": { "codepoints": [8598], "characters": "\u2196" },
+  "&nwArr;": { "codepoints": [8662], "characters": "\u21D6" },
+  "&nwarrow;": { "codepoints": [8598], "characters": "\u2196" },
+  "&nwnear;": { "codepoints": [10535], "characters": "\u2927" },
+  "&Oacute;": { "codepoints": [211], "characters": "\u00D3" },
+  "&Oacute": { "codepoints": [211], "characters": "\u00D3" },
+  "&oacute;": { "codepoints": [243], "characters": "\u00F3" },
+  "&oacute": { "codepoints": [243], "characters": "\u00F3" },
+  "&oast;": { "codepoints": [8859], "characters": "\u229B" },
+  "&Ocirc;": { "codepoints": [212], "characters": "\u00D4" },
+  "&Ocirc": { "codepoints": [212], "characters": "\u00D4" },
+  "&ocirc;": { "codepoints": [244], "characters": "\u00F4" },
+  "&ocirc": { "codepoints": [244], "characters": "\u00F4" },
+  "&ocir;": { "codepoints": [8858], "characters": "\u229A" },
+  "&Ocy;": { "codepoints": [1054], "characters": "\u041E" },
+  "&ocy;": { "codepoints": [1086], "characters": "\u043E" },
+  "&odash;": { "codepoints": [8861], "characters": "\u229D" },
+  "&Odblac;": { "codepoints": [336], "characters": "\u0150" },
+  "&odblac;": { "codepoints": [337], "characters": "\u0151" },
+  "&odiv;": { "codepoints": [10808], "characters": "\u2A38" },
+  "&odot;": { "codepoints": [8857], "characters": "\u2299" },
+  "&odsold;": { "codepoints": [10684], "characters": "\u29BC" },
+  "&OElig;": { "codepoints": [338], "characters": "\u0152" },
+  "&oelig;": { "codepoints": [339], "characters": "\u0153" },
+  "&ofcir;": { "codepoints": [10687], "characters": "\u29BF" },
+  "&Ofr;": { "codepoints": [120082], "characters": "\uD835\uDD12" },
+  "&ofr;": { "codepoints": [120108], "characters": "\uD835\uDD2C" },
+  "&ogon;": { "codepoints": [731], "characters": "\u02DB" },
+  "&Ograve;": { "codepoints": [210], "characters": "\u00D2" },
+  "&Ograve": { "codepoints": [210], "characters": "\u00D2" },
+  "&ograve;": { "codepoints": [242], "characters": "\u00F2" },
+  "&ograve": { "codepoints": [242], "characters": "\u00F2" },
+  "&ogt;": { "codepoints": [10689], "characters": "\u29C1" },
+  "&ohbar;": { "codepoints": [10677], "characters": "\u29B5" },
+  "&ohm;": { "codepoints": [937], "characters": "\u03A9" },
+  "&oint;": { "codepoints": [8750], "characters": "\u222E" },
+  "&olarr;": { "codepoints": [8634], "characters": "\u21BA" },
+  "&olcir;": { "codepoints": [10686], "characters": "\u29BE" },
+  "&olcross;": { "codepoints": [10683], "characters": "\u29BB" },
+  "&oline;": { "codepoints": [8254], "characters": "\u203E" },
+  "&olt;": { "codepoints": [10688], "characters": "\u29C0" },
+  "&Omacr;": { "codepoints": [332], "characters": "\u014C" },
+  "&omacr;": { "codepoints": [333], "characters": "\u014D" },
+  "&Omega;": { "codepoints": [937], "characters": "\u03A9" },
+  "&omega;": { "codepoints": [969], "characters": "\u03C9" },
+  "&Omicron;": { "codepoints": [927], "characters": "\u039F" },
+  "&omicron;": { "codepoints": [959], "characters": "\u03BF" },
+  "&omid;": { "codepoints": [10678], "characters": "\u29B6" },
+  "&ominus;": { "codepoints": [8854], "characters": "\u2296" },
+  "&Oopf;": { "codepoints": [120134], "characters": "\uD835\uDD46" },
+  "&oopf;": { "codepoints": [120160], "characters": "\uD835\uDD60" },
+  "&opar;": { "codepoints": [10679], "characters": "\u29B7" },
+  "&OpenCurlyDoubleQuote;": { "codepoints": [8220], "characters": "\u201C" },
+  "&OpenCurlyQuote;": { "codepoints": [8216], "characters": "\u2018" },
+  "&operp;": { "codepoints": [10681], "characters": "\u29B9" },
+  "&oplus;": { "codepoints": [8853], "characters": "\u2295" },
+  "&orarr;": { "codepoints": [8635], "characters": "\u21BB" },
+  "&Or;": { "codepoints": [10836], "characters": "\u2A54" },
+  "&or;": { "codepoints": [8744], "characters": "\u2228" },
+  "&ord;": { "codepoints": [10845], "characters": "\u2A5D" },
+  "&order;": { "codepoints": [8500], "characters": "\u2134" },
+  "&orderof;": { "codepoints": [8500], "characters": "\u2134" },
+  "&ordf;": { "codepoints": [170], "characters": "\u00AA" },
+  "&ordf": { "codepoints": [170], "characters": "\u00AA" },
+  "&ordm;": { "codepoints": [186], "characters": "\u00BA" },
+  "&ordm": { "codepoints": [186], "characters": "\u00BA" },
+  "&origof;": { "codepoints": [8886], "characters": "\u22B6" },
+  "&oror;": { "codepoints": [10838], "characters": "\u2A56" },
+  "&orslope;": { "codepoints": [10839], "characters": "\u2A57" },
+  "&orv;": { "codepoints": [10843], "characters": "\u2A5B" },
+  "&oS;": { "codepoints": [9416], "characters": "\u24C8" },
+  "&Oscr;": { "codepoints": [119978], "characters": "\uD835\uDCAA" },
+  "&oscr;": { "codepoints": [8500], "characters": "\u2134" },
+  "&Oslash;": { "codepoints": [216], "characters": "\u00D8" },
+  "&Oslash": { "codepoints": [216], "characters": "\u00D8" },
+  "&oslash;": { "codepoints": [248], "characters": "\u00F8" },
+  "&oslash": { "codepoints": [248], "characters": "\u00F8" },
+  "&osol;": { "codepoints": [8856], "characters": "\u2298" },
+  "&Otilde;": { "codepoints": [213], "characters": "\u00D5" },
+  "&Otilde": { "codepoints": [213], "characters": "\u00D5" },
+  "&otilde;": { "codepoints": [245], "characters": "\u00F5" },
+  "&otilde": { "codepoints": [245], "characters": "\u00F5" },
+  "&otimesas;": { "codepoints": [10806], "characters": "\u2A36" },
+  "&Otimes;": { "codepoints": [10807], "characters": "\u2A37" },
+  "&otimes;": { "codepoints": [8855], "characters": "\u2297" },
+  "&Ouml;": { "codepoints": [214], "characters": "\u00D6" },
+  "&Ouml": { "codepoints": [214], "characters": "\u00D6" },
+  "&ouml;": { "codepoints": [246], "characters": "\u00F6" },
+  "&ouml": { "codepoints": [246], "characters": "\u00F6" },
+  "&ovbar;": { "codepoints": [9021], "characters": "\u233D" },
+  "&OverBar;": { "codepoints": [8254], "characters": "\u203E" },
+  "&OverBrace;": { "codepoints": [9182], "characters": "\u23DE" },
+  "&OverBracket;": { "codepoints": [9140], "characters": "\u23B4" },
+  "&OverParenthesis;": { "codepoints": [9180], "characters": "\u23DC" },
+  "&para;": { "codepoints": [182], "characters": "\u00B6" },
+  "&para": { "codepoints": [182], "characters": "\u00B6" },
+  "&parallel;": { "codepoints": [8741], "characters": "\u2225" },
+  "&par;": { "codepoints": [8741], "characters": "\u2225" },
+  "&parsim;": { "codepoints": [10995], "characters": "\u2AF3" },
+  "&parsl;": { "codepoints": [11005], "characters": "\u2AFD" },
+  "&part;": { "codepoints": [8706], "characters": "\u2202" },
+  "&PartialD;": { "codepoints": [8706], "characters": "\u2202" },
+  "&Pcy;": { "codepoints": [1055], "characters": "\u041F" },
+  "&pcy;": { "codepoints": [1087], "characters": "\u043F" },
+  "&percnt;": { "codepoints": [37], "characters": "\u0025" },
+  "&period;": { "codepoints": [46], "characters": "\u002E" },
+  "&permil;": { "codepoints": [8240], "characters": "\u2030" },
+  "&perp;": { "codepoints": [8869], "characters": "\u22A5" },
+  "&pertenk;": { "codepoints": [8241], "characters": "\u2031" },
+  "&Pfr;": { "codepoints": [120083], "characters": "\uD835\uDD13" },
+  "&pfr;": { "codepoints": [120109], "characters": "\uD835\uDD2D" },
+  "&Phi;": { "codepoints": [934], "characters": "\u03A6" },
+  "&phi;": { "codepoints": [966], "characters": "\u03C6" },
+  "&phiv;": { "codepoints": [981], "characters": "\u03D5" },
+  "&phmmat;": { "codepoints": [8499], "characters": "\u2133" },
+  "&phone;": { "codepoints": [9742], "characters": "\u260E" },
+  "&Pi;": { "codepoints": [928], "characters": "\u03A0" },
+  "&pi;": { "codepoints": [960], "characters": "\u03C0" },
+  "&pitchfork;": { "codepoints": [8916], "characters": "\u22D4" },
+  "&piv;": { "codepoints": [982], "characters": "\u03D6" },
+  "&planck;": { "codepoints": [8463], "characters": "\u210F" },
+  "&planckh;": { "codepoints": [8462], "characters": "\u210E" },
+  "&plankv;": { "codepoints": [8463], "characters": "\u210F" },
+  "&plusacir;": { "codepoints": [10787], "characters": "\u2A23" },
+  "&plusb;": { "codepoints": [8862], "characters": "\u229E" },
+  "&pluscir;": { "codepoints": [10786], "characters": "\u2A22" },
+  "&plus;": { "codepoints": [43], "characters": "\u002B" },
+  "&plusdo;": { "codepoints": [8724], "characters": "\u2214" },
+  "&plusdu;": { "codepoints": [10789], "characters": "\u2A25" },
+  "&pluse;": { "codepoints": [10866], "characters": "\u2A72" },
+  "&PlusMinus;": { "codepoints": [177], "characters": "\u00B1" },
+  "&plusmn;": { "codepoints": [177], "characters": "\u00B1" },
+  "&plusmn": { "codepoints": [177], "characters": "\u00B1" },
+  "&plussim;": { "codepoints": [10790], "characters": "\u2A26" },
+  "&plustwo;": { "codepoints": [10791], "characters": "\u2A27" },
+  "&pm;": { "codepoints": [177], "characters": "\u00B1" },
+  "&Poincareplane;": { "codepoints": [8460], "characters": "\u210C" },
+  "&pointint;": { "codepoints": [10773], "characters": "\u2A15" },
+  "&popf;": { "codepoints": [120161], "characters": "\uD835\uDD61" },
+  "&Popf;": { "codepoints": [8473], "characters": "\u2119" },
+  "&pound;": { "codepoints": [163], "characters": "\u00A3" },
+  "&pound": { "codepoints": [163], "characters": "\u00A3" },
+  "&prap;": { "codepoints": [10935], "characters": "\u2AB7" },
+  "&Pr;": { "codepoints": [10939], "characters": "\u2ABB" },
+  "&pr;": { "codepoints": [8826], "characters": "\u227A" },
+  "&prcue;": { "codepoints": [8828], "characters": "\u227C" },
+  "&precapprox;": { "codepoints": [10935], "characters": "\u2AB7" },
+  "&prec;": { "codepoints": [8826], "characters": "\u227A" },
+  "&preccurlyeq;": { "codepoints": [8828], "characters": "\u227C" },
+  "&Precedes;": { "codepoints": [8826], "characters": "\u227A" },
+  "&PrecedesEqual;": { "codepoints": [10927], "characters": "\u2AAF" },
+  "&PrecedesSlantEqual;": { "codepoints": [8828], "characters": "\u227C" },
+  "&PrecedesTilde;": { "codepoints": [8830], "characters": "\u227E" },
+  "&preceq;": { "codepoints": [10927], "characters": "\u2AAF" },
+  "&precnapprox;": { "codepoints": [10937], "characters": "\u2AB9" },
+  "&precneqq;": { "codepoints": [10933], "characters": "\u2AB5" },
+  "&precnsim;": { "codepoints": [8936], "characters": "\u22E8" },
+  "&pre;": { "codepoints": [10927], "characters": "\u2AAF" },
+  "&prE;": { "codepoints": [10931], "characters": "\u2AB3" },
+  "&precsim;": { "codepoints": [8830], "characters": "\u227E" },
+  "&prime;": { "codepoints": [8242], "characters": "\u2032" },
+  "&Prime;": { "codepoints": [8243], "characters": "\u2033" },
+  "&primes;": { "codepoints": [8473], "characters": "\u2119" },
+  "&prnap;": { "codepoints": [10937], "characters": "\u2AB9" },
+  "&prnE;": { "codepoints": [10933], "characters": "\u2AB5" },
+  "&prnsim;": { "codepoints": [8936], "characters": "\u22E8" },
+  "&prod;": { "codepoints": [8719], "characters": "\u220F" },
+  "&Product;": { "codepoints": [8719], "characters": "\u220F" },
+  "&profalar;": { "codepoints": [9006], "characters": "\u232E" },
+  "&profline;": { "codepoints": [8978], "characters": "\u2312" },
+  "&profsurf;": { "codepoints": [8979], "characters": "\u2313" },
+  "&prop;": { "codepoints": [8733], "characters": "\u221D" },
+  "&Proportional;": { "codepoints": [8733], "characters": "\u221D" },
+  "&Proportion;": { "codepoints": [8759], "characters": "\u2237" },
+  "&propto;": { "codepoints": [8733], "characters": "\u221D" },
+  "&prsim;": { "codepoints": [8830], "characters": "\u227E" },
+  "&prurel;": { "codepoints": [8880], "characters": "\u22B0" },
+  "&Pscr;": { "codepoints": [119979], "characters": "\uD835\uDCAB" },
+  "&pscr;": { "codepoints": [120005], "characters": "\uD835\uDCC5" },
+  "&Psi;": { "codepoints": [936], "characters": "\u03A8" },
+  "&psi;": { "codepoints": [968], "characters": "\u03C8" },
+  "&puncsp;": { "codepoints": [8200], "characters": "\u2008" },
+  "&Qfr;": { "codepoints": [120084], "characters": "\uD835\uDD14" },
+  "&qfr;": { "codepoints": [120110], "characters": "\uD835\uDD2E" },
+  "&qint;": { "codepoints": [10764], "characters": "\u2A0C" },
+  "&qopf;": { "codepoints": [120162], "characters": "\uD835\uDD62" },
+  "&Qopf;": { "codepoints": [8474], "characters": "\u211A" },
+  "&qprime;": { "codepoints": [8279], "characters": "\u2057" },
+  "&Qscr;": { "codepoints": [119980], "characters": "\uD835\uDCAC" },
+  "&qscr;": { "codepoints": [120006], "characters": "\uD835\uDCC6" },
+  "&quaternions;": { "codepoints": [8461], "characters": "\u210D" },
+  "&quatint;": { "codepoints": [10774], "characters": "\u2A16" },
+  "&quest;": { "codepoints": [63], "characters": "\u003F" },
+  "&questeq;": { "codepoints": [8799], "characters": "\u225F" },
+  "&quot;": { "codepoints": [34], "characters": "\u0022" },
+  "&quot": { "codepoints": [34], "characters": "\u0022" },
+  "&QUOT;": { "codepoints": [34], "characters": "\u0022" },
+  "&QUOT": { "codepoints": [34], "characters": "\u0022" },
+  "&rAarr;": { "codepoints": [8667], "characters": "\u21DB" },
+  "&race;": { "codepoints": [8765, 817], "characters": "\u223D\u0331" },
+  "&Racute;": { "codepoints": [340], "characters": "\u0154" },
+  "&racute;": { "codepoints": [341], "characters": "\u0155" },
+  "&radic;": { "codepoints": [8730], "characters": "\u221A" },
+  "&raemptyv;": { "codepoints": [10675], "characters": "\u29B3" },
+  "&rang;": { "codepoints": [10217], "characters": "\u27E9" },
+  "&Rang;": { "codepoints": [10219], "characters": "\u27EB" },
+  "&rangd;": { "codepoints": [10642], "characters": "\u2992" },
+  "&range;": { "codepoints": [10661], "characters": "\u29A5" },
+  "&rangle;": { "codepoints": [10217], "characters": "\u27E9" },
+  "&raquo;": { "codepoints": [187], "characters": "\u00BB" },
+  "&raquo": { "codepoints": [187], "characters": "\u00BB" },
+  "&rarrap;": { "codepoints": [10613], "characters": "\u2975" },
+  "&rarrb;": { "codepoints": [8677], "characters": "\u21E5" },
+  "&rarrbfs;": { "codepoints": [10528], "characters": "\u2920" },
+  "&rarrc;": { "codepoints": [10547], "characters": "\u2933" },
+  "&rarr;": { "codepoints": [8594], "characters": "\u2192" },
+  "&Rarr;": { "codepoints": [8608], "characters": "\u21A0" },
+  "&rArr;": { "codepoints": [8658], "characters": "\u21D2" },
+  "&rarrfs;": { "codepoints": [10526], "characters": "\u291E" },
+  "&rarrhk;": { "codepoints": [8618], "characters": "\u21AA" },
+  "&rarrlp;": { "codepoints": [8620], "characters": "\u21AC" },
+  "&rarrpl;": { "codepoints": [10565], "characters": "\u2945" },
+  "&rarrsim;": { "codepoints": [10612], "characters": "\u2974" },
+  "&Rarrtl;": { "codepoints": [10518], "characters": "\u2916" },
+  "&rarrtl;": { "codepoints": [8611], "characters": "\u21A3" },
+  "&rarrw;": { "codepoints": [8605], "characters": "\u219D" },
+  "&ratail;": { "codepoints": [10522], "characters": "\u291A" },
+  "&rAtail;": { "codepoints": [10524], "characters": "\u291C" },
+  "&ratio;": { "codepoints": [8758], "characters": "\u2236" },
+  "&rationals;": { "codepoints": [8474], "characters": "\u211A" },
+  "&rbarr;": { "codepoints": [10509], "characters": "\u290D" },
+  "&rBarr;": { "codepoints": [10511], "characters": "\u290F" },
+  "&RBarr;": { "codepoints": [10512], "characters": "\u2910" },
+  "&rbbrk;": { "codepoints": [10099], "characters": "\u2773" },
+  "&rbrace;": { "codepoints": [125], "characters": "\u007D" },
+  "&rbrack;": { "codepoints": [93], "characters": "\u005D" },
+  "&rbrke;": { "codepoints": [10636], "characters": "\u298C" },
+  "&rbrksld;": { "codepoints": [10638], "characters": "\u298E" },
+  "&rbrkslu;": { "codepoints": [10640], "characters": "\u2990" },
+  "&Rcaron;": { "codepoints": [344], "characters": "\u0158" },
+  "&rcaron;": { "codepoints": [345], "characters": "\u0159" },
+  "&Rcedil;": { "codepoints": [342], "characters": "\u0156" },
+  "&rcedil;": { "codepoints": [343], "characters": "\u0157" },
+  "&rceil;": { "codepoints": [8969], "characters": "\u2309" },
+  "&rcub;": { "codepoints": [125], "characters": "\u007D" },
+  "&Rcy;": { "codepoints": [1056], "characters": "\u0420" },
+  "&rcy;": { "codepoints": [1088], "characters": "\u0440" },
+  "&rdca;": { "codepoints": [10551], "characters": "\u2937" },
+  "&rdldhar;": { "codepoints": [10601], "characters": "\u2969" },
+  "&rdquo;": { "codepoints": [8221], "characters": "\u201D" },
+  "&rdquor;": { "codepoints": [8221], "characters": "\u201D" },
+  "&rdsh;": { "codepoints": [8627], "characters": "\u21B3" },
+  "&real;": { "codepoints": [8476], "characters": "\u211C" },
+  "&realine;": { "codepoints": [8475], "characters": "\u211B" },
+  "&realpart;": { "codepoints": [8476], "characters": "\u211C" },
+  "&reals;": { "codepoints": [8477], "characters": "\u211D" },
+  "&Re;": { "codepoints": [8476], "characters": "\u211C" },
+  "&rect;": { "codepoints": [9645], "characters": "\u25AD" },
+  "&reg;": { "codepoints": [174], "characters": "\u00AE" },
+  "&reg": { "codepoints": [174], "characters": "\u00AE" },
+  "&REG;": { "codepoints": [174], "characters": "\u00AE" },
+  "&REG": { "codepoints": [174], "characters": "\u00AE" },
+  "&ReverseElement;": { "codepoints": [8715], "characters": "\u220B" },
+  "&ReverseEquilibrium;": { "codepoints": [8651], "characters": "\u21CB" },
+  "&ReverseUpEquilibrium;": { "codepoints": [10607], "characters": "\u296F" },
+  "&rfisht;": { "codepoints": [10621], "characters": "\u297D" },
+  "&rfloor;": { "codepoints": [8971], "characters": "\u230B" },
+  "&rfr;": { "codepoints": [120111], "characters": "\uD835\uDD2F" },
+  "&Rfr;": { "codepoints": [8476], "characters": "\u211C" },
+  "&rHar;": { "codepoints": [10596], "characters": "\u2964" },
+  "&rhard;": { "codepoints": [8641], "characters": "\u21C1" },
+  "&rharu;": { "codepoints": [8640], "characters": "\u21C0" },
+  "&rharul;": { "codepoints": [10604], "characters": "\u296C" },
+  "&Rho;": { "codepoints": [929], "characters": "\u03A1" },
+  "&rho;": { "codepoints": [961], "characters": "\u03C1" },
+  "&rhov;": { "codepoints": [1009], "characters": "\u03F1" },
+  "&RightAngleBracket;": { "codepoints": [10217], "characters": "\u27E9" },
+  "&RightArrowBar;": { "codepoints": [8677], "characters": "\u21E5" },
+  "&rightarrow;": { "codepoints": [8594], "characters": "\u2192" },
+  "&RightArrow;": { "codepoints": [8594], "characters": "\u2192" },
+  "&Rightarrow;": { "codepoints": [8658], "characters": "\u21D2" },
+  "&RightArrowLeftArrow;": { "codepoints": [8644], "characters": "\u21C4" },
+  "&rightarrowtail;": { "codepoints": [8611], "characters": "\u21A3" },
+  "&RightCeiling;": { "codepoints": [8969], "characters": "\u2309" },
+  "&RightDoubleBracket;": { "codepoints": [10215], "characters": "\u27E7" },
+  "&RightDownTeeVector;": { "codepoints": [10589], "characters": "\u295D" },
+  "&RightDownVectorBar;": { "codepoints": [10581], "characters": "\u2955" },
+  "&RightDownVector;": { "codepoints": [8642], "characters": "\u21C2" },
+  "&RightFloor;": { "codepoints": [8971], "characters": "\u230B" },
+  "&rightharpoondown;": { "codepoints": [8641], "characters": "\u21C1" },
+  "&rightharpoonup;": { "codepoints": [8640], "characters": "\u21C0" },
+  "&rightleftarrows;": { "codepoints": [8644], "characters": "\u21C4" },
+  "&rightleftharpoons;": { "codepoints": [8652], "characters": "\u21CC" },
+  "&rightrightarrows;": { "codepoints": [8649], "characters": "\u21C9" },
+  "&rightsquigarrow;": { "codepoints": [8605], "characters": "\u219D" },
+  "&RightTeeArrow;": { "codepoints": [8614], "characters": "\u21A6" },
+  "&RightTee;": { "codepoints": [8866], "characters": "\u22A2" },
+  "&RightTeeVector;": { "codepoints": [10587], "characters": "\u295B" },
+  "&rightthreetimes;": { "codepoints": [8908], "characters": "\u22CC" },
+  "&RightTriangleBar;": { "codepoints": [10704], "characters": "\u29D0" },
+  "&RightTriangle;": { "codepoints": [8883], "characters": "\u22B3" },
+  "&RightTriangleEqual;": { "codepoints": [8885], "characters": "\u22B5" },
+  "&RightUpDownVector;": { "codepoints": [10575], "characters": "\u294F" },
+  "&RightUpTeeVector;": { "codepoints": [10588], "characters": "\u295C" },
+  "&RightUpVectorBar;": { "codepoints": [10580], "characters": "\u2954" },
+  "&RightUpVector;": { "codepoints": [8638], "characters": "\u21BE" },
+  "&RightVectorBar;": { "codepoints": [10579], "characters": "\u2953" },
+  "&RightVector;": { "codepoints": [8640], "characters": "\u21C0" },
+  "&ring;": { "codepoints": [730], "characters": "\u02DA" },
+  "&risingdotseq;": { "codepoints": [8787], "characters": "\u2253" },
+  "&rlarr;": { "codepoints": [8644], "characters": "\u21C4" },
+  "&rlhar;": { "codepoints": [8652], "characters": "\u21CC" },
+  "&rlm;": { "codepoints": [8207], "characters": "\u200F" },
+  "&rmoustache;": { "codepoints": [9137], "characters": "\u23B1" },
+  "&rmoust;": { "codepoints": [9137], "characters": "\u23B1" },
+  "&rnmid;": { "codepoints": [10990], "characters": "\u2AEE" },
+  "&roang;": { "codepoints": [10221], "characters": "\u27ED" },
+  "&roarr;": { "codepoints": [8702], "characters": "\u21FE" },
+  "&robrk;": { "codepoints": [10215], "characters": "\u27E7" },
+  "&ropar;": { "codepoints": [10630], "characters": "\u2986" },
+  "&ropf;": { "codepoints": [120163], "characters": "\uD835\uDD63" },
+  "&Ropf;": { "codepoints": [8477], "characters": "\u211D" },
+  "&roplus;": { "codepoints": [10798], "characters": "\u2A2E" },
+  "&rotimes;": { "codepoints": [10805], "characters": "\u2A35" },
+  "&RoundImplies;": { "codepoints": [10608], "characters": "\u2970" },
+  "&rpar;": { "codepoints": [41], "characters": "\u0029" },
+  "&rpargt;": { "codepoints": [10644], "characters": "\u2994" },
+  "&rppolint;": { "codepoints": [10770], "characters": "\u2A12" },
+  "&rrarr;": { "codepoints": [8649], "characters": "\u21C9" },
+  "&Rrightarrow;": { "codepoints": [8667], "characters": "\u21DB" },
+  "&rsaquo;": { "codepoints": [8250], "characters": "\u203A" },
+  "&rscr;": { "codepoints": [120007], "characters": "\uD835\uDCC7" },
+  "&Rscr;": { "codepoints": [8475], "characters": "\u211B" },
+  "&rsh;": { "codepoints": [8625], "characters": "\u21B1" },
+  "&Rsh;": { "codepoints": [8625], "characters": "\u21B1" },
+  "&rsqb;": { "codepoints": [93], "characters": "\u005D" },
+  "&rsquo;": { "codepoints": [8217], "characters": "\u2019" },
+  "&rsquor;": { "codepoints": [8217], "characters": "\u2019" },
+  "&rthree;": { "codepoints": [8908], "characters": "\u22CC" },
+  "&rtimes;": { "codepoints": [8906], "characters": "\u22CA" },
+  "&rtri;": { "codepoints": [9657], "characters": "\u25B9" },
+  "&rtrie;": { "codepoints": [8885], "characters": "\u22B5" },
+  "&rtrif;": { "codepoints": [9656], "characters": "\u25B8" },
+  "&rtriltri;": { "codepoints": [10702], "characters": "\u29CE" },
+  "&RuleDelayed;": { "codepoints": [10740], "characters": "\u29F4" },
+  "&ruluhar;": { "codepoints": [10600], "characters": "\u2968" },
+  "&rx;": { "codepoints": [8478], "characters": "\u211E" },
+  "&Sacute;": { "codepoints": [346], "characters": "\u015A" },
+  "&sacute;": { "codepoints": [347], "characters": "\u015B" },
+  "&sbquo;": { "codepoints": [8218], "characters": "\u201A" },
+  "&scap;": { "codepoints": [10936], "characters": "\u2AB8" },
+  "&Scaron;": { "codepoints": [352], "characters": "\u0160" },
+  "&scaron;": { "codepoints": [353], "characters": "\u0161" },
+  "&Sc;": { "codepoints": [10940], "characters": "\u2ABC" },
+  "&sc;": { "codepoints": [8827], "characters": "\u227B" },
+  "&sccue;": { "codepoints": [8829], "characters": "\u227D" },
+  "&sce;": { "codepoints": [10928], "characters": "\u2AB0" },
+  "&scE;": { "codepoints": [10932], "characters": "\u2AB4" },
+  "&Scedil;": { "codepoints": [350], "characters": "\u015E" },
+  "&scedil;": { "codepoints": [351], "characters": "\u015F" },
+  "&Scirc;": { "codepoints": [348], "characters": "\u015C" },
+  "&scirc;": { "codepoints": [349], "characters": "\u015D" },
+  "&scnap;": { "codepoints": [10938], "characters": "\u2ABA" },
+  "&scnE;": { "codepoints": [10934], "characters": "\u2AB6" },
+  "&scnsim;": { "codepoints": [8937], "characters": "\u22E9" },
+  "&scpolint;": { "codepoints": [10771], "characters": "\u2A13" },
+  "&scsim;": { "codepoints": [8831], "characters": "\u227F" },
+  "&Scy;": { "codepoints": [1057], "characters": "\u0421" },
+  "&scy;": { "codepoints": [1089], "characters": "\u0441" },
+  "&sdotb;": { "codepoints": [8865], "characters": "\u22A1" },
+  "&sdot;": { "codepoints": [8901], "characters": "\u22C5" },
+  "&sdote;": { "codepoints": [10854], "characters": "\u2A66" },
+  "&searhk;": { "codepoints": [10533], "characters": "\u2925" },
+  "&searr;": { "codepoints": [8600], "characters": "\u2198" },
+  "&seArr;": { "codepoints": [8664], "characters": "\u21D8" },
+  "&searrow;": { "codepoints": [8600], "characters": "\u2198" },
+  "&sect;": { "codepoints": [167], "characters": "\u00A7" },
+  "&sect": { "codepoints": [167], "characters": "\u00A7" },
+  "&semi;": { "codepoints": [59], "characters": "\u003B" },
+  "&seswar;": { "codepoints": [10537], "characters": "\u2929" },
+  "&setminus;": { "codepoints": [8726], "characters": "\u2216" },
+  "&setmn;": { "codepoints": [8726], "characters": "\u2216" },
+  "&sext;": { "codepoints": [10038], "characters": "\u2736" },
+  "&Sfr;": { "codepoints": [120086], "characters": "\uD835\uDD16" },
+  "&sfr;": { "codepoints": [120112], "characters": "\uD835\uDD30" },
+  "&sfrown;": { "codepoints": [8994], "characters": "\u2322" },
+  "&sharp;": { "codepoints": [9839], "characters": "\u266F" },
+  "&SHCHcy;": { "codepoints": [1065], "characters": "\u0429" },
+  "&shchcy;": { "codepoints": [1097], "characters": "\u0449" },
+  "&SHcy;": { "codepoints": [1064], "characters": "\u0428" },
+  "&shcy;": { "codepoints": [1096], "characters": "\u0448" },
+  "&ShortDownArrow;": { "codepoints": [8595], "characters": "\u2193" },
+  "&ShortLeftArrow;": { "codepoints": [8592], "characters": "\u2190" },
+  "&shortmid;": { "codepoints": [8739], "characters": "\u2223" },
+  "&shortparallel;": { "codepoints": [8741], "characters": "\u2225" },
+  "&ShortRightArrow;": { "codepoints": [8594], "characters": "\u2192" },
+  "&ShortUpArrow;": { "codepoints": [8593], "characters": "\u2191" },
+  "&shy;": { "codepoints": [173], "characters": "\u00AD" },
+  "&shy": { "codepoints": [173], "characters": "\u00AD" },
+  "&Sigma;": { "codepoints": [931], "characters": "\u03A3" },
+  "&sigma;": { "codepoints": [963], "characters": "\u03C3" },
+  "&sigmaf;": { "codepoints": [962], "characters": "\u03C2" },
+  "&sigmav;": { "codepoints": [962], "characters": "\u03C2" },
+  "&sim;": { "codepoints": [8764], "characters": "\u223C" },
+  "&simdot;": { "codepoints": [10858], "characters": "\u2A6A" },
+  "&sime;": { "codepoints": [8771], "characters": "\u2243" },
+  "&simeq;": { "codepoints": [8771], "characters": "\u2243" },
+  "&simg;": { "codepoints": [10910], "characters": "\u2A9E" },
+  "&simgE;": { "codepoints": [10912], "characters": "\u2AA0" },
+  "&siml;": { "codepoints": [10909], "characters": "\u2A9D" },
+  "&simlE;": { "codepoints": [10911], "characters": "\u2A9F" },
+  "&simne;": { "codepoints": [8774], "characters": "\u2246" },
+  "&simplus;": { "codepoints": [10788], "characters": "\u2A24" },
+  "&simrarr;": { "codepoints": [10610], "characters": "\u2972" },
+  "&slarr;": { "codepoints": [8592], "characters": "\u2190" },
+  "&SmallCircle;": { "codepoints": [8728], "characters": "\u2218" },
+  "&smallsetminus;": { "codepoints": [8726], "characters": "\u2216" },
+  "&smashp;": { "codepoints": [10803], "characters": "\u2A33" },
+  "&smeparsl;": { "codepoints": [10724], "characters": "\u29E4" },
+  "&smid;": { "codepoints": [8739], "characters": "\u2223" },
+  "&smile;": { "codepoints": [8995], "characters": "\u2323" },
+  "&smt;": { "codepoints": [10922], "characters": "\u2AAA" },
+  "&smte;": { "codepoints": [10924], "characters": "\u2AAC" },
+  "&smtes;": { "codepoints": [10924, 65024], "characters": "\u2AAC\uFE00" },
+  "&SOFTcy;": { "codepoints": [1068], "characters": "\u042C" },
+  "&softcy;": { "codepoints": [1100], "characters": "\u044C" },
+  "&solbar;": { "codepoints": [9023], "characters": "\u233F" },
+  "&solb;": { "codepoints": [10692], "characters": "\u29C4" },
+  "&sol;": { "codepoints": [47], "characters": "\u002F" },
+  "&Sopf;": { "codepoints": [120138], "characters": "\uD835\uDD4A" },
+  "&sopf;": { "codepoints": [120164], "characters": "\uD835\uDD64" },
+  "&spades;": { "codepoints": [9824], "characters": "\u2660" },
+  "&spadesuit;": { "codepoints": [9824], "characters": "\u2660" },
+  "&spar;": { "codepoints": [8741], "characters": "\u2225" },
+  "&sqcap;": { "codepoints": [8851], "characters": "\u2293" },
+  "&sqcaps;": { "codepoints": [8851, 65024], "characters": "\u2293\uFE00" },
+  "&sqcup;": { "codepoints": [8852], "characters": "\u2294" },
+  "&sqcups;": { "codepoints": [8852, 65024], "characters": "\u2294\uFE00" },
+  "&Sqrt;": { "codepoints": [8730], "characters": "\u221A" },
+  "&sqsub;": { "codepoints": [8847], "characters": "\u228F" },
+  "&sqsube;": { "codepoints": [8849], "characters": "\u2291" },
+  "&sqsubset;": { "codepoints": [8847], "characters": "\u228F" },
+  "&sqsubseteq;": { "codepoints": [8849], "characters": "\u2291" },
+  "&sqsup;": { "codepoints": [8848], "characters": "\u2290" },
+  "&sqsupe;": { "codepoints": [8850], "characters": "\u2292" },
+  "&sqsupset;": { "codepoints": [8848], "characters": "\u2290" },
+  "&sqsupseteq;": { "codepoints": [8850], "characters": "\u2292" },
+  "&square;": { "codepoints": [9633], "characters": "\u25A1" },
+  "&Square;": { "codepoints": [9633], "characters": "\u25A1" },
+  "&SquareIntersection;": { "codepoints": [8851], "characters": "\u2293" },
+  "&SquareSubset;": { "codepoints": [8847], "characters": "\u228F" },
+  "&SquareSubsetEqual;": { "codepoints": [8849], "characters": "\u2291" },
+  "&SquareSuperset;": { "codepoints": [8848], "characters": "\u2290" },
+  "&SquareSupersetEqual;": { "codepoints": [8850], "characters": "\u2292" },
+  "&SquareUnion;": { "codepoints": [8852], "characters": "\u2294" },
+  "&squarf;": { "codepoints": [9642], "characters": "\u25AA" },
+  "&squ;": { "codepoints": [9633], "characters": "\u25A1" },
+  "&squf;": { "codepoints": [9642], "characters": "\u25AA" },
+  "&srarr;": { "codepoints": [8594], "characters": "\u2192" },
+  "&Sscr;": { "codepoints": [119982], "characters": "\uD835\uDCAE" },
+  "&sscr;": { "codepoints": [120008], "characters": "\uD835\uDCC8" },
+  "&ssetmn;": { "codepoints": [8726], "characters": "\u2216" },
+  "&ssmile;": { "codepoints": [8995], "characters": "\u2323" },
+  "&sstarf;": { "codepoints": [8902], "characters": "\u22C6" },
+  "&Star;": { "codepoints": [8902], "characters": "\u22C6" },
+  "&star;": { "codepoints": [9734], "characters": "\u2606" },
+  "&starf;": { "codepoints": [9733], "characters": "\u2605" },
+  "&straightepsilon;": { "codepoints": [1013], "characters": "\u03F5" },
+  "&straightphi;": { "codepoints": [981], "characters": "\u03D5" },
+  "&strns;": { "codepoints": [175], "characters": "\u00AF" },
+  "&sub;": { "codepoints": [8834], "characters": "\u2282" },
+  "&Sub;": { "codepoints": [8912], "characters": "\u22D0" },
+  "&subdot;": { "codepoints": [10941], "characters": "\u2ABD" },
+  "&subE;": { "codepoints": [10949], "characters": "\u2AC5" },
+  "&sube;": { "codepoints": [8838], "characters": "\u2286" },
+  "&subedot;": { "codepoints": [10947], "characters": "\u2AC3" },
+  "&submult;": { "codepoints": [10945], "characters": "\u2AC1" },
+  "&subnE;": { "codepoints": [10955], "characters": "\u2ACB" },
+  "&subne;": { "codepoints": [8842], "characters": "\u228A" },
+  "&subplus;": { "codepoints": [10943], "characters": "\u2ABF" },
+  "&subrarr;": { "codepoints": [10617], "characters": "\u2979" },
+  "&subset;": { "codepoints": [8834], "characters": "\u2282" },
+  "&Subset;": { "codepoints": [8912], "characters": "\u22D0" },
+  "&subseteq;": { "codepoints": [8838], "characters": "\u2286" },
+  "&subseteqq;": { "codepoints": [10949], "characters": "\u2AC5" },
+  "&SubsetEqual;": { "codepoints": [8838], "characters": "\u2286" },
+  "&subsetneq;": { "codepoints": [8842], "characters": "\u228A" },
+  "&subsetneqq;": { "codepoints": [10955], "characters": "\u2ACB" },
+  "&subsim;": { "codepoints": [10951], "characters": "\u2AC7" },
+  "&subsub;": { "codepoints": [10965], "characters": "\u2AD5" },
+  "&subsup;": { "codepoints": [10963], "characters": "\u2AD3" },
+  "&succapprox;": { "codepoints": [10936], "characters": "\u2AB8" },
+  "&succ;": { "codepoints": [8827], "characters": "\u227B" },
+  "&succcurlyeq;": { "codepoints": [8829], "characters": "\u227D" },
+  "&Succeeds;": { "codepoints": [8827], "characters": "\u227B" },
+  "&SucceedsEqual;": { "codepoints": [10928], "characters": "\u2AB0" },
+  "&SucceedsSlantEqual;": { "codepoints": [8829], "characters": "\u227D" },
+  "&SucceedsTilde;": { "codepoints": [8831], "characters": "\u227F" },
+  "&succeq;": { "codepoints": [10928], "characters": "\u2AB0" },
+  "&succnapprox;": { "codepoints": [10938], "characters": "\u2ABA" },
+  "&succneqq;": { "codepoints": [10934], "characters": "\u2AB6" },
+  "&succnsim;": { "codepoints": [8937], "characters": "\u22E9" },
+  "&succsim;": { "codepoints": [8831], "characters": "\u227F" },
+  "&SuchThat;": { "codepoints": [8715], "characters": "\u220B" },
+  "&sum;": { "codepoints": [8721], "characters": "\u2211" },
+  "&Sum;": { "codepoints": [8721], "characters": "\u2211" },
+  "&sung;": { "codepoints": [9834], "characters": "\u266A" },
+  "&sup1;": { "codepoints": [185], "characters": "\u00B9" },
+  "&sup1": { "codepoints": [185], "characters": "\u00B9" },
+  "&sup2;": { "codepoints": [178], "characters": "\u00B2" },
+  "&sup2": { "codepoints": [178], "characters": "\u00B2" },
+  "&sup3;": { "codepoints": [179], "characters": "\u00B3" },
+  "&sup3": { "codepoints": [179], "characters": "\u00B3" },
+  "&sup;": { "codepoints": [8835], "characters": "\u2283" },
+  "&Sup;": { "codepoints": [8913], "characters": "\u22D1" },
+  "&supdot;": { "codepoints": [10942], "characters": "\u2ABE" },
+  "&supdsub;": { "codepoints": [10968], "characters": "\u2AD8" },
+  "&supE;": { "codepoints": [10950], "characters": "\u2AC6" },
+  "&supe;": { "codepoints": [8839], "characters": "\u2287" },
+  "&supedot;": { "codepoints": [10948], "characters": "\u2AC4" },
+  "&Superset;": { "codepoints": [8835], "characters": "\u2283" },
+  "&SupersetEqual;": { "codepoints": [8839], "characters": "\u2287" },
+  "&suphsol;": { "codepoints": [10185], "characters": "\u27C9" },
+  "&suphsub;": { "codepoints": [10967], "characters": "\u2AD7" },
+  "&suplarr;": { "codepoints": [10619], "characters": "\u297B" },
+  "&supmult;": { "codepoints": [10946], "characters": "\u2AC2" },
+  "&supnE;": { "codepoints": [10956], "characters": "\u2ACC" },
+  "&supne;": { "codepoints": [8843], "characters": "\u228B" },
+  "&supplus;": { "codepoints": [10944], "characters": "\u2AC0" },
+  "&supset;": { "codepoints": [8835], "characters": "\u2283" },
+  "&Supset;": { "codepoints": [8913], "characters": "\u22D1" },
+  "&supseteq;": { "codepoints": [8839], "characters": "\u2287" },
+  "&supseteqq;": { "codepoints": [10950], "characters": "\u2AC6" },
+  "&supsetneq;": { "codepoints": [8843], "characters": "\u228B" },
+  "&supsetneqq;": { "codepoints": [10956], "characters": "\u2ACC" },
+  "&supsim;": { "codepoints": [10952], "characters": "\u2AC8" },
+  "&supsub;": { "codepoints": [10964], "characters": "\u2AD4" },
+  "&supsup;": { "codepoints": [10966], "characters": "\u2AD6" },
+  "&swarhk;": { "codepoints": [10534], "characters": "\u2926" },
+  "&swarr;": { "codepoints": [8601], "characters": "\u2199" },
+  "&swArr;": { "codepoints": [8665], "characters": "\u21D9" },
+  "&swarrow;": { "codepoints": [8601], "characters": "\u2199" },
+  "&swnwar;": { "codepoints": [10538], "characters": "\u292A" },
+  "&szlig;": { "codepoints": [223], "characters": "\u00DF" },
+  "&szlig": { "codepoints": [223], "characters": "\u00DF" },
+  "&Tab;": { "codepoints": [9], "characters": "\u0009" },
+  "&target;": { "codepoints": [8982], "characters": "\u2316" },
+  "&Tau;": { "codepoints": [932], "characters": "\u03A4" },
+  "&tau;": { "codepoints": [964], "characters": "\u03C4" },
+  "&tbrk;": { "codepoints": [9140], "characters": "\u23B4" },
+  "&Tcaron;": { "codepoints": [356], "characters": "\u0164" },
+  "&tcaron;": { "codepoints": [357], "characters": "\u0165" },
+  "&Tcedil;": { "codepoints": [354], "characters": "\u0162" },
+  "&tcedil;": { "codepoints": [355], "characters": "\u0163" },
+  "&Tcy;": { "codepoints": [1058], "characters": "\u0422" },
+  "&tcy;": { "codepoints": [1090], "characters": "\u0442" },
+  "&tdot;": { "codepoints": [8411], "characters": "\u20DB" },
+  "&telrec;": { "codepoints": [8981], "characters": "\u2315" },
+  "&Tfr;": { "codepoints": [120087], "characters": "\uD835\uDD17" },
+  "&tfr;": { "codepoints": [120113], "characters": "\uD835\uDD31" },
+  "&there4;": { "codepoints": [8756], "characters": "\u2234" },
+  "&therefore;": { "codepoints": [8756], "characters": "\u2234" },
+  "&Therefore;": { "codepoints": [8756], "characters": "\u2234" },
+  "&Theta;": { "codepoints": [920], "characters": "\u0398" },
+  "&theta;": { "codepoints": [952], "characters": "\u03B8" },
+  "&thetasym;": { "codepoints": [977], "characters": "\u03D1" },
+  "&thetav;": { "codepoints": [977], "characters": "\u03D1" },
+  "&thickapprox;": { "codepoints": [8776], "characters": "\u2248" },
+  "&thicksim;": { "codepoints": [8764], "characters": "\u223C" },
+  "&ThickSpace;": { "codepoints": [8287, 8202], "characters": "\u205F\u200A" },
+  "&ThinSpace;": { "codepoints": [8201], "characters": "\u2009" },
+  "&thinsp;": { "codepoints": [8201], "characters": "\u2009" },
+  "&thkap;": { "codepoints": [8776], "characters": "\u2248" },
+  "&thksim;": { "codepoints": [8764], "characters": "\u223C" },
+  "&THORN;": { "codepoints": [222], "characters": "\u00DE" },
+  "&THORN": { "codepoints": [222], "characters": "\u00DE" },
+  "&thorn;": { "codepoints": [254], "characters": "\u00FE" },
+  "&thorn": { "codepoints": [254], "characters": "\u00FE" },
+  "&tilde;": { "codepoints": [732], "characters": "\u02DC" },
+  "&Tilde;": { "codepoints": [8764], "characters": "\u223C" },
+  "&TildeEqual;": { "codepoints": [8771], "characters": "\u2243" },
+  "&TildeFullEqual;": { "codepoints": [8773], "characters": "\u2245" },
+  "&TildeTilde;": { "codepoints": [8776], "characters": "\u2248" },
+  "&timesbar;": { "codepoints": [10801], "characters": "\u2A31" },
+  "&timesb;": { "codepoints": [8864], "characters": "\u22A0" },
+  "&times;": { "codepoints": [215], "characters": "\u00D7" },
+  "&times": { "codepoints": [215], "characters": "\u00D7" },
+  "&timesd;": { "codepoints": [10800], "characters": "\u2A30" },
+  "&tint;": { "codepoints": [8749], "characters": "\u222D" },
+  "&toea;": { "codepoints": [10536], "characters": "\u2928" },
+  "&topbot;": { "codepoints": [9014], "characters": "\u2336" },
+  "&topcir;": { "codepoints": [10993], "characters": "\u2AF1" },
+  "&top;": { "codepoints": [8868], "characters": "\u22A4" },
+  "&Topf;": { "codepoints": [120139], "characters": "\uD835\uDD4B" },
+  "&topf;": { "codepoints": [120165], "characters": "\uD835\uDD65" },
+  "&topfork;": { "codepoints": [10970], "characters": "\u2ADA" },
+  "&tosa;": { "codepoints": [10537], "characters": "\u2929" },
+  "&tprime;": { "codepoints": [8244], "characters": "\u2034" },
+  "&trade;": { "codepoints": [8482], "characters": "\u2122" },
+  "&TRADE;": { "codepoints": [8482], "characters": "\u2122" },
+  "&triangle;": { "codepoints": [9653], "characters": "\u25B5" },
+  "&triangledown;": { "codepoints": [9663], "characters": "\u25BF" },
+  "&triangleleft;": { "codepoints": [9667], "characters": "\u25C3" },
+  "&trianglelefteq;": { "codepoints": [8884], "characters": "\u22B4" },
+  "&triangleq;": { "codepoints": [8796], "characters": "\u225C" },
+  "&triangleright;": { "codepoints": [9657], "characters": "\u25B9" },
+  "&trianglerighteq;": { "codepoints": [8885], "characters": "\u22B5" },
+  "&tridot;": { "codepoints": [9708], "characters": "\u25EC" },
+  "&trie;": { "codepoints": [8796], "characters": "\u225C" },
+  "&triminus;": { "codepoints": [10810], "characters": "\u2A3A" },
+  "&TripleDot;": { "codepoints": [8411], "characters": "\u20DB" },
+  "&triplus;": { "codepoints": [10809], "characters": "\u2A39" },
+  "&trisb;": { "codepoints": [10701], "characters": "\u29CD" },
+  "&tritime;": { "codepoints": [10811], "characters": "\u2A3B" },
+  "&trpezium;": { "codepoints": [9186], "characters": "\u23E2" },
+  "&Tscr;": { "codepoints": [119983], "characters": "\uD835\uDCAF" },
+  "&tscr;": { "codepoints": [120009], "characters": "\uD835\uDCC9" },
+  "&TScy;": { "codepoints": [1062], "characters": "\u0426" },
+  "&tscy;": { "codepoints": [1094], "characters": "\u0446" },
+  "&TSHcy;": { "codepoints": [1035], "characters": "\u040B" },
+  "&tshcy;": { "codepoints": [1115], "characters": "\u045B" },
+  "&Tstrok;": { "codepoints": [358], "characters": "\u0166" },
+  "&tstrok;": { "codepoints": [359], "characters": "\u0167" },
+  "&twixt;": { "codepoints": [8812], "characters": "\u226C" },
+  "&twoheadleftarrow;": { "codepoints": [8606], "characters": "\u219E" },
+  "&twoheadrightarrow;": { "codepoints": [8608], "characters": "\u21A0" },
+  "&Uacute;": { "codepoints": [218], "characters": "\u00DA" },
+  "&Uacute": { "codepoints": [218], "characters": "\u00DA" },
+  "&uacute;": { "codepoints": [250], "characters": "\u00FA" },
+  "&uacute": { "codepoints": [250], "characters": "\u00FA" },
+  "&uarr;": { "codepoints": [8593], "characters": "\u2191" },
+  "&Uarr;": { "codepoints": [8607], "characters": "\u219F" },
+  "&uArr;": { "codepoints": [8657], "characters": "\u21D1" },
+  "&Uarrocir;": { "codepoints": [10569], "characters": "\u2949" },
+  "&Ubrcy;": { "codepoints": [1038], "characters": "\u040E" },
+  "&ubrcy;": { "codepoints": [1118], "characters": "\u045E" },
+  "&Ubreve;": { "codepoints": [364], "characters": "\u016C" },
+  "&ubreve;": { "codepoints": [365], "characters": "\u016D" },
+  "&Ucirc;": { "codepoints": [219], "characters": "\u00DB" },
+  "&Ucirc": { "codepoints": [219], "characters": "\u00DB" },
+  "&ucirc;": { "codepoints": [251], "characters": "\u00FB" },
+  "&ucirc": { "codepoints": [251], "characters": "\u00FB" },
+  "&Ucy;": { "codepoints": [1059], "characters": "\u0423" },
+  "&ucy;": { "codepoints": [1091], "characters": "\u0443" },
+  "&udarr;": { "codepoints": [8645], "characters": "\u21C5" },
+  "&Udblac;": { "codepoints": [368], "characters": "\u0170" },
+  "&udblac;": { "codepoints": [369], "characters": "\u0171" },
+  "&udhar;": { "codepoints": [10606], "characters": "\u296E" },
+  "&ufisht;": { "codepoints": [10622], "characters": "\u297E" },
+  "&Ufr;": { "codepoints": [120088], "characters": "\uD835\uDD18" },
+  "&ufr;": { "codepoints": [120114], "characters": "\uD835\uDD32" },
+  "&Ugrave;": { "codepoints": [217], "characters": "\u00D9" },
+  "&Ugrave": { "codepoints": [217], "characters": "\u00D9" },
+  "&ugrave;": { "codepoints": [249], "characters": "\u00F9" },
+  "&ugrave": { "codepoints": [249], "characters": "\u00F9" },
+  "&uHar;": { "codepoints": [10595], "characters": "\u2963" },
+  "&uharl;": { "codepoints": [8639], "characters": "\u21BF" },
+  "&uharr;": { "codepoints": [8638], "characters": "\u21BE" },
+  "&uhblk;": { "codepoints": [9600], "characters": "\u2580" },
+  "&ulcorn;": { "codepoints": [8988], "characters": "\u231C" },
+  "&ulcorner;": { "codepoints": [8988], "characters": "\u231C" },
+  "&ulcrop;": { "codepoints": [8975], "characters": "\u230F" },
+  "&ultri;": { "codepoints": [9720], "characters": "\u25F8" },
+  "&Umacr;": { "codepoints": [362], "characters": "\u016A" },
+  "&umacr;": { "codepoints": [363], "characters": "\u016B" },
+  "&uml;": { "codepoints": [168], "characters": "\u00A8" },
+  "&uml": { "codepoints": [168], "characters": "\u00A8" },
+  "&UnderBar;": { "codepoints": [95], "characters": "\u005F" },
+  "&UnderBrace;": { "codepoints": [9183], "characters": "\u23DF" },
+  "&UnderBracket;": { "codepoints": [9141], "characters": "\u23B5" },
+  "&UnderParenthesis;": { "codepoints": [9181], "characters": "\u23DD" },
+  "&Union;": { "codepoints": [8899], "characters": "\u22C3" },
+  "&UnionPlus;": { "codepoints": [8846], "characters": "\u228E" },
+  "&Uogon;": { "codepoints": [370], "characters": "\u0172" },
+  "&uogon;": { "codepoints": [371], "characters": "\u0173" },
+  "&Uopf;": { "codepoints": [120140], "characters": "\uD835\uDD4C" },
+  "&uopf;": { "codepoints": [120166], "characters": "\uD835\uDD66" },
+  "&UpArrowBar;": { "codepoints": [10514], "characters": "\u2912" },
+  "&uparrow;": { "codepoints": [8593], "characters": "\u2191" },
+  "&UpArrow;": { "codepoints": [8593], "characters": "\u2191" },
+  "&Uparrow;": { "codepoints": [8657], "characters": "\u21D1" },
+  "&UpArrowDownArrow;": { "codepoints": [8645], "characters": "\u21C5" },
+  "&updownarrow;": { "codepoints": [8597], "characters": "\u2195" },
+  "&UpDownArrow;": { "codepoints": [8597], "characters": "\u2195" },
+  "&Updownarrow;": { "codepoints": [8661], "characters": "\u21D5" },
+  "&UpEquilibrium;": { "codepoints": [10606], "characters": "\u296E" },
+  "&upharpoonleft;": { "codepoints": [8639], "characters": "\u21BF" },
+  "&upharpoonright;": { "codepoints": [8638], "characters": "\u21BE" },
+  "&uplus;": { "codepoints": [8846], "characters": "\u228E" },
+  "&UpperLeftArrow;": { "codepoints": [8598], "characters": "\u2196" },
+  "&UpperRightArrow;": { "codepoints": [8599], "characters": "\u2197" },
+  "&upsi;": { "codepoints": [965], "characters": "\u03C5" },
+  "&Upsi;": { "codepoints": [978], "characters": "\u03D2" },
+  "&upsih;": { "codepoints": [978], "characters": "\u03D2" },
+  "&Upsilon;": { "codepoints": [933], "characters": "\u03A5" },
+  "&upsilon;": { "codepoints": [965], "characters": "\u03C5" },
+  "&UpTeeArrow;": { "codepoints": [8613], "characters": "\u21A5" },
+  "&UpTee;": { "codepoints": [8869], "characters": "\u22A5" },
+  "&upuparrows;": { "codepoints": [8648], "characters": "\u21C8" },
+  "&urcorn;": { "codepoints": [8989], "characters": "\u231D" },
+  "&urcorner;": { "codepoints": [8989], "characters": "\u231D" },
+  "&urcrop;": { "codepoints": [8974], "characters": "\u230E" },
+  "&Uring;": { "codepoints": [366], "characters": "\u016E" },
+  "&uring;": { "codepoints": [367], "characters": "\u016F" },
+  "&urtri;": { "codepoints": [9721], "characters": "\u25F9" },
+  "&Uscr;": { "codepoints": [119984], "characters": "\uD835\uDCB0" },
+  "&uscr;": { "codepoints": [120010], "characters": "\uD835\uDCCA" },
+  "&utdot;": { "codepoints": [8944], "characters": "\u22F0" },
+  "&Utilde;": { "codepoints": [360], "characters": "\u0168" },
+  "&utilde;": { "codepoints": [361], "characters": "\u0169" },
+  "&utri;": { "codepoints": [9653], "characters": "\u25B5" },
+  "&utrif;": { "codepoints": [9652], "characters": "\u25B4" },
+  "&uuarr;": { "codepoints": [8648], "characters": "\u21C8" },
+  "&Uuml;": { "codepoints": [220], "characters": "\u00DC" },
+  "&Uuml": { "codepoints": [220], "characters": "\u00DC" },
+  "&uuml;": { "codepoints": [252], "characters": "\u00FC" },
+  "&uuml": { "codepoints": [252], "characters": "\u00FC" },
+  "&uwangle;": { "codepoints": [10663], "characters": "\u29A7" },
+  "&vangrt;": { "codepoints": [10652], "characters": "\u299C" },
+  "&varepsilon;": { "codepoints": [1013], "characters": "\u03F5" },
+  "&varkappa;": { "codepoints": [1008], "characters": "\u03F0" },
+  "&varnothing;": { "codepoints": [8709], "characters": "\u2205" },
+  "&varphi;": { "codepoints": [981], "characters": "\u03D5" },
+  "&varpi;": { "codepoints": [982], "characters": "\u03D6" },
+  "&varpropto;": { "codepoints": [8733], "characters": "\u221D" },
+  "&varr;": { "codepoints": [8597], "characters": "\u2195" },
+  "&vArr;": { "codepoints": [8661], "characters": "\u21D5" },
+  "&varrho;": { "codepoints": [1009], "characters": "\u03F1" },
+  "&varsigma;": { "codepoints": [962], "characters": "\u03C2" },
+  "&varsubsetneq;": { "codepoints": [8842, 65024], "characters": "\u228A\uFE00" },
+  "&varsubsetneqq;": { "codepoints": [10955, 65024], "characters": "\u2ACB\uFE00" },
+  "&varsupsetneq;": { "codepoints": [8843, 65024], "characters": "\u228B\uFE00" },
+  "&varsupsetneqq;": { "codepoints": [10956, 65024], "characters": "\u2ACC\uFE00" },
+  "&vartheta;": { "codepoints": [977], "characters": "\u03D1" },
+  "&vartriangleleft;": { "codepoints": [8882], "characters": "\u22B2" },
+  "&vartriangleright;": { "codepoints": [8883], "characters": "\u22B3" },
+  "&vBar;": { "codepoints": [10984], "characters": "\u2AE8" },
+  "&Vbar;": { "codepoints": [10987], "characters": "\u2AEB" },
+  "&vBarv;": { "codepoints": [10985], "characters": "\u2AE9" },
+  "&Vcy;": { "codepoints": [1042], "characters": "\u0412" },
+  "&vcy;": { "codepoints": [1074], "characters": "\u0432" },
+  "&vdash;": { "codepoints": [8866], "characters": "\u22A2" },
+  "&vDash;": { "codepoints": [8872], "characters": "\u22A8" },
+  "&Vdash;": { "codepoints": [8873], "characters": "\u22A9" },
+  "&VDash;": { "codepoints": [8875], "characters": "\u22AB" },
+  "&Vdashl;": { "codepoints": [10982], "characters": "\u2AE6" },
+  "&veebar;": { "codepoints": [8891], "characters": "\u22BB" },
+  "&vee;": { "codepoints": [8744], "characters": "\u2228" },
+  "&Vee;": { "codepoints": [8897], "characters": "\u22C1" },
+  "&veeeq;": { "codepoints": [8794], "characters": "\u225A" },
+  "&vellip;": { "codepoints": [8942], "characters": "\u22EE" },
+  "&verbar;": { "codepoints": [124], "characters": "\u007C" },
+  "&Verbar;": { "codepoints": [8214], "characters": "\u2016" },
+  "&vert;": { "codepoints": [124], "characters": "\u007C" },
+  "&Vert;": { "codepoints": [8214], "characters": "\u2016" },
+  "&VerticalBar;": { "codepoints": [8739], "characters": "\u2223" },
+  "&VerticalLine;": { "codepoints": [124], "characters": "\u007C" },
+  "&VerticalSeparator;": { "codepoints": [10072], "characters": "\u2758" },
+  "&VerticalTilde;": { "codepoints": [8768], "characters": "\u2240" },
+  "&VeryThinSpace;": { "codepoints": [8202], "characters": "\u200A" },
+  "&Vfr;": { "codepoints": [120089], "characters": "\uD835\uDD19" },
+  "&vfr;": { "codepoints": [120115], "characters": "\uD835\uDD33" },
+  "&vltri;": { "codepoints": [8882], "characters": "\u22B2" },
+  "&vnsub;": { "codepoints": [8834, 8402], "characters": "\u2282\u20D2" },
+  "&vnsup;": { "codepoints": [8835, 8402], "characters": "\u2283\u20D2" },
+  "&Vopf;": { "codepoints": [120141], "characters": "\uD835\uDD4D" },
+  "&vopf;": { "codepoints": [120167], "characters": "\uD835\uDD67" },
+  "&vprop;": { "codepoints": [8733], "characters": "\u221D" },
+  "&vrtri;": { "codepoints": [8883], "characters": "\u22B3" },
+  "&Vscr;": { "codepoints": [119985], "characters": "\uD835\uDCB1" },
+  "&vscr;": { "codepoints": [120011], "characters": "\uD835\uDCCB" },
+  "&vsubnE;": { "codepoints": [10955, 65024], "characters": "\u2ACB\uFE00" },
+  "&vsubne;": { "codepoints": [8842, 65024], "characters": "\u228A\uFE00" },
+  "&vsupnE;": { "codepoints": [10956, 65024], "characters": "\u2ACC\uFE00" },
+  "&vsupne;": { "codepoints": [8843, 65024], "characters": "\u228B\uFE00" },
+  "&Vvdash;": { "codepoints": [8874], "characters": "\u22AA" },
+  "&vzigzag;": { "codepoints": [10650], "characters": "\u299A" },
+  "&Wcirc;": { "codepoints": [372], "characters": "\u0174" },
+  "&wcirc;": { "codepoints": [373], "characters": "\u0175" },
+  "&wedbar;": { "codepoints": [10847], "characters": "\u2A5F" },
+  "&wedge;": { "codepoints": [8743], "characters": "\u2227" },
+  "&Wedge;": { "codepoints": [8896], "characters": "\u22C0" },
+  "&wedgeq;": { "codepoints": [8793], "characters": "\u2259" },
+  "&weierp;": { "codepoints": [8472], "characters": "\u2118" },
+  "&Wfr;": { "codepoints": [120090], "characters": "\uD835\uDD1A" },
+  "&wfr;": { "codepoints": [120116], "characters": "\uD835\uDD34" },
+  "&Wopf;": { "codepoints": [120142], "characters": "\uD835\uDD4E" },
+  "&wopf;": { "codepoints": [120168], "characters": "\uD835\uDD68" },
+  "&wp;": { "codepoints": [8472], "characters": "\u2118" },
+  "&wr;": { "codepoints": [8768], "characters": "\u2240" },
+  "&wreath;": { "codepoints": [8768], "characters": "\u2240" },
+  "&Wscr;": { "codepoints": [119986], "characters": "\uD835\uDCB2" },
+  "&wscr;": { "codepoints": [120012], "characters": "\uD835\uDCCC" },
+  "&xcap;": { "codepoints": [8898], "characters": "\u22C2" },
+  "&xcirc;": { "codepoints": [9711], "characters": "\u25EF" },
+  "&xcup;": { "codepoints": [8899], "characters": "\u22C3" },
+  "&xdtri;": { "codepoints": [9661], "characters": "\u25BD" },
+  "&Xfr;": { "codepoints": [120091], "characters": "\uD835\uDD1B" },
+  "&xfr;": { "codepoints": [120117], "characters": "\uD835\uDD35" },
+  "&xharr;": { "codepoints": [10231], "characters": "\u27F7" },
+  "&xhArr;": { "codepoints": [10234], "characters": "\u27FA" },
+  "&Xi;": { "codepoints": [926], "characters": "\u039E" },
+  "&xi;": { "codepoints": [958], "characters": "\u03BE" },
+  "&xlarr;": { "codepoints": [10229], "characters": "\u27F5" },
+  "&xlArr;": { "codepoints": [10232], "characters": "\u27F8" },
+  "&xmap;": { "codepoints": [10236], "characters": "\u27FC" },
+  "&xnis;": { "codepoints": [8955], "characters": "\u22FB" },
+  "&xodot;": { "codepoints": [10752], "characters": "\u2A00" },
+  "&Xopf;": { "codepoints": [120143], "characters": "\uD835\uDD4F" },
+  "&xopf;": { "codepoints": [120169], "characters": "\uD835\uDD69" },
+  "&xoplus;": { "codepoints": [10753], "characters": "\u2A01" },
+  "&xotime;": { "codepoints": [10754], "characters": "\u2A02" },
+  "&xrarr;": { "codepoints": [10230], "characters": "\u27F6" },
+  "&xrArr;": { "codepoints": [10233], "characters": "\u27F9" },
+  "&Xscr;": { "codepoints": [119987], "characters": "\uD835\uDCB3" },
+  "&xscr;": { "codepoints": [120013], "characters": "\uD835\uDCCD" },
+  "&xsqcup;": { "codepoints": [10758], "characters": "\u2A06" },
+  "&xuplus;": { "codepoints": [10756], "characters": "\u2A04" },
+  "&xutri;": { "codepoints": [9651], "characters": "\u25B3" },
+  "&xvee;": { "codepoints": [8897], "characters": "\u22C1" },
+  "&xwedge;": { "codepoints": [8896], "characters": "\u22C0" },
+  "&Yacute;": { "codepoints": [221], "characters": "\u00DD" },
+  "&Yacute": { "codepoints": [221], "characters": "\u00DD" },
+  "&yacute;": { "codepoints": [253], "characters": "\u00FD" },
+  "&yacute": { "codepoints": [253], "characters": "\u00FD" },
+  "&YAcy;": { "codepoints": [1071], "characters": "\u042F" },
+  "&yacy;": { "codepoints": [1103], "characters": "\u044F" },
+  "&Ycirc;": { "codepoints": [374], "characters": "\u0176" },
+  "&ycirc;": { "codepoints": [375], "characters": "\u0177" },
+  "&Ycy;": { "codepoints": [1067], "characters": "\u042B" },
+  "&ycy;": { "codepoints": [1099], "characters": "\u044B" },
+  "&yen;": { "codepoints": [165], "characters": "\u00A5" },
+  "&yen": { "codepoints": [165], "characters": "\u00A5" },
+  "&Yfr;": { "codepoints": [120092], "characters": "\uD835\uDD1C" },
+  "&yfr;": { "codepoints": [120118], "characters": "\uD835\uDD36" },
+  "&YIcy;": { "codepoints": [1031], "characters": "\u0407" },
+  "&yicy;": { "codepoints": [1111], "characters": "\u0457" },
+  "&Yopf;": { "codepoints": [120144], "characters": "\uD835\uDD50" },
+  "&yopf;": { "codepoints": [120170], "characters": "\uD835\uDD6A" },
+  "&Yscr;": { "codepoints": [119988], "characters": "\uD835\uDCB4" },
+  "&yscr;": { "codepoints": [120014], "characters": "\uD835\uDCCE" },
+  "&YUcy;": { "codepoints": [1070], "characters": "\u042E" },
+  "&yucy;": { "codepoints": [1102], "characters": "\u044E" },
+  "&yuml;": { "codepoints": [255], "characters": "\u00FF" },
+  "&yuml": { "codepoints": [255], "characters": "\u00FF" },
+  "&Yuml;": { "codepoints": [376], "characters": "\u0178" },
+  "&Zacute;": { "codepoints": [377], "characters": "\u0179" },
+  "&zacute;": { "codepoints": [378], "characters": "\u017A" },
+  "&Zcaron;": { "codepoints": [381], "characters": "\u017D" },
+  "&zcaron;": { "codepoints": [382], "characters": "\u017E" },
+  "&Zcy;": { "codepoints": [1047], "characters": "\u0417" },
+  "&zcy;": { "codepoints": [1079], "characters": "\u0437" },
+  "&Zdot;": { "codepoints": [379], "characters": "\u017B" },
+  "&zdot;": { "codepoints": [380], "characters": "\u017C" },
+  "&zeetrf;": { "codepoints": [8488], "characters": "\u2128" },
+  "&ZeroWidthSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&Zeta;": { "codepoints": [918], "characters": "\u0396" },
+  "&zeta;": { "codepoints": [950], "characters": "\u03B6" },
+  "&zfr;": { "codepoints": [120119], "characters": "\uD835\uDD37" },
+  "&Zfr;": { "codepoints": [8488], "characters": "\u2128" },
+  "&ZHcy;": { "codepoints": [1046], "characters": "\u0416" },
+  "&zhcy;": { "codepoints": [1078], "characters": "\u0436" },
+  "&zigrarr;": { "codepoints": [8669], "characters": "\u21DD" },
+  "&zopf;": { "codepoints": [120171], "characters": "\uD835\uDD6B" },
+  "&Zopf;": { "codepoints": [8484], "characters": "\u2124" },
+  "&Zscr;": { "codepoints": [119989], "characters": "\uD835\uDCB5" },
+  "&zscr;": { "codepoints": [120015], "characters": "\uD835\uDCCF" },
+  "&zwj;": { "codepoints": [8205], "characters": "\u200D" },
+  "&zwnj;": { "codepoints": [8204], "characters": "\u200C" }
+};
+
+var ALPHANUMERIC = /^[a-zA-Z0-9]/;
+var getPossibleNamedEntityStart = makeRegexMatcher(/^&[a-zA-Z0-9]/);
+var getApparentNamedEntity = makeRegexMatcher(/^&[a-zA-Z0-9]+;/);
+
+var getNamedEntityByFirstChar = {};
+(function () {
+  var namedEntitiesByFirstChar = {};
+  for (var ent in ENTITIES) {
+    var chr = ent.charAt(1);
+    namedEntitiesByFirstChar[chr] = (namedEntitiesByFirstChar[chr] || []);
+    namedEntitiesByFirstChar[chr].push(ent.slice(2));
+  }
+  for (var chr in namedEntitiesByFirstChar) {
+    getNamedEntityByFirstChar[chr] = makeRegexMatcher(
+      new RegExp('^&' + chr + '(?:' +
+                 namedEntitiesByFirstChar[chr].join('|') + ')'));
+  }
+})();
+
+// Run a provided "matcher" function but reset the current position afterwards.
+// Fatal failure of the matcher is not suppressed.
+var peekMatcher = function (scanner, matcher) {
+  var start = scanner.pos;
+  var result = matcher(scanner);
+  scanner.pos = start;
+  return result;
+};
+
+// Returns a string like "&amp;" or a falsy value if no match.  Fails fatally
+// if something looks like a named entity but isn't.
+var getNamedCharRef = function (scanner, inAttribute) {
+  // look for `&` followed by alphanumeric
+  if (! peekMatcher(scanner, getPossibleNamedEntityStart))
+    return null;
+
+  var matcher = getNamedEntityByFirstChar[scanner.rest().charAt(1)];
+  var entity = null;
+  if (matcher)
+    entity = peekMatcher(scanner, matcher);
+
+  if (entity) {
+    if (entity.slice(-1) !== ';') {
+      // Certain character references with no semi are an error, like `&lt`.
+      // In attribute values, however, this is not fatal if the next character
+      // is alphanumeric.
+      //
+      // This rule affects href attributes, for example, deeming "/?foo=bar&ltc=abc"
+      // to be ok but "/?foo=bar&lt=abc" to not be.
+      if (inAttribute && ALPHANUMERIC.test(scanner.rest().charAt(entity.length)))
+        return null;
+      scanner.fatal("Character reference requires semicolon: " + entity);
+    } else {
+      scanner.pos += entity.length;
+      return entity;
+    }
+  } else {
+    // we couldn't match any real entity, so see if this is a bad entity
+    // or something we can overlook.
+    var badEntity = peekMatcher(scanner, getApparentNamedEntity);
+    if (badEntity)
+      scanner.fatal("Invalid character reference: " + badEntity);
+    // `&aaaa` is ok with no semicolon
+    return null;
+  }
+};
+
+// Returns the sequence of one or two codepoints making up an entity as an array.
+// Codepoints in the array are integers and may be out of the single-char JavaScript
+// range.
+var getCodePoints = function (namedEntity) {
+  return ENTITIES[namedEntity].codepoints;
+};
+
+var ALLOWED_AFTER_AMP = /^[\u0009\u000a\u000c <&]/;
+
+var getCharRefNumber = makeRegexMatcher(/^(?:[xX][0-9a-fA-F]+|[0-9]+);/);
+
+var BIG_BAD_CODEPOINTS = (function (obj) {
+  var list = [0x1FFFE, 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE, 0x3FFFF,
+              0x4FFFE, 0x4FFFF, 0x5FFFE, 0x5FFFF, 0x6FFFE, 0x6FFFF,
+              0x7FFFE, 0x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE, 0x9FFFF,
+              0xAFFFE, 0xAFFFF, 0xBFFFE, 0xBFFFF, 0xCFFFE, 0xCFFFF,
+              0xDFFFE, 0xDFFFF, 0xEFFFE, 0xEFFFF, 0xFFFFE, 0xFFFFF,
+              0x10FFFE, 0x10FFFF];
+  for (var i = 0; i < list.length; i++)
+    obj[list[i]] = true;
+
+  return obj;
+})({});
+
+var isLegalCodepoint = function (cp) {
+  if ((cp === 0) ||
+      (cp >= 0x80 && cp <= 0x9f) ||
+      (cp >= 0xd800 && cp <= 0xdfff) ||
+      (cp >= 0x10ffff) ||
+      (cp >= 0x1 && cp <= 0x8) ||
+      (cp === 0xb) ||
+      (cp >= 0xd && cp <= 0x1f) ||
+      (cp >= 0x7f && cp <= 0x9f) ||
+      (cp >= 0xfdd0 && cp <= 0xfdef) ||
+      (cp === 0xfffe) ||
+      (cp === 0xffff) ||
+      (cp >= 0x10000 && BIG_BAD_CODEPOINTS[cp]))
+    return false;
+
+  return true;
+};
+
+// http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#consume-a-character-reference
+//
+// Matches a character reference if possible, including the initial `&`.
+// Fails fatally in error cases (assuming an initial `&` is matched), like a disallowed codepoint
+// number or a bad named character reference.
+//
+// `inAttribute` is truthy if we are in an attribute value.
+//
+// `allowedChar` is an optional character that,
+// if found after the initial `&`, aborts parsing silently rather than failing fatally.  In real use it is
+// either `"`, `'`, or `>` and is supplied when parsing attribute values.  NOTE: In the current spec, the
+// value of `allowedChar` doesn't actually seem to end up mattering, but there is still some debate about
+// the right approach to ampersands.
+getCharacterReference = HTMLTools.Parse.getCharacterReference = function (scanner, inAttribute, allowedChar) {
+  if (scanner.peek() !== '&')
+    // no ampersand
+    return null;
+
+  var afterAmp = scanner.rest().charAt(1);
+
+  if (afterAmp === '#') {
+    scanner.pos += 2;
+    // refNumber includes possible initial `x` and final semicolon
+    var refNumber = getCharRefNumber(scanner);
+    // At this point we've consumed the input, so we're committed to returning
+    // something or failing fatally.
+    if (! refNumber)
+      scanner.fatal("Invalid numerical character reference starting with &#");
+    var codepoint;
+    if (refNumber.charAt(0) === 'x' || refNumber.charAt(0) === 'X') {
+      // hex
+      var hex = refNumber.slice(1, -1);
+      while (hex.charAt(0) === '0')
+        hex = hex.slice(1);
+      if (hex.length > 6)
+        scanner.fatal("Numerical character reference too large: 0x" + hex);
+      codepoint = parseInt(hex || "0", 16);
+    } else {
+      var dec = refNumber.slice(0, -1);
+      while (dec.charAt(0) === '0')
+        dec = dec.slice(1);
+      if (dec.length > 7)
+        scanner.fatal("Numerical character reference too large: " + dec);
+      codepoint = parseInt(dec || "0", 10);
+    }
+    if (! isLegalCodepoint(codepoint))
+      scanner.fatal("Illegal codepoint in numerical character reference: &#" + refNumber);
+    return { t: 'CharRef',
+             v: '&#' + refNumber,
+             cp: [codepoint] };
+  } else if ((! afterAmp) // EOF
+             || (allowedChar && afterAmp === allowedChar)
+             || ALLOWED_AFTER_AMP.test(afterAmp)) {
+    return null;
+  } else {
+    var namedEntity = getNamedCharRef(scanner, inAttribute);
+    if (namedEntity) {
+      return { t: 'CharRef',
+               v: namedEntity,
+               cp: getCodePoints(namedEntity) };
+    } else {
+      return null;
+    }
+  }
+};
diff --git a/packages/html-tools/charref_tests.js b/packages/html-tools/charref_tests.js
new file mode 100644
index 0000000000..153e5a3500
--- /dev/null
+++ b/packages/html-tools/charref_tests.js
@@ -0,0 +1,114 @@
+var Scanner = HTMLTools.Scanner;
+var getCharacterReference = HTMLTools.Parse.getCharacterReference;
+
+Tinytest.add("html-tools - entities", function (test) {
+  var succeed = function (input, match, codepoints) {
+    if (typeof input === 'string')
+      input = {input: input};
+
+    // match arg is optional; codepoints is never a string
+    if (typeof match !== 'string') {
+      codepoints = match;
+      match = input.input;
+    }
+
+    var scanner = new Scanner(input.input);
+    var result = getCharacterReference(scanner, input.inAttribute, input.allowedChar);
+    test.isTrue(result);
+    test.equal(scanner.pos, match.length);
+    test.equal(result, {
+      t: 'CharRef',
+      v: match,
+      cp: _.map(codepoints,
+                function (x) { return (typeof x === 'string' ?
+                                       x.charCodeAt(0) : x); })
+    });
+  };
+
+  var ignore = function (input) {
+    if (typeof input === 'string')
+      input = {input: input};
+
+    var scanner = new Scanner(input.input);
+    var result = getCharacterReference(scanner, input.inAttribute, input.allowedChar);
+    test.isFalse(result);
+    test.equal(scanner.pos, 0);
+  };
+
+  var fatal = function (input, messageContains) {
+    if (typeof input === 'string')
+      input = {input: input};
+
+    var scanner = new Scanner(input.input);
+    var error;
+    try {
+      getCharacterReference(scanner, input.inAttribute, input.allowedChar);
+    } catch (e) {
+      error = e;
+    }
+    test.isTrue(error);
+    if (error)
+      test.isTrue(messageContains && error.message.indexOf(messageContains) >= 0, error.message);
+  };
+
+  ignore('a');
+  ignore('&');
+  ignore('&&');
+  ignore('&\t');
+  ignore('& ');
+  fatal('&#', 'Invalid numerical character reference starting with &#');
+  ignore('&a');
+  fatal('&a;', 'Invalid character reference: &a;');
+  ignore({input: '&"', allowedChar: '"'});
+  ignore('&"');
+
+  succeed('&gt;', ['>']);
+  fatal('&gt', 'Character reference requires semicolon');
+  ignore('&aaa');
+  fatal('&gta', 'Character reference requires semicolon');
+  ignore({input: '&gta', inAttribute: true});
+  fatal({input: '&gt=', inAttribute: true}, 'Character reference requires semicolon: &gt');
+
+  succeed('&gt;;', '&gt;', ['>']);
+
+  fatal('&asdflkj;', 'Invalid character reference: &asdflkj;');
+  fatal('&A0asdflkj;', 'Invalid character reference: &A0asdflkj;');
+  ignore('&A0asdflkj');
+
+  succeed('&zopf;', [120171]);
+  succeed('&acE;', [8766, 819]);
+
+  succeed('&#10;', [10]);
+  fatal('&#10', 'Invalid numerical character reference starting with &#');
+  fatal('&#xg;', 'Invalid numerical character reference starting with &#');
+  fatal('&#;', 'Invalid numerical character reference starting with &#');
+  fatal('&#a;', 'Invalid numerical character reference starting with &#');
+  fatal('&#a', 'Invalid numerical character reference starting with &#');
+  fatal('&#z', 'Invalid numerical character reference starting with &#');
+  succeed('&#000000000000010;', [10]);
+  fatal('&#0001000000000010;', 'Numerical character reference too large: 1000000000010');
+  succeed('&#x00000000000000000000a;', [10]);
+  fatal('&#x000100000000000a;', 'Numerical character reference too large: 0x100000000000a');
+  succeed('&#010;', [10]);
+  succeed('&#xa;', [10]);
+  succeed('&#Xa;', [10]);
+  succeed('&#XA;', [10]);
+  succeed('&#xA;', [10]);
+
+  fatal('&#0;', 'Illegal codepoint in numerical character reference: &#0;');
+  fatal('&#x0;', 'Illegal codepoint in numerical character reference: &#x0;');
+
+  fatal('&#xb;', 'Illegal codepoint in numerical character reference: &#xb;');
+  succeed('&#xc;', [12]);
+  fatal('&#11;', 'Illegal codepoint in numerical character reference: &#11;');
+  succeed('&#12;', [12]);
+
+  fatal('&#x10ffff;', 'Illegal codepoint in numerical character reference');
+  fatal('&#x10fffe;', 'Illegal codepoint in numerical character reference');
+  succeed('&#x10fffd;', [0x10fffd]);
+
+  fatal('&#1114111;', 'Illegal codepoint in numerical character reference');
+  fatal('&#1114110;', 'Illegal codepoint in numerical character reference');
+  succeed('&#1114109;', [0x10fffd]);
+
+});
\ No newline at end of file
diff --git a/packages/html-tools/package.js b/packages/html-tools/package.js
new file mode 100644
index 0000000000..2628475d8b
--- /dev/null
+++ b/packages/html-tools/package.js
@@ -0,0 +1,30 @@
+
+Package.describe({
+  name: "html-tools",
+  test: "html-tools-test",
+  summary: "Standards-compliant HTML tools",
+  version: '1.0.0',
+  internal: true
+});
+
+Package.on_use(function (api) {
+  api.use('htmljs');
+
+  api.export('HTMLTools');
+
+  api.add_files(['utils.js',
+                 'scanner.js',
+                 'charref.js',
+                 'tokenize.js',
+                 'parse.js']);
+});
+
+Package.on_test(function (api) {
+  api.use('tinytest');
+  api.use('html-tools');
+  api.use('underscore');
+  api.use('spacebars-compiler'); // for `HTML.toJS`
+  api.add_files(['charref_tests.js',
+                 'tokenize_tests.js',
+                 'parse_tests.js']);
+});
diff --git a/packages/html-tools/parse.js b/packages/html-tools/parse.js
new file mode 100644
index 0000000000..1c25bf4225
--- /dev/null
+++ b/packages/html-tools/parse.js
@@ -0,0 +1,350 @@
+
+HTMLTools.Special = function (value) {
+  if (! (this instanceof HTMLTools.Special))
+    // called without `new`
+    return new HTMLTools.Special(value);
+
+  this.value = value;
+};
+HTMLTools.Special.prototype.toJS = function (options) {
+  // XXX this is weird because toJS is defined in spacebars-compiler.
+  // Think about where HTMLTools.Special and toJS should go.
+  return HTML.Tag.prototype.toJS.call({tagName: 'HTMLTools.Special',
+                                       attrs: this.value,
+                                       children: []},
+                                      options);
+};
+
+// Parse a "fragment" of HTML, up to the end of the input or a particular
+// template tag (using the "shouldStop" option).
+HTMLTools.parseFragment = function (input, options) {
+  var scanner;
+  if (typeof input === 'string')
+    scanner = new Scanner(input);
+  else
+    // input can be a scanner.  We'd better not have a different
+    // value for the "getSpecialTag" option as when the scanner
+    // was created, because we don't do anything special to reset
+    // the value (which is attached to the scanner).
+    scanner = input;
+
+  // ```
+  // { getSpecialTag: function (scanner, templateTagPosition) {
+  //     if (templateTagPosition === HTMLTools.TEMPLATE_TAG_POSITION.ELEMENT) {
+  //       ...
+  // ```
+  if (options && options.getSpecialTag)
+    scanner.getSpecialTag = options.getSpecialTag;
+
+  // function (scanner) -> boolean
+  var shouldStop = options && options.shouldStop;
+
+  var result;
+  if (options && options.textMode) {
+    if (options.textMode === HTML.TEXTMODE.STRING) {
+      result = getRawText(scanner, null, shouldStop);
+    } else if (options.textMode === HTML.TEXTMODE.RCDATA) {
+      result = getRCData(scanner, null, shouldStop);
+    } else {
+      throw new Error("Unsupported textMode: " + options.textMode);
+    }
+  } else {
+    result = getContent(scanner, shouldStop);
+  }
+  if (! scanner.isEOF()) {
+    // If we aren't at the end of the input, we either stopped at an unmatched
+    // HTML end tag or at a template tag (like `{{else}}` or `{{/if}}`).
+    // Detect the former case (stopped at an HTML end tag) and throw a good
+    // error.
+
+    var posBefore = scanner.pos;
+
+    try {
+      var endTag = getHTMLToken(scanner);
+    } catch (e) {
+      // ignore errors from getSpecialTag
+    }
+
+    // XXX we make some assumptions about shouldStop here, like that it
+    // won't tell us to stop at an HTML end tag.  Should refactor
+    // `shouldStop` into something more suitable.
+    if (endTag && endTag.t === 'Tag' && endTag.isEnd) {
+      var closeTag = endTag.n;
+      var isVoidElement = HTML.isVoidElement(closeTag);
+      scanner.fatal("Unexpected HTML close tag" +
+                    (isVoidElement ?
+                     '.  <' + endTag.n + '> should have no close tag.' : ''));
+    }
+
+    scanner.pos = posBefore; // rewind, we'll continue parsing as usual
+
+    // If no "shouldStop" option was provided, we should have consumed the whole
+    // input.
+    if (! shouldStop)
+      scanner.fatal("Expected EOF");
+  }
+
+  return result;
+};
+
+// Take a numeric Unicode code point, which may be larger than 16 bits,
+// and encode it as a JavaScript UTF-16 string.
+//
+// Adapted from
+// http://stackoverflow.com/questions/7126384/expressing-utf-16-unicode-characters-in-javascript/7126661.
+codePointToString = HTMLTools.codePointToString = function(cp) {
+  if (cp >= 0 && cp <= 0xD7FF || cp >= 0xE000 && cp <= 0xFFFF) {
+    return String.fromCharCode(cp);
+  } else if (cp >= 0x10000 && cp <= 0x10FFFF) {
+
+    // we substract 0x10000 from cp to get a 20-bit number
+    // in the range 0..0xFFFF
+    cp -= 0x10000;
+
+    // we add 0xD800 to the number formed by the first 10 bits
+    // to give the first byte
+    var first = ((0xffc00 & cp) >> 10) + 0xD800;
+
+    // we add 0xDC00 to the number formed by the low 10 bits
+    // to give the second byte
+    var second = (0x3ff & cp) + 0xDC00;
+
+    return String.fromCharCode(first) + String.fromCharCode(second);
+  } else {
+    return '';
+  }
+};
+
+getContent = HTMLTools.Parse.getContent = function (scanner, shouldStopFunc) {
+  var items = [];
+
+  while (! scanner.isEOF()) {
+    if (shouldStopFunc && shouldStopFunc(scanner))
+      break;
+
+    var posBefore = scanner.pos;
+    var token = getHTMLToken(scanner);
+    if (! token)
+      // tokenizer reached EOF on its own, e.g. while scanning
+      // template comments like `{{! foo}}`.
+      continue;
+
+    if (token.t === 'Doctype') {
+      scanner.fatal("Unexpected Doctype");
+    } else if (token.t === 'Chars') {
+      pushOrAppendString(items, token.v);
+    } else if (token.t === 'CharRef') {
+      items.push(convertCharRef(token));
+    } else if (token.t === 'Comment') {
+      items.push(HTML.Comment(token.v));
+    } else if (token.t === 'Special') {
+      // token.v is an object `{ ... }`
+      items.push(HTMLTools.Special(token.v));
+    } else if (token.t === 'Tag') {
+      if (token.isEnd) {
+        // Stop when we encounter an end tag at the top level.
+        // Rewind; we'll re-parse the end tag later.
+        scanner.pos = posBefore;
+        break;
+      }
+
+      var tagName = token.n;
+      // is this an element with no close tag (a BR, HR, IMG, etc.) based
+      // on its name?
+      var isVoid = HTML.isVoidElement(tagName);
+      if (token.isSelfClosing) {
+        if (! (isVoid || HTML.isKnownSVGElement(tagName) || tagName.indexOf(':') >= 0))
+          scanner.fatal('Only certain elements like BR, HR, IMG, etc. (and foreign elements like SVG) are allowed to self-close');
+      }
+
+      // may be null
+      var attrs = parseAttrs(token.attrs);
+
+      var tagFunc = HTML.getTag(tagName);
+      if (isVoid || token.isSelfClosing) {
+        items.push(attrs ? tagFunc(attrs) : tagFunc());
+      } else {
+        // parse HTML tag contents.
+
+        // HTML treats a final `/` in a tag as part of an attribute, as in `<a href=/foo/>`, but the template author who writes `<circle r={{r}}/>`, say, may not be thinking about that, so generate a good error message in the "looks like self-close" case.
+        var looksLikeSelfClose = (scanner.input.substr(scanner.pos - 2, 2) === '/>');
+
+        var content;
+        if (token.n === 'textarea') {
+          if (scanner.peek() === '\n')
+            scanner.pos++;
+          content = getRCData(scanner, token.n, shouldStopFunc);
+        } else {
+          content = getContent(scanner, shouldStopFunc);
+        }
+
+        var endTag = getHTMLToken(scanner);
+
+        if (! (endTag && endTag.t === 'Tag' && endTag.isEnd && endTag.n === tagName))
+          scanner.fatal('Expected "' + tagName + '" end tag' + (looksLikeSelfClose ? ' -- if the "<' + token.n + ' />" tag was supposed to self-close, try adding a space before the "/"' : ''));
+
+        // XXX support implied end tags in cases allowed by the spec
+
+        // make `content` into an array suitable for applying tag constructor
+        // as in `FOO.apply(null, content)`.
+        if (content == null)
+          content = [];
+        else if (! (content instanceof Array))
+          content = [content];
+
+        items.push(HTML.getTag(tagName).apply(
+          null, (attrs ? [attrs] : []).concat(content)));
+      }
+    } else {
+      scanner.fatal("Unknown token type: " + token.t);
+    }
+  }
+
+  if (items.length === 0)
+    return null;
+  else if (items.length === 1)
+    return items[0];
+  else
+    return items;
+};
+
+var pushOrAppendString = function (items, string) {
+  if (items.length &&
+      typeof items[items.length - 1] === 'string')
+    items[items.length - 1] += string;
+  else
+    items.push(string);
+};
+
+// get RCDATA to go in the lowercase (or camel case) tagName (e.g. "textarea")
+getRCData = HTMLTools.Parse.getRCData = function (scanner, tagName, shouldStopFunc) {
+  var items = [];
+
+  while (! scanner.isEOF()) {
+    // break at appropriate end tag
+    if (tagName && isLookingAtEndTag(scanner, tagName))
+      break;
+
+    if (shouldStopFunc && shouldStopFunc(scanner))
+      break;
+
+    var token = getHTMLToken(scanner, 'rcdata');
+    if (! token)
+      // tokenizer reached EOF on its own, e.g. while scanning
+      // template comments like `{{! foo}}`.
+      continue;
+
+    if (token.t === 'Chars') {
+      pushOrAppendString(items, token.v);
+    } else if (token.t === 'CharRef') {
+      items.push(convertCharRef(token));
+    } else if (token.t === 'Special') {
+      // token.v is an object `{ ... }`
+      items.push(HTMLTools.Special(token.v));
+    } else {
+      // (can't happen)
+      scanner.fatal("Unknown or unexpected token type: " + token.t);
+    }
+  }
+
+  if (items.length === 0)
+    return null;
+  else if (items.length === 1)
+    return items[0];
+  else
+    return items;
+};
+
+var getRawText = function (scanner, tagName, shouldStopFunc) {
+  var items = [];
+
+  while (! scanner.isEOF()) {
+    // break at appropriate end tag
+    if (tagName && isLookingAtEndTag(scanner, tagName))
+      break;
+
+    if (shouldStopFunc && shouldStopFunc(scanner))
+      break;
+
+    var token = getHTMLToken(scanner, 'rawtext');
+    if (! token)
+      // tokenizer reached EOF on its own, e.g. while scanning
+      // template comments like `{{! foo}}`.
+      continue;
+
+    if (token.t === 'Chars') {
+      pushOrAppendString(items, token.v);
+    } else if (token.t === 'Special') {
+      // token.v is an object `{ ... }`
+      items.push(HTMLTools.Special(token.v));
+    } else {
+      // (can't happen)
+      scanner.fatal("Unknown or unexpected token type: " + token.t);
+    }
+  }
+
+  if (items.length === 0)
+    return null;
+  else if (items.length === 1)
+    return items[0];
+  else
+    return items;
+};
+
+// Input: A token like `{ t: 'CharRef', v: '&amp;', cp: [38] }`.
+//
+// Output: A tag like `HTML.CharRef({ html: '&amp;', str: '&' })`.
+var convertCharRef = function (token) {
+  var codePoints = token.cp;
+  var str = '';
+  for (var i = 0; i < codePoints.length; i++)
+    str += codePointToString(codePoints[i]);
+  return HTML.CharRef({ html: token.v, str: str });
+};
+
+// Input is always a dictionary (even if zero attributes) and each
+// value in the dictionary is an array of `Chars`, `CharRef`,
+// and maybe `Special` tokens.
+//
+// Output is null if there are zero attributes, and otherwise a
+// dictionary.  Each value in the dictionary is HTMLjs (e.g. a
+// string or an array of `Chars`, `CharRef`, and `Special`
+// nodes).
+//
+// An attribute value with no input tokens is represented as "",
+// not an empty array, in order to prop open empty attributes
+// with no template tags.
+var parseAttrs = function (attrs) {
+  var result = null;
+
+  for (var k in attrs) {
+    if (! result)
+      result = {};
+
+    var inValue = attrs[k];
+    var outParts = [];
+    for (var i = 0; i < inValue.length; i++) {
+      var token = inValue[i];
+      if (token.t === 'CharRef') {
+        outParts.push(convertCharRef(token));
+      } else if (token.t === 'Special') {
+        outParts.push(HTMLTools.Special(token.v));
+      } else if (token.t === 'Chars') {
+        pushOrAppendString(outParts, token.v);
+      }
+    }
+
+    if (k === '$specials') {
+      // the `$specials` pseudo-attribute should always get an
+      // array, even if there is only one Special.
+      result[k] = outParts;
+    } else {
+      var outValue = (inValue.length === 0 ? '' :
+                      (outParts.length === 1 ? outParts[0] : outParts));
+      var properKey = HTMLTools.properCaseAttributeName(k);
+      result[properKey] = outValue;
+    }
+  }
+
+  return result;
+};
diff --git a/packages/html-tools/parse_tests.js b/packages/html-tools/parse_tests.js
new file mode 100644
index 0000000000..cd24e134d3
--- /dev/null
+++ b/packages/html-tools/parse_tests.js
@@ -0,0 +1,360 @@
+var Scanner = HTMLTools.Scanner;
+var getContent = HTMLTools.Parse.getContent;
+
+var CharRef = HTML.CharRef;
+var Comment = HTML.Comment;
+var Special = HTMLTools.Special;
+
+var BR = HTML.BR;
+var HR = HTML.HR;
+var INPUT = HTML.INPUT;
+var A = HTML.A;
+var DIV = HTML.DIV;
+var P = HTML.P;
+var TEXTAREA = HTML.TEXTAREA;
+
+Tinytest.add("html-tools - parser getContent", function (test) {
+
+  var succeed = function (input, expected) {
+    var endPos = input.indexOf('^^^');
+    if (endPos < 0)
+      endPos = input.length;
+
+    var scanner = new Scanner(input.replace('^^^', ''));
+    var result = getContent(scanner);
+    test.equal(scanner.pos, endPos);
+    test.equal(HTML.toJS(result), HTML.toJS(expected));
+  };
+
+  var fatal = function (input, messageContains) {
+    var scanner = new Scanner(input);
+    var error;
+    try {
+      getContent(scanner);
+    } catch (e) {
+      error = e;
+    }
+    test.isTrue(error);
+    if (messageContains)
+      test.isTrue(messageContains && error.message.indexOf(messageContains) >= 0, error.message);
+  };
+
+
+  succeed('', null);
+  succeed('abc', 'abc');
+  succeed('abc^^^</x>', 'abc');
+  succeed('a&lt;b', ['a', CharRef({html: '&lt;', str: '<'}), 'b']);
+  succeed('<!-- x -->', Comment(' x '));
+  succeed('&acE;', CharRef({html: '&acE;', str: '\u223e\u0333'}));
+  succeed('&zopf;', CharRef({html: '&zopf;', str: '\ud835\udd6b'}));
+  succeed('&&>&g&gt;;', ['&&>&g', CharRef({html: '&gt;', str: '>'}), ';']);
+
+  // Can't have an unescaped `&` if followed by certain names like `gt`
+  fatal('&gt&');
+  // tests for other failure cases
+  fatal('<');
+
+  succeed('<br>', BR());
+  succeed('<br/>', BR());
+  fatal('<div/>', 'self-close');
+
+  succeed('<hr id=foo>', HR({id:'foo'}));
+  succeed('<hr id=&lt;foo&gt;>', HR({id:[CharRef({html:'&lt;', str:'<'}),
+                                         'foo',
+                                         CharRef({html:'&gt;', str:'>'})]}));
+  succeed('<input selected>', INPUT({selected: ''}));
+  succeed('<input selected/>', INPUT({selected: ''}));
+  succeed('<input selected />', INPUT({selected: ''}));
+  var FOO = HTML.getTag('foo');
+  succeed('<foo bar></foo>', FOO({bar: ''}));
+  succeed('<foo bar baz ></foo>', FOO({bar: '', baz: ''}));
+  succeed('<foo bar=x baz qux=y blah ></foo>',
+          FOO({bar: 'x', baz: '', qux: 'y', blah: ''}));
+  succeed('<foo bar="x" baz qux="y" blah ></foo>',
+          FOO({bar: 'x', baz: '', qux: 'y', blah: ''}));
+  fatal('<input bar"baz">');
+  fatal('<input x="y"z >');
+  fatal('<input x=\'y\'z >');
+  succeed('<br x=&&&>', BR({x: '&&&'}));
+  succeed('<br><br><br>', [BR(), BR(), BR()]);
+  succeed('aaa<br>\nbbb<br>\nccc<br>', ['aaa', BR(), '\nbbb', BR(), '\nccc', BR()]);
+
+  succeed('<a></a>', A());
+  fatal('<');
+  fatal('<a');
+  fatal('<a>');
+  fatal('<a><');
+  fatal('<a></');
+  fatal('<a></a');
+
+  succeed('<a href="http://www.apple.com/">Apple</a>',
+          A({href: "http://www.apple.com/"}, 'Apple'));
+
+  (function () {
+    var A = HTML.getTag('a');
+    var B = HTML.getTag('b');
+    var C = HTML.getTag('c');
+    var D = HTML.getTag('d');
+
+    succeed('<a>1<b>2<c>3<d>4</d>5</c>6</b>7</a>8',
+            [A('1', B('2', C('3', D('4'), '5'), '6'), '7'), '8']);
+  })();
+
+  fatal('<b>hello <i>there</b> world</i>');
+
+  // XXX support implied end tags in cases allowed by the spec
+  fatal('<p>');
+
+  fatal('<a>Foo</a/>');
+  fatal('<a>Foo</a b=c>');
+
+  succeed('<textarea>asdf</textarea>', TEXTAREA("asdf"));
+  succeed('<textarea x=y>asdf</textarea>', TEXTAREA({x: "y"}, "asdf"));
+  succeed('<textarea><p></textarea>', TEXTAREA("<p>"));
+  succeed('<textarea>a&amp;b</textarea>',
+          TEXTAREA("a", CharRef({html: '&amp;', str: '&'}), "b"));
+  succeed('<textarea></textarea</textarea>', TEXTAREA("</textarea"));
+  // absorb up to one initial newline, as per HTML parsing spec
+  succeed('<textarea>\n</textarea>', TEXTAREA());
+  succeed('<textarea>\nasdf</textarea>', TEXTAREA("asdf"));
+  succeed('<textarea>\n\nasdf</textarea>', TEXTAREA("\nasdf"));
+  succeed('<textarea>\n\n</textarea>', TEXTAREA("\n"));
+  succeed('<textarea>\nasdf\n</textarea>', TEXTAREA("asdf\n"));
+  succeed('<textarea><!-- --></textarea>', TEXTAREA("<!-- -->"));
+  succeed('<tExTaReA>asdf</TEXTarea>', TEXTAREA("asdf"));
+  fatal('<textarea>asdf');
+  fatal('<textarea>asdf</textarea');
+  fatal('<textarea>&davidgreenspan;</textarea>');
+  succeed('<textarea>&</textarea>', TEXTAREA("&"));
+  succeed('<textarea></textarea  \n<</textarea  \n>asdf',
+          [TEXTAREA("</textarea  \n<"), "asdf"]);
+
+  // CR/LF behavior
+  succeed('<br\r\n x>', BR({x:''}));
+  succeed('<br\r x>', BR({x:''}));
+  succeed('<br x="y"\r\n>', BR({x:'y'}));
+  succeed('<br x="y"\r>', BR({x:'y'}));
+  succeed('<br x=\r\n"y">', BR({x:'y'}));
+  succeed('<br x=\r"y">', BR({x:'y'}));
+  succeed('<br x\r=\r"y">', BR({x:'y'}));
+  succeed('<!--\r\n-->', Comment('\n'));
+  succeed('<!--\r-->', Comment('\n'));
+  succeed('<textarea>a\r\nb\r\nc</textarea>', TEXTAREA('a\nb\nc'));
+  succeed('<textarea>a\rb\rc</textarea>', TEXTAREA('a\nb\nc'));
+  succeed('<br x="\r\n\r\n">', BR({x:'\n\n'}));
+  succeed('<br x="\r\r">', BR({x:'\n\n'}));
+  succeed('<br x=y\r>', BR({x:'y'}));
+  fatal('<br x=\r>');
+});
+
+Tinytest.add("html-tools - parseFragment", function (test) {
+  test.equal(HTML.toJS(HTMLTools.parseFragment("<div><p id=foo>Hello</p></div>")),
+             HTML.toJS(DIV(P({id:'foo'}, 'Hello'))));
+
+  _.each(['asdf</br>', '{{!foo}}</br>', '{{!foo}} </br>',
+          'asdf</a>', '{{!foo}}</a>', '{{!foo}} </a>'], function (badFrag) {
+            test.throws(function() {
+              HTMLTools.parseFragment(badFrag);
+            }, /Unexpected HTML close tag/);
+          });
+
+  (function () {
+    var p = HTMLTools.parseFragment('<p></p>');
+    test.equal(p.tagName, 'p');
+    test.equal(p.attrs, null);
+    test.isTrue(p instanceof HTML.Tag);
+    test.equal(p.children.length, 0);
+  })();
+
+  (function () {
+    var p = HTMLTools.parseFragment('<p>x</p>');
+    test.equal(p.tagName, 'p');
+    test.equal(p.attrs, null);
+    test.isTrue(p instanceof HTML.Tag);
+    test.equal(p.children.length, 1);
+    test.equal(p.children[0], 'x');
+  })();
+
+  (function () {
+    var p = HTMLTools.parseFragment('<p>x&#65;</p>');
+    test.equal(p.tagName, 'p');
+    test.equal(p.attrs, null);
+    test.isTrue(p instanceof HTML.Tag);
+    test.equal(p.children.length, 2);
+    test.equal(p.children[0], 'x');
+
+    test.isTrue(p.children[1] instanceof HTML.CharRef);
+    test.equal(p.children[1].html, '&#65;');
+    test.equal(p.children[1].str, 'A');
+  })();
+
+  (function () {
+    var pp = HTMLTools.parseFragment('<p>x</p><p>y</p>');
+    test.isTrue(pp instanceof Array);
+    test.equal(pp.length, 2);
+
+    test.equal(pp[0].tagName, 'p');
+    test.equal(pp[0].attrs, null);
+    test.isTrue(pp[0] instanceof HTML.Tag);
+    test.equal(pp[0].children.length, 1);
+    test.equal(pp[0].children[0], 'x');
+
+    test.equal(pp[1].tagName, 'p');
+    test.equal(pp[1].attrs, null);
+    test.isTrue(pp[1] instanceof HTML.Tag);
+    test.equal(pp[1].children.length, 1);
+    test.equal(pp[1].children[0], 'y');
+  })();
+
+  var scanner = new Scanner('asdf');
+  scanner.pos = 1;
+  test.equal(HTMLTools.parseFragment(scanner), 'sdf');
+
+  test.throws(function () {
+    var scanner = new Scanner('asdf</p>');
+    scanner.pos = 1;
+    HTMLTools.parseFragment(scanner);
+  });
+});
+
+Tinytest.add("html-tools - getSpecialTag", function (test) {
+
+  // match a simple tag consisting of `{{`, an optional `!`, one
+  // or more ASCII letters, spaces or html tags, and a closing `}}`.
+  var mustache = /^\{\{(!?[a-zA-Z 0-9</>]+)\}\}/;
+
+  // This implementation of `getSpecialTag` looks for "{{" and if it
+  // finds it, it will match the regex above or fail fatally trying.
+  // The object it returns is opaque to the tokenizer/parser and can
+  // be anything we want.
+  var getSpecialTag = function (scanner, position) {
+    if (! (scanner.peek() === '{' && // one-char peek is just an optimization
+           scanner.rest().slice(0, 2) === '{{'))
+      return null;
+
+    var match = mustache.exec(scanner.rest());
+    if (! match)
+      scanner.fatal("Bad mustache");
+
+    scanner.pos += match[0].length;
+
+    if (match[1].charAt(0) === '!')
+      return null; // `{{!foo}}` is like a comment
+
+    return { stuff: match[1] };
+  };
+
+
+
+  var succeed = function (input, expected) {
+    var endPos = input.indexOf('^^^');
+    if (endPos < 0)
+      endPos = input.length;
+
+    var scanner = new Scanner(input.replace('^^^', ''));
+    scanner.getSpecialTag = getSpecialTag;
+    var result;
+    try {
+      result = getContent(scanner);
+    } catch (e) {
+      result = String(e);
+    }
+    test.equal(scanner.pos, endPos);
+    test.equal(HTML.toJS(result), HTML.toJS(expected));
+  };
+
+  var fatal = function (input, messageContains) {
+    var scanner = new Scanner(input);
+    scanner.getSpecialTag = getSpecialTag;
+    var error;
+    try {
+      getContent(scanner);
+    } catch (e) {
+      error = e;
+    }
+    test.isTrue(error);
+    if (messageContains)
+      test.isTrue(messageContains && error.message.indexOf(messageContains) >= 0, error.message);
+  };
+
+
+  succeed('{{foo}}', Special({stuff: 'foo'}));
+
+  succeed('<a href=http://www.apple.com/>{{foo}}</a>',
+          A({href: "http://www.apple.com/"}, Special({stuff: 'foo'})));
+
+  // tags not parsed in comments
+  succeed('<!--{{foo}}-->', Comment("{{foo}}"));
+  succeed('<!--{{foo-->', Comment("{{foo"));
+
+  succeed('&am{{foo}}p;', ['&am', Special({stuff: 'foo'}), 'p;']);
+
+  // can't start a mustache and not finish it
+  fatal('{{foo');
+  fatal('<a>{{</a>');
+
+  // no mustache allowed in tag name
+  fatal('<{{a}}>');
+  fatal('<{{a}}b>');
+  fatal('<a{{b}}>');
+
+  // single curly brace is no biggie
+  succeed('a{b', 'a{b');
+  succeed('<br x={ />', BR({x:'{'}));
+  succeed('<br x={foo} />', BR({x:'{foo}'}));
+
+  succeed('<br {{x}}>', BR({$specials: [Special({stuff: 'x'})]}));
+  succeed('<br {{x}} {{y}}>', BR({$specials: [Special({stuff: 'x'}),
+                                              Special({stuff: 'y'})]}));
+  succeed('<br {{x}} y>', BR({$specials: [Special({stuff: 'x'})], y:''}));
+  fatal('<br {{x}}y>');
+  fatal('<br {{x}}=y>');
+  succeed('<br x={{y}} z>', BR({x: Special({stuff: 'y'}), z: ''}));
+  succeed('<br x=y{{z}}w>', BR({x: ['y', Special({stuff: 'z'}), 'w']}));
+  succeed('<br x="y{{z}}w">', BR({x: ['y', Special({stuff: 'z'}), 'w']}));
+  succeed('<br x="y {{z}}{{w}} v">', BR({x: ['y ', Special({stuff: 'z'}),
+                                             Special({stuff: 'w'}), ' v']}));
+  // Slash is parsed as part of unquoted attribute!  This is consistent with
+  // the HTML tokenization spec.  It seems odd for some inputs but is probably
+  // for cases like `<a href=http://foo.com/>` or `<a href=/foo/>`.
+  succeed('<br x={{y}}/>', BR({x: [Special({stuff: 'y'}), '/']}));
+  succeed('<br x={{z}}{{w}}>', BR({x: [Special({stuff: 'z'}),
+                                       Special({stuff: 'w'})]}));
+  fatal('<br x="y"{{z}}>');
+
+  succeed('<br x=&amp;>', BR({x:CharRef({html: '&amp;', str: '&'})}));
+
+
+  // check tokenization of stache tags with spaces
+  succeed('<br {{x 1}}>', BR({$specials: [Special({stuff: 'x 1'})]}));
+  succeed('<br {{x 1}} {{y 2}}>', BR({$specials: [Special({stuff: 'x 1'}),
+                                                  Special({stuff: 'y 2'})]}));
+  succeed('<br {{x 1}} y>', BR({$specials: [Special({stuff: 'x 1'})], y:''}));
+  fatal('<br {{x 1}}y>');
+  fatal('<br {{x 1}}=y>');
+  succeed('<br x={{y 2}} z>', BR({x: Special({stuff: 'y 2'}), z: ''}));
+  succeed('<br x=y{{z 3}}w>', BR({x: ['y', Special({stuff: 'z 3'}), 'w']}));
+  succeed('<br x="y{{z 3}}w">', BR({x: ['y', Special({stuff: 'z 3'}), 'w']}));
+  succeed('<br x="y {{z 3}}{{w 4}} v">', BR({x: ['y ', Special({stuff: 'z 3'}),
+                                                 Special({stuff: 'w 4'}), ' v']}));
+  succeed('<br x={{y 2}}/>', BR({x: [Special({stuff: 'y 2'}), '/']}));
+  succeed('<br x={{z 3}}{{w 4}}>', BR({x: [Special({stuff: 'z 3'}),
+                                           Special({stuff: 'w 4'})]}));
+
+  succeed('<p></p>', P());
+
+  succeed('x{{foo}}{{bar}}y', ['x', Special({stuff: 'foo'}),
+                               Special({stuff: 'bar'}), 'y']);
+  succeed('x{{!foo}}{{!bar}}y', 'xy');
+  succeed('x{{!foo}}{{bar}}y', ['x', Special({stuff: 'bar'}), 'y']);
+  succeed('x{{foo}}{{!bar}}y', ['x', Special({stuff: 'foo'}), 'y']);
+  succeed('<div>{{!foo}}{{!bar}}</div>', DIV());
+  succeed('<div>{{!foo}}<br />{{!bar}}</div>', DIV(BR()));
+  succeed('<div> {{!foo}} {{!bar}} </div>', DIV("   "));
+  succeed('<div> {{!foo}} <br /> {{!bar}}</div>', DIV("  ", BR(), " "));
+  succeed('{{! <div></div> }}', null);
+  succeed('{{!<div></div>}}', null);
+
+  succeed('', null);
+  succeed('{{!foo}}', null);
+});
diff --git a/packages/html-tools/scanner.js b/packages/html-tools/scanner.js
new file mode 100644
index 0000000000..d110a8a814
--- /dev/null
+++ b/packages/html-tools/scanner.js
@@ -0,0 +1,82 @@
+// This is a Scanner class suitable for any parser/lexer/tokenizer.
+//
+// A Scanner has an immutable source document (string) `input` and a current
+// position `pos`, an index into the string, which can be set at will.
+//
+// * `new Scanner(input)` - constructs a Scanner with source string `input`
+// * `scanner.rest()` - returns the rest of the input after `pos`
+// * `scanner.peek()` - returns the character at `pos`
+// * `scanner.isEOF()` - true if `pos` is at or beyond the end of `input`
+// * `scanner.fatal(msg)` - throw an error indicating a problem at `pos`
+
+Scanner = HTMLTools.Scanner = function (input) {
+  this.input = input; // public, read-only
+  this.pos = 0; // public, read-write
+};
+
+Scanner.prototype.rest = function () {
+  // Slicing a string is O(1) in modern JavaScript VMs (including old IE).
+  return this.input.slice(this.pos);
+};
+
+Scanner.prototype.isEOF = function () {
+  return this.pos >= this.input.length;
+};
+
+Scanner.prototype.fatal = function (msg) {
+  // despite this default, you should always provide a message!
+  msg = (msg || "Parse error");
+
+  var CONTEXT_AMOUNT = 20;
+
+  var input = this.input;
+  var pos = this.pos;
+  var pastInput = input.substring(pos - CONTEXT_AMOUNT - 1, pos);
+  if (pastInput.length > CONTEXT_AMOUNT)
+    pastInput = '...' + pastInput.substring(-CONTEXT_AMOUNT);
+
+  var upcomingInput = input.substring(pos, pos + CONTEXT_AMOUNT + 1);
+  if (upcomingInput.length > CONTEXT_AMOUNT)
+    upcomingInput = upcomingInput.substring(0, CONTEXT_AMOUNT) + '...';
+
+  var positionDisplay = ((pastInput + upcomingInput).replace(/\n/g, ' ') + '\n' +
+                         (new Array(pastInput.length + 1).join(' ')) + "^");
+
+  var e = new Error(msg + "\n" + positionDisplay);
+
+  e.offset = pos;
+  var allPastInput = input.substring(0, pos);
+  e.line = (1 + (allPastInput.match(/\n/g) || []).length);
+  e.col = (1 + pos - allPastInput.lastIndexOf('\n'));
+  e.scanner = this;
+
+  throw e;
+};
+
+// Peek at the next character.
+//
+// If `isEOF`, returns an empty string.
+Scanner.prototype.peek = function () {
+  return this.input.charAt(this.pos);
+};
+
+// Constructs a `getFoo` function where `foo` is specified with a regex.
+// The regex should start with `^`.  The constructed function will return
+// match group 1, if it exists and matches a non-empty string, or else
+// the entire matched string (or null if there is no match).
+//
+// A `getFoo` function tries to match and consume a foo.  If it succeeds,
+// the current position of the scanner is advanced.  If it fails, the
+// current position is not advanced and a falsy value (typically null)
+// is returned.
+makeRegexMatcher = function (regex) {
+  return function (scanner) {
+    var match = regex.exec(scanner.rest());
+
+    if (! match)
+      return null;
+
+    scanner.pos += match[0].length;
+    return match[1] || match[0];
+  };
+};
diff --git a/packages/html-tools/tokenize.js b/packages/html-tools/tokenize.js
new file mode 100644
index 0000000000..85aaf7be3b
--- /dev/null
+++ b/packages/html-tools/tokenize.js
@@ -0,0 +1,532 @@
+// Token types:
+//
+// { t: 'Doctype',
+//   v: String (entire Doctype declaration from the source),
+//   name: String,
+//   systemId: String (optional),
+//   publicId: String (optional)
+// }
+//
+// { t: 'Comment',
+//   v: String (not including "<!--" and "-->")
+// }
+//
+// { t: 'Chars',
+//   v: String (pure text like you might pass to document.createTextNode,
+//              no character references)
+// }
+//
+// { t: 'Tag',
+//   isEnd: Boolean (optional),
+//   isSelfClosing: Boolean (optional),
+//   n: String (tag name, in lowercase or camel case),
+//   attrs: { String: [zero or more 'Chars' or 'CharRef' objects] }
+//     (only for start tags; required)
+// }
+//
+// { t: 'CharRef',
+//   v: String (entire character reference from the source, e.g. "&amp;"),
+//   cp: [Integer] (array of Unicode code point numbers it expands to)
+// }
+//
+// We keep around both the original form of the character reference and its
+// expansion so that subsequent processing steps have the option to
+// re-emit it (if they are generating HTML) or interpret it.  Named and
+// numerical code points may be more than 16 bits, in which case they
+// need to passed through codePointToString to make a JavaScript string.
+// Most named entities and all numeric character references are one codepoint
+// (e.g. "&amp;" is [38]), but a few are two codepoints.
+//
+// { t: 'Special',
+//   v: { ... anything ... }
+// }
+
+// The HTML tokenization spec says to preprocess the input stream to replace
+// CR(LF)? with LF.  However, preprocessing `scanner` would complicate things
+// by making indexes not match the input (e.g. for error messages), so we just
+// keep in mind as we go along that an LF might be represented by CRLF or CR.
+// In most cases, it doesn't actually matter what combination of whitespace
+// characters are present (e.g. inside tags).
+var HTML_SPACE = /^[\f\n\r\t ]/;
+
+var convertCRLF = function (str) {
+  return str.replace(/\r\n?/g, '\n');
+};
+
+getComment = HTMLTools.Parse.getComment = function (scanner) {
+  if (scanner.rest().slice(0, 4) !== '<!--')
+    return null;
+  scanner.pos += 4;
+
+  // Valid comments are easy to parse; they end at the first `--`!
+  // Our main job is throwing errors.
+
+  var rest = scanner.rest();
+  if (rest.charAt(0) === '>' || rest.slice(0, 2) === '->')
+    scanner.fatal("HTML comment can't start with > or ->");
+
+  var closePos = rest.indexOf('-->');
+  if (closePos < 0)
+    scanner.fatal("Unclosed HTML comment");
+
+  var commentContents = rest.slice(0, closePos);
+  if (commentContents.slice(-1) === '-')
+    scanner.fatal("HTML comment must end at first `--`");
+  if (commentContents.indexOf("--") >= 0)
+    scanner.fatal("HTML comment cannot contain `--` anywhere");
+  if (commentContents.indexOf('\u0000') >= 0)
+    scanner.fatal("HTML comment cannot contain NULL");
+
+  scanner.pos += closePos + 3;
+
+  return { t: 'Comment',
+           v: convertCRLF(commentContents) };
+};
+
+var skipSpaces = function (scanner) {
+  while (HTML_SPACE.test(scanner.peek()))
+    scanner.pos++;
+};
+
+var requireSpaces = function (scanner) {
+  if (! HTML_SPACE.test(scanner.peek()))
+    scanner.fatal("Expected space");
+  skipSpaces(scanner);
+};
+
+var getDoctypeQuotedString = function (scanner) {
+  var quote = scanner.peek();
+  if (! (quote === '"' || quote === "'"))
+    scanner.fatal("Expected single or double quote in DOCTYPE");
+  scanner.pos++;
+
+  if (scanner.peek() === quote)
+    // prevent a falsy return value (empty string)
+    scanner.fatal("Malformed DOCTYPE");
+
+  var str = '';
+  var ch;
+  while ((ch = scanner.peek()), ch !== quote) {
+    if ((! ch) || (ch === '\u0000') || (ch === '>'))
+      scanner.fatal("Malformed DOCTYPE");
+    str += ch;
+    scanner.pos++;
+  }
+
+  scanner.pos++;
+
+  return str;
+};
+
+// See http://www.whatwg.org/specs/web-apps/current-work/multipage/syntax.html#the-doctype.
+//
+// If `getDocType` sees "<!DOCTYPE" (case-insensitive), it will match or fail fatally.
+getDoctype = HTMLTools.Parse.getDoctype = function (scanner) {
+  if (HTMLTools.asciiLowerCase(scanner.rest().slice(0, 9)) !== '<!doctype')
+    return null;
+  var start = scanner.pos;
+  scanner.pos += 9;
+
+  requireSpaces(scanner);
+
+  var ch = scanner.peek();
+  if ((! ch) || (ch === '>') || (ch === '\u0000'))
+    scanner.fatal('Malformed DOCTYPE');
+  var name = ch;
+  scanner.pos++;
+
+  while ((ch = scanner.peek()), ! (HTML_SPACE.test(ch) || ch === '>')) {
+    if ((! ch) || (ch === '\u0000'))
+      scanner.fatal('Malformed DOCTYPE');
+    name += ch;
+    scanner.pos++;
+  }
+  name = HTMLTools.asciiLowerCase(name);
+
+  // Now we're looking at a space or a `>`.
+  skipSpaces(scanner);
+
+  var systemId = null;
+  var publicId = null;
+
+  if (scanner.peek() !== '>') {
+    // Now we're essentially in the "After DOCTYPE name state" of the tokenizer,
+    // but we're not looking at space or `>`.
+
+    // this should be "public" or "system".
+    var publicOrSystem = HTMLTools.asciiLowerCase(scanner.rest().slice(0, 6));
+
+    if (publicOrSystem === 'system') {
+      scanner.pos += 6;
+      requireSpaces(scanner);
+      systemId = getDoctypeQuotedString(scanner);
+      skipSpaces(scanner);
+      if (scanner.peek() !== '>')
+        scanner.fatal("Malformed DOCTYPE");
+    } else if (publicOrSystem === 'public') {
+      scanner.pos += 6;
+      requireSpaces(scanner);
+      publicId = getDoctypeQuotedString(scanner);
+      if (scanner.peek() !== '>') {
+        requireSpaces(scanner);
+        if (scanner.peek() !== '>') {
+          systemId = getDoctypeQuotedString(scanner);
+          skipSpaces(scanner);
+          if (scanner.peek() !== '>')
+            scanner.fatal("Malformed DOCTYPE");
+        }
+      }
+    } else {
+      scanner.fatal("Expected PUBLIC or SYSTEM in DOCTYPE");
+    }
+  }
+
+  // looking at `>`
+  scanner.pos++;
+  var result = { t: 'Doctype',
+                 v: scanner.input.slice(start, scanner.pos),
+                 name: name };
+
+  if (systemId)
+    result.systemId = systemId;
+  if (publicId)
+    result.publicId = publicId;
+
+  return result;
+};
+
+// The special character `{` is only allowed as the first character
+// of a Chars, so that we have a chance to detect template tags.
+var getChars = makeRegexMatcher(/^[^&<\u0000][^&<\u0000{]*/);
+
+// Returns the next HTML token, or `null` if we reach EOF.
+//
+// Note that if we have a `getSpecialTag` function that sometimes
+// consumes characters and emits nothing (e.g. in the case of template
+// comments), we may go from not-at-EOF to at-EOF and return `null`,
+// while otherwise we always find some token to return.
+getHTMLToken = HTMLTools.Parse.getHTMLToken = function (scanner, dataMode) {
+  var result = null;
+  if (scanner.getSpecialTag) {
+    var lastPos = -1;
+    // Try to parse a "special tag" by calling out to the provided
+    // `getSpecialTag` function.  If the function returns `null` but
+    // consumes characters, it must have parsed a comment or something,
+    // so we loop and try it again.  If it ever returns `null` without
+    // consuming anything, that means it didn't see anything interesting
+    // so we look for a normal token.  If it returns a truthy value,
+    // the value must be an object.  We wrap it in a Special token.
+    while ((! result) && scanner.pos > lastPos) {
+      lastPos = scanner.pos;
+      result = scanner.getSpecialTag(
+        scanner,
+        (dataMode === 'rcdata' ? TEMPLATE_TAG_POSITION.IN_RCDATA :
+         (dataMode === 'rawtext' ? TEMPLATE_TAG_POSITION.IN_RAWTEXT :
+          TEMPLATE_TAG_POSITION.ELEMENT)));
+    }
+    if (result)
+      return { t: 'Special', v: result };
+  }
+
+  var chars = getChars(scanner);
+  if (chars)
+    return { t: 'Chars',
+             v: convertCRLF(chars) };
+
+  var ch = scanner.peek();
+  if (! ch)
+    return null; // EOF
+
+  if (ch === '\u0000')
+    scanner.fatal("Illegal NULL character");
+
+  if (ch === '&') {
+    if (dataMode !== 'rawtext') {
+      var charRef = getCharacterReference(scanner);
+      if (charRef)
+        return charRef;
+    }
+
+    scanner.pos++;
+    return { t: 'Chars',
+             v: '&' };
+  }
+
+  // If we're here, we're looking at `<`.
+
+  if (scanner.peek() === '<' && dataMode) {
+    // don't interpret tags
+    scanner.pos++;
+    return { t: 'Chars',
+             v: '<' };
+  }
+
+  // `getTag` will claim anything starting with `<` not followed by `!`.
+  // `getComment` takes `<!--` and getDoctype takes `<!doctype`.
+  result = (getTagToken(scanner) || getComment(scanner) || getDoctype(scanner));
+
+  if (result)
+    return result;
+
+  scanner.fatal("Unexpected `<!` directive.");
+};
+
+var getTagName = makeRegexMatcher(/^[a-zA-Z][^\f\n\r\t />{]*/);
+var getClangle = makeRegexMatcher(/^>/);
+var getSlash = makeRegexMatcher(/^\//);
+var getAttributeName = makeRegexMatcher(/^[^>/\u0000"'<=\f\n\r\t ][^\f\n\r\t /=>"'<\u0000]*/);
+
+// Try to parse `>` or `/>`, mutating `tag` to be self-closing in the latter
+// case (and failing fatally if `/` isn't followed by `>`).
+// Return tag if successful.
+var handleEndOfTag = function (scanner, tag) {
+  if (getClangle(scanner))
+    return tag;
+
+  if (getSlash(scanner)) {
+    if (! getClangle(scanner))
+      scanner.fatal("Expected `>` after `/`");
+    tag.isSelfClosing = true;
+    return tag;
+  }
+
+  return null;
+};
+
+var getQuotedAttributeValue = function (scanner, quote) {
+  if (scanner.peek() !== quote)
+    return null;
+  scanner.pos++;
+
+  var tokens = [];
+  var charsTokenToExtend = null;
+
+  var charRef;
+  while (true) {
+    var ch = scanner.peek();
+    var special;
+    var curPos = scanner.pos;
+    if (ch === quote) {
+      scanner.pos++;
+      return tokens;
+    } else if (! ch) {
+      scanner.fatal("Unclosed quoted attribute in tag");
+    } else if (ch === '\u0000') {
+      scanner.fatal("Unexpected NULL character in attribute value");
+    } else if (ch === '&' && (charRef = getCharacterReference(scanner, true, quote))) {
+      tokens.push(charRef);
+      charsTokenToExtend = null;
+    } else if (scanner.getSpecialTag &&
+               ((special = scanner.getSpecialTag(scanner,
+                                                 TEMPLATE_TAG_POSITION.IN_ATTRIBUTE)) ||
+                scanner.pos > curPos /* `{{! comment}}` */)) {
+      // note: this code is messy because it turns out to be annoying for getSpecialTag
+      // to return `null` when it scans a comment.  Also, this code should be de-duped
+      // with getUnquotedAttributeValue
+      if (special) {
+        tokens.push({t: 'Special', v: special});
+        charsTokenToExtend = null;
+      }
+    } else {
+      if (! charsTokenToExtend) {
+        charsTokenToExtend = { t: 'Chars', v: '' };
+        tokens.push(charsTokenToExtend);
+      }
+      charsTokenToExtend.v += (ch === '\r' ? '\n' : ch);
+      scanner.pos++;
+      if (ch === '\r' && scanner.peek() === '\n')
+        scanner.pos++;
+    }
+  }
+};
+
+var getUnquotedAttributeValue = function (scanner) {
+  var tokens = [];
+  var charsTokenToExtend = null;
+
+  var charRef;
+  while (true) {
+    var ch = scanner.peek();
+    var special;
+    var curPos = scanner.pos;
+    if (HTML_SPACE.test(ch) || ch === '>') {
+      return tokens;
+    } else if (! ch) {
+      scanner.fatal("Unclosed attribute in tag");
+    } else if ('\u0000"\'<=`'.indexOf(ch) >= 0) {
+      scanner.fatal("Unexpected character in attribute value");
+    } else if (ch === '&' && (charRef = getCharacterReference(scanner, true, '>'))) {
+      tokens.push(charRef);
+      charsTokenToExtend = null;
+    } else if (scanner.getSpecialTag &&
+               ((special = scanner.getSpecialTag(scanner,
+                                                 TEMPLATE_TAG_POSITION.IN_ATTRIBUTE)) ||
+                scanner.pos > curPos /* `{{! comment}}` */)) {
+      if (special) {
+        tokens.push({t: 'Special', v: special});
+        charsTokenToExtend = null;
+      }
+    } else {
+      if (! charsTokenToExtend) {
+        charsTokenToExtend = { t: 'Chars', v: '' };
+        tokens.push(charsTokenToExtend);
+      }
+      charsTokenToExtend.v += ch;
+      scanner.pos++;
+    }
+  }
+};
+
+getTagToken = HTMLTools.Parse.getTagToken = function (scanner) {
+  if (! (scanner.peek() === '<' && scanner.rest().charAt(1) !== '!'))
+    return null;
+  scanner.pos++;
+
+  var tag = { t: 'Tag' };
+
+  // now looking at the character after `<`, which is not a `!`
+  if (scanner.peek() === '/') {
+    tag.isEnd = true;
+    scanner.pos++;
+  }
+
+  var tagName = getTagName(scanner);
+  if (! tagName)
+    scanner.fatal("Expected tag name after `<`");
+  tag.n = HTMLTools.properCaseTagName(tagName);
+
+  if (scanner.peek() === '/' && tag.isEnd)
+    scanner.fatal("End tag can't have trailing slash");
+  if (handleEndOfTag(scanner, tag))
+    return tag;
+
+  if (scanner.isEOF())
+    scanner.fatal("Unclosed `<`");
+
+  if (! HTML_SPACE.test(scanner.peek()))
+    // e.g. `<a{{b}}>`
+    scanner.fatal("Expected space after tag name");
+
+  // we're now in "Before attribute name state" of the tokenizer
+  skipSpaces(scanner);
+
+  if (scanner.peek() === '/' && tag.isEnd)
+    scanner.fatal("End tag can't have trailing slash");
+  if (handleEndOfTag(scanner, tag))
+    return tag;
+
+  if (tag.isEnd)
+    scanner.fatal("End tag can't have attributes");
+
+  tag.attrs = {};
+
+  while (true) {
+    // Note: at the top of this loop, we've already skipped any spaces.
+
+    // This will be set to true if after parsing the attribute, we should
+    // require spaces (or else an end of tag, i.e. `>` or `/>`).
+    var spacesRequiredAfter = false;
+
+    // first, try for a special tag.
+    var curPos = scanner.pos;
+    var special = (scanner.getSpecialTag &&
+                   scanner.getSpecialTag(scanner,
+                                         TEMPLATE_TAG_POSITION.IN_START_TAG));
+    if (special || (scanner.pos > curPos)) {
+      if (special) {
+        tag.attrs.$specials = (tag.attrs.$specials || []);
+        tag.attrs.$specials.push({ t: 'Special', v: special });
+      } // else, must have scanned a `{{! comment}}`
+
+      spacesRequiredAfter = true;
+    } else {
+
+      var attributeName = getAttributeName(scanner);
+      if (! attributeName)
+        scanner.fatal("Expected attribute name in tag");
+      // Throw error on `{` in attribute name.  This provides *some* error message
+      // if someone writes `<a x{{y}}>` or `<a x{{y}}=z>`.  The HTML tokenization
+      // spec doesn't say that `{` is invalid, but the DOM API (setAttribute) won't
+      // allow it, so who cares.
+      if (attributeName.indexOf('{') >= 0)
+        scanner.fatal("Unexpected `{` in attribute name.");
+      attributeName = HTMLTools.properCaseAttributeName(attributeName);
+
+      if (tag.attrs.hasOwnProperty(attributeName))
+        scanner.fatal("Duplicate attribute in tag: " + attributeName);
+
+      tag.attrs[attributeName] = [];
+
+      skipSpaces(scanner);
+
+      if (handleEndOfTag(scanner, tag))
+        return tag;
+
+      var ch = scanner.peek();
+      if (! ch)
+        scanner.fatal("Unclosed <");
+      if ('\u0000"\'<'.indexOf(ch) >= 0)
+        scanner.fatal("Unexpected character after attribute name in tag");
+
+      if (ch === '=') {
+        scanner.pos++;
+
+        skipSpaces(scanner);
+
+        ch = scanner.peek();
+        if (! ch)
+          scanner.fatal("Unclosed <");
+        if ('\u0000><=`'.indexOf(ch) >= 0)
+          scanner.fatal("Unexpected character after = in tag");
+
+        if ((ch === '"') || (ch === "'"))
+          tag.attrs[attributeName] = getQuotedAttributeValue(scanner, ch);
+        else
+          tag.attrs[attributeName] = getUnquotedAttributeValue(scanner);
+
+        spacesRequiredAfter = true;
+      }
+    }
+    // now we are in the "post-attribute" position, whether it was a special attribute
+    // (like `{{x}}`) or a normal one (like `x` or `x=y`).
+
+    if (handleEndOfTag(scanner, tag))
+      return tag;
+
+    if (scanner.isEOF())
+      scanner.fatal("Unclosed `<`");
+
+    if (spacesRequiredAfter)
+      requireSpaces(scanner);
+    else
+      skipSpaces(scanner);
+
+    if (handleEndOfTag(scanner, tag))
+      return tag;
+  }
+};
+
+TEMPLATE_TAG_POSITION = HTMLTools.TEMPLATE_TAG_POSITION = {
+  ELEMENT: 1,
+  IN_START_TAG: 2,
+  IN_ATTRIBUTE: 3,
+  IN_RCDATA: 4,
+  IN_RAWTEXT: 5
+};
+
+// tagName must be proper case
+isLookingAtEndTag = function (scanner, tagName) {
+  var rest = scanner.rest();
+  var pos = 0; // into rest
+  var firstPart = /^<\/([a-zA-Z]+)/.exec(rest);
+  if (firstPart &&
+      HTMLTools.properCaseTagName(firstPart[1]) === tagName) {
+    // we've seen `</foo`, now see if the end tag continues
+    pos += firstPart[0].length;
+    while (pos < rest.length && HTML_SPACE.test(rest.charAt(pos)))
+      pos++;
+    if (pos < rest.length && rest.charAt(pos) === '>')
+      return true;
+  }
+  return false;
+};
diff --git a/packages/html-tools/tokenize_tests.js b/packages/html-tools/tokenize_tests.js
new file mode 100644
index 0000000000..752eb2ee5d
--- /dev/null
+++ b/packages/html-tools/tokenize_tests.js
@@ -0,0 +1,344 @@
+var Scanner = HTMLTools.Scanner;
+var getComment = HTMLTools.Parse.getComment;
+var getDoctype = HTMLTools.Parse.getDoctype;
+var getHTMLToken = HTMLTools.Parse.getHTMLToken;
+
+// "tokenize" is not really a great operation for real use, because
+// it ignores the special content rules for tags like "style" and
+// "script".
+var tokenize = function (input) {
+  var scanner = new Scanner(input);
+  var tokens = [];
+  while (! scanner.isEOF()) {
+    var token = getHTMLToken(scanner);
+    if (token)
+      tokens.push(token);
+  }
+
+  return tokens;
+};
+
+
+Tinytest.add("html-tools - comments", function (test) {
+  var succeed = function (input, content) {
+    var scanner = new Scanner(input);
+    var result = getComment(scanner);
+    test.isTrue(result);
+    test.equal(scanner.pos, content.length + 7);
+    test.equal(result, {
+      t: 'Comment',
+      v: content
+    });
+  };
+
+  var ignore = function (input) {
+    var scanner = new Scanner(input);
+    var result = getComment(scanner);;
+    test.isFalse(result);
+    test.equal(scanner.pos, 0);
+  };
+
+  var fatal = function (input, messageContains) {
+    var scanner = new Scanner(input);
+    var error;
+    try {
+      getComment(scanner);
+    } catch (e) {
+      error = e;
+    }
+    test.isTrue(error);
+    if (error)
+      test.isTrue(messageContains && error.message.indexOf(messageContains) >= 0, error.message);
+  };
+
+  test.equal(getComment(new Scanner("<!-- hello -->")),
+             { t: 'Comment', v: ' hello ' });
+
+  ignore("<!DOCTYPE>");
+  ignore("<!-a");
+  ignore("<--");
+  ignore("<!");
+  ignore("abc");
+  ignore("<a");
+
+  fatal('<!--', 'Unclosed');
+  fatal('<!---', 'Unclosed');
+  fatal('<!----', 'Unclosed');
+  fatal('<!-- -', 'Unclosed');
+  fatal('<!-- --', 'Unclosed');
+  fatal('<!-- -- abcd', 'Unclosed');
+  fatal('<!-- ->', 'Unclosed');
+  fatal('<!-- a--b -->', 'cannot contain');
+  fatal('<!--x--->', 'must end at first');
+
+  fatal('<!-- a\u0000b -->', 'cannot contain');
+  fatal('<!--\u0000 x-->', 'cannot contain');
+
+  succeed('<!---->', '');
+  succeed('<!---x-->', '-x');
+  succeed('<!--x-->', 'x');
+  succeed('<!-- hello - - world -->', ' hello - - world ');
+});
+
+Tinytest.add("html-tools - doctype", function (test) {
+  var succeed = function (input, expectedProps) {
+    var scanner = new Scanner(input);
+    var result = getDoctype(scanner);
+    test.isTrue(result);
+    test.equal(scanner.pos, result.v.length);
+    test.equal(input.slice(0, result.v.length), result.v);
+    var actualProps = _.extend({}, result);
+    delete actualProps.t;
+    delete actualProps.v;
+    test.equal(actualProps, expectedProps);
+  };
+
+  var fatal = function (input, messageContains) {
+    var scanner = new Scanner(input);
+    var error;
+    try {
+      getDoctype(scanner);
+    } catch (e) {
+      error = e;
+    }
+    test.isTrue(error);
+    if (messageContains)
+      test.isTrue(error.message.indexOf(messageContains) >= 0, error.message);
+  };
+
+  test.equal(getDoctype(new Scanner("<!DOCTYPE html>x")),
+             { t: 'Doctype',
+               v: '<!DOCTYPE html>',
+               name: 'html' });
+
+  test.equal(getDoctype(new Scanner("<!DOCTYPE html SYSTEM 'about:legacy-compat'>x")),
+             { t: 'Doctype',
+               v: "<!DOCTYPE html SYSTEM 'about:legacy-compat'>",
+               name: 'html',
+               systemId: 'about:legacy-compat' });
+
+  test.equal(getDoctype(new Scanner("<!DOCTYPE html PUBLIC '-//W3C//DTD HTML 4.0//EN'>x")),
+             { t: 'Doctype',
+               v: "<!DOCTYPE html PUBLIC '-//W3C//DTD HTML 4.0//EN'>",
+               name: 'html',
+               publicId: '-//W3C//DTD HTML 4.0//EN' });
+
+  test.equal(getDoctype(new Scanner("<!DOCTYPE html PUBLIC '-//W3C//DTD HTML 4.0//EN' 'http://www.w3.org/TR/html4/strict.dtd'>x")),
+             { t: 'Doctype',
+               v: "<!DOCTYPE html PUBLIC '-//W3C//DTD HTML 4.0//EN' 'http://www.w3.org/TR/html4/strict.dtd'>",
+               name: 'html',
+               publicId: '-//W3C//DTD HTML 4.0//EN',
+               systemId: 'http://www.w3.org/TR/html4/strict.dtd' });
+
+  succeed('<!DOCTYPE html>', {name: 'html'});
+  succeed('<!DOCTYPE htML>', {name: 'html'});
+  succeed('<!DOCTYPE HTML>', {name: 'html'});
+  succeed('<!doctype html>', {name: 'html'});
+  succeed('<!doctYPE html>', {name: 'html'});
+  succeed('<!DOCTYPE html \u000c>', {name: 'html'});
+  fatal('<!DOCTYPE', 'Expected space');
+  fatal('<!DOCTYPE ', 'Malformed DOCTYPE');
+  fatal('<!DOCTYPE  ', 'Malformed DOCTYPE');
+  fatal('<!DOCTYPE>', 'Expected space');
+  fatal('<!DOCTYPE >', 'Malformed DOCTYPE');
+  fatal('<!DOCTYPE\u0000', 'Expected space');
+  fatal('<!DOCTYPE \u0000', 'Malformed DOCTYPE');
+  fatal('<!DOCTYPE html\u0000>', 'Malformed DOCTYPE');
+  fatal('<!DOCTYPE html', 'Malformed DOCTYPE');
+
+  succeed('<!DOCTYPE html SYSTEM "about:legacy-compat">', {name: 'html', systemId: 'about:legacy-compat'});
+  succeed('<!doctype HTML system "about:legacy-compat">', {name: 'html', systemId: 'about:legacy-compat'});
+  succeed("<!DOCTYPE html SYSTEM 'about:legacy-compat'>", {name: 'html', systemId: 'about:legacy-compat'});
+  succeed("<!dOcTyPe HtMl sYsTeM 'about:legacy-compat'>", {name: 'html', systemId: 'about:legacy-compat'});
+  succeed('<!DOCTYPE  html\tSYSTEM\t"about:legacy-compat"   \t>', {name: 'html', systemId: 'about:legacy-compat'});
+  fatal('<!DOCTYPE html SYSTE "about:legacy-compat">', 'Expected PUBLIC or SYSTEM');
+  fatal('<!DOCTYPE html SYSTE', 'Expected PUBLIC or SYSTEM');
+  fatal('<!DOCTYPE html SYSTEM"about:legacy-compat">', 'Expected space');
+  fatal('<!DOCTYPE html SYSTEM');
+  fatal('<!DOCTYPE html SYSTEM ');
+  fatal('<!DOCTYPE html SYSTEM>');
+  fatal('<!DOCTYPE html SYSTEM >');
+  fatal('<!DOCTYPE html SYSTEM ">">');
+  fatal('<!DOCTYPE html SYSTEM "\u0000about:legacy-compat">');
+  fatal('<!DOCTYPE html SYSTEM "about:legacy-compat\u0000">');
+  fatal('<!DOCTYPE html SYSTEM "');
+  fatal('<!DOCTYPE html SYSTEM "">');
+  fatal('<!DOCTYPE html SYSTEM \'');
+  fatal('<!DOCTYPE html SYSTEM\'a\'>');
+  fatal('<!DOCTYPE html SYSTEM about:legacy-compat>');
+
+  succeed('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN">',
+          { name: 'html',
+            publicId: '-//W3C//DTD HTML 4.0//EN'});
+  succeed('<!DOCTYPE html PUBLIC \'-//W3C//DTD HTML 4.0//EN\'>',
+          { name: 'html',
+            publicId: '-//W3C//DTD HTML 4.0//EN'});
+  succeed('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">',
+          { name: 'html',
+            publicId: '-//W3C//DTD HTML 4.0//EN',
+            systemId: 'http://www.w3.org/TR/REC-html40/strict.dtd'});
+  succeed('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN" \'http://www.w3.org/TR/REC-html40/strict.dtd\'>',
+          { name: 'html',
+            publicId: '-//W3C//DTD HTML 4.0//EN',
+            systemId: 'http://www.w3.org/TR/REC-html40/strict.dtd'});
+  succeed('<!DOCTYPE html public \'-//W3C//DTD HTML 4.0//EN\' \'http://www.w3.org/TR/REC-html40/strict.dtd\'>',
+          { name: 'html',
+            publicId: '-//W3C//DTD HTML 4.0//EN',
+            systemId: 'http://www.w3.org/TR/REC-html40/strict.dtd'});
+  succeed('<!DOCTYPE html public \'-//W3C//DTD HTML 4.0//EN\'\t\'http://www.w3.org/TR/REC-html40/strict.dtd\'   >',
+          { name: 'html',
+            publicId: '-//W3C//DTD HTML 4.0//EN',
+            systemId: 'http://www.w3.org/TR/REC-html40/strict.dtd'});
+  fatal('<!DOCTYPE html public \'-//W3C//DTD HTML 4.0//EN\' \'http://www.w3.org/TR/REC-html40/strict.dtd\'');
+  fatal('<!DOCTYPE html public \'-//W3C//DTD HTML 4.0//EN\' \'http://www.w3.org/TR/REC-html40/strict.dtd\'');
+  fatal('<!DOCTYPE html public \'-//W3C//DTD HTML 4.0//EN\' \'http://www.w3.org/TR/REC-html40/strict.dtd');
+  fatal('<!DOCTYPE html public \'-//W3C//DTD HTML 4.0//EN\' \'');
+  fatal('<!DOCTYPE html public \'-//W3C//DTD HTML 4.0//EN\' ');
+  fatal('<!DOCTYPE html public \'- ');
+  fatal('<!DOCTYPE html public>');
+  fatal('<!DOCTYPE html public "-//W3C//DTD HTML 4.0//EN""http://www.w3.org/TR/REC-html40/strict.dtd">');
+});
+
+Tinytest.add("html-tools - tokenize", function (test) {
+
+  var fatal = function (input, messageContains) {
+    var error;
+    try {
+      tokenize(input);
+    } catch (e) {
+      error = e;
+    }
+    test.isTrue(error);
+    if (messageContains)
+      test.isTrue(error.message.indexOf(messageContains) >= 0, error.message);
+  };
+
+
+  test.equal(tokenize(''), []);
+  test.equal(tokenize('abc'), [{t: 'Chars', v: 'abc'}]);
+  test.equal(tokenize('&'), [{t: 'Chars', v: '&'}]);
+  test.equal(tokenize('&amp;'), [{t: 'CharRef', v: '&amp;', cp: [38]}]);
+  test.equal(tokenize('ok&#32;fine'),
+             [{t: 'Chars', v: 'ok'},
+              {t: 'CharRef', v: '&#32;', cp: [32]},
+              {t: 'Chars', v: 'fine'}]);
+
+  test.equal(tokenize('a<!--b-->c'),
+             [{t: 'Chars',
+               v: 'a'},
+              {t: 'Comment',
+               v: 'b'},
+              {t: 'Chars',
+               v: 'c'}]);
+
+  test.equal(tokenize('<a>'), [{t: 'Tag', n: 'a'}]);
+
+  fatal('<');
+  fatal('<x');
+  fatal('<x ');
+  fatal('<x a');
+  fatal('<x a ');
+  fatal('<x a =');
+  fatal('<x a = ');
+  fatal('<x a = b');
+  fatal('<x a = "b');
+  fatal('<x a = \'b');
+  fatal('<x a = b ');
+  fatal('<x a = b /');
+  test.equal(tokenize('<x a = b />'),
+             [{t: 'Tag', n: 'x',
+               attrs: { a: [{t: 'Chars', v: 'b'}] },
+               isSelfClosing: true}]);
+
+  test.equal(tokenize('<a>X</a>'),
+             [{t: 'Tag', n: 'a'},
+              {t: 'Chars', v: 'X'},
+              {t: 'Tag', n: 'a', isEnd: true}]);
+
+  fatal('<x a a>'); // duplicate attribute value
+  test.equal(tokenize('<a b  >'),
+             [{t: 'Tag', n: 'a', attrs: { b: [] }}]);
+  fatal('< a>');
+  fatal('< /a>');
+  fatal('</ a>');
+
+  // Slash does not end an unquoted attribute, interestingly
+  test.equal(tokenize('<a b=/>'),
+             [{t: 'Tag', n: 'a', attrs: { b: [{t: 'Chars', v: '/'}] }}]);
+
+  test.equal(tokenize('<a b="c" d=e f=\'g\' h \t>'),
+             [{t: 'Tag', n: 'a',
+               attrs: { b: [{t: 'Chars', v: 'c'}],
+                        d: [{t: 'Chars', v: 'e'}],
+                        f: [{t: 'Chars', v: 'g'}],
+                        h: [] }}]);
+
+  fatal('</a b="c" d=e f=\'g\' h \t\u0000>');
+  fatal('</a b="c" d=ef=\'g\' h \t>');
+  fatal('</a b="c"d=e f=\'g\' h \t>');
+
+  test.equal(tokenize('<a/>'), [{t: 'Tag', n: 'a', isSelfClosing: true}]);
+
+  fatal('<a/ >');
+  fatal('<a/b>');
+  fatal('<a b=c`>');
+  fatal('<a b=c<>');
+
+  test.equal(tokenize('<a# b0="c@" d1=e2 f#=\'g  \' h \t>'),
+             [{t: 'Tag', n: 'a#',
+               attrs: { b0: [{t: 'Chars', v: 'c@'}],
+                        d1: [{t: 'Chars', v: 'e2'}],
+                        'f#': [{t: 'Chars', v: 'g  '}],
+                        h: [] }}]);
+
+  test.equal(tokenize('<div class=""></div>'),
+             [{t: 'Tag', n: 'div', attrs: { 'class': [] }},
+              {t: 'Tag', n: 'div', isEnd: true}]);
+
+  test.equal(tokenize('<div class="&">'),
+             [{t: 'Tag', n: 'div', attrs: { 'class': [{t: 'Chars', v: '&'}] }}]);
+  test.equal(tokenize('<div class=&>'),
+             [{t: 'Tag', n: 'div', attrs: { 'class': [{t: 'Chars', v: '&'}] }}]);
+  test.equal(tokenize('<div class=&amp;>'),
+             [{t: 'Tag', n: 'div', attrs: { 'class': [{t: 'CharRef', v: '&amp;', cp: [38]}] }}]);
+
+  test.equal(tokenize('<div class=aa&&zopf;&acE;&bb>'),
+             [{t: 'Tag', n: 'div', attrs: { 'class': [
+               {t: 'Chars', v: 'aa&'},
+               {t: 'CharRef', v: '&zopf;', cp: [120171]},
+               {t: 'CharRef', v: '&acE;', cp: [8766, 819]},
+               {t: 'Chars', v: '&bb'}
+             ] }}]);
+
+  test.equal(tokenize('<div class="aa &&zopf;&acE;& bb">'),
+             [{t: 'Tag', n: 'div', attrs: { 'class': [
+               {t: 'Chars', v: 'aa &'},
+               {t: 'CharRef', v: '&zopf;', cp: [120171]},
+               {t: 'CharRef', v: '&acE;', cp: [8766, 819]},
+               {t: 'Chars', v: '& bb'}
+             ] }}]);
+
+  test.equal(tokenize('<a b="\'`<>&">'),
+             [{t: 'Tag', n: 'a', attrs: { b: [{t: 'Chars', v: '\'`<>&'}] }}]);
+  test.equal(tokenize('<a b=\'"`<>&\'>'),
+             [{t: 'Tag', n: 'a', attrs: { b: [{t: 'Chars', v: '"`<>&'}] }}]);
+
+  fatal('&gt');
+  fatal('&gtc');
+  test.equal(tokenize('<a b=&gtc>'),
+             [{t: 'Tag', n: 'a', attrs: { b: [{t: 'Chars', v: '&gtc' }] }}]);
+  test.equal(tokenize('<a b="&gtc">'),
+             [{t: 'Tag', n: 'a', attrs: { b: [{t: 'Chars', v: '&gtc' }] }}]);
+  fatal('<a b=&gt>');
+  fatal('<a b="&gt">');
+  fatal('<a b="&gt=">');
+
+  fatal('<!');
+  fatal('<!x>');
+
+  fatal('<a{{b}}>');
+  fatal('<{{a}}>');
+  fatal('</a b=c>'); // end tag can't have attributes
+  fatal('</a/>'); // end tag can't be self-closing
+  fatal('</a  />');
+});
diff --git a/packages/html-tools/utils.js b/packages/html-tools/utils.js
new file mode 100644
index 0000000000..934bc09e02
--- /dev/null
+++ b/packages/html-tools/utils.js
@@ -0,0 +1,50 @@
+
+HTMLTools = {};
+HTMLTools.Parse = {};
+
+var asciiLowerCase = HTMLTools.asciiLowerCase = function (str) {
+  return str.replace(/[A-Z]/g, function (c) {
+    return String.fromCharCode(c.charCodeAt(0) + 32);
+  });
+};
+
+var svgCamelCaseAttributes = 'attributeName attributeType baseFrequency baseProfile calcMode clipPathUnits contentScriptType contentStyleType diffuseConstant edgeMode externalResourcesRequired filterRes filterUnits glyphRef glyphRef gradientTransform gradientTransform gradientUnits gradientUnits kernelMatrix kernelUnitLength kernelUnitLength kernelUnitLength keyPoints keySplines keyTimes lengthAdjust limitingConeAngle markerHeight markerUnits markerWidth maskContentUnits maskUnits numOctaves pathLength patternContentUnits patternTransform patternUnits pointsAtX pointsAtY pointsAtZ preserveAlpha preserveAspectRatio primitiveUnits refX refY repeatCount repeatDur requiredExtensions requiredFeatures specularConstant specularExponent specularExponent spreadMethod spreadMethod startOffset stdDeviation stitchTiles surfaceScale surfaceScale systemLanguage tableValues targetX targetY textLength textLength viewBox viewTarget xChannelSelector yChannelSelector zoomAndPan'.split(' ');
+
+var properAttributeCaseMap = (function (map) {
+  for (var i = 0; i < svgCamelCaseAttributes.length; i++) {
+    var a = svgCamelCaseAttributes[i];
+    map[asciiLowerCase(a)] = a;
+  }
+  return map;
+})({});
+
+var properTagCaseMap = (function (map) {
+  var knownElements = HTML.knownElementNames;
+  for (var i = 0; i < knownElements.length; i++) {
+    var a = knownElements[i];
+    map[asciiLowerCase(a)] = a;
+  }
+  return map;
+})({});
+
+// Take a tag name in any case and make it the proper case for HTML.
+//
+// Modern browsers let you embed SVG in HTML, but SVG elements are special
+// in that they have a case-sensitive DOM API (nodeName, getAttribute,
+// setAttribute).  For example, it has to be `setAttribute("viewBox")`,
+// not `"viewbox"`.  However, the browser's HTML parser is NOT case sensitive
+// and will fix the case for you, so if you write `<svg viewbox="...">`
+// you actually get a `"viewBox"` attribute.  Any HTML-parsing toolchain
+// must do the same.
+HTMLTools.properCaseTagName = function (name) {
+  var lowered = asciiLowerCase(name);
+  return properTagCaseMap.hasOwnProperty(lowered) ?
+    properTagCaseMap[lowered] : lowered;
+};
+
+// See docs for properCaseTagName.
+HTMLTools.properCaseAttributeName = function (name) {
+  var lowered = asciiLowerCase(name);
+  return properAttributeCaseMap.hasOwnProperty(lowered) ?
+    properAttributeCaseMap[lowered] : lowered;
+};
diff --git a/packages/htmljs/README.md b/packages/htmljs/README.md
new file mode 100644
index 0000000000..ef2d26ab88
--- /dev/null
+++ b/packages/htmljs/README.md
@@ -0,0 +1,237 @@
+# HTMLjs
+
+A small (500-line) library for expressing HTML trees in a concise
+syntax.  This library is used at compile time and run time by Meteor UI.
+
+```
+var UL = HTML.UL, LI = HTML.LI, B = HTML.B;
+
+HTML.toHTML(
+  UL({id: 'mylist'},
+     LI({'class': 'item'}, "Hello ", B("world"), "!"),
+     LI({'class': 'item'}, "Goodbye, world")))
+```
+
+```
+<ul id="mylist">
+  <li class="item">Hello <b>world</b>!</li>
+  <li class="item">Goodbye, world</li>
+</ul>
+```
+
+The functions `UL`, `LI`, and so on are "tag constructors" which
+return an object representation that can be used to generate HTML, or,
+via other packages, be used to generate DOM (`ui`), be parsed from
+HTML (`html-tools`), or serve as the backbone of the intermediate
+representation for a template compiler (`spacebars-compiler`).
+
+## Syntax
+
+Tag constructors take an optional first argument `attrs` followed by
+zero or more arguments, the `children`.  The first argument is taken
+to be `attrs` if it is a "vanilla" JavaScript object such as an object
+literal.
+
+> Ideally, a "vanilla" object would be one whose direct prototype is
+> `Object.prototype`.  Since this test is impossible in IE 8, we test
+> `obj.constructor === Object`, which is true for object literals
+> (except ones like `{constructor: blah}`!) and false for most objects
+> with custom prototypes (because JavaScript sets
+> `MyClass.prototype.constructor = MyClass` when you create a function
+> `MyClass`).
+
+Children of a tag may be of any of several built-in types:
+
+* Tag (HTML.Tag)
+* HTML.CharRef
+* HTML.Comment
+* HTML.Raw
+* String
+* Boolean or Number (which will be converted to String)
+* Array (which will be flattened)
+* Null or undefined (which will be ignored)
+* Template/Component
+* Function returning one of these types
+
+The set of allowed types is *open* in that any object may be included
+in the tree as long as the code consuming the tree can handle it.
+
+Character references (like `&amp;`) are *not* interpreted in strings.
+To include a character reference, use `HTML.CharRef({html:
+'&amp;', str: '&'})`, specifying both the raw HTML form and the string
+form of the character.
+
+> In other words, string values are of the form you would pass to
+`document.createTextNode`, not of the form you would see in an HTML
+document.  The intent here is to only need to parse and interpret
+character references at compile time, making the representation
+maximally flexible easy to consume at runtime.
+>
+> The reason we represent character references at all, rather than
+> simply converting them to Unicode when parsing the source HTML
+> (and then escaping `&` and `<` at the very end)
+> is 1) to preserve the HTML author's intent, and 2) in case there
+> is a character-encoding-related reason that a character reference
+> is being used.
+
+Attribute values can contain character references, using arrays to
+hold the string and CharRef parts:
+
+```
+var amp = HTML.CharRef({html: '&amp;', str: '&'});
+
+HTML.toHTML(HTML.SPAN({title: ['M', amp, 'Ms']},
+                      'M', amp, 'M candies'))
+```
+
+```
+<span title="M&amp;Ms">M&amp;M candies</span>
+```
+
+A comment looks like `HTML.Comment("value here")`, where the value
+should not contain two consecutive hyphen (`-`) characters or an
+initial or final hyphen (or they will be stripped out).
+
+A "raw" object like `HTML.Raw("<br>")` represents raw HTML to insert
+into the document.  The HTML should be known to be safe and contain
+balanced tags!  It will be injected without any parsing or checking
+when the representation is converted to an HTML string.  If the
+representation is used to generate DOM directly, the "raw" node will
+be materialized using an innerHTML-like method.
+
+Functions in the tree are used as reactivity boundaries when
+generating DOM directly.  When generating HTML, they are simply called
+for their return value.  Functions are passed no arguments and are
+given no particular value of `this`.
+
+Templates/components like `Template.foo` can also be included in the
+representation.  HTMLjs has very limited knowledge of what a component
+is.  It knows components have an `instantiate` method that returns
+something with a `render` method.  Operations that realize an HTMLjs
+tree as HTML, DOM, or some other form have a bit of boilerplate that
+they use to detect and instantiate components:
+
+```
+HTML.toHTML = function (node, parentComponent) {
+  // ... handle various types of `node`
+  if (typeof node.instantiate === 'function') {
+    // component
+    var instance = node.instantiate(parentComponent || null);
+    var content = instance.render();
+    // recurse with a new value for parentComponent
+    return HTML.toHTML(content, instance);
+  }
+  // ...
+};
+```
+
+The argument `parentComponent` is used to set a pointer that points
+from each component to its parent, used for name lookups.
+
+## "Known" and Custom Tags
+
+All the usual HTML and HTML5 tags are available as `HTML.A`,
+`HTML.ABBR`, `HTML.ADDRESS`, etc.  These tags are called "known" tags
+and have predefined tag constructors.  If you want to use a custom
+tag, you'll have to create the tag constructor using `getTag` or `ensureTag`.
+
+```
+var SPAN = HTML.SPAN;
+var FOO = HTML.getTag('FOO');
+```
+
+```
+HTML.ensureTag('FOO');
+var SPAN = HTML.SPAN;
+var FOO = HTML.FOO;
+```
+
+All of these functions handle case conversion of `tagName` as
+appropriate, so whether you provide `foo` or `Foo` or `FOO`, the
+symbol on `HTML` will be `HTML.FOO`, while generated HTML and DOM will use
+the lowercase name `foo`.
+
+`HTML.getTag(tagName)` - Returns a tag constructor for `tagName`, calling `ensureTag` if it doesn't exist.
+
+`HTML.ensureTag(tagName)` - Creates a tag constructor for `tagName` if one doesn't exist and attaches it to the `HTML` object.
+
+`HTML.isTagEnsured(tagName)` - Returns true if `tagName` has a built-in, predefined constructor.  Useful for code generators that want to know if they should emit a call to `ensureTag`.
+
+## Object Representation
+
+Tag constructors follow an object-oriented paradigm with optional
+`new`.  The returned objects are `instanceof` the tag constructor and
+also of `HTML.Tag`.  In other words, all of the following are true:
+
+```
+HTML.P() instanceof HTML.P
+HTML.P() instanceof HTML.Tag
+(new HTML.P) instanceof HTML.P
+(new HTML.P) instanceof HTML.Tag
+```
+
+Similarly, objects constructed with `HTML.Comment` are instances of `HTML.Comment`, and so on.
+
+In general, HTMLjs objects should be considered immutable.
+
+HTML.Tag objects have these properties:
+
+* `tagName` - the uppercase tag name
+* `attrs` - an object or null
+* `children` - an array of zero or more children
+
+HTML.CharRef objects have `html` and `str` properties, specified by
+the object passed to the constructor.
+
+HTML.Comment and HTML.Raw objects have a `value` property.
+
+### Attributes
+
+Attribute values can contain most kinds of HTMLjs content, but not Tag, Comment, or Raw.  They may contain functions and components, even though these functions won't ever establish reactivity boundaries at a finer level than an entire attribute value.
+
+The attributes dictionary of a tag can have a special entry `$dynamic`, which holds additional attributes dictionaries to combine with the main dictionary.  These additional dictionaries may be computed by functions, lending generality to the calculation of the attributes dictionary that would not otherwise be present.
+
+Specifically, the value of `$dynamic` must be an array, each element of which is either an attributes dictionary or a function returning an attributes dictionary.  (These dictionaries may not themselves have a `$dynamic` key.)  When calculating the final attributes dictionary for a tag, each dictionary obtained from the `$dynamic` array is used to modify the existing dictionary by copying the new attribute entries over it, except for entries with a "nully" value.  A "nully" value is one that is either `null`, `undefined`, `[]`, or an array of nully values.  Before checking if the dynamic attribute value is nully, all functions and components are evaluated (i.e. the functions are called and the components are instantiated, such that no functions or components remain).
+
+The `$dynamic` feature is designed to support writing `<div class="myClass" {{moreAttrs1}} {{moreAttrs2}}>` in templates.
+
+`HTML.evaluateDynamicAttributes(attrs, parentComponent)` - Returns the final attributes dictionary for a tag after interpreting the `$dynamic` property, if present.  Takes a tag's `attrs` property and a `parentComponent` (used to instantiate any components in the attributes).  `attrs` may be null.
+
+`tag.evaluateDynamicAttributes(parentComponent)` - Shorthand for `HTML.evaluateDynamicAttributes(tag.attrs, parentComponent)`.
+
+`HTML.isNully(value)` - Returns true if `value` is a nully value, i.e. one of `null`, `undefined`, `[]`, or an array of nully values.
+
+`HTML.evaluate(node, parentComponent)` - Calls all functions and instantiates all components in an HTMLjs tree.
+
+## toHTML and toText
+
+`HTML.toHTML(node, parentComponent)` - Converts the HTMLjs content `node` to an HTML string, using `parentComponent` as the parent scope pointer when instantiating components.
+
+`HTML.toText(node, textMode, parentComponent)` - Converts the HTMLjs content `node` into text, suitable for being included as part of an attribute value or textarea, for example.  `node` must not contain Tags or Comments, but may contain CharRefs, functions, and components.  The required argument `textMode` specifies what sort of text to generate, which affects how charater references are handled and which characters are escaped.
+
+* `HTML.TEXTMODE.STRING` - JavaScript string suitable for `document.createTextNode` or `element.setAttribute`.  Character references are replaced by the characters they represent.  No escaping is performed.
+
+* `HTML.TEXTMODE.ATTRIBUTE` - HTML string suitable for a quoted attribute.  Character references are included in raw HTML form (i.e. `&foo;`).  `&` and `"` are escaped when found in strings in the HTMLjs tree.
+
+* `HTML.TEXTMODE.RCDATA` - HTML string suitable for the content of a TEXTAREA element, for example.  (RCDATA stands for "replaced character data" as in the HTML syntax spec.)  Character references are included in raw HTML form.  `&` and `<` are escaped when found in strings in the HTMLjs tree.
+
+> The reason to perform the escaping as part of `HTML.toText` rather than as a post-processing step is in order to support `HTML.CharRef`, allowing the HTML author's choice of character reference encoding to be passed through.  If we only had `STRING` mode, we would lose the original form of the character references.  If we only had `RCDATA` mode, say, we would have to interpret the character references at runtime to use the DOM API.  On a related note, we don't allow `HTML.Raw` because character references are the only "raw" thing there is in text mode (and, again, we don't want to interpret them at runtime).  `HTML.CharRef` is sort of like a one-character version of `Raw`.
+
+## Name Utilities
+
+All of these functions take case-insensitive input.
+
+`HTML.properCaseTagName(tagName)` - Case-convert a tag name for inclusion in HTML or passing to `document.createElement`.  Most tags belong in lowercase, but there are some camel-case SVG tags.  HTML processors must know the proper case for tag names, because HTML is case-insensitive but the DOM is sometimes case-sensitive.
+
+`HTML.properCaseAttributeName(name)` - Case-convert an attribute name for inclusion in HTML or passing to `element.setAttribute`.  See `HTML.properCaseTagName`.
+
+`HTML.isValidAttributeName(name)` - Returns true if `name` conforms to a restricted set of legal characters known to work both in HTML and the DOM APIs.  Allows at least ASCII numbers and letters, hyphens, and underscores, where the first character can't be a number or a hyphen.
+
+`HTML.isKnownElement(tagName)` - Returns true if `tagName` is a known HTML/HTML5 element, excluding SVG and other foreign elements.
+
+`HTML.isKnownSVGElement(tagName)` - Returns true if `tagName` is a known SVG element.
+
+`HTML.isVoidElement(tagName)` - Returns true if `tagName` is a known void element such as `BR`, `HR`, or `INPUT`.  Void elements are output as `<br>` instead of `<br></br>`.  Note that neither HTML4 nor HTML5 has true self-closing tags (except when parsing SVG).  `<br/>` is the same as `<br>` and `<div/>` is the same as `<div>`.  It was only the now-abandoned XHTML standard that said otherwise, which was a backwards-incompatible change.  Modern browsers refer to the list of void elements instead.
+
+`HTML.asciiLowerCase(str)` - "ASCII-lowercases" `str`, converting `A-Z` to `a-z`.  The case-insensitive parts of the HTML spec use this operation for case folding.
+
diff --git a/packages/htmljs/html.js b/packages/htmljs/html.js
index aea248fa87..f8348d6793 100644
--- a/packages/htmljs/html.js
+++ b/packages/htmljs/html.js
@@ -1,124 +1,290 @@
-/***
- * A convenient way to create DOM elements. ('cls' will be
- * automatically expanded to 'class', since 'class' may not appear as
- * a key of an object, even in quotes, in Safari.)
- *
- * DIV({cls: "mydiv", style: "color: blue;"}, [
- *   "Some text",
- *   A({href: "/some/location"}, ["A link"]),
- *   DIV({cls: "emptydiv"}),
- *   // if an object is inserted, the value of its 'element'
- *   // attribute will be used
- *   myView,
- *   DIV([
- *     "Both the attributes and the contents are optional",
- *     ["Lists", "are", "flattened"]
- *   })
- * ]);
- */
 
-// XXX find a place to document the contract for *View classes -- they
-// should have an attribute named 'element'
+// Tag instances are `instanceof HTML.Tag`.
+//
+// Tag objects should be considered immutable.
+//
+// This is a private constructor of an abstract class; don't call it.
+HTML.Tag = function () {};
+HTML.Tag.prototype.tagName = ''; // this will be set per Tag subclass
+HTML.Tag.prototype.attrs = null;
+HTML.Tag.prototype.children = Object.freeze ? Object.freeze([]) : [];
 
-// XXX consider not requiring the contents to be wrapped in an
-// array. eg: DIV({stuff: 12}, "thing1", "thing2"). backwards
-// compatible with current behavior due to array flattening. could
-// eliminate spurious wrapper div inserted by Layout.TwoColumnsFixedRight
+// Given "p", create and assign `HTML.P` if it doesn't already exist.
+// Then return it.  `tagName` must have proper case (usually all lowercase).
+HTML.getTag = function (tagName) {
+  var symbolName = HTML.getSymbolName(tagName);
+  if (symbolName === tagName) // all-caps tagName
+    throw new Error("Use the lowercase or camelCase form of '" + tagName + "' here");
 
-// XXX allow style to be set as an object
+  if (! HTML[symbolName])
+    HTML[symbolName] = makeTagConstructor(tagName);
 
-var event_names = {
-  blur: true,
-  change: true,
-  click: true,
-  dblclick: true,
-  error: true,
-  focus: true,
-  focusin: true,
-  focusout: true,
-  keydown: true,
-  keypress: true,
-  keyup: true,
-  load: true,
-  mousedown: true,
-  mouseenter: true,
-  mouseleave: true,
-  mousemove: true,
-  mouseout: true,
-  mouseover: true,
-  mouseup: true,
-  resize: true,
-  scroll: true,
-  select: true,
-  submit: true
+  return HTML[symbolName];
 };
 
-var testDiv = document.createElement("div");
-testDiv.innerHTML = '<a style="top:1px">a</a>';
-var styleGetSetSupport = /top/.test(testDiv.firstChild.getAttribute("style"));
+// Given "p", make sure `HTML.P` exists.  `tagName` must have proper case
+// (usually all lowercase).
+HTML.ensureTag = function (tagName) {
+  HTML.getTag(tagName); // don't return it
+};
 
-// All HTML4 elements, excluding deprecated elements
-// http://www.w3.org/TR/html4/index/elements.html
-// also excluding the following elements that seem unlikely to be
-// used in the body:
-// HEAD, HTML, LINK, MAP, META, NOFRAMES, NOSCRIPT, STYLE, TITLE
-var tag_names =
-  ('A ABBR ACRONYM B BDO BIG BLOCKQUOTE BR BUTTON CAPTION CITE CODE COL ' +
-   'COLGROUP DD DEL DFN DIV DL DT EM FIELDSET FORM H1 H2 H3 H4 H5 H6 HR ' +
-   'I IFRAME IMG INPUT INS KBD LABEL LEGEND LI OBJECT OL OPTGROUP OPTION ' +
-   'P PARAM PRE Q S SAMP SCRIPT SELECT SMALL SPAN STRIKE STRONG SUB SUP ' +
-   'TABLE TBODY TD TEXTAREA TFOOT TH THEAD TR TT U UL VAR').split(' ');
+// Given "p" create the function `HTML.P`.
+var makeTagConstructor = function (tagName) {
+  // HTMLTag is the per-tagName constructor of a HTML.Tag subclass
+  var HTMLTag = function HTMLTag(/*arguments*/) {
+    // Work with or without `new`.  If not called with `new`,
+    // perform instantiation by recursively calling this constructor.
+    // We can't pass varargs, so pass no args.
+    var instance = (this instanceof HTML.Tag) ? this : new HTMLTag;
 
-_.each(tag_names, function (tag) {
-  var f = function (arg1, arg2) {
-    var attrs, contents;
-    if (arg2) {
-      attrs = arg1;
-      contents = arg2;
-    } else {
-      if (arg1 instanceof Array) {
-        attrs = {};
-        contents = arg1;
-      } else {
-        attrs = arg1;
-        contents = [];
-      }
+    var i = 0;
+    var attrs = arguments.length && arguments[0];
+    if (attrs && (typeof attrs === 'object') &&
+        (attrs.constructor === Object)) {
+      instance.attrs = attrs;
+      i++;
     }
-    var elt = document.createElement(tag);
-    for (var a in attrs) {
-      if (a === 'cls')
-        elt.setAttribute('class', attrs[a]);
-      else if (a === '_for')
-        elt.setAttribute('for', attrs[a]);
-      else if (a === 'style' && ! styleGetSetSupport)
-        elt.style.cssText = String(attrs[a]);
-      else if (event_names[a]) {
-        if (typeof $ === "undefined")
-          throw new Error("Event binding is supported only if " +
-                          "jQuery or similar is available");
-        ($(elt)[a])(attrs[a]);
-      }
-      else
-        elt.setAttribute(a, attrs[a]);
-    }
-    var addChildren = function (children) {
-      for (var i = 0; i < children.length; i++) {
-        var c = children[i];
-        if (!c && c !== '')
-          throw new Error("Bad value for element body: " + c);
-        else if (c instanceof Array)
-          addChildren(c);
-        else if (typeof c === "string")
-          elt.appendChild(document.createTextNode(c));
-        else if ('element' in c)
-          addChildren([c.element]);
-        else
-          elt.appendChild(c);
-      };
-    };
-    addChildren(contents);
-    return elt;
+
+    // If no children, don't create an array at all, use the prototype's
+    // (frozen, empty) array.  This way we don't create an empty array
+    // every time someone creates a tag without `new` and this constructor
+    // calls itself with no arguments (above).
+    if (i < arguments.length)
+      instance.children = Array.prototype.slice.call(arguments, i);
+
+    return instance;
   };
-  // Put the function onto the package-scope variable with this name.
-  eval(tag + " = f;");
-});
+  HTMLTag.prototype = new HTML.Tag;
+  HTMLTag.prototype.constructor = HTMLTag;
+  HTMLTag.prototype.tagName = tagName;
+
+  return HTMLTag;
+};
+
+var CharRef = HTML.CharRef = function (attrs) {
+  if (! (this instanceof CharRef))
+    // called without `new`
+    return new CharRef(attrs);
+
+  if (! (attrs && attrs.html && attrs.str))
+    throw new Error(
+      "HTML.CharRef must be constructed with ({html:..., str:...})");
+
+  this.html = attrs.html;
+  this.str = attrs.str;
+};
+
+var Comment = HTML.Comment = function (value) {
+  if (! (this instanceof Comment))
+    // called without `new`
+    return new Comment(value);
+
+  if (typeof value !== 'string')
+    throw new Error('HTML.Comment must be constructed with a string');
+
+  this.value = value;
+  // Kill illegal hyphens in comment value (no way to escape them in HTML)
+  this.sanitizedValue = value.replace(/^-|--+|-$/g, '');
+};
+
+
+//---------- KNOWN ELEMENTS
+
+// These lists of known elements are public.  You can use them, for example, to
+// write a helper that determines the proper case for an SVG element name.
+// Such helpers that may not be needed at runtime are not provided here.
+
+HTML.knownElementNames = 'a abbr acronym address applet area b base basefont bdo big blockquote body br button caption center cite code col colgroup dd del dfn dir div dl dt em fieldset font form frame frameset h1 h2 h3 h4 h5 h6 head hr html i iframe img input ins isindex kbd label legend li link map menu meta noframes noscript object ol optgroup option p param pre q s samp script select small span strike strong style sub sup table tbody td textarea tfoot th thead title tr tt u ul var article aside audio bdi canvas command data datagrid datalist details embed eventsource figcaption figure footer header hgroup keygen mark meter nav output progress ruby rp rt section source summary time track video wbr'.split(' ');
+
+// omitted because also an HTML element: "a"
+HTML.knownSVGElementNames = 'altGlyph altGlyphDef altGlyphItem animate animateColor animateMotion animateTransform circle clipPath color-profile cursor defs desc ellipse feBlend feColorMatrix feComponentTransfer feComposite feConvolveMatrix feDiffuseLighting feDisplacementMap feDistantLight feFlood feFuncA feFuncB feFuncG feFuncR feGaussianBlur feImage feMerge feMergeNode feMorphology feOffset fePointLight feSpecularLighting feSpotLight feTile feTurbulence filter font font-face font-face-format font-face-name font-face-src font-face-uri foreignObject g glyph glyphRef hkern image line linearGradient marker mask metadata missing-glyph path pattern polygon polyline radialGradient rect script set stop style svg switch symbol text textPath title tref tspan use view vkern'.split(' ');
+// Append SVG element names to list of known element names
+HTML.knownElementNames = HTML.knownElementNames.concat(HTML.knownSVGElementNames);
+
+HTML.voidElementNames = 'area base br col command embed hr img input keygen link meta param source track wbr'.split(' ');
+
+// Speed up search through lists of known elements by creating internal "sets"
+// of strings.
+var YES = {yes:true};
+var makeSet = function (array) {
+  var set = {};
+  for (var i = 0; i < array.length; i++)
+    set[array[i]] = YES;
+  return set;
+};
+var voidElementSet = makeSet(HTML.voidElementNames);
+var knownElementSet = makeSet(HTML.knownElementNames);
+var knownSVGElementSet = makeSet(HTML.knownSVGElementNames);
+
+// Is the given element (in proper case) a known HTML element?
+// This includes SVG elements.
+HTML.isKnownElement = function (name) {
+  return knownElementSet[name] === YES;
+};
+
+// Is the given element (in proper case) an element with no end tag
+// in HTML, like "br", "hr", or "input"?
+HTML.isVoidElement = function (name) {
+  return voidElementSet[name] === YES;
+};
+
+// Is the given element (in proper case) a known SVG element?
+HTML.isKnownSVGElement = function (name) {
+  return knownSVGElementSet[name] === YES;
+};
+
+// For code generators, is a particular tag (in proper case) guaranteed
+// to be available on the HTML object (under the name returned by
+// getSymbolName)?
+HTML.isTagEnsured = function (t) {
+  return HTML.isKnownElement(t);
+};
+
+// For code generators, take a tagName like "p" and return an uppercase
+// symbol name like "P" which is available on the "HTML" object for
+// known elements or after calling getTag or ensureTag.
+HTML.getSymbolName = function (tagName) {
+  // "foo-bar" -> "FOO_BAR"
+  return tagName.toUpperCase().replace(/-/g, '_');
+};
+
+// Ensure tags for all known elements
+for (var i = 0; i < HTML.knownElementNames.length; i++)
+  HTML.ensureTag(HTML.knownElementNames[i]);
+
+////////////////////////////////////////////////////////////////////////////////
+
+callReactiveFunction = function (func) {
+  var result;
+  var cc = Deps.currentComputation;
+  var h = Deps.autorun(function (c) {
+    result = func();
+  });
+  h.onInvalidate(function () {
+    if (cc)
+      cc.invalidate();
+  });
+  if (Deps.active) {
+    Deps.onInvalidate(function () {
+      h.stop();
+      func.stop && func.stop();
+    });
+  } else {
+    h.stop();
+    func.stop && func.stop();
+  }
+  return result;
+};
+
+stopWithLater = function (instance) {
+  if (instance.materialized && instance.materialized.isWith) {
+    if (Deps.active) {
+      instance.materialized();
+    } else {
+      if (instance.data) // `UI.With`
+        instance.data.stop();
+      else if (instance.v) // `Spacebars.With`
+        instance.v.stop();
+    }
+  }
+};
+
+// Call all functions and instantiate all components, when fine-grained
+// reactivity is not needed (for example, in attributes).
+HTML.evaluate = function (node, parentComponent) {
+  if (node == null) {
+    return node;
+  } else if (typeof node === 'function') {
+    return HTML.evaluate(callReactiveFunction(node), parentComponent);
+  } else if (node instanceof Array) {
+    var result = [];
+    for (var i = 0; i < node.length; i++)
+      result.push(HTML.evaluate(node[i], parentComponent));
+    return result;
+  } else if (typeof node.instantiate === 'function') {
+    // component
+    var instance = node.instantiate(parentComponent || null);
+    var content = instance.render('STATIC');
+    stopWithLater(instance);
+    return HTML.evaluate(content, instance);
+  }  else if (node instanceof HTML.Tag) {
+    var newChildren = [];
+    for (var i = 0; i < node.children.length; i++)
+      newChildren.push(HTML.evaluate(node.children[i], parentComponent));
+    var newTag = HTML.getTag(node.tagName).apply(null, newChildren);
+    newTag.attrs = {};
+    for (var k in node.attrs)
+      newTag.attrs[k] = HTML.evaluate(node.attrs[k], parentComponent);
+    return newTag;
+  } else {
+    return node;
+  }
+};
+
+var extendAttrs = function (tgt, src, parentComponent) {
+  for (var k in src) {
+    if (k === '$dynamic')
+      continue;
+    if (! HTML.isValidAttributeName(k))
+      throw new Error("Illegal HTML attribute name: " + k);
+    var value = HTML.evaluate(src[k], parentComponent);
+    if (! HTML.isNully(value))
+      tgt[k] = value;
+  }
+};
+
+// Process the `attrs.$dynamic` directive, if present, returning the final
+// attributes dictionary.  The value of `attrs.$dynamic` must be an array
+// of attributes dictionaries or functions returning attribute dictionaries.
+// These attributes are used to extend `attrs` as long as they are non-nully.
+// All attributes are "evaluated," calling functions and instantiating
+// components.
+HTML.evaluateAttributes = function (attrs, parentComponent) {
+  if (! attrs)
+    return attrs;
+
+  var result = {};
+  extendAttrs(result, attrs, parentComponent);
+
+  if ('$dynamic' in attrs) {
+    if (! (attrs.$dynamic instanceof Array))
+      throw new Error("$dynamic must be an array");
+    // iterate over attrs.$dynamic, calling each element if it
+    // is a function and then using it to extend `result`.
+    var dynamics = attrs.$dynamic;
+    for (var i = 0; i < dynamics.length; i++) {
+      var moreAttrs = dynamics[i];
+      if (typeof moreAttrs === 'function')
+        moreAttrs = moreAttrs();
+      extendAttrs(result, moreAttrs, parentComponent);
+    }
+  }
+
+  return result;
+};
+
+HTML.Tag.prototype.evaluateAttributes = function (parentComponent) {
+  return HTML.evaluateAttributes(this.attrs, parentComponent);
+};
+
+HTML.Raw = function (value) {
+  if (! (this instanceof HTML.Raw))
+    // called without `new`
+    return new HTML.Raw(value);
+
+  if (typeof value !== 'string')
+    throw new Error('HTML.Raw must be constructed with a string');
+
+  this.value = value;
+};
+
+HTML.EmitCode = function (value) {
+  if (! (this instanceof HTML.EmitCode))
+    // called without `new`
+    return new HTML.EmitCode(value);
+
+  if (typeof value !== 'string')
+    throw new Error('HTML.EmitCode must be constructed with a string');
+
+  this.value = value;
+};
diff --git a/packages/htmljs/htmljs_test.js b/packages/htmljs/htmljs_test.js
index c9ded674f7..65cf28ecaa 100644
--- a/packages/htmljs/htmljs_test.js
+++ b/packages/htmljs/htmljs_test.js
@@ -1,5 +1,102 @@
 
-Tinytest.add("htmljs", function (test) {
-  // Make sure "style" works, which has to be special-cased for IE.
-  test.equal(DIV({style:"display:none"}).style.display, "none");
+Tinytest.add("htmljs - getTag", function (test) {
+  var FOO = HTML.getTag('foo');
+  test.isTrue(HTML.FOO === FOO);
+  var x = FOO();
+
+  test.equal(x.tagName, 'foo');
+  test.isTrue(x instanceof HTML.FOO);
+  test.isTrue(x instanceof HTML.Tag);
+  test.equal(x.children, []);
+  test.equal(x.attrs, null);
+
+  test.isTrue((new FOO) instanceof HTML.FOO);
+  test.isTrue((new FOO) instanceof HTML.Tag);
+  test.isFalse((new HTML.P) instanceof HTML.FOO);
+
+  var result = HTML.ensureTag('Bar');
+  test.equal(typeof result, 'undefined');
+  var BAR = HTML.BAR;
+  test.equal(BAR().tagName, 'Bar');
 });
+
+Tinytest.add("htmljs - construction", function (test) {
+  var A = HTML.getTag('a');
+  var B = HTML.getTag('b');
+  var C = HTML.getTag('c');
+
+  var a = A(0, B({q:0}, C(A(B({})), 'foo')));
+  test.equal(a.tagName, 'a');
+  test.equal(a.attrs, null);
+  test.equal(a.children.length, 2);
+  test.equal(a.children[0], 0);
+  var b = a.children[1];
+  test.equal(b.tagName, 'b');
+  test.equal(b.attrs, {q:0});
+  test.equal(b.children.length, 1);
+  var c = b.children[0];
+  test.equal(c.tagName, 'c');
+  test.equal(c.attrs, null);
+  test.equal(c.children.length, 2);
+  test.equal(c.children[0].tagName, 'a');
+  test.equal(c.children[0].attrs, null);
+  test.equal(c.children[0].children.length, 1);
+  test.equal(c.children[0].children[0].tagName, 'b');
+  test.equal(c.children[0].children[0].children.length, 0);
+  test.equal(c.children[0].children[0].attrs, {});
+  test.equal(c.children[1], 'foo');
+
+  var a2 = new A({m:1}, {n:2}, B(), {o:3}, 'foo');
+  test.equal(a2.tagName, 'a');
+  test.equal(a2.attrs, {m:1});
+  test.equal(a2.children.length, 4);
+  test.equal(a2.children[0], {n:2});
+  test.equal(a2.children[1].tagName, 'b');
+  test.equal(a2.children[2], {o:3});
+  test.equal(a2.children[3], 'foo');
+
+  test.equal(A({x:1}).children.length, 0);
+  var f = function () {};
+  test.equal(A(new f).children.length, 1);
+  test.equal(A(new Date).children.length, 1);
+
+  test.equal(HTML.toHTML(HTML.CharRef({html: '&amp;', str: '&'})), '&amp;');
+  test.throws(function () {
+    HTML.CharRef({html: '&amp;'}); // no 'str'
+  });
+});
+
+Tinytest.add("htmljs - utils", function (test) {
+
+  test.notEqual("\u00c9".toLowerCase(), "\u00c9");
+  test.equal(HTMLTools.asciiLowerCase("\u00c9"), "\u00c9");
+
+  test.equal(HTMLTools.asciiLowerCase("Hello There"), "hello there");
+
+  test.isTrue(HTML.isVoidElement("br"));
+  test.isFalse(HTML.isVoidElement("div"));
+  test.isTrue(HTML.isKnownElement("div"));
+
+});
+
+Tinytest.add("htmljs - attributes", function (test) {
+  var SPAN = HTML.SPAN;
+  var amp = HTML.CharRef({html: '&amp;', str: '&'});
+
+  test.equal(HTML.toHTML(SPAN({title: ['M', amp, 'Ms']}, 'M', amp, 'M candies')),
+             '<span title="M&amp;Ms">M&amp;M candies</span>');
+
+  // test that evaluateAttributes calls functions in both normal and dynamic attributes
+  test.equal(HTML.evaluateAttributes({x: function () { return 'abc'; }}),
+             { x: 'abc' });
+  test.equal(HTML.evaluateAttributes({x: function () { return 'abc'; },
+                                             $dynamic: []}),
+             { x: 'abc' });
+  test.equal(HTML.evaluateAttributes({x: function () { return 'abc'; },
+                                             $dynamic: [{ x: function () { return 'def'; }}]}),
+             { x: 'def' });
+});
+
+Tinytest.add("htmljs - details", function (test) {
+  test.equal(HTML.toHTML(false), "false");
+});
\ No newline at end of file
diff --git a/packages/htmljs/package.js b/packages/htmljs/package.js
index 46b82f24ea..c924565723 100644
--- a/packages/htmljs/package.js
+++ b/packages/htmljs/package.js
@@ -1,28 +1,21 @@
 Package.describe({
   name: "htmljs",
   test: "htmljs-test",
-  summary: "Easy macros for generating DOM elements in Javascript",
-  version: '1.0.0'
+  summary: "Small library for expressing HTML trees",
+  version: '1.0.0',
+  internal: true
 });
 
 Package.on_use(function (api) {
-  api.use('underscore', 'client');
-  // Note: html.js will optionally use jquery if it's available
-  api.add_files('html.js', 'client');
-  api.export([
-    'A', 'ABBR', 'ACRONYM', 'B', 'BDO', 'BIG', 'BLOCKQUOTE', 'BR', 'BUTTON',
-    'CAPTION', 'CITE', 'CODE', 'COL', 'COLGROUP', 'DD', 'DEL', 'DFN', 'DIV',
-    'DL', 'DT', 'EM', 'FIELDSET', 'FORM', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6',
-    'HR', 'I', 'IFRAME', 'IMG', 'INPUT', 'INS', 'KBD', 'LABEL', 'LEGEND', 'LI',
-    'OBJECT', 'OL', 'OPTGROUP', 'OPTION', 'P', 'PARAM', 'PRE', 'Q', 'S', 'SAMP',
-    'SCRIPT', 'SELECT', 'SMALL', 'SPAN', 'STRIKE', 'STRONG', 'SUB', 'SUP',
-    'TABLE', 'TBODY', 'TD', 'TEXTAREA', 'TFOOT', 'TH', 'THEAD', 'TR', 'TT', 'U',
-    'UL', 'VAR'
-  ], 'client');
+  api.export('HTML');
+
+  api.add_files(['utils.js', 'html.js', 'tohtml.js']);
 });
 
 Package.on_test(function (api) {
-  api.use('htmljs', 'client');
+  api.use('htmljs');
+  api.use('html-tools');
   api.use('tinytest');
-  api.add_files('htmljs_test.js', 'client');
+  api.use('underscore');
+  api.add_files(['htmljs_test.js']);
 });
diff --git a/packages/htmljs/tohtml.js b/packages/htmljs/tohtml.js
new file mode 100644
index 0000000000..2d9e9453f3
--- /dev/null
+++ b/packages/htmljs/tohtml.js
@@ -0,0 +1,159 @@
+
+HTML.toHTML = function (node, parentComponent) {
+  if (node == null) {
+    // null or undefined
+    return '';
+  } else if ((typeof node === 'string') || (typeof node === 'boolean') || (typeof node === 'number')) {
+    // string; escape special chars
+    return HTML.escapeData(String(node));
+  } else if (node instanceof Array) {
+    // array
+    var parts = [];
+    for (var i = 0; i < node.length; i++)
+      parts.push(HTML.toHTML(node[i], parentComponent));
+    return parts.join('');
+  } else if (typeof node.instantiate === 'function') {
+    // component
+    var instance = node.instantiate(parentComponent || null);
+    var content = instance.render('STATIC');
+    stopWithLater(instance);
+    // recurse with a new value for parentComponent
+    return HTML.toHTML(content, instance);
+  } else if (typeof node === 'function') {
+    return HTML.toHTML(callReactiveFunction(node), parentComponent);
+  } else if (node.toHTML) {
+    // Tag or something else
+    return node.toHTML(parentComponent);
+  } else {
+    throw new Error("Expected tag, string, array, component, null, undefined, or " +
+                    "object with a toHTML method; found: " + node);
+  }
+};
+
+HTML.Comment.prototype.toHTML = function () {
+  return '<!--' + this.sanitizedValue + '-->';
+};
+
+HTML.CharRef.prototype.toHTML = function () {
+  return this.html;
+};
+
+HTML.Raw.prototype.toHTML = function () {
+  return this.value;
+};
+
+HTML.Tag.prototype.toHTML = function (parentComponent) {
+  var attrStrs = [];
+  var attrs = this.evaluateAttributes(parentComponent);
+  if (attrs) {
+    for (var k in attrs) {
+      var v = HTML.toText(attrs[k], HTML.TEXTMODE.ATTRIBUTE, parentComponent);
+      attrStrs.push(' ' + k + '="' + v + '"');
+    }
+  }
+
+  var tagName = this.tagName;
+  var startTag = '<' + tagName + attrStrs.join('') + '>';
+
+  var childStrs = [];
+  var content;
+  if (tagName === 'textarea') {
+    for (var i = 0; i < this.children.length; i++)
+      childStrs.push(HTML.toText(this.children[i], HTML.TEXTMODE.RCDATA, parentComponent));
+
+    content = childStrs.join('');
+    if (content.slice(0, 1) === '\n')
+      // TEXTAREA will absorb a newline, so if we see one, add
+      // another one.
+      content = '\n' + content;
+
+  } else {
+    for (var i = 0; i < this.children.length; i++)
+      childStrs.push(HTML.toHTML(this.children[i], parentComponent));
+
+    content = childStrs.join('');
+  }
+
+  var result = startTag + content;
+
+  if (this.children.length || ! HTML.isVoidElement(tagName)) {
+    // "Void" elements like BR are the only ones that don't get a close
+    // tag in HTML5.  They shouldn't have contents, either, so we could
+    // throw an error upon seeing contents here.
+    result += '</' + tagName + '>';
+  }
+
+  return result;
+};
+
+HTML.TEXTMODE = {
+  ATTRIBUTE: 1,
+  RCDATA: 2,
+  STRING: 3
+};
+
+HTML.toText = function (node, textMode, parentComponent) {
+  if (node == null) {
+    // null or undefined
+    return '';
+  } else if ((typeof node === 'string') || (typeof node === 'boolean') || (typeof node === 'number')) {
+    node = String(node);
+    // string
+    if (textMode === HTML.TEXTMODE.STRING) {
+      return node;
+    } else if (textMode === HTML.TEXTMODE.RCDATA) {
+      return HTML.escapeData(node);
+    } else if (textMode === HTML.TEXTMODE.ATTRIBUTE) {
+      // escape `&` and `"` this time, not `&` and `<`
+      return node.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+    } else {
+      throw new Error("Unknown TEXTMODE: " + textMode);
+    }
+  } else if (node instanceof Array) {
+    // array
+    var parts = [];
+    for (var i = 0; i < node.length; i++)
+      parts.push(HTML.toText(node[i], textMode, parentComponent));
+    return parts.join('');
+  } else if (typeof node === 'function') {
+    return HTML.toText(callReactiveFunction(node), textMode, parentComponent);
+  } else if (typeof node.instantiate === 'function') {
+    // component
+    var instance = node.instantiate(parentComponent || null);
+    var content = instance.render('STATIC');
+    var result = HTML.toText(content, textMode, instance);
+    stopWithLater(instance);
+    return result;
+  } else if (node.toText) {
+    // Something else
+    return node.toText(textMode, parentComponent);
+  } else {
+    throw new Error("Expected tag, string, array, component, null, undefined, or " +
+                    "object with a toText method; found: " + node);
+  }
+
+};
+
+HTML.Raw.prototype.toText = function () {
+  return this.value;
+};
+
+// used when including templates within {{#markdown}}
+HTML.Tag.prototype.toText = function (textMode, parentComponent) {
+  if (textMode === HTML.TEXTMODE.STRING)
+    // stringify the tag as HTML, then convert to text
+    return HTML.toText(this.toHTML(parentComponent), textMode);
+  else
+    throw new Error("Can't insert tags in attributes or TEXTAREA elements");
+};
+
+HTML.CharRef.prototype.toText = function (textMode) {
+  if (textMode === HTML.TEXTMODE.STRING)
+    return this.str;
+  else if (textMode === HTML.TEXTMODE.RCDATA)
+    return this.html;
+  else if (textMode === HTML.TEXTMODE.ATTRIBUTE)
+    return this.html;
+  else
+    throw new Error("Unknown TEXTMODE: " + textMode);
+};
diff --git a/packages/htmljs/utils.js b/packages/htmljs/utils.js
new file mode 100644
index 0000000000..94b31d5c5f
--- /dev/null
+++ b/packages/htmljs/utils.js
@@ -0,0 +1,42 @@
+
+HTML = {};
+
+HTML.isNully = function (node) {
+  if (node == null)
+    // null or undefined
+    return true;
+
+  if (node instanceof Array) {
+    // is it an empty array or an array of all nully items?
+    for (var i = 0; i < node.length; i++)
+      if (! HTML.isNully(node[i]))
+        return false;
+    return true;
+  }
+
+  return false;
+};
+
+HTML.escapeData = function (str) {
+  // string; escape the two special chars in HTML data and RCDATA
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;');
+};
+
+
+// The HTML spec and the DOM API (in particular `setAttribute`) have different
+// definitions of what characters are legal in an attribute.  The HTML
+// parser is extremely permissive (allowing, for example, `<a %=%>`), while
+// `setAttribute` seems to use something like the XML grammar for names (and
+// throws an error if a name is invalid, making that attribute unsettable).
+// If we knew exactly what grammar browsers used for `setAttribute`, we could
+// include various Unicode ranges in what's legal.  For now, allow ASCII chars
+// that are known to be valid XML, valid HTML, and settable via `setAttribute`:
+//
+// * Starts with `:`, `_`, `A-Z` or `a-z`
+// * Consists of any of those plus `-`, `.`, and `0-9`.
+//
+// See <http://www.w3.org/TR/REC-xml/#NT-Name> and
+// <http://dev.w3.org/html5/markup/syntax.html#syntax-attributes>.
+HTML.isValidAttributeName = function (name) {
+  return /^[:_A-Za-z][:_A-Za-z0-9.\-]*/.test(name);
+};
diff --git a/packages/http/httpcall_common.js b/packages/http/httpcall_common.js
index a2fe4bdd2b..5b6c4f9b66 100644
--- a/packages/http/httpcall_common.js
+++ b/packages/http/httpcall_common.js
@@ -1,5 +1,5 @@
 makeErrorByStatus = function(statusCode, content) {
-  var MAX_LENGTH = 160; // if you change this, also change the appropriate test
+  var MAX_LENGTH = 500; // if you change this, also change the appropriate test
 
   var truncate = function(str, length) {
     return str.length > length ? str.slice(0, length) + '...' : str;
diff --git a/packages/http/httpcall_tests.js b/packages/http/httpcall_tests.js
index c05ad92482..0849254408 100644
--- a/packages/http/httpcall_tests.js
+++ b/packages/http/httpcall_tests.js
@@ -116,8 +116,8 @@ testAsyncMulti("httpcall - errors", [
       // in test_responder.js we make a very long response body, to make sure
       // that we truncate messages. first of all, make sure we didn't make that
       // message too short, so that we can be sure we're verifying that we truncate.
-      test.isTrue(error.response.content.length > 180);
-      test.isTrue(error.message.length < 180); // make sure we truncate.
+      test.isTrue(error.response.content.length > 520);
+      test.isTrue(error.message.length < 520); // make sure we truncate.
     };
     HTTP.call("GET", url_prefix()+"/fail", expect(error500Callback));
 
diff --git a/packages/http/test_responder.js b/packages/http/test_responder.js
index 90940c1b53..47239e6672 100644
--- a/packages/http/test_responder.js
+++ b/packages/http/test_responder.js
@@ -10,8 +10,10 @@ var respond = function(req, res) {
     return;
   } else if (req.url === "/fail") {
     res.statusCode = 500;
-    res.end("SOME SORT OF SERVER ERROR. " +
-            "MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. MAKE THIS VERY LONG TO MAKE SURE WE TRUNCATE. ");
+    res.end("SOME SORT OF SERVER ERROR. foo" +
+            _.times(100, function () {
+              return "MAKE THIS LONG TO TEST THAT WE TRUNCATE";
+            }).join(' '));
     return;
   } else if (req.url === "/redirect") {
     res.statusCode = 301;
diff --git a/packages/js-analyze/.npm/package/npm-shrinkwrap.json b/packages/js-analyze/.npm/package/npm-shrinkwrap.json
index a084b12ea5..d0887e7f77 100644
--- a/packages/js-analyze/.npm/package/npm-shrinkwrap.json
+++ b/packages/js-analyze/.npm/package/npm-shrinkwrap.json
@@ -1,8 +1,5 @@
 {
   "dependencies": {
-    "esprima": {
-      "version": "https://github.com/ariya/esprima/tarball/2a41dbf0ddadade0b09a9a7cc9a0c8df9c434018"
-    },
     "escope": {
       "version": "1.0.0",
       "dependencies": {
@@ -10,6 +7,9 @@
           "version": "1.3.1"
         }
       }
+    },
+    "esprima": {
+      "version": "https://github.com/ariya/esprima/tarball/2a41dbf0ddadade0b09a9a7cc9a0c8df9c434018"
     }
   }
 }
diff --git a/packages/less/less_tests.html b/packages/less/less_tests.html
new file mode 100644
index 0000000000..854059a78f
--- /dev/null
+++ b/packages/less/less_tests.html
@@ -0,0 +1,3 @@
+<template name="less_test_presence">
+  <p class="less-dashy-left-border"></p>
+</template>
diff --git a/packages/less/less_tests.js b/packages/less/less_tests.js
index f64a5b7304..b341761c9b 100644
--- a/packages/less/less_tests.js
+++ b/packages/less/less_tests.js
@@ -1,16 +1,17 @@
 
 Tinytest.add("less - presence", function(test) {
 
-  var d = OnscreenDiv(Meteor.render(function() {
-    return '<p class="less-dashy-left-border"></p>'; }));
-  d.node().style.display = 'block';
+  var div = document.createElement('div');
+  UI.materialize(Template.less_test_presence, div);
+  div.style.display = 'block';
+  document.body.appendChild(div);
 
-  var p = d.node().firstChild;
+  var p = div.querySelector('p');
   test.equal(getStyleProperty(p, 'border-left-style'), "dashed");
 
   // test @import
   test.equal(getStyleProperty(p, 'border-right-style'), "dotted");
   test.equal(getStyleProperty(p, 'border-bottom-style'), "double");
 
-  d.kill();
+  document.body.removeChild(div);
 });
diff --git a/packages/less/package.js b/packages/less/package.js
index c4ab5b0253..ffb825c444 100644
--- a/packages/less/package.js
+++ b/packages/less/package.js
@@ -15,8 +15,8 @@ Package._transitional_registerBuildPlugin({
 });
 
 Package.on_test(function (api) {
-  api.use(['test-helpers', 'tinytest', 'less']);
-  api.use(['spark']);
-  api.add_files(['less_tests.less', 'less_tests.js', 'less_tests.import.less',
-                 'less_tests_empty.less'], 'client');
+  api.use(['test-helpers', 'tinytest', 'less', 'templating']);
+  api.add_files(['less_tests.less', 'less_tests.js', 'less_tests.html',
+                 'less_tests.import.less', 'less_tests_empty.less'],
+                'client');
 });
diff --git a/packages/less/plugin/compile-less.js b/packages/less/plugin/compile-less.js
index a1e15445b5..5b00d99293 100644
--- a/packages/less/plugin/compile-less.js
+++ b/packages/less/plugin/compile-less.js
@@ -15,6 +15,7 @@ Plugin.registerSourceHandler("less", function (compileStep) {
 
   var source = compileStep.read().toString('utf8');
   var options = {
+    filename: compileStep.inputPath,
     // Use fs.readFileSync to process @imports. This is the bundler, so
     // that's not going to cause concurrency issues, and it means that (a)
     // we don't have to use Futures and (b) errors thrown by bugs in less
diff --git a/packages/livedata/.npm/package/npm-shrinkwrap.json b/packages/livedata/.npm/package/npm-shrinkwrap.json
index 92d8fd541c..e846e2ff4d 100644
--- a/packages/livedata/.npm/package/npm-shrinkwrap.json
+++ b/packages/livedata/.npm/package/npm-shrinkwrap.json
@@ -1,5 +1,13 @@
 {
   "dependencies": {
+    "faye-websocket": {
+      "version": "0.7.2",
+      "dependencies": {
+        "websocket-driver": {
+          "version": "0.3.2"
+        }
+      }
+    },
     "sockjs": {
       "version": "0.3.8",
       "dependencies": {
@@ -15,14 +23,6 @@
           }
         }
       }
-    },
-    "faye-websocket": {
-      "version": "0.7.2",
-      "dependencies": {
-        "websocket-driver": {
-          "version": "0.3.2"
-        }
-      }
     }
   }
 }
diff --git a/packages/livedata/DDP.md b/packages/livedata/DDP.md
index 655f1ca105..0cb9d137f9 100644
--- a/packages/livedata/DDP.md
+++ b/packages/livedata/DDP.md
@@ -7,7 +7,7 @@ DDP is a protocol between a client and a server that supports two operations:
    client informed about the contents of those documents as they change over
    time.
 
-This document specifies the version "pre1" of DDP. It's a rough description of
+This document specifies the version "pre2" of DDP. It's a rough description of
 the protocol and not intended to be entirely definitive.
 
 ## General Message Structure:
@@ -71,6 +71,23 @@ connections. The client can rely on the server sending a `failed`
 message if a better version is possible as a result of the client or
 the server having been upgraded.
 
+## Heartbeats
+
+### Messages:
+
+ * `ping`
+   - `id`: optional string (identifier used to correlate with response)
+ * `pong`
+   - `id`: optional string (same as received in the `ping` message)
+
+### Procedure:
+
+At any time after the connection is established either side may send a `ping`
+message. The sender may chose to include an `id` field in the `ping`
+message. When the other side receives a `ping` it must immediately respond with
+a `pong` message. If the received `ping` message includes an `id` field, the
+`pong` message must include the same `id` field.
+
 ## Managing Data:
 
 ### Messages:
@@ -170,6 +187,8 @@ the server having been upgraded.
    - `method`: string (method name)
    - `params`: optional array of EJSON items (parameters to the method)
    - `id`: string (an arbitrary client-determined identifier for this method call)
+   - `randomSeed`: optional JSON value (an arbitrary client-determined seed
+     for pseudo-random generators)
  * `result` (server -> client):
    - `id`: string (the id passed to 'method')
    - `error`: optional Error (an error thrown by the method (or method-not-found)
@@ -193,6 +212,19 @@ the server having been upgraded.
  * There is no particular required ordering between `result` and `updated`
    messages for a method call.
 
+ * The client may provide a randomSeed JSON value.  If provided, this value is
+   used to seed pseudo-random number generation.  By using the same seed with
+   the same algorithm, the same pseudo-random values can be generated on the
+   client and the server.  In particular, this is used for generating ids for
+   newly created documents.  If randomSeed is not provided, then values
+   generated on the server and the client will not be identical.
+
+ * Currently randomSeed is expected to be a string, and the algorithm by which
+   values are produced from this is not yet documented.  It will likely be
+   formally specified in future when we are confident that the complete
+   requirements are known, or when a compatible implementation requires this
+   to be specified.
+
 ## Errors:
 
 Errors appear in `result` and `nosub` messages in an optional error field. An
@@ -260,3 +292,35 @@ of EJSON should not rely on key order, if possible.
 
 > MongoDB relies on key order.  When using EJSON with MongoDB, the
 > implementation of EJSON must preserve key order.
+
+
+## Appendix 2: randomSeed backward/forward compatibility
+
+randomSeed was added into DDP pre2, but it does not break backward or forward
+compatibility.
+
+If the client stub and the server produce documents that are different in any
+way, Meteor will reconcile this difference. This may cause 'flicker' in the UI
+as the values change on the client to reflect what happened on the server, but
+the final result will be correct: the server and the client will agree.
+
+Consistent id generation / randomSeed does not alter the syncing process, and
+thus will (at worst) be the same:
+
+* If neither the server nor the client support randomSeed, we will get the
+classical/flicker behavior.
+
+* If the client supports randomSeed, but the server does not, the server will
+ignore randomSeed, as it ignores any unknown properties in a DDP method call.
+Different ids will be generated, but this will be fixed by syncing.
+
+* If the server supports randomSeed, but the client does not, the server will
+generate unseeded random values (providing a randomSeed is optional); different
+ids will be generated; and again this will be fixed by syncing.
+
+* If both client and server support randomSeed, but different ids are
+generated, either because the generation procedure is buggy, or the stub
+behaves differently to the server, then syncing will fix this.
+
+* If both client and server support randomSeed, in the normal case the ids
+generated will be the same, and syncing will be a no-op.
diff --git a/packages/livedata/heartbeat.js b/packages/livedata/heartbeat.js
new file mode 100644
index 0000000000..0eaafd9cdc
--- /dev/null
+++ b/packages/livedata/heartbeat.js
@@ -0,0 +1,102 @@
+// Heartbeat options:
+//   heartbeatInterval: interval to send pings, in milliseconds.
+//   heartbeatTimeout: timeout to close the connection if a reply isn't
+//     received, in milliseconds.
+//   sendPing: function to call to send a ping on the connection.
+//   onTimeout: function to call to close the connection.
+
+Heartbeat = function (options) {
+  var self = this;
+
+  self.heartbeatInterval = options.heartbeatInterval;
+  self.heartbeatTimeout = options.heartbeatTimeout;
+  self._sendPing = options.sendPing;
+  self._onTimeout = options.onTimeout;
+
+  self._heartbeatIntervalHandle = null;
+  self._heartbeatTimeoutHandle = null;
+};
+
+_.extend(Heartbeat.prototype, {
+  stop: function () {
+    var self = this;
+    self._clearHeartbeatIntervalTimer();
+    self._clearHeartbeatTimeoutTimer();
+  },
+
+  start: function () {
+    var self = this;
+    self.stop();
+    self._startHeartbeatIntervalTimer();
+  },
+
+  _startHeartbeatIntervalTimer: function () {
+    var self = this;
+    self._heartbeatIntervalHandle = Meteor.setTimeout(
+      _.bind(self._heartbeatIntervalFired, self),
+      self.heartbeatInterval
+    );
+  },
+
+  _startHeartbeatTimeoutTimer: function () {
+    var self = this;
+    self._heartbeatTimeoutHandle = Meteor.setTimeout(
+      _.bind(self._heartbeatTimeoutFired, self),
+      self.heartbeatTimeout
+    );
+  },
+
+  _clearHeartbeatIntervalTimer: function () {
+    var self = this;
+    if (self._heartbeatIntervalHandle) {
+      Meteor.clearTimeout(self._heartbeatIntervalHandle);
+      self._heartbeatIntervalHandle = null;
+    }
+  },
+
+  _clearHeartbeatTimeoutTimer: function () {
+    var self = this;
+    if (self._heartbeatTimeoutHandle) {
+      Meteor.clearTimeout(self._heartbeatTimeoutHandle);
+      self._heartbeatTimeoutHandle = null;
+    }
+  },
+
+  // The heartbeat interval timer is fired when we should send a ping.
+  _heartbeatIntervalFired: function () {
+    var self = this;
+    self._heartbeatIntervalHandle = null;
+    self._sendPing();
+    // Wait for a pong.
+    self._startHeartbeatTimeoutTimer();
+  },
+
+  // The heartbeat timeout timer is fired when we sent a ping, but we
+  // timed out waiting for the pong.
+  _heartbeatTimeoutFired: function () {
+    var self = this;
+    self._heartbeatTimeoutHandle = null;
+    self._onTimeout();
+  },
+
+  pingReceived: function () {
+    var self = this;
+    // We know the connection is alive if we receive a ping, so we
+    // don't need to send a ping ourselves.  Reset the interval timer.
+    if (self._heartbeatIntervalHandle) {
+      self._clearHeartbeatIntervalTimer();
+      self._startHeartbeatIntervalTimer();
+    }
+  },
+
+  pongReceived: function () {
+    var self = this;
+
+    // Receiving a pong means we won't timeout, so clear the timeout
+    // timer and start the interval again.
+    if (self._heartbeatTimeoutHandle) {
+      self._clearHeartbeatTimeoutTimer();
+      self._startHeartbeatIntervalTimer();
+    }
+  }
+});
diff --git a/packages/livedata/livedata_common.js b/packages/livedata/livedata_common.js
index f9a873c6f7..7bacf467c4 100644
--- a/packages/livedata/livedata_common.js
+++ b/packages/livedata/livedata_common.js
@@ -1,6 +1,6 @@
 DDP = {};
 
-SUPPORTED_DDP_VERSIONS = [ 'pre1' ];
+SUPPORTED_DDP_VERSIONS = [ 'pre2', 'pre1' ];
 
 LivedataTest.SUPPORTED_DDP_VERSIONS = SUPPORTED_DDP_VERSIONS;
 
@@ -31,6 +31,12 @@ MethodInvocation = function (options) {
 
   // On the server, the connection this method call came in on.
   this.connection = options.connection;
+
+  // The seed for randomStream value generation
+  this.randomSeed = options.randomSeed;
+
+  // This is set by RandomStream.get; and holds the random stream state
+  this.randomStream = null;
 };
 
 _.extend(MethodInvocation.prototype, {
diff --git a/packages/livedata/livedata_connection.js b/packages/livedata/livedata_connection.js
index be5b79e15c..abb717f0a5 100644
--- a/packages/livedata/livedata_connection.js
+++ b/packages/livedata/livedata_connection.js
@@ -31,10 +31,13 @@ var Connection = function (url, options) {
     onDDPVersionNegotiationFailure: function (description) {
       Meteor._debug(description);
     },
+    heartbeatInterval: 35000,
+    heartbeatTimeout: 15000,
     // These options are only for testing.
     reloadWithOutstanding: false,
     supportedDDPVersions: SUPPORTED_DDP_VERSIONS,
-    retry: true
+    retry: true,
+    respondToPings: true
   }, options);
 
   // If set, called when we reconnect, queuing method calls _before_ the
@@ -64,6 +67,9 @@ var Connection = function (url, options) {
   self._nextMethodId = 1;
   self._supportedDDPVersions = options.supportedDDPVersions;
 
+  self._heartbeatInterval = options.heartbeatInterval;
+  self._heartbeatTimeout = options.heartbeatTimeout;
+
   // Tracks methods which the user has tried to call but which have not yet
   // called their user callback (ie, they are waiting on their result or for all
   // of their writes to be written to the local cache). Map from method ID to
@@ -224,6 +230,17 @@ var Connection = function (url, options) {
         options.onDDPVersionNegotiationFailure(description);
       }
     }
+    else if (msg.msg === 'ping') {
+      if (options.respondToPings)
+        self._send({msg: "pong", id: msg.id});
+      if (self._heartbeat)
+        self._heartbeat.pingReceived();
+    }
+    else if (msg.msg === 'pong') {
+      if (self._heartbeat) {
+        self._heartbeat.pongReceived();
+      }
+    }
     else if (_.include(['added', 'changed', 'removed', 'ready', 'updated'], msg.msg))
       self._livedata_data(msg);
     else if (msg.msg === 'nosub')
@@ -291,12 +308,21 @@ var Connection = function (url, options) {
     });
   };
 
+  var onDisconnect = function () {
+    if (self._heartbeat) {
+      self._heartbeat.stop()
+      self._heartbeat = null;
+    }
+  };
+
   if (Meteor.isServer) {
     self._stream.on('message', Meteor.bindEnvironment(onMessage, Meteor._debug));
     self._stream.on('reset', Meteor.bindEnvironment(onReset, Meteor._debug));
+    self._stream.on('disconnect', Meteor.bindEnvironment(onDisconnect, Meteor._debug));
   } else {
     self._stream.on('message', onMessage);
     self._stream.on('reset', onReset);
+    self._stream.on('disconnect', onDisconnect);
   }
 };
 
@@ -493,7 +519,7 @@ _.extend(Connection.prototype, {
       self._subscriptions[id] = {
         id: id,
         name: name,
-        params: params,
+        params: EJSON.clone(params),
         inactive: false,
         ready: false,
         readyDeps: (typeof Deps !== "undefined") && new Deps.Dependency,
@@ -596,6 +622,17 @@ _.extend(Connection.prototype, {
   //   onResultReceived: Function - a callback to call as soon as the method
   //                                result is received. the data written by
   //                                the method may not yet be in the cache!
+  //   returnStubValue: Boolean - If true then in cases where we would have
+  //                              otherwise discarded the stub's return value
+  //                              and returned undefined, instead we go ahead
+  //                              and return it.  Specifically, this is any
+  //                              time other than when (a) we are already
+  //                              inside a stub or (b) we are in Node and no
+  //                              callback was provided.  Currently we require
+  //                              this flag to be explicitly passed to reduce
+  //                              the likelihood that stub return values will
+  //                              be confused with server return values; we
+  //                              may improve this in future.
   // @param callback {Optional Function}
   apply: function (name, args, options, callback) {
     var self = this;
@@ -618,6 +655,10 @@ _.extend(Connection.prototype, {
       );
     }
 
+    // Keep our args safe from mutation (eg if we don't send the message for a
+    // while because of a wait method).
+    args = EJSON.clone(args);
+
     // Lazily allocate method ID once we know that it'll be needed.
     var methodId = (function () {
       var id;
@@ -628,6 +669,27 @@ _.extend(Connection.prototype, {
       };
     })();
 
+    var enclosing = DDP._CurrentInvocation.get();
+    var alreadyInSimulation = enclosing && enclosing.isSimulation;
+
+    // Lazily generate a randomSeed, only if it is requested by the stub.
+    // The random streams only have utility if they're used on both the client
+    // and the server; if the client doesn't generate any 'random' values
+    // then we don't expect the server to generate any either.
+    // Less commonly, the server may perform different actions from the client,
+    // and may in fact generate values where the client did not, but we don't
+    // have any client-side values to match, so even here we may as well just
+    // use a random seed on the server.  In that case, we don't pass the
+    // randomSeed to save bandwidth, and we don't even generate it to save a
+    // bit of CPU and to avoid consuming entropy.
+    var randomSeed = null;
+    var randomSeedGenerator = function () {
+      if (randomSeed === null) {
+        randomSeed = makeRpcSeed(enclosing, name);
+      }
+      return randomSeed;
+    };
+
     // Run the stub, if we have one. The stub is supposed to make some
     // temporary writes to the database to give the user a smooth experience
     // until the actual result of executing the method comes back from the
@@ -640,18 +702,17 @@ _.extend(Connection.prototype, {
     // to do a RPC, so we use the return value of the stub as our return
     // value.
 
-    var enclosing = DDP._CurrentInvocation.get();
-    var alreadyInSimulation = enclosing && enclosing.isSimulation;
-
     var stub = self._methodHandlers[name];
     if (stub) {
       var setUserId = function(userId) {
         self.setUserId(userId);
       };
+
       var invocation = new MethodInvocation({
         isSimulation: true,
         userId: self.userId(),
-        setUserId: setUserId
+        setUserId: setUserId,
+        randomSeed: function () { return randomSeedGenerator(); }
       });
 
       if (!alreadyInSimulation)
@@ -660,11 +721,12 @@ _.extend(Connection.prototype, {
       try {
         // Note that unlike in the corresponding server code, we never audit
         // that stubs check() their arguments.
-        var ret = DDP._CurrentInvocation.withValue(invocation, function () {
+        var stubReturnValue = DDP._CurrentInvocation.withValue(invocation, function () {
           if (Meteor.isServer) {
             // Because saveOriginals and retrieveOriginals aren't reentrant,
             // don't allow stubs to yield.
             return Meteor._noYieldsAllowed(function () {
+              // re-clone, so that the stub can't affect our caller's values
               return stub.apply(invocation, EJSON.clone(args));
             });
           } else {
@@ -685,12 +747,12 @@ _.extend(Connection.prototype, {
     // we'll end up returning undefined.
     if (alreadyInSimulation) {
       if (callback) {
-        callback(exception, ret);
+        callback(exception, stubReturnValue);
         return undefined;
       }
       if (exception)
         throw exception;
-      return ret;
+      return stubReturnValue;
     }
 
     // If an exception occurred in a stub, and we're ignoring it
@@ -725,18 +787,25 @@ _.extend(Connection.prototype, {
     // Send the RPC. Note that on the client, it is important that the
     // stub have finished before we send the RPC, so that we know we have
     // a complete list of which local documents the stub wrote.
+    var message = {
+      msg: 'method',
+      method: name,
+      params: args,
+      id: methodId()
+    };
+
+    // Send the randomSeed only if we used it
+    if (randomSeed !== null) {
+      message.randomSeed = randomSeed;
+    }
+
     var methodInvoker = new MethodInvoker({
       methodId: methodId(),
       callback: callback,
       connection: self,
       onResultReceived: options.onResultReceived,
       wait: !!options.wait,
-      message: {
-        msg: 'method',
-        method: name,
-        params: args,
-        id: methodId()
-      }
+      message: message
     });
 
     if (options.wait) {
@@ -761,7 +830,7 @@ _.extend(Connection.prototype, {
     if (future) {
       return future.wait();
     }
-    return undefined;
+    return options.returnStubValue ? stubReturnValue : undefined;
   },
 
   // Before calling a method stub, prepare all stores to track changes and allow
@@ -834,6 +903,14 @@ _.extend(Connection.prototype, {
     self._stream.send(stringifyDDP(obj));
   },
 
+  // We detected via DDP-level heartbeats that we've lost the
+  // connection.  Unlike `disconnect` or `close`, a lost connection
+  // will be automatically retried.
+  _lostConnection: function () {
+    var self = this;
+    self._stream._lostConnection();
+  },
+
   status: function (/*passthrough args*/) {
     var self = this;
     return self._stream.status.apply(self._stream, arguments);
@@ -893,6 +970,28 @@ _.extend(Connection.prototype, {
   _livedata_connected: function (msg) {
     var self = this;
 
+    if (self._version !== 'pre1' && self._heartbeatInterval !== 0) {
+      self._heartbeat = new Heartbeat({
+        heartbeatInterval: self._heartbeatInterval,
+        heartbeatTimeout: self._heartbeatTimeout,
+        onTimeout: function () {
+          if (Meteor.isClient) {
+            // only print on the client. this message is useful on the
+            // browser console to see that we've lost connection. on the
+            // server (eg when doing server-to-server DDP), it gets
+            // kinda annoying. also this matches the behavior with
+            // sockjs timeouts.
+            Meteor._debug("Connection timeout. No DDP heartbeat received.");
+          }
+          self._lostConnection();
+        },
+        sendPing: function () {
+          self._send({msg: 'ping'});
+        }
+      });
+      self._heartbeat.start();
+    }
+
     // If this is a reconnect, we'll have to reset all stores.
     if (self._lastSessionId)
       self._resetStores = true;
diff --git a/packages/livedata/livedata_connection_tests.js b/packages/livedata/livedata_connection_tests.js
index b37e3d97a7..1c404669b6 100644
--- a/packages/livedata/livedata_connection_tests.js
+++ b/packages/livedata/livedata_connection_tests.js
@@ -17,12 +17,16 @@ var makeConnectMessage = function (session) {
   return msg;
 }
 
+// Tests that stream got a message that matches expected.
+// Expected is normally an object, and allows a wildcard value of '*',
+// which will then match any value.
+// Returns the message (parsed as a JSON object if expected is an object);
+// which is particularly handy if you want to extract a value that was
+// matched as a wildcard.
 var testGotMessage = function (test, stream, expected) {
-  var retVal = undefined;
-
   if (stream.sent.length === 0) {
     test.fail({error: 'no message received', expected: expected});
-    return retVal;
+    return undefined;
   }
 
   var got = stream.sent.shift();
@@ -42,17 +46,10 @@ var testGotMessage = function (test, stream, expected) {
     _.each(keysWithStarValues, function (k) {
       expected[k] = got[k];
     });
-    if (keysWithStarValues.length === 1) {
-      retVal = got[keysWithStarValues[0]];
-    } else {
-      retVal = _.map(keysWithStarValues, function (k) {
-        return got[k];
-      });
-    }
   }
 
   test.equal(got, expected);
-  return retVal;
+  return got;
 };
 
 var startAndConnect = function(test, stream) {
@@ -275,6 +272,7 @@ Tinytest.add("livedata stub - this", function (test) {
   conn.call('test_this', _.identity);
   // satisfy method, quiesce connection
   var message = JSON.parse(stream.sent.shift());
+  test.isUndefined(message.randomSeed);
   test.equal(message, {msg: 'method', method: 'test_this',
                        params: [], id:message.id});
   test.length(stream.sent, 0);
@@ -322,9 +320,11 @@ if (Meteor.isClient) {
     test.equal(counts, {added: 1, removed: 0, changed: 0, moved: 0});
 
     // get response from server
-    var message = JSON.parse(stream.sent.shift());
-    test.equal(message, {msg: 'method', method: 'do_something',
-                         params: ['friday!'], id:message.id});
+    var message = testGotMessage(test, stream, {msg: 'method',
+                                                method: 'do_something',
+                                                params: ['friday!'],
+                                                id: '*',
+                                                randomSeed: '*'});
 
     test.equal(coll.find({}).count(), 1);
     test.equal(coll.find({value: 'friday!'}).count(), 1);
@@ -357,6 +357,7 @@ if (Meteor.isClient) {
 
     // test we still send a method request to server
     var message2 = JSON.parse(stream.sent.shift());
+    test.isUndefined(message2.randomSeed);
     test.equal(message2, {msg: 'method', method: 'do_something_else',
                           params: ['monday'], id: message2.id});
 
@@ -401,6 +402,7 @@ Tinytest.add("livedata stub - mutating method args", function (test) {
 
   // Method should be called with original arg, not mutated arg.
   var message = JSON.parse(stream.sent.shift());
+  test.isUndefined(message.randomSeed);
   test.equal(message, {msg: 'method', method: 'mutateArgs',
                        params: [{foo: 50}], id: message.id});
   test.length(stream.sent, 0);
@@ -453,9 +455,11 @@ if (Meteor.isClient) {
     conn.call('do_something', _.identity);
 
     // see we only send message for outer methods
-    var message = JSON.parse(stream.sent.shift());
-    test.equal(message, {msg: 'method', method: 'do_something',
-                         params: [], id:message.id});
+    var message = testGotMessage(test, stream, {msg: 'method',
+                                                method: 'do_something',
+                                                params: [],
+                                                id: '*',
+                                                randomSeed: '*'});
     test.length(stream.sent, 0);
 
     // but inner method runs locally.
@@ -566,6 +570,7 @@ Tinytest.add("livedata stub - reconnect", function (test) {
 
   // The non-wait method should send, but not the wait method.
   var methodMessage = JSON.parse(stream.sent.shift());
+  test.isUndefined(methodMessage.randomSeed);
   test.equal(methodMessage, {msg: 'method', method: 'do_something',
                              params: [], id:methodMessage.id});
   test.equal(stream.sent.length, 0);
@@ -623,6 +628,7 @@ Tinytest.add("livedata stub - reconnect", function (test) {
   o.expectCallbacks({added: 1, changed: 1});
 
   var waitMethodMessage = JSON.parse(stream.sent.shift());
+  test.isUndefined(waitMethodMessage.randomSeed);
   test.equal(waitMethodMessage, {msg: 'method', method: 'do_something_else',
                                  params: [], id: waitMethodMessage.id});
   test.equal(stream.sent.length, 0);
@@ -633,6 +639,7 @@ Tinytest.add("livedata stub - reconnect", function (test) {
   // wait method done means we can send the third method
   test.equal(stream.sent.length, 1);
   var laterMethodMessage = JSON.parse(stream.sent.shift());
+  test.isUndefined(laterMethodMessage.randomSeed);
   test.equal(laterMethodMessage, {msg: 'method', method: 'do_something_later',
                                   params: [], id: laterMethodMessage.id});
 
@@ -677,7 +684,7 @@ if (Meteor.isClient) {
     // Method sent.
     var methodId = testGotMessage(
       test, stream, {msg: 'method', method: 'writeSomething',
-                     params: [], id: '*'});
+                     params: [], id: '*', randomSeed: '*'}).id;
     test.equal(stream.sent.length, 0);
 
     // Get some data.
@@ -744,7 +751,7 @@ if (Meteor.isClient) {
     // Method sent.
     var methodId2 = testGotMessage(
       test, stream, {msg: 'method', method: 'writeSomething',
-                     params: [], id: '*'});
+                     params: [], id: '*', randomSeed: '*'}).id;
     test.equal(stream.sent.length, 0);
 
     // Get some data.
@@ -777,7 +784,7 @@ if (Meteor.isClient) {
     testGotMessage(test, stream, makeConnectMessage(SESSION_ID + 1));
     var slowMethodId = testGotMessage(
       test, stream,
-      {msg: 'method', method: 'slowMethod', params: [], id: '*'});
+      {msg: 'method', method: 'slowMethod', params: [], id: '*'}).id;
     // Still holding out hope for session resumption, so nothing updated yet.
     test.equal(coll.find().count(), 2);
     test.equal(coll.findOne(stubWrittenId2), {_id: stubWrittenId2, foo: 'bar'});
@@ -840,7 +847,7 @@ Tinytest.add("livedata stub - reconnect method which only got data", function (t
   // Method sent.
   var methodId = testGotMessage(
     test, stream, {msg: 'method', method: 'doLittle',
-                   params: [], id: '*'});
+                   params: [], id: '*'}).id;
   test.equal(stream.sent.length, 0);
 
   // Get some data.
@@ -930,7 +937,7 @@ if (Meteor.isClient) {
     // Method sent.
     var insertMethodId = testGotMessage(
       test, stream, {msg: 'method', method: 'insertSomething',
-                     params: [], id: '*'});
+                     params: [], id: '*', randomSeed: '*'}).id;
     test.equal(stream.sent.length, 0);
 
     // Call update method.
@@ -943,7 +950,7 @@ if (Meteor.isClient) {
     // Method sent.
     var updateMethodId = testGotMessage(
       test, stream, {msg: 'method', method: 'updateIt',
-                     params: [stubWrittenId], id: '*'});
+                     params: [stubWrittenId], id: '*'}).id;
     test.equal(stream.sent.length, 0);
 
     // Get some data... slightly different than what we wrote.
@@ -1019,7 +1026,7 @@ if (Meteor.isClient) {
     // first method sent
     var firstMethodId = testGotMessage(
       test, stream, {msg: 'method', method: 'no-op',
-                     params: [], id: '*'});
+                     params: [], id: '*'}).id;
     test.equal(stream.sent.length, 0);
 
     // ack the first method
@@ -1029,7 +1036,7 @@ if (Meteor.isClient) {
     // Wait method sent.
     var waitMethodId = testGotMessage(
       test, stream, {msg: 'method', method: 'no-op',
-                     params: [], id: '*'});
+                     params: [], id: '*'}).id;
     test.equal(stream.sent.length, 0);
 
     // ack the wait method
@@ -1039,7 +1046,7 @@ if (Meteor.isClient) {
     // insert method sent.
     var insertMethodId = testGotMessage(
       test, stream, {msg: 'method', method: 'insertSomething',
-                     params: [], id: '*'});
+                     params: [], id: '*', randomSeed: '*'}).id;
     test.equal(stream.sent.length, 0);
 
     // ack the insert method
@@ -1285,6 +1292,25 @@ Tinytest.add("livedata connection - onReconnect prepends messages correctly with
   ]);
 });
 
+Tinytest.add("livedata connection - ping without id", function (test) {
+  var stream = new StubStream();
+  var conn = newConnection(stream);
+  startAndConnect(test, stream);
+
+  stream.receive({msg: 'ping'});
+  testGotMessage(test, stream, {msg: 'pong'});
+});
+
+Tinytest.add("livedata connection - ping with id", function (test) {
+  var stream = new StubStream();
+  var conn = newConnection(stream);
+  startAndConnect(test, stream);
+
+  var id = Random.id();
+  stream.receive({msg: 'ping', id: id});
+  testGotMessage(test, stream, {msg: 'pong', id: id});
+});
+
 var getSelfConnectionUrl = function () {
   if (Meteor.isClient) {
     return Meteor._relativeToSiteRootUrl("/");
@@ -1429,7 +1455,7 @@ Tinytest.add("livedata connection - onReconnect with sent messages", function(te
   // Test that we sent just the login message.
   var loginId = testGotMessage(
     test, stream, {msg: 'method', method: 'do_something',
-                   params: ['login'], id: '*'});
+                   params: ['login'], id: '*'}).id;
 
   // we connect.
   stream.receive({msg: 'connected', session: Random.id()});
@@ -1444,7 +1470,7 @@ Tinytest.add("livedata connection - onReconnect with sent messages", function(te
 
   testGotMessage(
     test, stream, {msg: 'method', method: 'do_something',
-                   params: ['one'], id: '*'});
+                   params: ['one'], id: '*'}).id;
 });
 
 
@@ -1469,7 +1495,7 @@ Tinytest.add("livedata stub - reconnect double wait method", function (test) {
   // Method sent.
   var halfwayId = testGotMessage(
     test, stream, {msg: 'method', method: 'halfwayMethod',
-                   params: [], id: '*'});
+                   params: [], id: '*'}).id;
   test.equal(stream.sent.length, 0);
 
   // Get the result. This means it will not be resent.
@@ -1483,7 +1509,7 @@ Tinytest.add("livedata stub - reconnect double wait method", function (test) {
   testGotMessage(test, stream, makeConnectMessage(SESSION_ID));
   var reconnectId = testGotMessage(
     test, stream, {msg: 'method', method: 'reconnectMethod',
-                   params: [], id: '*'});
+                   params: [], id: '*'}).id;
   test.length(stream.sent, 0);
   // Still holding out hope for session resumption, so no callbacks yet.
   test.equal(output, []);
@@ -1574,6 +1600,7 @@ if (Meteor.isClient) {
     test.equal(coll.findOne(), {_id: "foo", bar: 42});
     // It also sends the method message.
     var methodMessage = JSON.parse(stream.sent.shift());
+    test.isUndefined(methodMessage.randomSeed);
     test.equal(methodMessage, {msg: 'method', method: '/' + collName + '/insert',
                                params: [{_id: "foo", bar: 42}],
                                id: methodMessage.id});
diff --git a/packages/livedata/livedata_server.js b/packages/livedata/livedata_server.js
index cbdd29ae63..fff6114866 100644
--- a/packages/livedata/livedata_server.js
+++ b/packages/livedata/livedata_server.js
@@ -216,7 +216,7 @@ _.extend(SessionCollectionView.prototype, {
 /* Session                                                                    */
 /******************************************************************************/
 
-var Session = function (server, version, socket) {
+var Session = function (server, version, socket, options) {
   var self = this;
   self.id = Random.id();
 
@@ -262,13 +262,16 @@ var Session = function (server, version, socket) {
   // temporary and will go away in the near future.
   self._socketUrl = socket.url;
 
+  // Allow tests to disable responding to pings.
+  self._respondToPings = options.respondToPings;
+
   // This object is the public interface to the session. In the public
   // API, it is called the `connection` object.  Internally we call it
   // a `connectionHandle` to avoid ambiguity.
   self.connectionHandle = {
     id: self.id,
     close: function () {
-      self.server._closeSession(self);
+      self.close();
     },
     onClose: function (fn) {
       var cb = Meteor.bindEnvironment(fn, "connection onClose callback");
@@ -290,6 +293,20 @@ var Session = function (server, version, socket) {
     self.startUniversalSubs();
   }).run();
 
+  if (version !== 'pre1' && options.heartbeatInterval !== 0) {
+    self.heartbeat = new Heartbeat({
+      heartbeatInterval: options.heartbeatInterval,
+      heartbeatTimeout: options.heartbeatTimeout,
+      onTimeout: function () {
+        self.destroy();
+      },
+      sendPing: function () {
+        self.send({msg: 'ping'});
+      }
+    });
+    self.heartbeat.start();
+  }
+
   Package.facts && Package.facts.Facts.incrementServerFact(
     "livedata", "sessions", 1);
 };
@@ -391,6 +408,15 @@ _.extend(Session.prototype, {
   destroy: function () {
     var self = this;
 
+    // Already destroyed.
+    if (!self.inQueue)
+      return;
+
+    if (self.heartbeat) {
+      self.heartbeat.stop();
+      self.heartbeat = null;
+    }
+
     if (self.socket) {
       self.socket.close();
       self.socket._meteorSession = null;
@@ -417,6 +443,19 @@ _.extend(Session.prototype, {
     });
   },
 
+  // Destroy this session and unregister it at the server.
+  close: function () {
+    var self = this;
+
+    // Unconditionally destroy this session, even if it's not
+    // registered at the server.
+    self.destroy();
+
+    // Unregister the session.  This will also call `destroy`, but
+    // that's OK because `destroy` is idempotent.
+    self.server._closeSession(self);
+  },
+
   // Send a message (doing nothing if no socket is connected right now.)
   // It should be a JSON object (it will be stringified.)
   send: function (msg) {
@@ -457,6 +496,32 @@ _.extend(Session.prototype, {
     if (!self.inQueue) // we have been destroyed.
       return;
 
+    // Respond to ping and pong messages immediately without queuing.
+    // If the negotiated DDP version is "pre1" which didn't support
+    // pings, preserve the "pre1" behavior of responding with a "bad
+    // request" for the unknown messages.
+    //
+    // Fibers are needed because heartbeat uses Meteor.setTimeout, which
+    // needs a Fiber. We could actually use regular setTimeout and avoid
+    // these new fibers, but it is easier to just make everything use
+    // Meteor.setTimeout and not think too hard.
+    if (self.version !== 'pre1' && msg_in.msg === 'ping') {
+      if (self._respondToPings)
+        self.send({msg: "pong", id: msg_in.id});
+      if (self.heartbeat)
+        Fiber(function () {
+          self.heartbeat.pingReceived();
+        }).run();
+      return;
+    }
+    if (self.version !== 'pre1' && msg_in.msg === 'pong') {
+      if (self.heartbeat)
+        Fiber(function () {
+          self.heartbeat.pongReceived();
+        }).run();
+      return;
+    }
+
     self.inQueue.push(msg_in);
     if (self.workerRunning)
       return;
@@ -530,14 +595,18 @@ _.extend(Session.prototype, {
       var self = this;
 
       // reject malformed messages
-      // XXX should also reject messages with unknown attributes?
+      // For now, we silently ignore unknown attributes,
+      // for forwards compatibility.
       if (typeof (msg.id) !== "string" ||
           typeof (msg.method) !== "string" ||
-          (('params' in msg) && !(msg.params instanceof Array))) {
+          (('params' in msg) && !(msg.params instanceof Array)) ||
+          (('randomSeed' in msg) && (typeof msg.randomSeed !== "string"))) {
         self.sendError("Malformed method invocation", msg);
         return;
       }
 
+      var randomSeed = msg.randomSeed || null;
+
       // set up to mark the method as satisfied once all observers
       // (and subscriptions) have reacted to any writes that were
       // done.
@@ -572,7 +641,8 @@ _.extend(Session.prototype, {
         userId: self.userId,
         setUserId: setUserId,
         unblock: unblock,
-        connection: self.connectionHandle
+        connection: self.connectionHandle,
+        randomSeed: randomSeed
       });
       try {
         var result = DDPServer._CurrentWriteFence.withValue(fence, function () {
@@ -1047,9 +1117,20 @@ _.extend(Subscription.prototype, {
 /* Server                                                                     */
 /******************************************************************************/
 
-Server = function () {
+Server = function (options) {
   var self = this;
 
+  // The default heartbeat interval is 30 seconds on the server and 35
+  // seconds on the client.  Since the client doesn't need to send a
+  // ping as long as it is receiving pings, this means that pings
+  // normally go from the server to the client.
+  self.options = _.defaults(options || {}, {
+    heartbeatInterval: 30000,
+    heartbeatTimeout: 15000,
+    // For testing, allow responding to pings to be disabled.
+    respondToPings: true
+  });
+
   // Map of callbacks to call when a new connection comes in to the
   // server and completes DDP version negotiation. Use an object instead
   // of an array so we can safely remove one from the list while
@@ -1120,7 +1201,7 @@ Server = function () {
     socket.on('close', function () {
       if (socket._meteorSession) {
         Fiber(function () {
-          self._closeSession(socket._meteorSession);
+          socket._meteorSession.close();
         }).run();
       }
     });
@@ -1142,7 +1223,7 @@ _.extend(Server.prototype, {
 
     if (msg.version === version) {
       // Creating a new session
-      socket._meteorSession = new Session(self, version, socket);
+      socket._meteorSession = new Session(self, version, socket, self.options);
       self.sessions[socket._meteorSession.id] = socket._meteorSession;
       self.onConnectionHook.each(function (callback) {
         if (socket._meteorSession)
@@ -1318,12 +1399,14 @@ _.extend(Server.prototype, {
         isSimulation: false,
         userId: userId,
         setUserId: setUserId,
-        connection: connection
+        connection: connection,
+        randomSeed: makeRpcSeed(currentInvocation, name)
       });
       try {
         var result = DDP._CurrentInvocation.withValue(invocation, function () {
           return maybeAuditArgumentChecks(
-            handler, invocation, args, "internal call to '" + name + "'");
+            handler, invocation, EJSON.clone(args), "internal call to '" +
+              name + "'");
         });
       } catch (e) {
         exception = e;
diff --git a/packages/livedata/package.js b/packages/livedata/package.js
index 5594a28beb..9211cd6909 100644
--- a/packages/livedata/package.js
+++ b/packages/livedata/package.js
@@ -52,6 +52,7 @@ Package.on_use(function (api) {
   // _idParse, _idStringify.
   api.use('minimongo', ['client', 'server']);
 
+  api.add_files('heartbeat.js', ['client', 'server']);
 
   api.add_files('livedata_server.js', 'server');
 
@@ -59,6 +60,7 @@ Package.on_use(function (api) {
   api.add_files('crossbar.js', 'server');
 
   api.add_files('livedata_common.js', ['client', 'server']);
+  api.add_files('random_stream.js', ['client', 'server']);
 
   api.add_files('livedata_connection.js', ['client', 'server']);
 
@@ -80,6 +82,7 @@ Package.on_test(function (api) {
   api.add_files('livedata_test_service.js', ['client', 'server']);
   api.add_files('session_view_tests.js', ['server']);
   api.add_files('crossbar_tests.js', ['server']);
+  api.add_files('random_stream_tests.js', ['client', 'server']);
 
   api.use('http', 'client');
   api.add_files(['stream_tests.js'], 'client');
diff --git a/packages/livedata/random_stream.js b/packages/livedata/random_stream.js
new file mode 100644
index 0000000000..b09a6eda2e
--- /dev/null
+++ b/packages/livedata/random_stream.js
@@ -0,0 +1,103 @@
+// RandomStream allows for generation of pseudo-random values, from a seed.
+//
+// We use this for consistent 'random' numbers across the client and server.
+// We want to generate probably-unique IDs on the client, and we ideally want
+// the server to generate the same IDs when it executes the method.
+//
+// For generated values to be the same, we must seed ourselves the same way,
+// and we must keep track of the current state of our pseudo-random generators.
+// We call this state the scope. By default, we use the current DDP method
+// invocation as our scope.  DDP now allows the client to specify a randomSeed.
+// If a randomSeed is provided it will be used to seed our random sequences.
+// In this way, client and server method calls will generate the same values.
+//
+// We expose multiple named streams; each stream is independent
+// and is seeded differently (but predictably from the name).
+// By using multiple streams, we support reordering of requests,
+// as long as they occur on different streams.
+//
+// @param options {Optional Object}
+//   seed: Array or value - Seed value(s) for the generator.
+//                          If an array, will be used as-is
+//                          If a value, will be converted to a single-value array
+//                          If omitted, a random array will be used as the seed.
+RandomStream = function (options) {
+  var self = this;
+
+  this.seed = [].concat(options.seed || randomToken());
+
+  this.sequences = {};
+};
+
+// Returns a random string of sufficient length for a random seed.
+// This is a placeholder function; a similar function is planned
+// for Random itself; when that is added we should remove this function,
+// and call Random's randomToken instead.
+function randomToken() {
+  return Random.hexString(20);
+};
+
+// Returns the random stream with the specified name, in the specified scope.
+// If scope is null (or otherwise falsey) then we will use Random, which will
+// give us as random numbers as possible, but won't produce the same
+// values across client and server.
+// However, scope will normally be the current DDP method invocation, so
+// we'll use the stream with the specified name, and we should get consistent
+// values on the client and server sides of a method call.
+RandomStream.get = function (scope, name) {
+  if (!name) {
+    name = "default";
+  }
+  if (!scope) {
+    // There was no scope passed in;
+    // the sequence won't actually be reproducible.
+    return Random;
+  }
+  var randomStream = scope.randomStream;
+  if (!randomStream) {
+    scope.randomStream = randomStream = new RandomStream({
+      seed: scope.randomSeed
+    });
+  }
+  return randomStream._sequence(name);
+};
+
+// Returns the named sequence of pseudo-random values.
+// The scope will be DDP._CurrentInvocation.get(), so the stream will produce
+// consistent values for method calls on the client and server.
+DDP.randomStream = function (name) {
+  var scope = DDP._CurrentInvocation.get();
+  return RandomStream.get(scope, name);
+};
+
+// Creates a randomSeed for passing to a method call.
+// Note that we take enclosing as an argument,
+// though we expect it to be DDP._CurrentInvocation.get()
+// However, we often evaluate makeRpcSeed lazily, and thus the relevant
+// invocation may not be the one currently in scope.
+// If enclosing is null, we'll use Random and values won't be repeatable.
+makeRpcSeed = function (enclosing, methodName) {
+  var stream = RandomStream.get(enclosing, '/rpc/' + methodName);
+  return stream.hexString(20);
+};
+
+_.extend(RandomStream.prototype, {
+  // Get a random sequence with the specified name, creating it if does not exist.
+  // New sequences are seeded with the seed concatenated with the name.
+  // By passing a seed into Random.create, we use the Alea generator.
+  _sequence: function (name) {
+    var self = this;
+
+    var sequence = self.sequences[name] || null;
+    if (sequence === null) {
+      var sequenceSeed = self.seed.concat(name);
+      for (var i = 0; i < sequenceSeed.length; i++) {
+        if (_.isFunction(sequenceSeed[i])) {
+          sequenceSeed[i] = sequenceSeed[i]();
+        }
+      }
+      self.sequences[name] = sequence = Random.createWithSeeds.apply(null, sequenceSeed);
+    }
+    return sequence;
+  }
+});
diff --git a/packages/livedata/random_stream_tests.js b/packages/livedata/random_stream_tests.js
new file mode 100644
index 0000000000..67f95f1e8e
--- /dev/null
+++ b/packages/livedata/random_stream_tests.js
@@ -0,0 +1,44 @@
+Tinytest.add("livedata - DDP.randomStream", function (test) {
+  var randomSeed = Random.id();
+  var context = { randomSeed: randomSeed };
+
+  var sequence = DDP._CurrentInvocation.withValue(context, function () {
+    return DDP.randomStream('1');
+  });
+
+  var seeds = sequence.alea.args;
+
+  test.equal(seeds.length, 2);
+  test.equal(seeds[0], randomSeed);
+  test.equal(seeds[1], '1');
+
+  var id1 = sequence.id();
+
+  // Clone the sequence by building it the same way RandomStream.get does
+  var sequenceClone = Random.createWithSeeds.apply(null, seeds);
+  var id1Cloned = sequenceClone.id();
+  var id2Cloned = sequenceClone.id();
+  test.equal(id1, id1Cloned);
+
+  // We should get the same sequence when we use the same key
+  sequence = DDP._CurrentInvocation.withValue(context, function () {
+    return DDP.randomStream('1');
+  });
+  seeds = sequence.alea.args;
+  test.equal(seeds.length, 2);
+  test.equal(seeds[0], randomSeed);
+  test.equal(seeds[1], '1');
+
+  // But we should be at the 'next' position in the stream
+  var id2 = sequence.id();
+
+  // Technically these could be equal, but likely to be a bug if hit
+  // http://search.dilbert.com/comic/Random%20Number%20Generator
+  test.notEqual(id1, id2);
+
+  test.equal(id2, id2Cloned);
+});
+
+Tinytest.add("livedata - DDP.randomStream with no-args", function (test) {
+  DDP.randomStream().id();
+});
diff --git a/packages/livedata/stream_client_common.js b/packages/livedata/stream_client_common.js
index 6f551ca424..cdc9092811 100644
--- a/packages/livedata/stream_client_common.js
+++ b/packages/livedata/stream_client_common.js
@@ -87,7 +87,7 @@ _.extend(LivedataTest.ClientStream.prototype, {
   on: function (name, callback) {
     var self = this;
 
-    if (name !== 'message' && name !== 'reset')
+    if (name !== 'message' && name !== 'reset' && name !== 'disconnect')
       throw new Error("unknown event type: " + name);
 
     if (!self.eventCallbacks[name])
diff --git a/packages/livedata/stream_client_nodejs.js b/packages/livedata/stream_client_nodejs.js
index a3bc996d27..718ee3fe41 100644
--- a/packages/livedata/stream_client_nodejs.js
+++ b/packages/livedata/stream_client_nodejs.js
@@ -96,6 +96,8 @@ _.extend(LivedataTest.ClientStream.prototype, {
       self.client = null;
       client.close();
     }
+
+    _.each(self.eventCallbacks.disconnect, function (callback) { callback(); });
   },
 
   _clearConnectionTimer: function () {
diff --git a/packages/livedata/stream_client_sockjs.js b/packages/livedata/stream_client_sockjs.js
index 3f42a76371..b7e39a13a4 100644
--- a/packages/livedata/stream_client_sockjs.js
+++ b/packages/livedata/stream_client_sockjs.js
@@ -12,13 +12,15 @@ LivedataTest.ClientStream = function (url, options) {
 
 
   // how long between hearing heartbeat from the server until we declare
-  // the connection dead. heartbeats come every 25s (stream_server.js)
+  // the connection dead. heartbeats come every 45s (stream_server.js)
   //
-  // NOTE: this is a workaround until sockjs detects heartbeats on the
-  // client automatically.
-  // https://github.com/sockjs/sockjs-client/issues/67
-  // https://github.com/sockjs/sockjs-node/issues/68
-  self.HEARTBEAT_TIMEOUT = 60000;
+  // NOTE: this is a older timeout mechanism. We now send heartbeats at
+  // the DDP level (https://github.com/meteor/meteor/pull/1865), and
+  // expect those timeouts to kill a non-responsive connection before
+  // this timeout fires. This is kept around for compatibility (when
+  // talking to a server that doesn't support DDP heartbeats) and can be
+  // removed later.
+  self.HEARTBEAT_TIMEOUT = 100*1000;
 
   self.rawUrl = url;
   self.socket = null;
@@ -88,6 +90,8 @@ _.extend(LivedataTest.ClientStream.prototype, {
       self.socket.close();
       self.socket = null;
     }
+
+    _.each(self.eventCallbacks.disconnect, function (callback) { callback(); });
   },
 
   _clearConnectionAndHeartbeatTimers: function () {
@@ -104,7 +108,7 @@ _.extend(LivedataTest.ClientStream.prototype, {
 
   _heartbeat_timeout: function () {
     var self = this;
-    Meteor._debug("Connection timeout. No heartbeat received.");
+    Meteor._debug("Connection timeout. No sockjs heartbeat received.");
     self._lostConnection();
   },
 
diff --git a/packages/livedata/stream_server.js b/packages/livedata/stream_server.js
index f344085380..83dffadb59 100644
--- a/packages/livedata/stream_server.js
+++ b/packages/livedata/stream_server.js
@@ -23,7 +23,7 @@ StreamServer = function () {
     log: function() {},
     // this is the default, but we code it explicitly because we depend
     // on it in stream_client:HEARTBEAT_TIMEOUT
-    heartbeat_delay: 25000,
+    heartbeat_delay: 45000,
     // The default disconnect_delay is 5 seconds, but if the server ends up CPU
     // bound for that much time, SockJS might not notice that the user has
     // reconnected because the timer (of disconnect_delay ms) can fire before
diff --git a/packages/livedata/stub_stream.js b/packages/livedata/stub_stream.js
index 1442024819..54e75c8367 100644
--- a/packages/livedata/stub_stream.js
+++ b/packages/livedata/stub_stream.js
@@ -30,6 +30,9 @@ _.extend(StubStream.prototype, {
     // no-op
   },
 
+  _lostConnection: function () {
+    // no-op
+  },
 
   // Methods for tests
   receive: function (data) {
diff --git a/packages/liverange/liverange.js b/packages/liverange/liverange.js
deleted file mode 100644
index 42def4b4b5..0000000000
--- a/packages/liverange/liverange.js
+++ /dev/null
@@ -1,682 +0,0 @@
-// Stand back, I'm going to try SCIENCE.
-
-// Possible optimization: get rid of _startIndex/_endIndex and just search
-// the list. Not clear which strategy will be faster.
-
-// Possible extension: could allow zero-length ranges is some cases,
-// by encoding both 'enter' and 'leave' type events in the same list
-
-var canSetTextProps = (function () {
-  // IE8 and earlier don't support expando attributes on text nodes,
-  // but fortunately they are allowed on comments.
-  var testElem = document.createTextNode("");
-  var exception;
-  try {
-    testElem.test = 123;
-  } catch (exception) { }
-  if (testElem.test !== 123)
-    return false;
-
-  // IE9 and 10 have a weird issue with multiple text nodes next to
-  // each other losing their expando attributes. Use the same
-  // workaround as IE8. Not sure how to test this as a feature, so use
-  // browser detection instead.
-  // See https://github.com/meteor/meteor/issues/458
-  if (document.documentMode)
-    return false;
-
-  return true;
-})();
-
-var wrapEndpoints = function (start, end) {
-  if (canSetTextProps) {
-    return [start, end];
-  } else {
-    // IE8 workaround: insert some empty comments.
-    // Comments whose text is "IE" are stripped out
-    // in cross-browser testing.
-    if (start.nodeType === 3 /* text node */) {
-      var placeholder = document.createComment("IE");
-      start.parentNode.insertBefore(placeholder, start);
-      start = placeholder;
-    }
-    if (end.nodeType === 3 /* text node */) {
-      var placeholder = document.createComment("IE");
-      end.parentNode.insertBefore(placeholder, end.nextSibling);
-      end = placeholder;
-    }
-    return [start, end];
-  }
-};
-
-
-// This is a constructor (invoke it as 'new LiveRange').
-//
-// Create a range, tagged 'tag', that includes start, end, and all
-// the nodes between them, and the children of all of those nodes,
-// but includes no other nodes. If there are other ranges tagged
-// 'tag' that contain this exact set of nodes, then: if inner is
-// false (the default), the new range will be outside all of them
-// (will contain all of them), or if inner is true, then it will be
-// inside all of them (be contained by all of them.) If there are no
-// other ranges tagged 'tag' that contain this exact set of nodes,
-// then 'inner' is ignored because the nesting of the new range with
-// respect to other ranges is uniquely determined. (Nesting of
-// ranges with different tags is undefined.)
-//
-// To track the range as it's relocated, some of the DOM nodes that
-// are part of the range will have an expando attribute set on
-// them. The name of the expando attribute will be the value of
-// 'tag', so pick something that won't collide.
-//
-// Instead of start and end, you can pass a document or
-// documentfragment for start and leave end undefined. Or you can
-// pass a node for start and leave end undefined, in which case end
-// === start. If start and end are distinct nodes, they must be
-// siblings.
-//
-// You can set any attributes you like on the returned LiveRange
-// object, with two exceptions. First, attribute names that start
-// with '_' are reserved. Second, the attribute 'tag' contains the
-// tag name of this range and mustn't be changed.
-//
-// It would be possible to add a fast path through this function
-// when caller can promise that there is no range that starts on
-// start that does not end by end, and vice versa. eg: when start
-// and end are the first and last child of their parent respectively
-// or when caller is building up the range tree from the inside
-// out. Let's wait for the profiler to tell us to add this.
-//
-// XXX Should eventually support LiveRanges where start === end
-// and start.parentNode is null.
-LiveRange = function (tag, start, end, inner) {
-  if (start.nodeType === 11 /* DocumentFragment */) {
-    end = start.lastChild;
-    start = start.firstChild;
-  } else {
-    if (! start.parentNode)
-      throw new Error("LiveRange start and end must have a parent");
-  }
-  end = end || start;
-
-  this.tag = tag; // must be set before calling _ensureTag
-
-  var endpoints = wrapEndpoints(start, end);
-  start = this._ensureTag(endpoints[0]);
-  end = this._ensureTag(endpoints[1]);
-
-  // Decide at what indices in start[tag][0] and end[tag][1] we
-  // should insert the new range.
-  //
-  // The start[tag][0] array lists the other ranges that start at
-  // `start`, and we must choose an insertion index that puts us
-  // inside the ones that end at later siblings, and outside the ones
-  // that end at earlier siblings.  The ones that end at the same
-  // sibling (i.e. share both our start and end) we must be inside
-  // or outside of depending on `inner`.  The array lists ranges
-  // from the outside in.
-  //
-  // The same logic applies to end[tag][1], which lists the other ranges
-  // that happen to end at `end` from in the inside out.
-  //
-  // Liveranges technically start just before, and end just after, their
-  // start and end nodes to which the liverange data is attached.
-
-  var startIndex = findPosition(start[tag][0], true, end, start, inner);
-  var endIndex = findPosition(end[tag][1], false, start, end, inner);
-
-  // this._start is the node N such that we begin before N, but not
-  // before the node before N in the preorder traversal of the
-  // document (if there is such a node.) this._start[this.tag][0]
-  // will be the list of all LiveRanges for which this._start is N,
-  // including us, sorted in the order that the ranges start. and
-  // finally, this._startIndex is the value such that
-  // this._start[this.tag][0][this._startIndex] === this.
-  //
-  // Similarly for this._end, except it's the node N such that we end
-  // after N, but not after the node after N in the postorder
-  // traversal; and the data is stored in this._end[this.tag][1], and
-  // it's sorted in the order that the ranges end.
-
-  // Set this._start, this._end, this._startIndex, this._endIndex
-  this._insertEntries(start, 0, startIndex, [this]);
-  this._insertEntries(end, 1, endIndex, [this]);
-};
-
-var findPosition = function(ranges, findEndNotStart, edge, otherEdge, inner) {
-  var index;
-  // For purpose of finding where we belong in start[tag][0],
-  // walk the array and determine where we start to see ranges
-  // end at `end` (==edge) or earlier.  For the purpose of finding
-  // where we belong in end[tag][1], walk the array and determine
-  // where we start to see ranges start at `start` (==edge) or
-  // earlier.  In both cases, we slide a sibling pointer backwards
-  // looking for `edge`, though the details are slightly different.
-  //
-  // Use `inner` to take first or last candidate index for insertion.
-  // Candidate indices are:  Right before a range whose edge is `edge`
-  // (i.e., a range with same start and end as we are creating),
-  // or the index where ranges start to have edges earlier than `edge`
-  // (treating the end of the list as such an index).  We detect the
-  // latter case when `n` hits `edge` without hitting the edge of the
-  // current range; that is, it is about to move past `edge`.  This is
-  // always an appropriate time to stop.
-  //
-  // Joint traversal of the array and DOM should be fast.  The most
-  // expensive thing to happen would be a single walk from lastChild
-  // to end looking for range ends, or from end to start looking for
-  // range starts.
-  //
-  // invariant: n >= edge ("n is after, or is, edge")
-  var initialN = (findEndNotStart ? edge.parentNode.lastChild : otherEdge);
-  var takeFirst = (findEndNotStart ? ! inner : inner);
-  for(var i=0, n=initialN; i<=ranges.length; i++) {
-    var r = ranges[i];
-    var curEdge = r && (findEndNotStart ? r._end : r._start);
-    while (n !== curEdge && n !== edge) {
-      n = n.previousSibling;
-    }
-    if (curEdge === edge) {
-      index = i;
-      if (takeFirst) break;
-    } else if (n === edge) {
-      index = i;
-      break;
-    }
-  }
-  return index;
-};
-
-LiveRange.prototype._ensureTag = function (node) {
-  if (!(this.tag in node))
-    node[this.tag] = [[], []];
-  return node;
-};
-
-var canDeleteExpandos = (function() {
-  // IE7 can't remove expando attributes from DOM nodes with
-  // delete. Instead you must remove them with node.removeAttribute.
-  var node = document.createElement("DIV");
-  var exception;
-  var result = false;
-  try {
-    node.test = 12;
-    delete node.test;
-    result = true;
-  } catch (exception) { }
-  return result;
-})();
-
-LiveRange._cleanNode = function (tag, node, force) {
-  var data = node[tag];
-  if (data && (!(data[0].length + data[1].length) || force)) {
-    if (canDeleteExpandos)
-      delete node[tag];
-    else
-      node.removeAttribute(tag);
-  }
-};
-
-// Delete a LiveRange. This is analogous to removing a DOM node from
-// its parent -- it will no longer appear when traversing the tree
-// with visit().
-//
-// On modern browsers there is no requirement to delete LiveRanges on
-// defunct nodes. They will be garbage collected just like any other
-// object. However, on old versions of IE, you probably do need to
-// manually remove all ranges because IE can't GC reference cycles
-// through the DOM.
-//
-// Pass true for `recursive` to also destroy all descendent ranges.
-LiveRange.prototype.destroy = function (recursive) {
-  var self = this;
-
-  if (recursive) {
-    // recursive case: destroy all descendent ranges too
-    // (more efficient than actually recursing)
-
-    this.visit(function(isStart, range) {
-      if (isStart) {
-        range._start = null;
-        range._end = null;
-      }
-    }, function(isStart, node) {
-      if (! isStart) {
-        // when leaving a node, force-clean its children
-        for(var n = node.firstChild; n; n = n.nextSibling) {
-          LiveRange._cleanNode(self.tag, n, true);
-        }
-      }
-    });
-
-    this._removeEntries(this._start, 0, this._startIndex);
-    this._removeEntries(this._end, 1, 0, this._endIndex + 1);
-
-    if (this._start !== this._end) {
-      // force-clean the top-level nodes in this, besides _start and _end
-      for(var n = this._start.nextSibling;
-          n !== this._end;
-          n = n.nextSibling) {
-        LiveRange._cleanNode(self.tag, n, true);
-      }
-
-      // clean ends on this._start and starts on this._end
-      if (this._start[self.tag])
-        this._removeEntries(this._start, 1);
-      if (this._end[self.tag])
-        this._removeEntries(this._end, 0);
-    }
-
-    this._start = this._end = null;
-
-  } else {
-    this._removeEntries(this._start, 0, this._startIndex, this._startIndex + 1);
-    this._removeEntries(this._end, 1, this._endIndex, this._endIndex + 1);
-    this._start = this._end = null;
-  }
-};
-
-// Return the first node in the range (in preorder traversal)
-LiveRange.prototype.firstNode = function () {
-  return this._start;
-};
-
-// Return the last node in the range (in postorder traversal)
-LiveRange.prototype.lastNode = function () {
-  return this._end;
-};
-
-// Return the node that immediately contains this LiveRange, that is,
-// the parentNode of firstNode and lastNode.
-LiveRange.prototype.containerNode = function() {
-  return this._start.parentNode;
-};
-
-// Walk through the current contents of a LiveRange, enumerating
-// either the contained ranges (with the same tag as this range),
-// the contained elements, or both.
-//
-// visitRange(isStart, range) is invoked for each range
-// start-point or end-point that we encounter as we walk the range
-// stored in 'this' (not counting the endpoints of 'this' itself.)
-// visitNode(isStart, node) is similar but for nodes.  Both
-// functions are optional.
-//
-// If you return false (i.e. a value === false) from visitRange
-// or visitNode when isStart is true, the children of that range
-// or node are skipped, and the next callback will be the same
-// range or node with isStart false.
-//
-// If you create or destroy ranges with this tag from a visitation
-// function, results are undefined!
-LiveRange.prototype.visit = function(visitRange, visitNode) {
-  visitRange = visitRange || function() {};
-  visitNode = visitNode || function() {};
-
-  var tag = this.tag;
-
-  var recurse = function(start, end, startRangeSkip) {
-    var startIndex = startRangeSkip || 0;
-    var after = end.nextSibling;
-    for(var n = start; n && n !== after; n = n.nextSibling) {
-      var startData = n[tag] && n[tag][0];
-      if (startData && startIndex < startData.length) {
-        // immediate child range that starts with n
-        var range = startData[startIndex];
-        // be robust if visitRange mutates _start or _end;
-        // useful in destroy(true)
-        var rangeStart = range._start;
-        var rangeEnd = range._end;
-        if (visitRange(true, range) !== false)
-          recurse(rangeStart, rangeEnd, startIndex+1);
-        visitRange(false, range);
-        n = rangeEnd;
-      } else {
-        // bare node
-        if (visitNode(true, n) !== false && n.firstChild)
-          recurse(n.firstChild, n.lastChild);
-        visitNode(false, n);
-      }
-      startIndex = 0;
-    }
-  };
-
-  recurse(this._start, this._end, this._startIndex + 1);
-};
-
-// startEnd === 0 for starts, 1 for ends
-LiveRange.prototype._removeEntries =
-  function(node, startEnd, i, j)
-{
-  var entries = node[this.tag][startEnd];
-  i = i || 0;
-  j = (j || j === 0) ? j : entries.length;
-  var removed = entries.splice(i, j-i);
-  // fix up remaining ranges (not removed ones)
-  for(var a = i; a < entries.length; a++) {
-    if (startEnd) entries[a]._endIndex = a;
-    else entries[a]._startIndex = a;
-  }
-
-  // potentially remove empty liverange data
-  if (! entries.length) {
-    LiveRange._cleanNode(this.tag, node);
-  }
-
-  return removed;
-};
-
-LiveRange.prototype._insertEntries =
-  function(node, startEnd, i, newRanges)
-{
-  // insert the new ranges and "adopt" them by setting node pointers
-  var entries = node[this.tag][startEnd];
-  Array.prototype.splice.apply(entries, [i, 0].concat(newRanges));
-  for(var a=i; a < entries.length; a++) {
-    if (startEnd) {
-      entries[a]._end = node;
-      entries[a]._endIndex = a;
-    } else {
-      entries[a]._start = node;
-      entries[a]._startIndex = a;
-    }
-  }
-};
-
-// Replace the contents of this range with the provided
-// DocumentFragment. Returns the previous contents as a
-// DocumentFragment.
-//
-// "The right thing happens" with child LiveRanges:
-// - If there were child LiveRanges inside us, they will end up in
-//   the returned DocumentFragment.
-// - If the input DocumentFragment has LiveRanges, they will become
-//   our children.
-//
-// It is illegal for newFrag to be empty.
-LiveRange.prototype.replaceContents = function (newFrag) {
-  if (! newFrag.firstChild)
-    throw new Error("replaceContents requires non-empty fragment");
-
-  return this.operate(function(oldStart, oldEnd) {
-    // Insert new fragment
-    oldStart.parentNode.insertBefore(newFrag, oldStart);
-
-    // Pull out departing fragment
-    // Possible optimization: use W3C Ranges on browsers that support them
-    var retFrag = oldStart.ownerDocument.createDocumentFragment();
-    var walk = oldStart;
-    while (true) {
-      var next = walk.nextSibling;
-      retFrag.appendChild(walk);
-      if (walk === oldEnd)
-        break;
-      walk = next;
-      if (!walk)
-        throw new Error("LiveRanges must begin and end on siblings in order");
-    }
-
-    return retFrag;
-  });
-};
-
-
-// Perform a user-specified DOM mutation on the contents of this range.
-//
-// `func` is called with two parameters, `oldStart` and `oldEnd`, equal
-// to the original firstNode() and lastNode() of this range.  `func` is allowed
-// to perform arbitrary operations on the sequence of nodes from `oldStart`
-// to `oldEnd` and on child ranges of this range.  `func` may NOT call methods
-// on this range itself or otherwise rely on the existence of this range and
-// enclosing ranges.  `func` must leave at least one node to become the new
-// contents of this range.
-//
-// The return value of `func` is returned.
-//
-// This method is a generalization of replaceContents that works by
-// temporarily removing this LiveRange from the DOM and restoring it after
-// `func` has been called.
-LiveRange.prototype.operate = function (func) {
-  // boundary nodes of departing fragment
-  var oldStart = this._start;
-  var oldEnd = this._end;
-
-  // pull off outer liverange data
-  var outerStarts =
-        this._removeEntries(oldStart, 0, 0, this._startIndex + 1);
-  var outerEnds =
-        this._removeEntries(oldEnd, 1, this._endIndex);
-
-  var containerNode = oldStart.parentNode;
-  var beforeNode = oldStart.previousSibling;
-  var afterNode = oldEnd.nextSibling;
-
-  var ret = null;
-
-  // perform user-specifiedDOM manipulation
-  ret = func(oldStart, oldEnd);
-
-  // see what we've got...
-
-  var newStart =
-        beforeNode ? beforeNode.nextSibling : containerNode.firstChild;
-  var newEnd =
-        afterNode ? afterNode.previousSibling : containerNode.lastChild;
-
-  if (! newStart || newStart === afterNode) {
-    throw new Error("Ranges must contain at least one element");
-  }
-
-  // wrap endpoints if necessary
-  var newEndpoints = wrapEndpoints(newStart, newEnd);
-  newStart = this._ensureTag(newEndpoints[0]);
-  newEnd = this._ensureTag(newEndpoints[1]);
-
-  // put the outer liveranges back
-
-  this._insertEntries(newStart, 0, 0, outerStarts);
-  this._insertEntries(newEnd, 1, newEnd[this.tag][1].length, outerEnds);
-
-  return ret;
-};
-
-// Move all liverange data represented in the DOM from sourceNode to
-// targetNode.  targetNode must be capable of receiving liverange tags
-// (for example, a node that has been the first or last node of a liverange
-// before; not a text node in IE).
-//
-// This is a low-level operation suitable for moving liveranges en masse
-// from one DOM tree to another, where transplantTag is called on every
-// pair of nodes such that targetNode takes the place of sourceNode.
-LiveRange.transplantTag = function(tag, targetNode, sourceNode) {
-
-  if (! sourceNode[tag])
-    return;
-
-  // copy data pointer
-  targetNode[tag] = sourceNode[tag];
-  sourceNode[tag] = null;
-
-  var starts = targetNode[tag][0];
-  var ends = targetNode[tag][1];
-
-  // fix _start and _end pointers
-  for(var i=0;i<starts.length;i++)
-    starts[i]._start = targetNode;
-  for(var i=0;i<ends.length;i++)
-    ends[i]._end = targetNode;
-};
-
-// Takes two sibling nodes tgtStart and tgtEnd with no LiveRange data on them
-// and a LiveRange srcRange in a separate DOM tree.  Transplants srcRange
-// to span from tgtStart to tgtEnd, and also copies info about enclosing ranges
-// starting on srcRange._start or ending on srcRange._end.  tgtStart and tgtEnd
-// must be capable of receiving liverange tags (for example, nodes that have
-// held liverange data in the past; not text nodes in IE).
-//
-// This is a low-level operation suitable for moving liveranges en masse
-// from one DOM tree to another.
-LiveRange.transplantRange = function(tgtStart, tgtEnd, srcRange) {
-  srcRange._ensureTag(tgtStart);
-  if (tgtEnd !== tgtStart)
-    srcRange._ensureTag(tgtEnd);
-
-  srcRange._insertEntries(
-    tgtStart, 0, 0,
-    srcRange._start[srcRange.tag][0].slice(0, srcRange._startIndex + 1));
-  srcRange._insertEntries(
-    tgtEnd, 1, 0,
-    srcRange._end[srcRange.tag][1].slice(srcRange._endIndex));
-};
-
-// Inserts a DocumentFragment immediately before this range.
-// The new nodes are outside this range but inside all
-// enclosing ranges.
-LiveRange.prototype.insertBefore = function(frag) {
-  var fragStart = frag.firstChild;
-
-  if (! fragStart) // empty frag
-    return;
-
-  // insert into DOM
-  this._start.parentNode.insertBefore(frag, this._start);
-
-  // move starts of ranges that begin on this._start, but are
-  // outside this, to beginning of fragStart
-  this._ensureTag(fragStart);
-  this._insertEntries(fragStart, 0, 0,
-                       this._removeEntries(this._start, 0, 0,
-                                            this._startIndex));
-};
-
-// Inserts a DocumentFragment immediately after this range.
-// The new nodes are outside this range but inside all
-// enclosing ranges.
-LiveRange.prototype.insertAfter = function(frag) {
-  var fragEnd = frag.lastChild;
-
-  if (! fragEnd) // empty frag
-    return;
-
-  // insert into DOM
-  this._end.parentNode.insertBefore(frag, this._end.nextSibling);
-
-  // move ends of ranges that end on this._end, but are
-  // outside this, to end of fragEnd
-  this._ensureTag(fragEnd);
-  this._insertEntries(fragEnd, 1, fragEnd[this.tag][1].length,
-                       this._removeEntries(this._end, 1,
-                                            this._endIndex + 1));
-};
-
-// Extracts this range and its contents from the DOM and
-// puts it into a DocumentFragment, which is returned.
-// All nodes and ranges outside this range are properly
-// preserved.
-//
-// Because liveranges must contain at least one node,
-// it is illegal to perform `extract` if the immediately
-// enclosing range would become empty.  If this precondition
-// is violated, no action is taken and null is returned.
-LiveRange.prototype.extract = function() {
-  if (this._startIndex > 0 &&
-      this._start[this.tag][0][this._startIndex - 1]._end === this._end) {
-    // immediately enclosing range wraps same nodes, so can't extract because
-    // it would empty it.
-    return null;
-  }
-
-  var before = this._start.previousSibling;
-  var after = this._end.nextSibling;
-  var parent = this._start.parentNode;
-
-  if (this._startIndex > 0) {
-    // must be a later node where outer ranges that start here end;
-    // move their starts to after
-    this._ensureTag(after);
-    this._insertEntries(after, 0, 0,
-                         this._removeEntries(this._start, 0, 0,
-                                              this._startIndex));
-  }
-
-  if (this._endIndex < this._end[this.tag][1].length - 1) {
-    // must be an earlier node where outer ranges that end here
-    // start; move their ends to before
-    this._ensureTag(before);
-    this._insertEntries(before, 1, before[this.tag][1].length,
-                         this._removeEntries(this._end, 1,
-                                              this._endIndex + 1));
-  }
-
-  var result = document.createDocumentFragment();
-
-  for(var n;
-      n = before ? before.nextSibling : parent.firstChild,
-      n && n !== after;)
-    result.appendChild(n);
-
-  return result;
-};
-
-// Find the immediately enclosing parent range of this range, or
-// null if this range has no enclosing ranges.
-//
-// If `withSameContainer` is true, we stop looking when we reach
-// this range's container node (the parent of its endpoints) and
-// only return liveranges whose first and last nodes are siblings
-// of this one's.
-LiveRange.prototype.findParent = function(withSameContainer) {
-  var result = enclosingRangeSearch(this.tag, this._end, this._endIndex);
-  if (result)
-    return result;
-
-  if (withSameContainer)
-    return null;
-
-  return LiveRange.findRange(this.tag, this.containerNode());
-};
-
-// Find the nearest enclosing range containing `node`, if any.
-LiveRange.findRange = function(tag, node) {
-  var result = enclosingRangeSearch(tag, node);
-  if (result)
-    return result;
-
-  if (! node.parentNode)
-    return null;
-
-  return LiveRange.findRange(tag, node.parentNode);
-};
-
-var enclosingRangeSearch = function(tag, end, endIndex) {
-  // Search for an enclosing range, at the same level,
-  // starting at node `end` or after the range whose
-  // position in the end array of `end` is `endIndex`.
-  // The search works by scanning forwards for range ends
-  // while skipping over ranges whose starts we encounter.
-
-  if (typeof endIndex === "undefined")
-    endIndex = -1;
-
-  if (end[tag] && endIndex + 1 < end[tag][1].length) {
-    // immediately enclosing range ends at same node as this one
-    return end[tag][1][endIndex + 1];
-  }
-
-  var node = end.nextSibling;
-  while (node) {
-    var endIndex = 0;
-    var startData = node[tag] && node[tag][0];
-    if (startData && startData.length) {
-      // skip over sibling of this range
-      var r = startData[0];
-      node = r._end;
-      endIndex = r._endIndex + 1;
-    }
-    if (node[tag] && endIndex < node[tag][1].length)
-      return node[tag][1][endIndex];
-    node = node.nextSibling;
-  }
-
-  return null;
-};
diff --git a/packages/liverange/liverange_test_helpers.js b/packages/liverange/liverange_test_helpers.js
deleted file mode 100644
index f9c436e961..0000000000
--- a/packages/liverange/liverange_test_helpers.js
+++ /dev/null
@@ -1,42 +0,0 @@
-// checks that ranges balance and that node and index pointers are
-// correct. if both of these things are true, then everything
-// contained by 'range' must be a valid subtree. (assuming that
-// visit() is actually working.)
-check_liverange_integrity = function (range) {
-  var stack = [];
-
-  var check_node = function (node) {
-    var data = node[range.tag] || [[], []];
-    for (var i = 0; i < data[0].length; i++) {
-      if (data[0][i]._start !== node)
-        throw new Error("integrity check failed - incorrect _start");
-      if (data[0][i]._startIndex !== i)
-        throw new Error("integrity check failed - incorrect _startIndex");
-    }
-    for (var i = 0; i < data[1].length; i++) {
-      if (data[1][i]._end !== node)
-        throw new Error("integrity check failed - incorrect _end");
-      if (data[1][i]._endIndex !== i)
-        throw new Error("integrity check failed - incorrect _endIndex");
-    }
-  };
-
-  range.visit(function (isStart, range) {
-    if (isStart)
-      stack.push(range);
-    else
-      if (range !== stack.pop())
-        throw new Error("integrity check failed - unbalanced range");
-  }, function (isStart, node) {
-    if (isStart) {
-      check_node(node);
-      stack.push(node);
-    }
-    else
-      if (node !== stack.pop())
-        throw new Error("integrity check failed - unbalanced node");
-  });
-
-  if (stack.length)
-    throw new Error("integrity check failed - missing close tags");
-};
diff --git a/packages/liverange/liverange_tests.js b/packages/liverange/liverange_tests.js
deleted file mode 100644
index 10088aa832..0000000000
--- a/packages/liverange/liverange_tests.js
+++ /dev/null
@@ -1,621 +0,0 @@
-/******************************************************************************/
-
-var create = function (id, start, end, inner, tag) {
-  var ret = new LiveRange(tag || 'a', start, end, inner);
-  ret.id = id;
-  return ret;
-};
-
-var frag = function (html) {
-  var ret = document.createDocumentFragment();
-  var q = $(html);
-  for (var i = 0; i < q.length; i++)
-    ret.appendChild(q[i]);
-  return ret;
-};
-
-// takes ranges or fragments. tag is used only for fragments.
-var dump = function (what, tag) {
-  var ret = "";
-
-  var emit = function (isStart, obj) {
-    ret += (isStart ? "<": "</") + obj.id + ">";
-  };
-
-  if (typeof what === 'object' && what.nodeType === 11 /* DocumentFragment */) {
-    if (what.firstChild) {
-      var range = new LiveRange(tag || 'a', what);
-      range.visit(emit, emit);
-      range.destroy();
-    }
-  } else {
-    emit(true, what);
-    what.visit(emit, emit);
-    emit(false, what);
-  }
-
-  return ret;
-};
-
-// actual can be a range or a fragment
-var assert_dump = function (test, expected, actual, tag) {
-  test.equal(dump(actual), expected, "Tree doesn't match");
-  if (actual instanceof LiveRange)
-    check_liverange_integrity(actual);
-  else {
-    if (actual.firstChild) {
-      var range = new LiveRange(tag || 'a', actual);
-      check_liverange_integrity(range);
-      range.destroy();
-    }
-  }
-};
-
-var contained_ranges = function (range) {
-  var result = {range: range, children: []};
-  var stack = [result];
-
-  range.visit(function (isStart, range) {
-    if (isStart) {
-      var record = {range: range, children: []};
-      stack[stack.length - 1].children.push(record);
-      stack.push(record);
-    } else
-      if (stack.pop().range !== range)
-        throw new Error("Overlapping ranges detected");
-  });
-
-  return result;
-};
-
-var assert_contained = function (r, expected) {
-  // one day, fold in the above function (use visit() directly)
-  var actual = contained_ranges(r);
-
-  var traverse = function (exp, act) {
-    if (exp.range !== act.range)
-      throw new Error("contained(): range doesn't match");
-    if (exp.children.length !== act.children.length)
-      throw new Error("contained(): different tree shape");
-    for (var i = 0; i < exp.children.length; i++)
-      traverse(exp.children[i], act.children[i]);
-  };
-
-  traverse(expected, actual);
-};
-
-/******************************************************************************/
-
-Tinytest.add("liverange - single node", function (test) {
-  var f = frag("<div id=1></div>");
-  var r_a = create("a", f);
-  test.instanceOf(r_a, LiveRange);
-  assert_dump(test, "<a><1></1></a>", r_a);
-  assert_dump(test, "<a><1></1></a>", f);
-  assert_contained(r_a, {range: r_a, children: []});
-
-  var r_b = create("b", f);
-  assert_dump(test, "<a><1></1></a>", r_a);
-  assert_dump(test, "<b><a><1></1></a></b>", r_b);
-  assert_dump(test, "<b><a><1></1></a></b>", f);
-  assert_contained(r_a, {range: r_a, children: []});
-  assert_contained(r_b, {range: r_b, children: [{range: r_a, children: []}]});
-  test.equal(r_a.firstNode(), f.firstChild);
-  test.equal(r_a.lastNode(), f.lastChild);
-  test.equal(r_b.firstNode(), f.firstChild);
-  test.equal(r_b.lastNode(), f.lastChild);
-
-  var ret1 = r_a.replaceContents(frag("<div id=2></div>"), true);
-  test.equal(ret1.nodeType, 11 /* DocumentFragment */);
-  assert_dump(test, "<1></1>", ret1);
-  assert_dump(test, "<a><2></2></a>", r_a);
-  assert_dump(test, "<b><a><2></2></a></b>", r_b);
-  assert_dump(test, "<b><a><2></2></a></b>", f);
-
-  var ret2 = r_b.replaceContents(frag("<div id=3></div>"), true);
-  assert_dump(test, "<a><2></2></a>", ret2);
-  assert_dump(test, "<a><2></2></a>", r_a);
-  assert_dump(test, "<b><3></3></b>", r_b);
-  assert_dump(test, "<b><3></3></b>", f);
-
-  r_a.destroy();
-  assert_dump(test, "<2></2>", ret2);
-
-  var r_c = create("c", f);
-  var r_d = create("d", f);
-  var r_e = create("e", f);
-  assert_dump(test, "<c><b><3></3></b></c>", r_c);
-  assert_dump(test, "<d><c><b><3></3></b></c></d>", r_d);
-  assert_dump(test, "<e><d><c><b><3></3></b></c></d></e>", r_e);
-  assert_dump(test, "<1></1>", ret1);
-  assert_dump(test, "<b><3></3></b>", r_b);
-
-  r_d.destroy();
-  assert_dump(test, "<b><3></3></b>", r_b);
-  assert_dump(test, "<c><b><3></3></b></c>", r_c);
-  assert_dump(test, "<e><c><b><3></3></b></c></e>", r_e);
-  assert_dump(test, "<1></1>", ret1);
-
-  assert_contained(r_e,
-                   {range: r_e,
-                    children: [{range: r_c,
-                                children: [{range: r_b, children: []}]}]});
-
-  test.equal(r_b.firstNode(), f.firstChild);
-  test.equal(r_b.lastNode(), f.lastChild);
-  test.equal(r_c.firstNode(), f.firstChild);
-  test.equal(r_c.lastNode(), f.lastChild);
-  test.equal(r_e.firstNode(), f.firstChild);
-  test.equal(r_e.lastNode(), f.lastChild);
-
-  r_b.destroy();
-  assert_dump(test, "<c><3></3></c>", r_c);
-  assert_dump(test, "<e><c><3></3></c></e>", r_e);
-
-  r_e.destroy();
-  assert_dump(test, "<c><3></3></c>", r_c);
-
-});
-
-Tinytest.add("liverange - empty replace", function (test) {
-  var f,r;
-
-  f = frag("<div id=1></div>");
-  r = create("z", f);
-  test.throws(function() {
-    r.replaceContents(frag(""));
-  });
-
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r = create("z", f.childNodes[1]);
-  assert_dump(test, "<1></1><z><2></2></z><3></3>", f);
-  test.throws(function() {
-    r.replaceContents(frag(""));
-  });
-});
-
-Tinytest.add("liverange - multiple nodes", function (test) {
-  var f = frag("<div id=1></div><div id=2></div><div id=3></div><div id=4></div><div id=5></div>");
-  assert_dump(test, "<1></1><2></2><3></3><4></4><5></5>", f);
-
-  var r_a = create("a", f.childNodes[2], f.childNodes[3]);
-  assert_dump(test, "<1></1><2></2><a><3></3><4></4></a><5></5>", f);
-  assert_dump(test, "<a><3></3><4></4></a>", r_a);
-
-  var r_b = create("b", f.childNodes[3], f.childNodes[3]);
-  assert_dump(test, "<1></1><2></2><a><3></3><b><4></4></b></a><5></5>", f);
-  assert_dump(test, "<a><3></3><b><4></4></b></a>", r_a);
-  assert_dump(test, "<b><4></4></b>", r_b);
-
-  var r_c = create("c", f.childNodes[2], f.childNodes[3]);
-  assert_dump(test, "<1></1><2></2><c><a><3></3><b><4></4></b></a></c><5></5>", f);
-  assert_dump(test, "<a><3></3><b><4></4></b></a>", r_a);
-  assert_dump(test, "<b><4></4></b>", r_b);
-  assert_dump(test, "<c><a><3></3><b><4></4></b></a></c>", r_c);
-
-  var r_d = create("d", f.childNodes[3], f.childNodes[3]);
-  assert_dump(test, "<1></1><2></2><c><a><3></3><d><b><4></4></b></d></a></c><5></5>", f);
-  assert_dump(test, "<a><3></3><d><b><4></4></b></d></a>", r_a);
-  assert_dump(test, "<b><4></4></b>", r_b);
-  assert_dump(test, "<c><a><3></3><d><b><4></4></b></d></a></c>", r_c);
-  assert_dump(test, "<d><b><4></4></b></d>", r_d);
-
-  var r_e = create("e", f.childNodes[2], f.childNodes[2]);
-  assert_dump(test, "<1></1><2></2><c><a><e><3></3></e><d><b><4></4></b></d></a></c><5></5>", f);
-  assert_dump(test, "<a><e><3></3></e><d><b><4></4></b></d></a>", r_a);
-  assert_dump(test, "<b><4></4></b>", r_b);
-  assert_dump(test, "<c><a><e><3></3></e><d><b><4></4></b></d></a></c>", r_c);
-  assert_dump(test, "<d><b><4></4></b></d>", r_d);
-  assert_dump(test, "<e><3></3></e>", r_e);
-
-  var r_f = create("f", f.childNodes[2], f.childNodes[3]);
-  assert_dump(test, "<1></1><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f><5></5>", f);
-  assert_dump(test, "<a><e><3></3></e><d><b><4></4></b></d></a>", r_a);
-  assert_dump(test, "<b><4></4></b>", r_b);
-  assert_dump(test, "<c><a><e><3></3></e><d><b><4></4></b></d></a></c>", r_c);
-  assert_dump(test, "<d><b><4></4></b></d>", r_d);
-  assert_dump(test, "<e><3></3></e>", r_e);
-  assert_dump(test, "<f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f>", r_f);
-
-  assert_contained(r_f, {range: r_f, children: [{range: r_c, children: [{range: r_a, children: [{range: r_e, children: []},{range: r_d, children: [{range: r_b, children: []}]}]}]}]});
-
-  var r_g = create("g", f.childNodes[0], f.childNodes[3]);
-  var r_h = create("h", f.childNodes[0], f.childNodes[3]);
-  var r_i = create("i", f.childNodes[1], f.childNodes[3]);
-  assert_dump(test, "<h><g><1></1><i><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f></i></g></h><5></5>", f);
-  assert_dump(test, "<a><e><3></3></e><d><b><4></4></b></d></a>", r_a);
-  assert_dump(test, "<b><4></4></b>", r_b);
-  assert_dump(test, "<c><a><e><3></3></e><d><b><4></4></b></d></a></c>", r_c);
-  assert_dump(test, "<d><b><4></4></b></d>", r_d);
-  assert_dump(test, "<e><3></3></e>", r_e);
-  assert_dump(test, "<f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f>", r_f);
-  assert_dump(test, "<g><1></1><i><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f></i></g>", r_g);
-  assert_dump(test, "<h><g><1></1><i><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f></i></g></h>", r_h);
-  assert_dump(test, "<i><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f></i>", r_i);
-
-  var f2 = frag("<div id=6></div><div id=7></div><div id=8></div>");
-  f2.childNodes[1].appendChild(f);
-  assert_dump(test, "", f);
-  assert_dump(test, "<6></6><7><h><g><1></1><i><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f></i></g></h><5></5></7><8></8>", f2);
-  assert_dump(test, "<a><e><3></3></e><d><b><4></4></b></d></a>", r_a);
-  assert_dump(test, "<b><4></4></b>", r_b);
-  assert_dump(test, "<c><a><e><3></3></e><d><b><4></4></b></d></a></c>", r_c);
-  assert_dump(test, "<d><b><4></4></b></d>", r_d);
-  assert_dump(test, "<e><3></3></e>", r_e);
-  assert_dump(test, "<f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f>", r_f);
-  assert_dump(test, "<g><1></1><i><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f></i></g>", r_g);
-  assert_dump(test, "<h><g><1></1><i><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f></i></g></h>", r_h);
-  assert_dump(test, "<i><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f></i>", r_i);
-
-  var r_j = create("j", f2.childNodes[1], f2.childNodes[2]);
-  var r_k = create("k", f2.childNodes[0], f2.childNodes[2]);
-  var r_l = create("l", f2.childNodes[0], f2.childNodes[2]);
-  assert_dump(test, "<l><k><6></6><j><7><h><g><1></1><i><2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f></i></g></h><5></5></7><8></8></j></k></l>", f2);
-
-  var f3 = frag("<div id=9></div><div id=10></div><div id=11></div>");
-  var r_m = create("m", f3.childNodes[0], f3.childNodes[2]);
-  var r_n = create("n", f3.childNodes[0], f3.childNodes[0]);
-  var r_o = create("o", f3.childNodes[0], f3.childNodes[0]);
-  assert_dump(test, "<m><o><n><9></9></n></o><10></10><11></11></m>", f3);
-
-  var ret1 = r_i.replaceContents(f3, true);
-  assert_dump(test, "", f3);
-  assert_dump(test, "<2></2><f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f>", ret1);
-  assert_dump(test, "<l><k><6></6><j><7><h><g><1></1><i><m><o><n><9></9></n></o><10></10><11></11></m></i></g></h><5></5></7><8></8></j></k></l>", f2);
-  assert_dump(test, "<a><e><3></3></e><d><b><4></4></b></d></a>", r_a);
-  assert_dump(test, "<b><4></4></b>", r_b);
-  assert_dump(test, "<c><a><e><3></3></e><d><b><4></4></b></d></a></c>", r_c);
-  assert_dump(test, "<d><b><4></4></b></d>", r_d);
-  assert_dump(test, "<e><3></3></e>", r_e);
-  assert_dump(test, "<f><c><a><e><3></3></e><d><b><4></4></b></d></a></c></f>", r_f);
-  assert_dump(test, "<g><1></1><i><m><o><n><9></9></n></o><10></10><11></11></m></i></g>", r_g);
-  assert_dump(test, "<h><g><1></1><i><m><o><n><9></9></n></o><10></10><11></11></m></i></g></h>", r_h);
-  assert_dump(test, "<i><m><o><n><9></9></n></o><10></10><11></11></m></i>",r_i);
-  assert_dump(test, "<j><7><h><g><1></1><i><m><o><n><9></9></n></o><10></10><11></11></m></i></g></h><5></5></7><8></8></j>", r_j);
-  assert_dump(test, "<k><6></6><j><7><h><g><1></1><i><m><o><n><9></9></n></o><10></10><11></11></m></i></g></h><5></5></7><8></8></j></k>", r_k);
-  assert_dump(test, "<l><k><6></6><j><7><h><g><1></1><i><m><o><n><9></9></n></o><10></10><11></11></m></i></g></h><5></5></7><8></8></j></k></l>", r_l);
-
-  r_h.destroy();
-  assert_dump(test, "<l><k><6></6><j><7><g><1></1><i><m><o><n><9></9></n></o><10></10><11></11></m></i></g><5></5></7><8></8></j></k></l>", f2);
-  r_m.destroy();
-  assert_dump(test, "<l><k><6></6><j><7><g><1></1><i><o><n><9></9></n></o><10></10><11></11></i></g><5></5></7><8></8></j></k></l>", f2);
-  r_n.destroy();
-  assert_dump(test, "<l><k><6></6><j><7><g><1></1><i><o><9></9></o><10></10><11></11></i></g><5></5></7><8></8></j></k></l>", f2);
-  r_j.destroy();
-  assert_dump(test, "<l><k><6></6><7><g><1></1><i><o><9></9></o><10></10><11></11></i></g><5></5></7><8></8></k></l>", f2);
-  r_o.destroy();
-  assert_dump(test, "<l><k><6></6><7><g><1></1><i><9></9><10></10><11></11></i></g><5></5></7><8></8></k></l>", f2);
-  r_g.destroy();
-  assert_dump(test, "<l><k><6></6><7><1></1><i><9></9><10></10><11></11></i><5></5></7><8></8></k></l>", f2);
-  r_l.destroy();
-  assert_dump(test, "<k><6></6><7><1></1><i><9></9><10></10><11></11></i><5></5></7><8></8></k>", f2);
-  r_i.destroy();
-  assert_dump(test, "<k><6></6><7><1></1><9></9><10></10><11></11><5></5></7><8></8></k>", f2);
-  r_k.destroy();
-  assert_dump(test, "<6></6><7><1></1><9></9><10></10><11></11><5></5></7><8></8>", f2);
-});
-
-Tinytest.add("liverange - deep visit", function (test) {
-
-  var f = frag("<div id=1><div id=2><div id=3><div id=4><div id=5></div></div></div></div></div>");
-
-  var dive = function (f, count) {
-    for (var i = 0; i < count; i ++)
-      f = f.firstChild;
-    return f;
-  };
-
-  var r_a = create("a", dive(f, 5), dive(f, 5));
-  var r_b = create("b", dive(f, 3), dive(f, 3));
-  var r_c = create("c", dive(f, 2), dive(f, 2));
-  var r_d = create("d", f);
-
-  assert_dump(test, "<d><1><c><2><b><3><4><a><5></5></a></4></3></b></2></c></1></d>",
-              f);
-
-  assert_contained(r_d,
-                   {range: r_d, children: [{range: r_c, children: [{range: r_b, children: [{range: r_a, children: []}]}]}]});
-});
-
-Tinytest.add("liverange - create inner", function (test) {
-  // Basics
-
-  var f = frag("<div id=1></div><div id=2></div><div id=3></div><div id=4></div><div id=5></div>");
-  assert_dump(test, "<1></1><2></2><3></3><4></4><5></5>", f);
-
-  var r_a = create("a", f.childNodes[2], f.childNodes[4], true);
-  assert_dump(test, "<1></1><2></2><a><3></3><4></4><5></5></a>", f);
-
-  var r_b = create("b", f.childNodes[2], f.childNodes[4], true);
-  assert_dump(test, "<1></1><2></2><a><b><3></3><4></4><5></5></b></a>", f);
-
-  var r_c = create("c", f.childNodes[2], f.childNodes[4]);
-  assert_dump(test, "<1></1><2></2><c><a><b><3></3><4></4><5></5></b></a></c>", f);
-
-  // [{[a] [b]}]
-
-  var r_d = create("d", f.childNodes[0], f.childNodes[0]);
-  var r_e = create("e", f.childNodes[1], f.childNodes[1]);
-  var r_f = create("f", f.childNodes[0], f.childNodes[1]);
-  assert_dump(test, "<f><d><1></1></d><e><2></2></e></f><c><a><b><3></3><4></4><5></5></b></a></c>", f);
-
-  var r_g = create("g", f.childNodes[0], f.childNodes[1], true);
-  assert_dump(test, "<f><g><d><1></1></d><e><2></2></e></g></f><c><a><b><3></3><4></4><5></5></b></a></c>", f);
-
-  var r_h = create("h", f.childNodes[0], f.childNodes[1]);
-  assert_dump(test, "<h><f><g><d><1></1></d><e><2></2></e></g></f></h><c><a><b><3></3><4></4><5></5></b></a></c>", f);
-
-  var r_i = create("i", f.childNodes[0], f.childNodes[1], true);
-  assert_dump(test, "<h><f><g><i><d><1></1></d><e><2></2></e></i></g></f></h><c><a><b><3></3><4></4><5></5></b></a></c>", f);
-
-  var r_j = create("j", f.childNodes[0], f.childNodes[0], true);
-  assert_dump(test, "<h><f><g><i><d><j><1></1></j></d><e><2></2></e></i></g></f></h><c><a><b><3></3><4></4><5></5></b></a></c>", f);
-
-  var r_k = create("k", f.childNodes[0], f.childNodes[0]);
-  assert_dump(test, "<h><f><g><i><k><d><j><1></1></j></d></k><e><2></2></e></i></g></f></h><c><a><b><3></3><4></4><5></5></b></a></c>", f);
-
-  var r_l = create("l", f.childNodes[0], f.childNodes[1], true);
-  assert_dump(test, "<h><f><g><i><l><k><d><j><1></1></j></d></k><e><2></2></e></l></i></g></f></h><c><a><b><3></3><4></4><5></5></b></a></c>", f);
-  assert_dump(test, "<c><a><b><3></3><4></4><5></5></b></a></c>", r_c);
-  assert_dump(test, "<b><3></3><4></4><5></5></b>", r_b);
-  assert_dump(test, "<a><b><3></3><4></4><5></5></b></a>", r_a);
-  assert_dump(test, "<d><j><1></1></j></d>", r_d);
-  assert_dump(test, "<e><2></2></e>", r_e);
-  assert_dump(test, "<f><g><i><l><k><d><j><1></1></j></d></k><e><2></2></e></l></i></g></f>", r_f);
-  assert_dump(test, "<g><i><l><k><d><j><1></1></j></d></k><e><2></2></e></l></i></g>", r_g);
-  assert_dump(test, "<h><f><g><i><l><k><d><j><1></1></j></d></k><e><2></2></e></l></i></g></f></h>", r_h);
-  assert_dump(test, "<i><l><k><d><j><1></1></j></d></k><e><2></2></e></l></i>", r_i);
-  assert_dump(test, "<j><1></1></j>", r_j);
-  assert_dump(test, "<k><d><j><1></1></j></d></k>", r_k);
-  assert_dump(test, "<l><k><d><j><1></1></j></d></k><e><2></2></e></l>", r_l);
-
-  // [{a b [c]}]
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r_a = create("a", f.childNodes[2], f.childNodes[2]);
-  r_b = create("b", f.childNodes[0], f.childNodes[2]);
-  r_c = create("c", f.childNodes[0], f.childNodes[2], true);
-  assert_dump(test, "<b><c><1></1><2></2><a><3></3></a></c></b>", f);
-
-  // [{[a] b c}]
-
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r_a = create("a", f.childNodes[0], f.childNodes[0]);
-  r_b = create("b", f.childNodes[0], f.childNodes[2]);
-  r_c = create("c", f.childNodes[0], f.childNodes[2], true);
-  assert_dump(test, "<b><c><a><1></1></a><2></2><3></3></c></b>", f);
-
-  // [{[a b] c}]
-
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r_a = create("a", f.childNodes[0], f.childNodes[1]);
-  r_b = create("b", f.childNodes[0], f.childNodes[2]);
-  r_c = create("c", f.childNodes[0], f.childNodes[2], true);
-  assert_dump(test, "<b><c><a><1></1><2></2></a><3></3></c></b>", f);
-
-  // Cases where start and end have no common ranges, and so the
-  // balance counter will have to run
-
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r_a = create("a", f.childNodes[0], f.childNodes[0]);
-  r_b = create("b", f.childNodes[0], f.childNodes[2]);
-  assert_dump(test, "<b><a><1></1></a><2></2><3></3></b>", f);
-
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r_a = create("a", f.childNodes[0], f.childNodes[2]);
-  r_b = create("b", f.childNodes[0], f.childNodes[0]);
-  assert_dump(test, "<a><b><1></1></b><2></2><3></3></a>", f);
-
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r_a = create("a", f.childNodes[2], f.childNodes[2]);
-  r_b = create("b", f.childNodes[0], f.childNodes[2]);
-  assert_dump(test, "<b><1></1><2></2><a><3></3></a></b>", f);
-
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r_a = create("a", f.childNodes[0], f.childNodes[2]);
-  r_b = create("b", f.childNodes[2], f.childNodes[2]);
-  assert_dump(test, "<a><1></1><2></2><b><3></3></b></a>", f);
-
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r_a = create("a", f.childNodes[0], f.childNodes[0]);
-  r_b = create("b", f.childNodes[0], f.childNodes[0]);
-  r_c = create("c", f.childNodes[2], f.childNodes[2]);
-  r_d = create("d", f.childNodes[2], f.childNodes[2]);
-  r_e = create("e", f.childNodes[0], f.childNodes[2]);
-  assert_dump(test, "<e><b><a><1></1></a></b><2></2><d><c><3></3></c></d></e>", f);
-
-  f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-  r_a = create("a", f.childNodes[0], f.childNodes[0]);
-  r_b = create("b", f.childNodes[0], f.childNodes[0]);
-  r_c = create("c", f.childNodes[2], f.childNodes[2]);
-  r_e = create("e", f.childNodes[0], f.childNodes[2]);
-  assert_dump(test, "<e><b><a><1></1></a></b><2></2><c><3></3></c></e>", f);
-
-  try_all_permutations(
-    function () {
-      f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-    },
-    [
-      function () { create("a", f.childNodes[1], f.childNodes[2]); },
-      function () { create("b", f.childNodes[2], f.childNodes[2]); },
-      function () { create("c", f.childNodes[0], f.childNodes[2]); }
-    ],
-    function () {
-      assert_dump(test, "<c><1></1><a><2></2><b><3></3></b></a></c>", f);
-    }
-  );
-
-  try_all_permutations(
-    function () {
-      f = frag("<div id=1></div><div id=2></div><div id=3></div>");
-    },
-    [
-      function () { create("a", f.childNodes[0], f.childNodes[0]); },
-      function () { create("b", f.childNodes[0], f.childNodes[1]); },
-      function () { create("c", f.childNodes[0], f.childNodes[2]); }
-    ],
-    function () {
-      assert_dump(test, "<c><b><a><1></1></a><2></2></b><3></3></c>", f);
-    }
-  );
-});
-
-var makeTestPattern = function(codedStr) {
-  codedStr = codedStr.replace(/\*/g, '[]');
-
-  var self = {};
-  self.tag = '_foo';
-  self.ranges = {};
-
-  // set up self.ranges
-  var curNode = document.createDocumentFragment();
-  var starts = [];
-  for(var i=0; i<codedStr.length; i++) {
-    var c = codedStr.charAt(i);
-    if (/[A-Z]/.test(c)) {
-      // open range
-      starts.push([curNode, curNode.childNodes.length]);
-    } else if (/[a-z]/.test(c)) {
-      // close range
-      var start = starts.pop();
-      var range =
-            new LiveRange(
-              self.tag, start[0].childNodes[start[1]],
-              start[0].lastChild);
-      range.letter = c.toUpperCase();
-      self.ranges[range.letter] = range;
-    } else if (c === '[') {
-      curNode.appendChild(document.createElement("DIV"));
-      curNode = curNode.lastChild;
-    } else if (c === ']') {
-      // close node
-      curNode = curNode.parentNode;
-    }
-  }
-
-  self.frag = curNode;
-
-  self.path = function(/*args*/) {
-    var node = self.frag;
-    _.each(arguments, function(i) {
-      node = node.childNodes[i];
-    });
-    return node;
-  };
-
-  self.findRange = function(node) {
-    return LiveRange.findRange(self.tag, node);
-  };
-
-  self.currentString = function() {
-    var buf = [];
-    var tempRange = new LiveRange(self.tag, self.frag);
-    tempRange.visit(function(isStart, range) {
-      buf.push(isStart ?
-               range.letter.toUpperCase() :
-               range.letter.toLowerCase());
-    }, function(isStart, node) {
-      buf.push(isStart ? '[' : ']');
-    });
-    tempRange.destroy();
-
-    return buf.join('').replace(/\[\]/g, '*');
-  };
-
-  return self;
-};
-
-Tinytest.add("liverange - findParent", function(test) {
-  var str = "I*[[AB[H***FDE*ed*fG*gh]*baC*c*]]i*";
-  var pat = makeTestPattern(str);
-  test.equal(pat.currentString(), str);
-
-  var ranges = pat.ranges;
-
-  test.equal(ranges.E.findParent().letter, 'D');
-  test.equal(ranges.D.findParent().letter, 'F');
-  test.equal(ranges.F.findParent().letter, 'H');
-  test.equal(ranges.H.findParent().letter, 'B');
-  test.equal(ranges.B.findParent().letter, 'A');
-  test.equal(ranges.A.findParent().letter, 'I');
-  test.equal(ranges.I.findParent(), null);
-
-  test.equal(ranges.E.findParent(true).letter, 'D');
-  test.equal(ranges.D.findParent(true).letter, 'F');
-  test.equal(ranges.F.findParent(true).letter, 'H');
-  test.equal(ranges.H.findParent(true), null);
-  test.equal(ranges.B.findParent(true).letter, 'A');
-  test.equal(ranges.A.findParent(true), null);
-  test.equal(ranges.I.findParent(true), null);
-
-
-  test.equal(pat.findRange(pat.path(0)).letter, 'I');
-  test.equal(pat.findRange(pat.path(1)).letter, 'I');
-  test.equal(pat.findRange(pat.path(2)), null);
-
-  test.equal(pat.findRange(pat.path(1, 0)).letter, 'I');
-  test.equal(pat.findRange(pat.path(1, 0, 0)).letter, 'B');
-  test.equal(pat.findRange(pat.path(1, 0, 1)).letter, 'B');
-  test.equal(pat.findRange(pat.path(1, 0, 2)).letter, 'C');
-  test.equal(pat.findRange(pat.path(1, 0, 3)).letter, 'I');
-
-  test.equal(pat.findRange(pat.path(1, 0, 0, 0)).letter, 'H');
-  test.equal(pat.findRange(pat.path(1, 0, 0, 1)).letter, 'H');
-  test.equal(pat.findRange(pat.path(1, 0, 0, 2)).letter, 'H');
-  test.equal(pat.findRange(pat.path(1, 0, 0, 3)).letter, 'E');
-  test.equal(pat.findRange(pat.path(1, 0, 0, 4)).letter, 'F');
-  test.equal(pat.findRange(pat.path(1, 0, 0, 5)).letter, 'G');
-
-});
-
-Tinytest.add("liverange - destroy", function(test) {
-  var str = "I*[[AB[H***FDE*ed*fG*gh]*baC*c*]]J*ji*";
-  var pat = makeTestPattern(str);
-
-  pat.ranges.D.destroy();
-  test.equal(pat.currentString(), str.replace(/[Dd]/g, ''));
-  pat.ranges.B.destroy();
-  test.equal(pat.currentString(), str.replace(/[DdBb]/g, ''));
-  pat.ranges.A.destroy();
-  test.equal(pat.currentString(), str.replace(/[DdBbAa]/g, ''));
-
-  // recursive destroy
-  pat.ranges.F.destroy(true);
-  test.equal(pat.currentString(),
-             "I*[[[H*****G*gh]*C*c*]]J*ji*");
-  pat.ranges.I.destroy(true);
-  test.equal(pat.currentString(),
-             "*[[[******]***]]**");
-
-  var childrenHaveNoTags = function(node) {
-    for(var n = node.firstChild; n; n = n.nextSibling) {
-      test.isFalse(node[pat.tag]);
-      if (n.firstChild)
-        childrenHaveNoTags(n); // recurse
-    }
-  };
-
-  childrenHaveNoTags(pat.frag);
-
-  // test recursive on single node
-  var frag = document.createDocumentFragment();
-  var txt = document.createComment("pudding");
-  frag.appendChild(txt);
-  var rng5 = new LiveRange('_pudding', txt);
-  var rng4 = new LiveRange('_pudding', txt);
-  var rng3 = new LiveRange('_pudding', txt);
-  var rng2 = new LiveRange('_pudding', txt);
-  var rng1 = new LiveRange('_pudding', txt);
-  rng1.num = 1;
-  rng2.num = 2;
-  rng3.num = 3;
-  rng4.num = 4;
-  rng5.num = 5;
-  // kill an inner range
-  rng4.destroy(true);
-  // check that outer ranges are still there
-  var buf = [];
-  rng1.visit(function(isStart, r) {
-    buf.push([isStart, r.num]);
-  });
-  test.equal(buf, [[true, 2], [true, 3], [false, 3], [false, 2]]);
-});
diff --git a/packages/liverange/package.js b/packages/liverange/package.js
deleted file mode 100644
index 8dc8ecc49e..0000000000
--- a/packages/liverange/package.js
+++ /dev/null
@@ -1,23 +0,0 @@
-Package.describe({
-  name: "liverange",
-  test: "liverange-test",
-  summary: "Mark, track, and update an arbitrary region in the DOM",
-  version: '1.0.0',
-  internal: true
-});
-
-Package.on_use(function (api) {
-  api.export('LiveRange', 'client');
-  api.add_files('liverange.js', 'client');
-});
-
-Package.on_test(function (api) {
-  api.use(['tinytest']);
-  api.use(['liverange', 'test-helpers', 'domutils', 'underscore', 'jquery'],
-          'client');
-
-  api.add_files([
-    'liverange_test_helpers.js',
-    'liverange_tests.js'
-  ], 'client');
-});
diff --git a/packages/madewith/madewith.css b/packages/madewith/madewith.css
deleted file mode 100644
index 4257396e81..0000000000
--- a/packages/madewith/madewith.css
+++ /dev/null
@@ -1,43 +0,0 @@
-/* CSS declarations go here */
-a.madewith_badge {
-  text-decoration: none;
-  z-index: 10000;
-  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
-  display: block;
-  position: absolute;
-  top: 0;
-  right: 0;
-  width: 280px;
-  height: 32px;
-  background-repeat: no-repeat;
-  background-position: left top;
-  font-weight: bold;
-}
-
-.madewith_upvote {
-  position: absolute;
-  top: 2px;
-  bottom: 2px;
-  left: 205px;
-  width: 26px;
-  cursor: pointer;
-  background-repeat: no-repeat;
-  background-position: 100px 100px; /* hidden */
-}
-
-.madewith_upvote:hover {
-  background-position: 5px 3px;
-}
-
-.madewith_vote_count {
-  position: absolute;
-  top: 2px;
-  bottom: 2px;
-  right: 2px;
-  width: 52px;
-  text-align: center;
-  overflow: visible;
-  color: #fff;
-  line-height: 28px;
-  font-size: 18px;
-}
\ No newline at end of file
diff --git a/packages/madewith/madewith.html b/packages/madewith/madewith.html
deleted file mode 100644
index 8bae7acd66..0000000000
--- a/packages/madewith/madewith.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<body>
-  {{> madewith}}
-</body>
-
-<template name="madewith">
-  <a class="madewith_badge" href="http://madewith.meteor.com/{{shortname}}" target="_blank">
-    <div class="madewith_votes">
-      <div class="madewith_upvote"></div>
-      <div class="madewith_vote_count">{{vote_count}}</div>
-    </div>
-  </a>
-</template>
diff --git a/packages/madewith/madewith.js b/packages/madewith/madewith.js
deleted file mode 100644
index 956296a1ad..0000000000
--- a/packages/madewith/madewith.js
+++ /dev/null
@@ -1,40 +0,0 @@
-// automatically capture this app's hostname
-var hostname = window.location.host;
-var match = hostname.match(/(.*)\.meteor.com$/);
-var shortname = match ? match[1] : hostname;
-
-// connect to madewith and subscribe to my app's record
-var server = DDP.connect("madewith.meteor.com");
-var sub = server.subscribe("myApp", hostname);
-
-// minimongo collection to hold my singleton app record.
-var apps = new Meteor.Collection('madewith_apps', {connection: server});
-
-server.methods({
-  vote: function (hostname) {
-    // This is a stub, so it doesn't need to call check.
-    apps.update({name: hostname}, {$inc: {vote_count: 1}});
-  }
-});
-
-Template.madewith.vote_count = function() {
-  var app = apps.findOne();
-  return app ? app.vote_count : '';
-};
-
-Template.madewith.shortname = function () {
-  return shortname;
-};
-
-Template.madewith.events({
-  'click .madewith_upvote': function(event) {
-    var app = apps.findOne();
-    if (app)
-      server.call('vote', hostname);
-
-    // stop these so you don't click through the link to go to the
-    // app.
-    event.stopPropagation();
-    event.preventDefault();
-  }
-});
diff --git a/packages/madewith/madewith_badge.css b/packages/madewith/madewith_badge.css
deleted file mode 100644
index 43f70b4a32..0000000000
--- a/packages/madewith/madewith_badge.css
+++ /dev/null
@@ -1,7 +0,0 @@
-.madewith_badge {
-  background-image:url(data:image/png;base64,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);
-}
-
-.madewith_upvote {
-  background-image:url(data:image/png;base64,R0lGODlhEQAXALMAACFogkiDcvL2CZe4TLnQLzR1d8zcJdXjG8zcHmiYdGOVXOHrFf3+AS9yoP//AAtZjyH5BAAAAAAALAAAAAARABcAAASO8LVHaRil0im1Es6RVRz3fE4qklLjJmCaGoHrdsEi7wTQSQXdjvcLIIbIwQQwQCIZg0cg5twZpAyZIJuiOgyAhPAw4H4HMUIDQAgVCmYEQJGNPhKrQNynQCQ2FXoyciw/WIM+gIaCKYSKJowOjh02L2YHNZWLZmCFkDuTJRVwMp2PGk0OAgoaoh4DARodEQA7);
-}
diff --git a/packages/madewith/package.js b/packages/madewith/package.js
deleted file mode 100644
index 046e205635..0000000000
--- a/packages/madewith/package.js
+++ /dev/null
@@ -1,14 +0,0 @@
-Package.describe({
-  summary: "Made With Meteor badge",
-  version: "1.0.0"
-});
-
-Package.on_use(function (api) {
-  api.use(['livedata', 'mongo-livedata', 'underscore', 'spark', 'templating'], 'client');
-
-  api.add_files([
-    'madewith.css',
-    'madewith_badge.css',
-    'madewith.html',
-    'madewith.js'], 'client');
-});
diff --git a/packages/meetup/meetup_client.js b/packages/meetup/meetup_client.js
index ee495a7598..03491dde2c 100644
--- a/packages/meetup/meetup_client.js
+++ b/packages/meetup/meetup_client.js
@@ -13,10 +13,11 @@ Meetup.requestCredential = function (options, credentialRequestCompleteCallback)
 
   var config = ServiceConfiguration.configurations.findOne({service: 'meetup'});
   if (!config) {
-    credentialRequestCompleteCallback && credentialRequestCompleteCallback(new ServiceConfiguration.ConfigError("Service not configured"));
+    credentialRequestCompleteCallback && credentialRequestCompleteCallback(
+      new ServiceConfiguration.ConfigError());
     return;
   }
-  var credentialToken = Random.id();
+  var credentialToken = Random.secret();
 
   var scope = (options && options.requestPermissions) || [];
   var flatScope = _.map(scope, encodeURIComponent).join('+');
@@ -34,7 +35,7 @@ Meetup.requestCredential = function (options, credentialRequestCompleteCallback)
   if (_.without(scope, 'basic').length)
     height += 130;
 
-  Oauth.showPopup(
+  OAuth.showPopup(
     loginUrl,
     _.bind(credentialRequestCompleteCallback, null, credentialToken),
     {width: 900, height: height}
diff --git a/packages/meetup/meetup_server.js b/packages/meetup/meetup_server.js
index fe4aa80e8e..38b4154df0 100644
--- a/packages/meetup/meetup_server.js
+++ b/packages/meetup/meetup_server.js
@@ -1,6 +1,6 @@
 Meetup = {};
 
-Oauth.registerService('meetup', 2, null, function(query) {
+OAuth.registerService('meetup', 2, null, function(query) {
 
   var accessToken = getAccessToken(query);
   var identity = getIdentity(accessToken);
@@ -17,7 +17,7 @@ Oauth.registerService('meetup', 2, null, function(query) {
 var getAccessToken = function (query) {
   var config = ServiceConfiguration.configurations.findOne({service: 'meetup'});
   if (!config)
-    throw new ServiceConfiguration.ConfigError("Service not configured");
+    throw new ServiceConfiguration.ConfigError();
 
   var response;
   try {
@@ -25,7 +25,7 @@ var getAccessToken = function (query) {
       "https://secure.meetup.com/oauth2/access", {headers: {Accept: 'application/json'}, params: {
         code: query.code,
         client_id: config.clientId,
-        client_secret: config.secret,
+        client_secret: OAuth.openSecret(config.secret),
         grant_type: 'authorization_code',
         redirect_uri: Meteor.absoluteUrl("_oauth/meetup?close"),
         state: query.state
@@ -56,5 +56,5 @@ var getIdentity = function (accessToken) {
 
 
 Meetup.retrieveCredential = function(credentialToken) {
-  return Oauth.retrieveCredential(credentialToken);
+  return OAuth.retrieveCredential(credentialToken);
 };
diff --git a/packages/meteor-developer/meteor_developer_client.js b/packages/meteor-developer/meteor_developer_client.js
index c76ebd9b66..58f3567cbc 100644
--- a/packages/meteor-developer/meteor_developer_client.js
+++ b/packages/meteor-developer/meteor_developer_client.js
@@ -8,13 +8,11 @@ var requestCredential = function (credentialRequestCompleteCallback) {
   });
   if (!config) {
     credentialRequestCompleteCallback &&
-      credentialRequestCompleteCallback(
-        new ServiceConfiguration.ConfigError("Service not configured")
-      );
+      credentialRequestCompleteCallback(new ServiceConfiguration.ConfigError());
     return;
   }
 
-  var credentialToken = Random.id();
+  var credentialToken = Random.secret();
 
   var loginUrl =
         MeteorDeveloperAccounts._server +
@@ -24,7 +22,7 @@ var requestCredential = function (credentialRequestCompleteCallback) {
         "client_id=" + config.clientId +
         "&redirect_uri=" + Meteor.absoluteUrl("_oauth/meteor-developer?close");
 
-  Oauth.showPopup(
+  OAuth.showPopup(
     loginUrl,
     _.bind(credentialRequestCompleteCallback, null, credentialToken),
     {
diff --git a/packages/meteor-developer/meteor_developer_server.js b/packages/meteor-developer/meteor_developer_server.js
index 385c873a00..a25ffbb3ac 100644
--- a/packages/meteor-developer/meteor_developer_server.js
+++ b/packages/meteor-developer/meteor_developer_server.js
@@ -1,10 +1,10 @@
-Oauth.registerService("meteor-developer", 2, null, function (query) {
+OAuth.registerService("meteor-developer", 2, null, function (query) {
   var response = getTokens(query);
   var accessToken = response.accessToken;
   var identity = getIdentity(accessToken);
 
   var serviceData = {
-    accessToken: accessToken,
+    accessToken: OAuth.sealSecret(accessToken),
     expiresAt: (+new Date) + (1000 * response.expiresIn)
   };
 
@@ -14,7 +14,7 @@ Oauth.registerService("meteor-developer", 2, null, function (query) {
   // that we don't lose old ones (since we only get this on the first
   // log in attempt)
   if (response.refreshToken)
-    serviceData.refreshToken = response.refreshToken;
+    serviceData.refreshToken = OAuth.sealSecret(response.refreshToken);
 
   return {
     serviceData: serviceData,
@@ -33,7 +33,7 @@ var getTokens = function (query) {
     service: 'meteor-developer'
   });
   if (!config)
-    throw new ServiceConfiguration.ConfigError("Service not configured");
+    throw new ServiceConfiguration.ConfigError();
 
   var response;
   try {
@@ -43,7 +43,7 @@ var getTokens = function (query) {
           grant_type: "authorization_code",
           code: query.code,
           client_id: config.clientId,
-          client_secret: config.secret,
+          client_secret: OAuth.openSecret(config.secret),
           redirect_uri: Meteor.absoluteUrl("_oauth/meteor-developer?close")
         }
       }
@@ -92,5 +92,5 @@ var getIdentity = function (accessToken) {
 };
 
 MeteorDeveloperAccounts.retrieveCredential = function (credentialToken) {
-  return Oauth.retrieveCredential(credentialToken);
+  return OAuth.retrieveCredential(credentialToken);
 };
diff --git a/packages/meteor/url_server.js b/packages/meteor/url_server.js
index 81b55e776f..9eee42f0c3 100644
--- a/packages/meteor/url_server.js
+++ b/packages/meteor/url_server.js
@@ -1,6 +1,15 @@
 if (process.env.ROOT_URL &&
     typeof __meteor_runtime_config__ === "object") {
   __meteor_runtime_config__.ROOT_URL = process.env.ROOT_URL;
-  var pathPrefix = Npm.require('url').parse(__meteor_runtime_config__.ROOT_URL).pathname;
-  __meteor_runtime_config__.ROOT_URL_PATH_PREFIX = pathPrefix === "/" ? "" : pathPrefix;
+  if (__meteor_runtime_config__.ROOT_URL) {
+    var parsedUrl = Npm.require('url').parse(__meteor_runtime_config__.ROOT_URL);
+    // Sometimes users try to pass, eg, ROOT_URL=mydomain.com.
+    if (!parsedUrl.host) {
+      throw Error("$ROOT_URL, if specified, must be an URL");
+    }
+    var pathPrefix = parsedUrl.pathname;
+    __meteor_runtime_config__.ROOT_URL_PATH_PREFIX = pathPrefix === "/" ? "" : pathPrefix;
+  } else {
+    __meteor_runtime_config__.ROOT_URL_PATH_PREFIX = "";
+  }
 }
diff --git a/packages/minifiers/.npm/package/npm-shrinkwrap.json b/packages/minifiers/.npm/package/npm-shrinkwrap.json
index 0b7c29a8b4..4b424c691b 100644
--- a/packages/minifiers/.npm/package/npm-shrinkwrap.json
+++ b/packages/minifiers/.npm/package/npm-shrinkwrap.json
@@ -1,5 +1,21 @@
 {
   "dependencies": {
+    "css-parse": {
+      "version": "https://github.com/reworkcss/css-parse/tarball/aa7e23285375ca621dd20250bac0266c6d8683a5"
+    },
+    "css-stringify": {
+      "version": "https://github.com/reworkcss/css-stringify/tarball/a7fe6de82e055d41d1c5923ec2ccef06f2a45efa",
+      "dependencies": {
+        "source-map": {
+          "version": "0.1.33",
+          "dependencies": {
+            "amdefine": {
+              "version": "0.1.0"
+            }
+          }
+        }
+      }
+    },
     "uglify-js": {
       "version": "2.4.7",
       "dependencies": {
@@ -26,22 +42,6 @@
           "version": "1.0.1"
         }
       }
-    },
-    "css-parse": {
-      "version": "1.7.0"
-    },
-    "css-stringify": {
-      "version": "1.4.1",
-      "dependencies": {
-        "source-map": {
-          "version": "0.1.31",
-          "dependencies": {
-            "amdefine": {
-              "version": "0.1.0"
-            }
-          }
-        }
-      }
     }
   }
 }
diff --git a/packages/minifiers/beautify-tests.js b/packages/minifiers/beautify-tests.js
new file mode 100644
index 0000000000..b519b19a9b
--- /dev/null
+++ b/packages/minifiers/beautify-tests.js
@@ -0,0 +1,16 @@
+
+// The UglifyJSMinify API can also be used for beautification.  Test that it
+// behaves as expected.
+
+Tinytest.add('minifiers - uglify beautify', function (test) {
+  // See <https://github.com/mishoo/UglifyJS2#the-simple-way> and
+  // <http://lisperator.net/uglifyjs/codegen> for the API we're calling.
+  test.equal(UglifyJSMinify('one = function () { return 1; };',
+                            { fromString: true,
+                              output: { beautify: true,
+                                        indent_level: 2,
+                                        width: 80 } }).code,
+             'one = function() {\n' +
+             '  return 1;\n' +
+             '};');
+});
diff --git a/packages/minifiers/minification.js b/packages/minifiers/minification.js
index 567b8af8c9..1637b51670 100644
--- a/packages/minifiers/minification.js
+++ b/packages/minifiers/minification.js
@@ -95,6 +95,13 @@ traverse.page = function(node) {
     + emit('}');
 };
 
+traverse['font-face'] = function(node){
+  return emit('@font-face', node.position, true)
+    + emit('{')
+    + mapVisit(node.declarations)
+    + emit('}');
+};
+
 traverse.rule = function(node) {
   var decls = node.declarations;
   if (!decls.length) return '';
diff --git a/packages/minifiers/minifiers-tests.js b/packages/minifiers/minifiers-tests.js
index 282517b430..4f62599fb6 100644
--- a/packages/minifiers/minifiers-tests.js
+++ b/packages/minifiers/minifiers-tests.js
@@ -1,3 +1,4 @@
+
 Tinytest.add("minifiers - simple css minification", function (test) {
   var t = function (css, expected, desc) {
     test.equal(CssTools.minifyCss(css), expected, desc);
@@ -18,4 +19,3 @@ Tinytest.add("minifiers - simple css minification", function (test) {
   'a{font:12px Helvetica,Arial,Nautica;background:url("/some/nice/picture.png")}',  'removing quotes in font and url (if possible)');
   t('/* no comments */ a { color: red; }', 'a{color:red}', 'remove comments');
 });
-
diff --git a/packages/minifiers/minifiers.js b/packages/minifiers/minifiers.js
index 133cf3610c..3d4496c803 100644
--- a/packages/minifiers/minifiers.js
+++ b/packages/minifiers/minifiers.js
@@ -2,6 +2,8 @@ UglifyJSMinify = Npm.require('uglify-js').minify;
 
 var cssParse = Npm.require('css-parse');
 var cssStringify = Npm.require('css-stringify');
+var path = Npm.require('path');
+var url = Npm.require('url');
 
 CssTools = {
   parseCss: cssParse,
@@ -52,6 +54,8 @@ CssTools = {
           break;
         }
 
+      CssTools.rewriteCssUrls(ast);
+
       var imports = ast.stylesheet.rules.splice(0, importCount);
       newAst.stylesheet.rules = newAst.stylesheet.rules.concat(imports);
 
@@ -71,6 +75,50 @@ CssTools = {
     });
 
     return newAst;
+  },
+
+  // We are looking for all relative urls defined with the `url()` functional
+  // notation and rewriting them to the equivalent absolute url using the
+  // `position.source` path provided by css-parse
+  // For performance reasons this function acts by side effect by modifying the
+  // given AST without doing a deep copy.
+  rewriteCssUrls: function (ast) {
+
+    var isRelative = function(path) {
+      return path.charAt(0) !== '/';
+    };
+
+    _.each(ast.stylesheet.rules, function(rule, ruleIndex) {
+      var basePath = path.dirname(rule.position.source);
+
+      _.each(rule.declarations, function(declaration, declarationIndex) {
+        var parts, resource, absolutePath, quotes, oldCssUrl, newCssUrl;
+        var value = declaration.value;
+
+        // Match css values containing some functional calls to `url(URI)` where
+        // URI is optionally quoted.
+        // Note that a css value can contains other elements, for instance:
+        //   background: top center url("background.png") black;
+        // or even multiple url(), for instance for multiple backgrounds.
+        var cssUrlRegex = /url\s*\(\s*(['"]?)(.+?)\1\s*\)/gi;
+        while (parts = cssUrlRegex.exec(value)) {
+          oldCssUrl = parts[0];
+          quotes = parts[1];
+          resource = url.parse(parts[2]);
+
+          // Rewrite relative paths to absolute paths.
+          // We don't rewrite urls starting with a protocol definition such as
+          // http, https, or data.
+          if (isRelative(resource.path) && resource.protocol === null) {
+            absolutePath = path.join(basePath, resource.path);
+            newCssUrl = "url(" + quotes + absolutePath + quotes + ")";
+            value = value.replace(oldCssUrl, newCssUrl);
+          }
+        }
+
+        declaration.value = value;
+      });
+    });
   }
 };
 
diff --git a/packages/minifiers/package.js b/packages/minifiers/package.js
index cfa9f18792..7cfa9a27b6 100644
--- a/packages/minifiers/package.js
+++ b/packages/minifiers/package.js
@@ -8,8 +8,8 @@ Package.describe({
 
 Npm.depends({
   "uglify-js": "2.4.7",
-  "css-parse": "1.7.0",
-  "css-stringify": "1.4.1"
+  "css-parse": "https://github.com/reworkcss/css-parse/tarball/aa7e23285375ca621dd20250bac0266c6d8683a5",
+  "css-stringify": "https://github.com/reworkcss/css-stringify/tarball/a7fe6de82e055d41d1c5923ec2ccef06f2a45efa"
 });
 
 Package.on_use(function (api) {
@@ -21,6 +21,10 @@ Package.on_use(function (api) {
 Package.on_test(function (api) {
   api.use('minifiers', 'server');
   api.use('tinytest');
-  api.add_files('minifiers-tests.js', 'server');
-});
 
+  api.add_files([
+    'beautify-tests.js',
+    'minifiers-tests.js',
+    'urlrewriting-tests.js'
+  ], 'server');
+});
diff --git a/packages/minifiers/urlrewriting-tests.js b/packages/minifiers/urlrewriting-tests.js
new file mode 100644
index 0000000000..6314f619c7
--- /dev/null
+++ b/packages/minifiers/urlrewriting-tests.js
@@ -0,0 +1,32 @@
+
+Tinytest.add("minifiers - url rewriting when merging", function (test) {
+  var stylesheet = function(backgroundPath) {
+    return "body { color: green; background: top center url(" + backgroundPath + ") black, bottom center url(" + backgroundPath + "); }"
+  };
+
+  var filename = 'dir/subdir/style.css';
+  var parseOptions = { source: filename, position: true };
+
+  var t = function(relativeUrl, absoluteUrl, desc) {
+    var ast1 = CssTools.parseCss(stylesheet(relativeUrl), parseOptions);
+    var ast2 = CssTools.parseCss(stylesheet(absoluteUrl), parseOptions);
+    CssTools.rewriteCssUrls(ast1);
+
+    test.equal(CssTools.stringifyCss(ast1), CssTools.stringifyCss(ast2), desc);
+  };
+
+  t('../image.png', 'dir/image.png', 'parent directory');
+  t('./../image.png', 'dir/image.png', 'parent directory');
+  t('../subdir2/image.png', 'dir/subdir2/image.png', 'cousin directory');
+  t('../../image.png', 'image.png', 'grand parent directory');
+  t('./image.png', 'dir/subdir/image.png', 'current directory');
+  t('./child/image.png', 'dir/subdir/child/image.png', 'child directory');
+  t('child/image.png', 'dir/subdir/child/image.png', 'child directory');
+  t('/image.png', '/image.png', 'absolute url');
+  t('"/image.png"', '"/image.png"', 'double quoted url');
+  t("'/image.png'", "'/image.png'", 'single quoted url');
+  t('"./../image.png"', '"dir/image.png"', 'quoted parent directory');
+  t('http://i.imgur.com/fBcdJIh.gif', 'http://i.imgur.com/fBcdJIh.gif', 'complete URL');
+  t('"http://i.imgur.com/fBcdJIh.gif"', '"http://i.imgur.com/fBcdJIh.gif"', 'complete quoted URL');
+  t('data:image/png;base64,iVBORw0K=', 'data:image/png;base64,iVBORw0K=', 'data URI');
+});
diff --git a/packages/mongo-livedata/.npm/package/npm-shrinkwrap.json b/packages/mongo-livedata/.npm/package/npm-shrinkwrap.json
index 6b4a386b67..ea17322d4e 100644
--- a/packages/mongo-livedata/.npm/package/npm-shrinkwrap.json
+++ b/packages/mongo-livedata/.npm/package/npm-shrinkwrap.json
@@ -1,10 +1,15 @@
 {
   "dependencies": {
     "mongodb": {
-      "version": "https://github.com/meteor/node-mongodb-native/tarball/779bbac916a751f305d84c727a6cc7dfddab7924",
+      "version": "1.4.1",
       "dependencies": {
         "bson": {
-          "version": "0.2.2"
+          "version": "0.2.7",
+          "dependencies": {
+            "nan": {
+              "version": "0.8.0"
+            }
+          }
         },
         "kerberos": {
           "version": "0.0.3"
diff --git a/packages/mongo-livedata/allow_tests.js b/packages/mongo-livedata/allow_tests.js
index ea2fb5b58d..e3f6c9e35e 100644
--- a/packages/mongo-livedata/allow_tests.js
+++ b/packages/mongo-livedata/allow_tests.js
@@ -132,7 +132,8 @@ if (Meteor.isServer) {
         }
       }, {
         insert: function(userId, doc) {
-          return doc.cantInsert2;
+          // Don't allow explicit ID to be set by the client.
+          return _.has(doc, '_id');
         },
         update: function(userId, doc, fields, modifier) {
           return -1 !== _.indexOf(fields, 'verySecret');
@@ -560,7 +561,7 @@ if (Meteor.isClient) {
           // insert with one allow and other deny. denied.
           function (test, expect) {
             collection.insert(
-              {canInsert: true, cantInsert2: true},
+              {canInsert: true, _id: Random.id()},
               expect(function (err, res) {
                 test.equal(err.error, 403);
                 test.equal(collection.find().count(), 0);
diff --git a/packages/mongo-livedata/collection.js b/packages/mongo-livedata/collection.js
index 4c0f1ff229..77a3ef714f 100644
--- a/packages/mongo-livedata/collection.js
+++ b/packages/mongo-livedata/collection.js
@@ -40,13 +40,15 @@ Meteor.Collection = function (name, options) {
   switch (options.idGeneration) {
   case 'MONGO':
     self._makeNewID = function () {
-      return new Meteor.Collection.ObjectID();
+      var src = name ? DDP.randomStream('/collection/' + name) : Random;
+      return new Meteor.Collection.ObjectID(src.hexString(24));
     };
     break;
   case 'STRING':
   default:
     self._makeNewID = function () {
-      return Random.id();
+      var src = name ? DDP.randomStream('/collection/' + name) : Random;
+      return src.id();
     };
     break;
   }
@@ -378,7 +380,19 @@ _.each(["insert", "update", "remove"], function (name) {
               || insertId instanceof Meteor.Collection.ObjectID))
           throw new Error("Meteor requires document _id fields to be non-empty strings or ObjectIDs");
       } else {
-        insertId = args[0]._id = self._makeNewID();
+        var generateId = true;
+        // Don't generate the id if we're the client and the 'outermost' call
+        // This optimization saves us passing both the randomSeed and the id
+        // Passing both is redundant.
+        if (self._connection && self._connection !== Meteor.server) {
+          var enclosing = DDP._CurrentInvocation.get();
+          if (!enclosing) {
+            generateId = false;
+          }
+        }
+        if (generateId) {
+          insertId = args[0]._id = self._makeNewID();
+        }
       }
     } else {
       args[0] = Meteor.Collection._rewriteSelector(args[0]);
@@ -405,10 +419,14 @@ _.each(["insert", "update", "remove"], function (name) {
     // On inserts, always return the id that we generated; on all other
     // operations, just return the result from the collection.
     var chooseReturnValueFromCollectionResult = function (result) {
-      if (name === "insert")
+      if (name === "insert") {
+        if (!insertId && result) {
+          insertId = result;
+        }
         return insertId;
-      else
+      } else {
         return result;
+      }
     };
 
     var wrappedCallback;
@@ -449,7 +467,7 @@ _.each(["insert", "update", "remove"], function (name) {
       }
 
       ret = chooseReturnValueFromCollectionResult(
-        self._connection.apply(self._prefix + name, args, wrappedCallback)
+        self._connection.apply(self._prefix + name, args, {returnStubValue: true}, wrappedCallback)
       );
 
     } else {
@@ -642,13 +660,31 @@ Meteor.Collection.prototype._defineMutationMethods = function() {
       m[self._prefix + method] = function (/* ... */) {
         // All the methods do their own validation, instead of using check().
         check(arguments, [Match.Any]);
+        var args = _.toArray(arguments);
         try {
-          if (this.isSimulation) {
+          // For an insert, if the client didn't specify an _id, generate one
+          // now; because this uses DDP.randomStream, it will be consistent with
+          // what the client generated. We generate it now rather than later so
+          // that if (eg) an allow/deny rule does an insert to the same
+          // collection (not that it really should), the generated _id will
+          // still be the first use of the stream and will be consistent.
+          //
+          // However, we don't actually stick the _id onto the document yet,
+          // because we want allow/deny rules to be able to differentiate
+          // between arbitrary client-specified _id fields and merely
+          // client-controlled-via-randomSeed fields.
+          var generatedId = null;
+          if (method === "insert" && !_.has(args[0], '_id')) {
+            generatedId = self._makeNewID();
+          }
 
+          if (this.isSimulation) {
             // In a client simulation, you can do any mutation (even with a
             // complex selector).
+            if (generatedId !== null)
+              args[0]._id = generatedId;
             return self._collection[method].apply(
-              self._collection, _.toArray(arguments));
+              self._collection, args);
           }
 
           // This is the server receiving a method call from the client.
@@ -656,7 +692,7 @@ Meteor.Collection.prototype._defineMutationMethods = function() {
           // We don't allow arbitrary selectors in mutations from the client: only
           // single-ID selectors.
           if (method !== 'insert')
-            throwIfSelectorIsNotId(arguments[0], method);
+            throwIfSelectorIsNotId(args[0], method);
 
           if (self._restricted) {
             // short circuit if there is no way it will pass.
@@ -668,12 +704,14 @@ Meteor.Collection.prototype._defineMutationMethods = function() {
 
             var validatedMethodName =
                   '_validated' + method.charAt(0).toUpperCase() + method.slice(1);
-            var argsWithUserId = [this.userId].concat(_.toArray(arguments));
-            return self[validatedMethodName].apply(self, argsWithUserId);
+            args.unshift(this.userId);
+            generatedId !== null && args.push(generatedId);
+            return self[validatedMethodName].apply(self, args);
           } else if (self._isInsecure()) {
+            if (generatedId !== null)
+              args[0]._id = generatedId;
             // In insecure mode, allow any mutation (with a simple selector).
-            return self._collection[method].apply(self._collection,
-                                                  _.toArray(arguments));
+            return self._collection[method].apply(self._collection, args);
           } else {
             // In secure mode, if we haven't called allow or deny, then nothing
             // is permitted.
@@ -719,30 +757,46 @@ Meteor.Collection.prototype._isInsecure = function () {
   return self._insecure;
 };
 
-var docToValidate = function (validator, doc) {
+var docToValidate = function (validator, doc, generatedId) {
   var ret = doc;
-  if (validator.transform)
-    ret = validator.transform(EJSON.clone(doc));
+  if (validator.transform) {
+    ret = EJSON.clone(doc);
+    // If you set a server-side transform on your collection, then you don't get
+    // to tell the difference between "client specified the ID" and "server
+    // generated the ID", because transforms expect to get _id.  If you want to
+    // do that check, you can do it with a specific
+    // `C.allow({insert: f, transform: null})` validator.
+    if (generatedId !== null) {
+      ret._id = generatedId;
+    }
+    ret = validator.transform(ret);
+  }
   return ret;
 };
 
-Meteor.Collection.prototype._validatedInsert = function(userId, doc) {
+Meteor.Collection.prototype._validatedInsert = function (userId, doc,
+                                                         generatedId) {
   var self = this;
 
   // call user validators.
   // Any deny returns true means denied.
   if (_.any(self._validators.insert.deny, function(validator) {
-    return validator(userId, docToValidate(validator, doc));
+    return validator(userId, docToValidate(validator, doc, generatedId));
   })) {
     throw new Meteor.Error(403, "Access denied");
   }
   // Any allow returns true means proceed. Throw error if they all fail.
   if (_.all(self._validators.insert.allow, function(validator) {
-    return !validator(userId, docToValidate(validator, doc));
+    return !validator(userId, docToValidate(validator, doc, generatedId));
   })) {
     throw new Meteor.Error(403, "Access denied");
   }
 
+  // If we generated an ID above, insert it now: after the validation, but
+  // before actually inserting.
+  if (generatedId !== null)
+    doc._id = generatedId;
+
   self._collection.insert.call(self._collection, doc);
 };
 
diff --git a/packages/mongo-livedata/mongo_driver.js b/packages/mongo-livedata/mongo_driver.js
index e43e00d68c..a7e9535888 100644
--- a/packages/mongo-livedata/mongo_driver.js
+++ b/packages/mongo-livedata/mongo_driver.js
@@ -113,6 +113,7 @@ MongoConnection = function (url, options) {
   options = options || {};
   self._connectCallbacks = [];
   self._observeMultiplexers = {};
+  self._onFailoverHook = new Hook;
 
   var mongoOptions = {db: {safe: true}, server: {}, replSet: {}};
 
@@ -144,18 +145,42 @@ MongoConnection = function (url, options) {
     mongoOptions.replSet.poolSize = options.poolSize;
   }
 
-  MongoDB.connect(url, mongoOptions, function(err, db) {
+  MongoDB.connect(url, mongoOptions, Meteor.bindEnvironment(function(err, db) {
     if (err)
       throw err;
     self.db = db;
+    // We keep track of the ReplSet's primary, so that we can trigger hooks when
+    // it changes.  The Node driver's joined callback seems to fire way too
+    // often, which is why we need to track it ourselves.
+    self._primary = null;
+    // First, figure out what the current primary is, if any.
+    if (self.db.serverConfig._state.master)
+      self._primary = self.db.serverConfig._state.master.name;
+    self.db.serverConfig.on(
+      'joined', Meteor.bindEnvironment(function (kind, doc) {
+        if (kind === 'primary') {
+          if (doc.primary !== self._primary) {
+            self._primary = doc.primary;
+            self._onFailoverHook.each(function (callback) {
+              callback();
+              return true;
+            });
+          }
+        } else if (doc.me === self._primary) {
+          // The thing we thought was primary is now something other than
+          // primary.  Forget that we thought it was primary.  (This means that
+          // if a server stops being primary and then starts being primary again
+          // without another server becoming primary in the middle, we'll
+          // correctly count it as a failover.)
+          self._primary = null;
+        }
+    }));
 
-    Fiber(function () {
-      // drain queue of pending callbacks
-      _.each(self._connectCallbacks, function (c) {
-        c(db);
-      });
-    }).run();
-  });
+    // drain queue of pending callbacks
+    _.each(self._connectCallbacks, function (c) {
+      c(db);
+    });
+  }));
 
   self._docFetcher = new DocFetcher(self);
   self._oplogHandle = null;
@@ -229,6 +254,12 @@ MongoConnection.prototype._maybeBeginWrite = function () {
     return {committed: function () {}};
 };
 
+// Internal interface: adds a callback which is called when the Mongo primary
+// changes. Returns a stop handle.
+MongoConnection.prototype._onFailover = function (callback) {
+  return this._onFailoverHook.register(callback);
+};
+
 
 //////////// Public API //////////
 
diff --git a/packages/mongo-livedata/mongo_livedata_tests.js b/packages/mongo-livedata/mongo_livedata_tests.js
index 20f2126886..4ec23a95a3 100644
--- a/packages/mongo-livedata/mongo_livedata_tests.js
+++ b/packages/mongo-livedata/mongo_livedata_tests.js
@@ -2,6 +2,10 @@
 // the selector (or inserted document) contains fail: true.
 
 var TRANSFORMS = {};
+
+// We keep track of the collections, so we can refer to them by name
+var COLLECTIONS = {};
+
 if (Meteor.isServer) {
   Meteor.methods({
     createInsecureCollection: function (name, options) {
@@ -15,6 +19,7 @@ if (Meteor.isServer) {
         options.transform = TRANSFORMS[options.transformName];
       }
       var c = new Meteor.Collection(name, options);
+      COLLECTIONS[name] = c;
       c._insecure = true;
       Meteor.publish('c-' + name, function () {
         return c.find();
@@ -23,6 +28,32 @@ if (Meteor.isServer) {
   });
 }
 
+// We store the generated id, keyed by collection, for each insert
+// This is so we can test the stub and the server generate the same id
+var INSERTED_IDS = {};
+
+Meteor.methods({
+  insertObjects: function (collectionName, doc, count) {
+    var c = COLLECTIONS[collectionName];
+    var ids = [];
+    for (var i = 0; i < count; i++) {
+      var id = c.insert(doc);
+      INSERTED_IDS[collectionName] = (INSERTED_IDS[collectionName] || []).concat([id]);
+      ids.push(id);
+    }
+    return ids;
+  },
+  upsertObject: function (collectionName, selector, modifier) {
+    var c = COLLECTIONS[collectionName];
+    return c.upsert(selector, modifier);
+  },
+  doMeteorCall: function (name /*, arguments */) {
+    var args = Array.prototype.slice.call(arguments);
+
+    return Meteor.call.apply(null, args);
+  }
+});
+
 var runInFence = function (f) {
   if (Meteor.isClient) {
     f();
@@ -1239,7 +1270,7 @@ testAsyncMulti('mongo-livedata - document with length, ' + idGeneration, [
     var self = this;
     var collectionName = Random.id();
     if (Meteor.isClient) {
-      Meteor.call('createInsecureCollection', collectionName);
+      Meteor.call('createInsecureCollection', collectionName, collectionOptions);
       Meteor.subscribe('c-' + collectionName);
     }
 
@@ -2125,6 +2156,193 @@ testAsyncMulti('mongo-livedata - specified _id', [
   }
 ]);
 
+
+// Consistent id generation tests
+function collectionInsert (test, expect, coll, index) {
+  var clientSideId = coll.insert({name: "foo"}, expect(function (err1, id) {
+    test.equal(id, clientSideId);
+    var o = coll.findOne(id);
+    test.isTrue(_.isObject(o));
+    test.equal(o.name, 'foo');
+  }));
+};
+
+function collectionUpsert (test, expect, coll, index) {
+  var upsertId = '123456' + index;
+
+  coll.upsert(upsertId, {$set: {name: "foo"}}, expect(function (err1, result) {
+    test.equal(result.insertedId, upsertId);
+    test.equal(result.numberAffected, 1);
+
+    var o = coll.findOne(upsertId);
+    test.isTrue(_.isObject(o));
+    test.equal(o.name, 'foo');
+  }));
+};
+
+function collectionUpsertExisting (test, expect, coll, index) {
+  var clientSideId = coll.insert({name: "foo"}, expect(function (err1, id) {
+    test.equal(id, clientSideId);
+
+    var o = coll.findOne(id);
+    test.isTrue(_.isObject(o));
+    // We're not testing sequencing/visibility rules here, so skip this check
+    // test.equal(o.name, 'foo');
+  }));
+
+  coll.upsert(clientSideId, {$set: {name: "bar"}}, expect(function (err1, result) {
+    test.equal(result.insertedId, clientSideId);
+    test.equal(result.numberAffected, 1);
+
+    var o = coll.findOne(clientSideId);
+    test.isTrue(_.isObject(o));
+    test.equal(o.name, 'bar');
+  }));
+};
+
+function functionCallsInsert (test, expect, coll, index) {
+  Meteor.call("insertObjects", coll._name, {name: "foo"}, 1, expect(function (err1, ids) {
+    test.notEqual((INSERTED_IDS[coll._name] || []).length, 0);
+    var stubId = INSERTED_IDS[coll._name][index];
+
+    test.equal(ids.length, 1);
+    test.equal(ids[0], stubId);
+
+    var o = coll.findOne(stubId);
+    test.isTrue(_.isObject(o));
+    test.equal(o.name, 'foo');
+  }));
+};
+
+function functionCallsUpsert (test, expect, coll, index) {
+  var upsertId = '123456' + index;
+  Meteor.call("upsertObject", coll._name, upsertId, {$set:{name: "foo"}}, expect(function (err1, result) {
+    test.equal(result.insertedId, upsertId);
+    test.equal(result.numberAffected, 1);
+
+    var o = coll.findOne(upsertId);
+    test.isTrue(_.isObject(o));
+    test.equal(o.name, 'foo');
+  }));
+};
+
+function functionCallsUpsertExisting (test, expect, coll, index) {
+  var id = coll.insert({name: "foo"});
+
+  var o = coll.findOne(id);
+  test.notEqual(null, o);
+  test.equal(o.name, 'foo');
+
+  Meteor.call("upsertObject", coll._name, id, {$set:{name: "bar"}}, expect(function (err1, result) {
+    test.equal(result.numberAffected, 1);
+    test.equal(result.insertedId, undefined);
+
+    var o = coll.findOne(id);
+    test.isTrue(_.isObject(o));
+    test.equal(o.name, 'bar');
+  }));
+};
+
+function functionCalls3Inserts (test, expect, coll, index) {
+  Meteor.call("insertObjects", coll._name, {name: "foo"}, 3, expect(function (err1, ids) {
+    test.notEqual((INSERTED_IDS[coll._name] || []).length, 0);
+    test.equal(ids.length, 3);
+
+    for (var i = 0; i < 3; i++) {
+      var stubId = INSERTED_IDS[coll._name][(3 * index) + i];
+      test.equal(ids[i], stubId);
+
+      var o = coll.findOne(stubId);
+      test.isTrue(_.isObject(o));
+      test.equal(o.name, 'foo');
+    }
+  }));
+};
+
+function functionChainInsert (test, expect, coll, index) {
+  Meteor.call("doMeteorCall", "insertObjects", coll._name, {name: "foo"}, 1, expect(function (err1, ids) {
+    test.notEqual((INSERTED_IDS[coll._name] || []).length, 0);
+    var stubId = INSERTED_IDS[coll._name][index];
+
+    test.equal(ids.length, 1);
+    test.equal(ids[0], stubId);
+
+    var o = coll.findOne(stubId);
+    test.isTrue(_.isObject(o));
+    test.equal(o.name, 'foo');
+  }));
+};
+
+function functionChain2Insert (test, expect, coll, index) {
+  Meteor.call("doMeteorCall", "doMeteorCall", "insertObjects", coll._name, {name: "foo"}, 1, expect(function (err1, ids) {
+    test.notEqual((INSERTED_IDS[coll._name] || []).length, 0);
+    var stubId = INSERTED_IDS[coll._name][index];
+
+    test.equal(ids.length, 1);
+    test.equal(ids[0], stubId);
+
+    var o = coll.findOne(stubId);
+    test.isTrue(_.isObject(o));
+    test.equal(o.name, 'foo');
+  }));
+};
+
+function functionChain2Upsert (test, expect, coll, index) {
+  var upsertId = '123456' + index;
+  Meteor.call("doMeteorCall", "doMeteorCall", "upsertObject", coll._name, upsertId, {$set:{name: "foo"}}, expect(function (err1, result) {
+    test.equal(result.insertedId, upsertId);
+    test.equal(result.numberAffected, 1);
+
+    var o = coll.findOne(upsertId);
+    test.isTrue(_.isObject(o));
+    test.equal(o.name, 'foo');
+  }));
+};
+
+_.each( [collectionInsert, collectionUpsert,
+         functionCallsInsert, functionCallsUpsert, functionCallsUpsertExisting,
+         functionCalls3Inserts,
+         functionChainInsert,
+         functionChain2Insert, functionChain2Upsert], function (fn) {
+_.each( [1, 3], function (repetitions) {
+_.each( [1, 3], function (collectionCount) {
+_.each( ['STRING', 'MONGO'], function (idGeneration) {
+
+  testAsyncMulti('mongo-livedata - consistent _id generation ' + fn.name + ', ' + repetitions + ' repetitions on ' + collectionCount + ' collections, idGeneration=' + idGeneration, [ function (test, expect) {
+    var collectionOptions = { idGeneration: idGeneration };
+
+    var collections = [];
+
+    for (var i = 0; i < collectionCount; i++) {
+      var collectionName = "consistentid_" + Random.id();
+      if (Meteor.isClient) {
+        Meteor.call('createInsecureCollection', collectionName, collectionOptions);
+        Meteor.subscribe('c-' + collectionName);
+      }
+
+      var coll = new Meteor.Collection(collectionName, collectionOptions);
+      COLLECTIONS[collectionName] = coll;
+
+      collections.push(coll);
+    }
+
+    // Reset state before actual test
+    INSERTED_IDS = {};
+
+    for (var i = 0; i < repetitions; i++) {
+      for (var j = 0; j < collectionCount; j++) {
+        fn(test, expect, collections[j], i);
+      }
+    }
+  }]);
+
+});
+});
+});
+});
+
+
+
 testAsyncMulti('mongo-livedata - empty string _id', [
   function (test, expect) {
     var self = this;
@@ -2676,3 +2894,21 @@ var waitUntilOplogCaughtUp = function () {
     oplogHandle.waitUntilCaughtUp();
 };
 
+
+Meteor.isServer && Tinytest.add("mongo-livedata - cursor dedup stop", function (test) {
+  var coll = new Meteor.Collection(Random.id());
+  _.times(100, function () {
+    coll.insert({foo: 'baz'});
+  });
+  var handler = coll.find({}).observeChanges({
+    added: function (id) {
+      coll.update(id, {$set: {foo: 'bar'}});
+    }
+  });
+  handler.stop();
+  // Previously, this would print
+  //    Exception in queued task: TypeError: Object.keys called on non-object
+  // Unfortunately, this test didn't fail before the bugfix, but it at least
+  // would print the error and no longer does.
+  // See https://github.com/meteor/meteor/issues/2070
+});
diff --git a/packages/mongo-livedata/observe_multiplex.js b/packages/mongo-livedata/observe_multiplex.js
index 8aa41ac6eb..f95e0388db 100644
--- a/packages/mongo-livedata/observe_multiplex.js
+++ b/packages/mongo-livedata/observe_multiplex.js
@@ -131,6 +131,10 @@ _.extend(ObserveMultiplexer.prototype, {
   _applyCallback: function (callbackName, args) {
     var self = this;
     self._queue.queueTask(function () {
+      // If we stopped in the meantime, do nothing.
+      if (!self._handles)
+        return;
+
       // First, apply the change to the cache.
       // XXX We could make applyChange callbacks promise not to hang on to any
       // state from their arguments (assuming that their supplied callbacks
@@ -151,7 +155,7 @@ _.extend(ObserveMultiplexer.prototype, {
       // use a handle that got removed, because removeHandle does not use the
       // queue; thus, we iterate over an array of keys that we control.)
       _.each(_.keys(self._handles), function (handleId) {
-        var handle = self._handles[handleId];
+        var handle = self._handles && self._handles[handleId];
         if (!handle)
           return;
         var callback = handle['_' + callbackName];
diff --git a/packages/mongo-livedata/oplog_observe_driver.js b/packages/mongo-livedata/oplog_observe_driver.js
index c153c96a51..8c9b8e9a93 100644
--- a/packages/mongo-livedata/oplog_observe_driver.js
+++ b/packages/mongo-livedata/oplog_observe_driver.js
@@ -151,6 +151,13 @@ OplogObserveDriver = function (options) {
     }
   ));
 
+  // When Mongo fails over, we need to repoll the query, in case we processed an
+  // oplog entry that got rolled back.
+  self._stopHandles.push(self._mongoHandle._onFailover(finishIfNeedToPollQuery(
+    function () {
+      self._needToPollQuery();
+    })));
+
   // Give _observeChanges a chance to add the new ObserveHandle to our
   // multiplexer, so that the added calls get streamed.
   Meteor.defer(finishIfNeedToPollQuery(function () {
@@ -424,7 +431,6 @@ _.extend(OplogObserveDriver.prototype, {
         var thisGeneration = ++self._fetchGeneration;
         self._needToFetch = new LocalCollection._IdMap;
         var waiting = 0;
-        var anyError = null;
         var fut = new Future;
         // This loop is safe, because _currentlyFetching will not be updated
         // during this loop (in fact, it is never mutated).
@@ -435,8 +441,15 @@ _.extend(OplogObserveDriver.prototype, {
             finishIfNeedToPollQuery(function (err, doc) {
               try {
                 if (err) {
-                  if (!anyError)
-                    anyError = err;
+                  Meteor._debug("Got exception while fetching documents: " +
+                                err);
+                  // If we get an error from the fetcher (eg, trouble connecting
+                  // to Mongo), let's just abandon the fetch phase altogether
+                  // and fall back to polling. It's not like we're getting live
+                  // updates anyway.
+                  if (self._phase !== PHASE.QUERYING) {
+                    self._needToPollQuery();
+                  }
                 } else if (!self._stopped && self._phase === PHASE.FETCHING
                            && self._fetchGeneration === thisGeneration) {
                   // We re-check the generation in case we've had an explicit
@@ -456,9 +469,6 @@ _.extend(OplogObserveDriver.prototype, {
             }));
         });
         fut.wait();
-        // XXX do this even if we've switched to PHASE.QUERYING?
-        if (anyError)
-          throw anyError;
         // Exit now if we've had a _pollQuery call (here or in another fiber).
         if (self._phase === PHASE.QUERYING)
           return;
@@ -599,22 +609,40 @@ _.extend(OplogObserveDriver.prototype, {
 
   _runQuery: function () {
     var self = this;
-    var newResults = new LocalCollection._IdMap;
-    var newBuffer = new LocalCollection._IdMap;
+    var newResults, newBuffer;
 
-    // Query 2x documents as the half excluded from the original query will go
-    // into unpublished buffer to reduce additional Mongo lookups in cases when
-    // documents are removed from the published set and need a replacement.
-    // XXX needs more thought on non-zero skip
-    // XXX 2 is a "magic number" meaning there is an extra chunk of docs for
-    // buffer if such is needed.
-    var cursor = self._cursorForQuery({ limit: self._limit * 2 });
-    cursor.forEach(function (doc, i) {
-      if (!self._limit || i < self._limit)
-        newResults.set(doc._id, doc);
-      else
-        newBuffer.set(doc._id, doc);
-    });
+    // This while loop is just to retry failures.
+    while (true) {
+      // If we've been stopped, we don't have to run anything any more.
+      if (self._stopped)
+        return;
+
+      newResults = new LocalCollection._IdMap;
+      newBuffer = new LocalCollection._IdMap;
+
+      // Query 2x documents as the half excluded from the original query will go
+      // into unpublished buffer to reduce additional Mongo lookups in cases
+      // when documents are removed from the published set and need a
+      // replacement.
+      // XXX needs more thought on non-zero skip
+      // XXX 2 is a "magic number" meaning there is an extra chunk of docs for
+      // buffer if such is needed.
+      var cursor = self._cursorForQuery({ limit: self._limit * 2 });
+      try {
+        cursor.forEach(function (doc, i) {
+          if (!self._limit || i < self._limit)
+            newResults.set(doc._id, doc);
+          else
+            newBuffer.set(doc._id, doc);
+        });
+        break;
+      } catch (e) {
+        // During failover (eg) if we get an exception we should log and retry
+        // instead of crashing.
+        Meteor._debug("Got exception while polling query: " + e);
+        Meteor._sleepForMs(100);
+      }
+    }
 
     self._publishNewResults(newResults, newBuffer);
   },
diff --git a/packages/mongo-livedata/oplog_tailing.js b/packages/mongo-livedata/oplog_tailing.js
index b203bfa412..0d1cacc187 100644
--- a/packages/mongo-livedata/oplog_tailing.js
+++ b/packages/mongo-livedata/oplog_tailing.js
@@ -101,12 +101,25 @@ _.extend(OplogHandle.prototype, {
     // be ready.
     self._readyFuture.wait();
 
-    // We need to make the selector at least as restrictive as the actual
-    // tailing selector (ie, we need to specify the DB name) or else we might
-    // find a TS that won't show up in the actual tail stream.
-    var lastEntry = self._oplogLastEntryConnection.findOne(
-      OPLOG_COLLECTION, self._baseOplogSelector,
-      {fields: {ts: 1}, sort: {$natural: -1}});
+    while (!self._stopped) {
+      // We need to make the selector at least as restrictive as the actual
+      // tailing selector (ie, we need to specify the DB name) or else we might
+      // find a TS that won't show up in the actual tail stream.
+      try {
+        var lastEntry = self._oplogLastEntryConnection.findOne(
+          OPLOG_COLLECTION, self._baseOplogSelector,
+          {fields: {ts: 1}, sort: {$natural: -1}});
+        break;
+      } catch (e) {
+        // During failover (eg) if we get an exception we should log and retry
+        // instead of crashing.
+        Meteor._debug("Got exception while reading last entry: " + e);
+        Meteor._sleepForMs(100);
+      }
+    }
+
+    if (self._stopped)
+      return;
 
     if (!lastEntry) {
       // Really, nothing in the oplog? Well, we've processed everything.
@@ -166,7 +179,7 @@ _.extend(OplogHandle.prototype, {
 
     // Find the last oplog entry.
     var lastOplogEntry = self._oplogLastEntryConnection.findOne(
-      OPLOG_COLLECTION, {}, {sort: {$natural: -1}});
+      OPLOG_COLLECTION, {}, {sort: {$natural: -1}, fields: {ts: 1}});
 
     var oplogSelector = _.clone(self._baseOplogSelector);
     if (lastOplogEntry) {
diff --git a/packages/mongo-livedata/package.js b/packages/mongo-livedata/package.js
index d12bd6b182..20321c1609 100644
--- a/packages/mongo-livedata/package.js
+++ b/packages/mongo-livedata/package.js
@@ -16,9 +16,7 @@ Package.describe({
 });
 
 Npm.depends({
-  // 1.3.19, plus a patch to add oplogReplay flag:
-  // https://github.com/mongodb/node-mongodb-native/pull/1108
-  mongodb: "https://github.com/meteor/node-mongodb-native/tarball/779bbac916a751f305d84c727a6cc7dfddab7924"
+  mongodb: "1.4.1"
 });
 
 Package.on_use(function (api) {
@@ -49,6 +47,8 @@ Package.on_use(function (api) {
   // If the facts package is loaded, publish some statistics.
   api.use('facts', 'server', {weak: true});
 
+  api.use('callback-hook', 'server');
+
   // Stuff that should be exposed via a real API, but we haven't yet.
   api.export('MongoInternals', 'server');
   // For tests only.
diff --git a/packages/liverange/.gitignore b/packages/oauth-encryption/.gitignore
similarity index 100%
rename from packages/liverange/.gitignore
rename to packages/oauth-encryption/.gitignore
diff --git a/packages/oauth-encryption/README.md b/packages/oauth-encryption/README.md
new file mode 100644
index 0000000000..852bd9237c
--- /dev/null
+++ b/packages/oauth-encryption/README.md
@@ -0,0 +1,74 @@
+# oauth-encryption
+
+Encrypts sensitive login secrets stored in the database such as a
+login service's application secret key and users' access tokens.
+
+
+## Generating a Key
+
+The encryption key is 16 bytes, encoded in base64.
+
+To generate a key:
+
+    $ ~/.meteor/tools/latest/bin/node -e 'console.log(require("crypto").randomBytes(16).toString("base64"))'
+
+
+## Using oauth-encryption with accounts
+
+On the server only, use the `oauthSecretKey` option to `Accounts.config`:
+
+    Accounts.config({oauthSecretKey: "onsqJ+1e4iGFlV0nhZYobg=="});
+
+This call to `Accounts.config` should be made at load time (place at
+the top level of your source file), not called from inside of a
+`Meteor.startup` block.
+
+To avoid storing the secret key in your application's source code, you
+can use [`Meteor.settings`](http://docs.meteor.com/#meteor_settings):
+
+    Accounts.config({oauthSecretKey: Meteor.settings.oauthSecretKey});
+
+
+## Migrating unencrypted user tokens
+
+This example for Twitter shows how existing unencrypted user tokens
+can be encrypted.  The query finds user documents which have a Twitter
+access token but not the `algorithm` field which is created when the
+token is encrypted.  The relevant fields in the service data are then
+encrypted.
+
+    Meteor.users.find({ $and: [
+        { 'services.twitter.accessToken': {$exists: true} },
+        { 'services.twitter.accessToken.algorithm': {$exists: false} }
+      ] }).
+    forEach(function (userDoc) {
+      var set = {};
+      _.each(['accessToken', 'accessTokenSecret', 'refreshToken'], function (field) {
+        var plaintext = userDoc.services.twitter[field];
+        if (!_.isString(plaintext))
+          return;
+        set['services.twitter.' + field] = OAuthEncryption.seal(
+          userDoc.services.twitter[field],
+          userDoc._id
+        );
+      });
+      Meteor.users.update(userDoc._id, {$set: set});
+    });
+
+## Using oauth-encryption without accounts
+
+If you're using the oauth packages directly instead of through the
+Meteor accounts packages, you can load the OAuth encryption key
+directly using `OAuthEncryption.loadKey`:
+
+    OAuthEncryption.loadKey("onsqJ+1e4iGFlV0nhZYobg==");
+
+If you call `retrieveCredential` (such as
+`Twitter.retrieveCredential`) as part of your process, you'll find
+when using oauth-encryption that the sensitive service data fields
+will be encrypted.
+
+You can decrypt them using `OAuth.openSecrets`:
+
+    var credentials = Twitter.retrieveCredential(token);
+    var serviceData = OAuth.openSecrets(credentials.serviceData);
diff --git a/packages/oauth-encryption/encrypt.js b/packages/oauth-encryption/encrypt.js
new file mode 100644
index 0000000000..5ea6f04db6
--- /dev/null
+++ b/packages/oauth-encryption/encrypt.js
@@ -0,0 +1,146 @@
+var crypto = Npm.require("crypto");
+// XXX We hope to be able to use the `crypto` module exclusively when
+// Node supports GCM in version 0.11.
+var gcm = Npm.require("node-aes-gcm");
+
+OAuthEncryption = {};
+
+var gcmKey = null;
+
+
+// Node leniently ignores non-base64 characters when parsing a base64
+// string, but we want to provide a more informative error message if
+// the developer doesn't use base64 encoding.
+//
+// Note that an empty string is valid base64 (denoting 0 bytes).
+//
+// Exported for the convenience of tests.
+//
+OAuthEncryption._isBase64 = function (str) {
+  return _.isString(str) && /^[A-Za-z0-9\+\/]*\={0,2}$/.test(str);
+};
+
+
+// Loads the OAuth secret key, which must be 16 bytes in length
+// encoded in base64.
+//
+// The key may be `null` which reverts to having no key (mainly used
+// by tests).
+//
+OAuthEncryption.loadKey = function (key) {
+  if (key === null) {
+    gcmKey = null;
+    return;
+  }
+
+  if (! OAuthEncryption._isBase64(key))
+    throw new Error("The OAuth encryption key must be encoded in base64");
+
+  var buf = new Buffer(key, "base64");
+
+  if (buf.length !== 16)
+    throw new Error("The OAuth encryption AES-128-GCM key must be 16 bytes in length");
+
+  gcmKey = buf;
+};
+
+
+// Encrypt `data`, which may be any EJSON-compatible object, using the
+// previously loaded OAuth secret key.
+//
+// The `userId` argument is optional. The data is encrypted as { data:
+// *, userId: * }. When the result of `seal` is passed to `open`, the
+// same user id must be supplied, which prevents user specific
+// credentials such as access tokens from being used by a different
+// user.
+//
+// We would actually like the user id to be AAD (additional
+// authenticated data), but the node crypto API does not currently have
+// support for specifying AAD.
+//
+OAuthEncryption.seal = function (data, userId) {
+  if (! gcmKey) {
+    throw new Error("No OAuth encryption key loaded");
+  }
+
+  var plaintext = new Buffer(EJSON.stringify({
+    data: data,
+    userId: userId
+  }));
+  var iv = crypto.randomBytes(12);
+  var result = gcm.encrypt(gcmKey, iv, plaintext, new Buffer([]) /* aad */);
+  return {
+    iv: iv.toString("base64"),
+    ciphertext: result.ciphertext.toString("base64"),
+    algorithm: "aes-128-gcm",
+    authTag: result.auth_tag.toString("base64")
+  };
+};
+
+// Decrypt the passed ciphertext (as returned from `seal`) using the
+// previously loaded OAuth secret key.
+//
+// `userId` must match the user id passed to `seal`: if the user id
+// wasn't specified, it must not be specified here, if it was
+// specified, it must be the same user id.
+//
+// To prevent an attacker from breaking the encryption key by
+// observing the result of sending manipulated ciphertexts, `open`
+// throws "decryption unsuccessful" on any error.
+OAuthEncryption.open = function (ciphertext, userId) {
+  if (! gcmKey)
+    throw new Error("No OAuth encryption key loaded");
+
+  try {
+    if (ciphertext.algorithm !== "aes-128-gcm") {
+      throw new Error();
+    }
+
+    var result = gcm.decrypt(
+      gcmKey,
+      new Buffer(ciphertext.iv, "base64"),
+      new Buffer(ciphertext.ciphertext, "base64"),
+      new Buffer([]), /* aad */
+      new Buffer(ciphertext.authTag, "base64")
+    );
+
+    if (! result.auth_ok) {
+      throw new Error();
+    }
+
+    var err;
+    var data;
+
+    try {
+      data = EJSON.parse(result.plaintext.toString());
+    } catch (e) {
+      err = new Error();
+    }
+
+    if (data.userId !== userId) {
+      err = new Error();
+    }
+
+    if (err) {
+      throw err;
+    } else {
+      return data.data;
+    }
+  } catch (e) {
+    throw new Error("decryption failed");
+  }
+};
+
+
+OAuthEncryption.isSealed = function (maybeCipherText) {
+  return maybeCipherText &&
+    OAuthEncryption._isBase64(maybeCipherText.iv) &&
+    OAuthEncryption._isBase64(maybeCipherText.ciphertext) &&
+    OAuthEncryption._isBase64(maybeCipherText.authTag) &&
+    _.isString(maybeCipherText.algorithm);
+};
+
+
+OAuthEncryption.keyIsLoaded = function () {
+  return !! gcmKey;
+};
diff --git a/packages/oauth-encryption/encrypt_tests.js b/packages/oauth-encryption/encrypt_tests.js
new file mode 100644
index 0000000000..a41d15897a
--- /dev/null
+++ b/packages/oauth-encryption/encrypt_tests.js
@@ -0,0 +1,150 @@
+Tinytest.add("oauth-encryption - loadKey", function (test) {
+  test.throws(
+    function () {
+      OAuthEncryption.loadKey("my encryption key");
+    },
+    "The OAuth encryption key must be encoded in base64"
+  );
+
+  test.throws(
+    function () {
+      OAuthEncryption.loadKey(new Buffer([1, 2, 3, 4, 5]).toString("base64"));
+    },
+    "The OAuth encryption AES-128-GCM key must be 16 bytes in length"
+  );
+
+  OAuthEncryption.loadKey(
+    new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).
+    toString("base64")
+  );
+
+  OAuthEncryption.loadKey(null);
+});
+
+Tinytest.add("oauth-encryption - seal", function (test) {
+  OAuthEncryption.loadKey(
+    new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).
+    toString("base64")
+  );
+
+  var ciphertext = OAuthEncryption.seal({a: 1, b: 2});
+  test.isTrue(new Buffer(ciphertext.iv, "base64").length === 12);
+  test.isTrue(OAuthEncryption._isBase64(ciphertext.ciphertext));
+  test.isTrue(ciphertext.algorithm === "aes-128-gcm");
+  test.isTrue(OAuthEncryption._isBase64(ciphertext.authTag));
+
+  OAuthEncryption.loadKey(null);
+});
+
+Tinytest.add("oauth-encryption - open successful", function (test) {
+  OAuthEncryption.loadKey(
+    new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).
+    toString("base64")
+  );
+  var userId = "rH6rNSWd2hBTfkwcc";
+  var ciphertext = OAuthEncryption.seal({a: 1, b: 2}, userId);
+
+  var decrypted = OAuthEncryption.open(ciphertext, userId);
+  test.equal(decrypted, {a: 1, b: 2});
+
+  OAuthEncryption.loadKey(null);
+});
+
+Tinytest.add("oauth-encryption - open with wrong key", function (test) {
+  OAuthEncryption.loadKey(
+    new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).
+    toString("base64")
+  );
+  var userId = "rH6rNSWd2hBTfkwcc";
+  var ciphertext = OAuthEncryption.seal({a: 1, b: 2}, userId);
+
+  OAuthEncryption.loadKey(
+    new Buffer([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]).
+    toString("base64")
+  );
+  test.throws(
+    function () {
+      OAuthEncryption.open(ciphertext, userId);
+    },
+    "decryption failed"
+  );
+
+  OAuthEncryption.loadKey(null);
+});
+
+Tinytest.add("oauth-encryption - open with wrong userId", function (test) {
+  OAuthEncryption.loadKey(
+    new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).
+    toString("base64")
+  );
+  var userId = "rH6rNSWd2hBTfkwcc";
+  var ciphertext = OAuthEncryption.seal({a: 1, b: 2}, userId);
+
+  var differentUser = "3FPxY2mBNeBpigm86";
+  test.throws(
+    function () {
+      OAuthEncryption.open(ciphertext, differentUser);
+    },
+    "decryption failed"
+  );
+
+  OAuthEncryption.loadKey(null);
+});
+
+Tinytest.add("oauth-encryption - seal and open with no userId", function (test) {
+  OAuthEncryption.loadKey(
+    new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).
+    toString("base64")
+  );
+  var ciphertext = OAuthEncryption.seal({a: 1, b: 2});
+  var decrypted = OAuthEncryption.open(ciphertext);
+  test.equal(decrypted, {a: 1, b: 2});
+});
+
+Tinytest.add("oauth-encryption - open modified ciphertext", function (test) {
+  OAuthEncryption.loadKey(
+    new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).
+    toString("base64")
+  );
+  var ciphertext = OAuthEncryption.seal({a: 1, b: 2});
+
+  var b = new Buffer(ciphertext.ciphertext, "base64");
+  b[0] = b[0] ^ 1;
+  ciphertext.ciphertext = b.toString("base64");
+
+  test.throws(
+    function () {
+      OAuthEncryption.open(ciphertext);
+    },
+    "decryption failed"
+  );
+});
+
+
+Tinytest.add("oauth-encryption - isSealed", function (test) {
+  OAuthEncryption.loadKey(
+    new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).
+    toString("base64")
+  );
+  var userId = "rH6rNSWd2hBTfkwcc";
+  var ciphertext = OAuthEncryption.seal({a: 1, b: 2}, userId);
+  test.isTrue(OAuthEncryption.isSealed(ciphertext));
+
+  test.isFalse(OAuthEncryption.isSealed("abcdef"));
+  test.isFalse(OAuthEncryption.isSealed({a: 1, b: 2}));
+
+  OAuthEncryption.loadKey(null);
+});
+
+Tinytest.add("oauth-encryption - keyIsLoaded", function (test) {
+  OAuthEncryption.loadKey(null);
+  test.isFalse(OAuthEncryption.keyIsLoaded());
+
+  OAuthEncryption.loadKey(
+    new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]).
+    toString("base64")
+  );
+  test.isTrue(OAuthEncryption.keyIsLoaded());
+
+  OAuthEncryption.loadKey(null);
+});
diff --git a/packages/oauth-encryption/package.js b/packages/oauth-encryption/package.js
new file mode 100644
index 0000000000..c72dd37bf8
--- /dev/null
+++ b/packages/oauth-encryption/package.js
@@ -0,0 +1,20 @@
+// Uses the node-aes-gcm NPM module from the dev bundle (because
+// binary modules aren't working yet).
+
+Package.describe({
+  name: "oauth-encryption",
+  test: "oauth-encryption-test",
+  summary: "Encrypt account secrets stored in the database",
+  version: '1.0.0'
+});
+
+Package.on_use(function (api) {
+  api.export("OAuthEncryption", ["server"]);
+  api.add_files("encrypt.js", ["server"]);
+});
+
+Package.on_test(function (api) {
+  api.use("tinytest");
+  api.use("oauth-encryption");
+  api.add_files("encrypt_tests.js", ["server"]);
+});
diff --git a/packages/oauth/deprecated.js b/packages/oauth/deprecated.js
new file mode 100644
index 0000000000..180859d505
--- /dev/null
+++ b/packages/oauth/deprecated.js
@@ -0,0 +1,3 @@
+// XXX COMPAT WITH 0.8.0
+
+Oauth = OAuth;
diff --git a/packages/oauth/oauth_client.js b/packages/oauth/oauth_client.js
index dad37006a3..051b16c55e 100644
--- a/packages/oauth/oauth_client.js
+++ b/packages/oauth/oauth_client.js
@@ -1,4 +1,4 @@
-Oauth = {};
+OAuth = {};
 
 // Open a popup window, centered on the screen, and call a callback when it
 // closes.
@@ -8,7 +8,7 @@ Oauth = {};
 //   arguments.
 // @param dimensions {optional Object(width, height)} The dimensions of
 //   the popup. If not passed defaults to something sane.
-Oauth.showPopup = function (url, callback, dimensions) {
+OAuth.showPopup = function (url, callback, dimensions) {
   // default dimensions that worked well for facebook and google
   var popup = openCenteredPopup(
     url,
@@ -64,8 +64,8 @@ var openCenteredPopup = function(url, width, height) {
 
 // XXX COMPAT WITH 0.7.0.1
 // Private interface but probably used by many oauth clients in atmosphere.
-Oauth.initiateLogin = function (credentialToken, url, callback, dimensions) {
-  Oauth.showPopup(
+OAuth.initiateLogin = function (credentialToken, url, callback, dimensions) {
+  OAuth.showPopup(
     url,
     _.bind(callback, null, credentialToken),
     dimensions
diff --git a/packages/oauth/oauth_server.js b/packages/oauth/oauth_server.js
index 736748e8ee..32ec57e0a4 100644
--- a/packages/oauth/oauth_server.js
+++ b/packages/oauth/oauth_server.js
@@ -1,8 +1,8 @@
 var Fiber = Npm.require('fibers');
 var url = Npm.require('url');
 
-Oauth = {};
-OauthTest = {};
+OAuth = {};
+OAuthTest = {};
 
 RoutePolicy.declare('/_oauth/', 'network');
 
@@ -12,7 +12,7 @@ var registeredServices = {};
 // 'oauth1' and 'oauth2' packages manipulate this directly to register
 // for callbacks.
 //
-Oauth._requestHandlers = {};
+OAuth._requestHandlers = {};
 
 
 // Register a handler for an OAuth service. The handler will be called
@@ -31,7 +31,7 @@ Oauth._requestHandlers = {};
 //       up in the user's services[name] field
 //     - `null` if the user declined to give permissions
 //
-Oauth.registerService = function (name, version, urls, handleOauthRequest) {
+OAuth.registerService = function (name, version, urls, handleOauthRequest) {
   if (registeredServices[name])
     throw new Error("Already registered the " + name + " OAuth service");
 
@@ -44,32 +44,15 @@ Oauth.registerService = function (name, version, urls, handleOauthRequest) {
 };
 
 // For test cleanup.
-OauthTest.unregisterService = function (name) {
+OAuthTest.unregisterService = function (name) {
   delete registeredServices[name];
 };
 
 
-// When we get an incoming OAuth http request we complete the oauth
-// handshake, account and token setup before responding.  The
-// results are stored in this map which is then read when the login
-// method is called. Maps credentialToken --> return value of `login`
-//
-// NB: the oauth1 and oauth2 packages manipulate this directly. might
-// be nice for them to have a setter instead
-//
-// XXX we should periodically clear old entries
-//
-Oauth._loginResultForCredentialToken = {};
+OAuth.retrieveCredential = function(credentialToken) {
+  return OAuth._retrievePendingCredential(credentialToken);
+};
 
-Oauth.hasCredential = function(credentialToken) {
-  return _.has(Oauth._loginResultForCredentialToken, credentialToken);
-}
-
-Oauth.retrieveCredential = function(credentialToken) {
-  var result = Oauth._loginResultForCredentialToken[credentialToken];
-  delete Oauth._loginResultForCredentialToken[credentialToken];
-  return result;
-}
 
 // Listen to incoming OAuth http requests
 WebApp.connectHandlers.use(function(req, res, next) {
@@ -100,20 +83,20 @@ middleware = function (req, res, next) {
     // Make sure we're configured
     ensureConfigured(serviceName);
 
-    var handler = Oauth._requestHandlers[service.version];
+    var handler = OAuth._requestHandlers[service.version];
     if (!handler)
       throw new Error("Unexpected OAuth version " + service.version);
     handler(service, req.query, res);
   } catch (err) {
     // if we got thrown an error, save it off, it will get passed to
-    // the approporiate login call (if any) and reported there.
+    // the appropriate login call (if any) and reported there.
     //
     // The other option would be to display it in the popup tab that
     // is still open at this point, ignoring the 'close' or 'redirect'
     // we were passed. But then the developer wouldn't be able to
     // style the error or react to it in any way.
     if (req.query.state && err instanceof Error)
-      Oauth._loginResultForCredentialToken[req.query.state] = err;
+      OAuth._storePendingCredential(req.query.state, err);
 
     // XXX the following is actually wrong. if someone wants to
     // redirect rather than close once we are done with the OAuth
@@ -130,7 +113,7 @@ middleware = function (req, res, next) {
   }
 };
 
-OauthTest.middleware = middleware;
+OAuthTest.middleware = middleware;
 
 // Handle /_oauth/* paths and extract the service name.
 //
@@ -154,16 +137,16 @@ var oauthServiceName = function (req) {
 // Make sure we're configured
 var ensureConfigured = function(serviceName) {
   if (!ServiceConfiguration.configurations.findOne({service: serviceName})) {
-    throw new ServiceConfiguration.ConfigError("Service not configured");
-  };
+    throw new ServiceConfiguration.ConfigError();
+  }
 };
 
 // Internal: used by the oauth1 and oauth2 packages
-Oauth._renderOauthResults = function(res, query) {
+OAuth._renderOauthResults = function(res, query) {
   // We support ?close and ?redirect=URL. Any other query should
   // just serve a blank page
   if (query.error) {
-    Log.warn("Error in Oauth Server: " + query.error);
+    Log.warn("Error in OAuth Server: " + query.error);
     closePopup(res);
   } else if ('close' in query) { // check with 'in' because we don't set a value
     closePopup(res);
@@ -192,3 +175,50 @@ var closePopup = function(res) {
         '<html><head><script>window.close()</script></head></html>';
   res.end(content, 'utf-8');
 };
+
+
+var OAuthEncryption = Package["oauth-encryption"] && Package["oauth-encryption"].OAuthEncryption;
+
+var usingOAuthEncryption = function () {
+  return OAuthEncryption && OAuthEncryption.keyIsLoaded();
+};
+
+// Encrypt sensitive service data such as access tokens if the
+// "oauth-encryption" package is loaded and the oauth secret key has
+// been specified.  Returns the unencrypted plaintext otherwise.
+//
+// The user id is not specified because the user isn't known yet at
+// this point in the oauth authentication process.  After the oauth
+// authentication process completes the encrypted service data fields
+// will be re-encrypted with the user id included before inserting the
+// service data into the user document.
+//
+OAuth.sealSecret = function (plaintext) {
+  if (usingOAuthEncryption())
+    return OAuthEncryption.seal(plaintext);
+  else
+    return plaintext;
+}
+
+// Unencrypt a service data field, if the "oauth-encryption"
+// package is loaded and the field is encrypted.
+//
+// Throws an error if the "oauth-encryption" package is loaded and the
+// field is encrypted, but the oauth secret key hasn't been specified.
+//
+OAuth.openSecret = function (maybeSecret, userId) {
+  if (!Package["oauth-encryption"] || !OAuthEncryption.isSealed(maybeSecret))
+    return maybeSecret;
+
+  return OAuthEncryption.open(maybeSecret, userId);
+};
+
+// Unencrypt fields in the service data object.
+//
+OAuth.openSecrets = function (serviceData, userId) {
+  var result = {};
+  _.each(_.keys(serviceData), function (key) {
+    result[key] = OAuth.openSecret(serviceData[key], userId);
+  });
+  return result;
+};
diff --git a/packages/oauth/oauth_tests.js b/packages/oauth/oauth_tests.js
new file mode 100644
index 0000000000..0984ab57ad
--- /dev/null
+++ b/packages/oauth/oauth_tests.js
@@ -0,0 +1,49 @@
+Tinytest.add("oauth - pendingCredential handles Errors", function (test) {
+  var credentialToken = Random.id();
+
+  var testError = new Error("This is a test error");
+  testError.stack = 'test stack';
+  OAuth._storePendingCredential(credentialToken, testError);
+
+  // Test that the result for the token is the expected error
+  var result = OAuth._retrievePendingCredential(credentialToken);
+  test.instanceOf(result, Error);
+  test.equal(result.message, testError.message);
+  test.equal(result.stack, testError.stack);
+});
+
+Tinytest.add("oauth - pendingCredential handles Meteor.Errors", function (test) {
+  var credentialToken = Random.id();
+
+  var testError = new Meteor.Error(401, "This is a test error");
+  testError.stack = 'test stack';
+  OAuth._storePendingCredential(credentialToken, testError);
+
+  // Test that the result for the token is the expected error
+  var result = OAuth._retrievePendingCredential(credentialToken);
+  test.instanceOf(result, Meteor.Error);
+  test.equal(result.error, testError.error);
+  test.equal(result.message, testError.message);
+  test.equal(result.reason, testError.reason);
+  test.equal(result.stack, testError.stack);
+  test.isUndefined(result.meteorError);
+});
+
+Tinytest.add("oauth - null, undefined key for pendingCredential", function (test) {
+  var cred = Random.id();
+  test.throws(function () {
+    OAuth._storePendingCredential(null, cred);
+  });
+  test.throws(function () {
+    OAuth._storePendingCredential(undefined, cred);
+  });
+});
+
+Tinytest.add("oauth - pendingCredential handles duplicate key", function (test) {
+  var key = Random.id();
+  var cred = Random.id();
+  OAuth._storePendingCredential(key, cred);
+  var newCred = Random.id();
+  OAuth._storePendingCredential(key, newCred);
+  test.equal(OAuth._retrievePendingCredential(key), newCred);
+});
diff --git a/packages/oauth/package.js b/packages/oauth/package.js
index b348f9eec4..a777dafd36 100644
--- a/packages/oauth/package.js
+++ b/packages/oauth/package.js
@@ -7,11 +7,29 @@ Package.describe({
 Package.on_use(function (api) {
   api.use('routepolicy', 'server');
   api.use('webapp', 'server');
+  api.use('mongo-livedata', 'server');
+
   api.use(['underscore', 'service-configuration', 'logging'], 'server');
 
-  api.export('Oauth');
-  api.export('OauthTest', 'server', {testOnly: true});
+  api.use('oauth-encryption', 'server', {weak: true});
+
+  api.export('OAuth');
+  api.export('OAuthTest', 'server', {testOnly: true});
 
   api.add_files('oauth_client.js', 'client');
   api.add_files('oauth_server.js', 'server');
+  api.add_files('pending_credentials.js', 'server');
+
+  // XXX COMPAT WITH 0.8.0
+  api.export('Oauth');
+  api.add_files('deprecated.js', ['client', 'server']);
+});
+
+
+Package.on_test(function (api) {
+  api.use('tinytest');
+  api.use('random');
+  api.use('service-configuration', 'server');
+  api.use('oauth', 'server');
+  api.add_files("oauth_tests.js", 'server');
 });
diff --git a/packages/oauth/pending_credentials.js b/packages/oauth/pending_credentials.js
new file mode 100644
index 0000000000..d5197a8d53
--- /dev/null
+++ b/packages/oauth/pending_credentials.js
@@ -0,0 +1,115 @@
+//
+// When an oauth request is made, Meteor receives oauth credentials
+// in one browser tab, and temporarily persists them while that
+// tab is closed, then retrieves them in the browser tab that
+// initiated the credential request.
+//
+// _pendingCredentials is the storage mechanism used to share the
+// credential between the 2 tabs
+//
+
+
+// Collection containing pending credentials of oauth credential requests
+// Has key, credential, and createdAt fields.
+OAuth._pendingCredentials = new Meteor.Collection(
+  "meteor_oauth_pendingCredentials", {
+    _preventAutopublish: true
+  });
+
+OAuth._pendingCredentials._ensureIndex('key', {unique: 1});
+OAuth._pendingCredentials._ensureIndex('createdAt');
+
+
+
+// Periodically clear old entries that were never retrieved
+var _cleanStaleResults = function() {
+  // Remove credentials older than 1 minute
+  var timeCutoff = new Date();
+  timeCutoff.setMinutes(timeCutoff.getMinutes() - 1);
+  OAuth._pendingCredentials.remove({ createdAt: { $lt: timeCutoff } });
+};
+var _cleanupHandle = Meteor.setInterval(_cleanStaleResults, 60 * 1000);
+
+
+// Stores the key and credential in the _pendingCredentials collection.
+// Will throw an exception if `key` is not a string.
+//
+// @param key {string}
+// @param credential {string}   The credential to store
+//
+OAuth._storePendingCredential = function (key, credential) {
+  check(key, String);
+
+  if (credential instanceof Error) {
+    credential = storableError(credential);
+  } else {
+    credential = OAuth.sealSecret(credential);
+  }
+
+  // We do an upsert here instead of an insert in case the user happens
+  // to somehow send the same `state` parameter twice during an OAuth
+  // login; we don't want a duplicate key error.
+  OAuth._pendingCredentials.upsert({
+    key: key
+  }, {
+    key: key,
+    credential: credential,
+    createdAt: new Date()
+  });
+};
+
+
+// Retrieves and removes a credential from the _pendingCredentials collection
+//
+// @param key {string}
+//
+OAuth._retrievePendingCredential = function (key) {
+  check(key, String);
+
+  var pendingCredential = OAuth._pendingCredentials.findOne({ key:key });
+  if (pendingCredential) {
+    OAuth._pendingCredentials.remove({ _id: pendingCredential._id });
+    if (pendingCredential.credential.error)
+      return recreateError(pendingCredential.credential.error);
+    else
+      return OAuth.openSecret(pendingCredential.credential);
+  } else {
+    return undefined;
+  }
+};
+
+
+// Convert an Error into an object that can be stored in mongo
+// Note: A Meteor.Error is reconstructed as a Meteor.Error
+// All other error classes are reconstructed as a plain Error.
+var storableError = function(error) {
+  var plainObject = {};
+  Object.getOwnPropertyNames(error).forEach(function(key) {
+    plainObject[key] = error[key];
+  });
+
+  // Keep track of whether it's a Meteor.Error
+  if(error instanceof Meteor.Error) {
+    plainObject['meteorError'] = true;
+  }
+
+  return { error: plainObject };
+};
+
+// Create an error from the error format stored in mongo
+var recreateError = function(errorDoc) {
+  var error;
+
+  if (errorDoc.meteorError) {
+    error = new Meteor.Error();
+    delete errorDoc.meteorError;
+  } else {
+    error = new Error();
+  }
+
+  Object.getOwnPropertyNames(errorDoc).forEach(function(key) {
+    error[key] = errorDoc[key];
+  });
+
+  return error;
+};
diff --git a/packages/oauth1/oauth1_binding.js b/packages/oauth1/oauth1_binding.js
index 43e63a111b..839f2529f3 100644
--- a/packages/oauth1/oauth1_binding.js
+++ b/packages/oauth1/oauth1_binding.js
@@ -85,7 +85,7 @@ OAuth1Binding.prototype._buildHeader = function(headers) {
   var self = this;
   return _.extend({
     oauth_consumer_key: self._config.consumerKey,
-    oauth_nonce: Random.id().replace(/\W/g, ''),
+    oauth_nonce: Random.secret().replace(/\W/g, ''),
     oauth_signature_method: 'HMAC-SHA1',
     oauth_timestamp: (new Date().valueOf()/1000).toFixed().toString(),
     oauth_version: '1.0'
@@ -106,7 +106,9 @@ OAuth1Binding.prototype._getSignature = function(method, url, rawHeaders, access
     self._encodeString(parameters)
   ].join('&');
 
-  var signingKey = self._encodeString(self._config.secret) + '&';
+  var secret = OAuth.openSecret(self._config.secret);
+
+  var signingKey = self._encodeString(secret) + '&';
   if (accessTokenSecret)
     signingKey += self._encodeString(accessTokenSecret);
 
diff --git a/packages/oauth1/oauth1_pending_request_tokens.js b/packages/oauth1/oauth1_pending_request_tokens.js
new file mode 100644
index 0000000000..ff025a577f
--- /dev/null
+++ b/packages/oauth1/oauth1_pending_request_tokens.js
@@ -0,0 +1,86 @@
+//
+// _pendingRequestTokens are request tokens that have been received
+// but not yet fully authorized (processed).
+//
+// During the oauth1 authorization process, the Meteor App opens
+// a pop-up, requests a request token from the oauth1 service, and
+// redirects the browser to the oauth1 service for the user
+// to grant authorization.  The user is then returned to the
+// Meteor Apps' callback url and the request token is verified.
+//
+// When Meteor Apps run on multiple servers, it's possible that
+// 2 different servers may be used to generate the request token
+// and to verify it in the callback once the user has authorized.
+//
+// For this reason, the _pendingRequestTokens are stored in the database
+// so they can be shared across Meteor App servers.
+//
+// XXX This code is fairly similar to oauth/pending_credentials.js --
+// maybe we can combine them somehow.
+
+// Collection containing pending request tokens
+// Has key, requestToken, requestTokenSecret, and createdAt fields.
+OAuth._pendingRequestTokens = new Meteor.Collection(
+  "meteor_oauth_pendingRequestTokens", {
+    _preventAutopublish: true
+  });
+
+OAuth._pendingRequestTokens._ensureIndex('key', {unique: 1});
+OAuth._pendingRequestTokens._ensureIndex('createdAt');
+
+
+
+// Periodically clear old entries that never got completed
+var _cleanStaleResults = function() {
+  // Remove request tokens older than 5 minute
+  var timeCutoff = new Date();
+  timeCutoff.setMinutes(timeCutoff.getMinutes() - 5);
+  OAuth._pendingRequestTokens.remove({ createdAt: { $lt: timeCutoff } });
+};
+var _cleanupHandle = Meteor.setInterval(_cleanStaleResults, 60 * 1000);
+
+
+// Stores the key and request token in the _pendingRequestTokens collection.
+// Will throw an exception if `key` is not a string.
+//
+// @param key {string}
+// @param requestToken {string}
+// @param requestTokenSecret {string}
+//
+OAuth._storeRequestToken = function (key, requestToken, requestTokenSecret) {
+  check(key, String);
+
+  // We do an upsert here instead of an insert in case the user happens
+  // to somehow send the same `state` parameter twice during an OAuth
+  // login; we don't want a duplicate key error.
+  OAuth._pendingRequestTokens.upsert({
+    key: key
+  }, {
+    key: key,
+    requestToken: OAuth.sealSecret(requestToken),
+    requestTokenSecret: OAuth.sealSecret(requestTokenSecret),
+    createdAt: new Date()
+  });
+};
+
+
+// Retrieves and removes a request token from the _pendingRequestTokens collection
+// Returns an object containing requestToken and requestTokenSecret properties
+//
+// @param key {string}
+//
+OAuth._retrieveRequestToken = function (key) {
+  check(key, String);
+
+  var pendingRequestToken = OAuth._pendingRequestTokens.findOne({ key: key });
+  if (pendingRequestToken) {
+    OAuth._pendingRequestTokens.remove({ _id: pendingRequestToken._id });
+    return {
+      requestToken: OAuth.openSecret(pendingRequestToken.requestToken),
+      requestTokenSecret: OAuth.openSecret(
+        pendingRequestToken.requestTokenSecret)
+    };
+  } else {
+    return undefined;
+  }
+};
diff --git a/packages/oauth1/oauth1_server.js b/packages/oauth1/oauth1_server.js
index 6a61fbd6c7..ab1d58c8a8 100644
--- a/packages/oauth1/oauth1_server.js
+++ b/packages/oauth1/oauth1_server.js
@@ -1,14 +1,9 @@
-// A place to store request tokens pending verification
-var requestTokens = {};
-
-OAuth1Test = {requestTokens: requestTokens};
-
 // connect middleware
-Oauth._requestHandlers['1'] = function (service, query, res) {
+OAuth._requestHandlers['1'] = function (service, query, res) {
 
   var config = ServiceConfiguration.configurations.findOne({service: service.serviceName});
   if (!config) {
-    throw new ServiceConfiguration.ConfigError("Service " + service.serviceName + " not configured");
+    throw new ServiceConfiguration.ConfigError(service.serviceName);
   }
 
   var urls = service.urls;
@@ -16,15 +11,17 @@ Oauth._requestHandlers['1'] = function (service, query, res) {
 
   if (query.requestTokenAndRedirect) {
     // step 1 - get and store a request token
+    var callbackUrl = Meteor.absoluteUrl("_oauth/twitter?close&state=" +
+                                         query.state);
 
     // Get a request token to start auth process
-    oauthBinding.prepareRequestToken(query.requestTokenAndRedirect);
+    oauthBinding.prepareRequestToken(callbackUrl);
 
     // Keep track of request token so we can verify it on the next step
-    requestTokens[query.state] = {
-      requestToken: oauthBinding.requestToken, 
-      requestTokenSecret: oauthBinding.requestTokenSecret
-    };
+    OAuth._storeRequestToken(query.state,
+      oauthBinding.requestToken,
+      oauthBinding.requestTokenSecret
+    );
 
     // support for scope/name parameters
     var redirectUrl = undefined;
@@ -38,38 +35,36 @@ Oauth._requestHandlers['1'] = function (service, query, res) {
     res.writeHead(302, {'Location': redirectUrl});
     res.end();
   } else {
-    // step 2, redirected from provider login - complete the login
-    // process: if the user authorized permissions, get an access
-    // token and access token secret and log in as user
+    // step 2, redirected from provider login - store the result
+    // and close the window to allow the login handler to proceed
 
     // Get the user's request token so we can verify it and clear it
-    var requestToken = requestTokens[query.state].requestToken;
-    var requestTokenSecret = requestTokens[query.state].requestTokenSecret;
-    delete requestTokens[query.state];
+    var requestTokenInfo = OAuth._retrieveRequestToken(query.state);
 
     // Verify user authorized access and the oauth_token matches
     // the requestToken from previous step
-    if (query.oauth_token && query.oauth_token === requestToken) {
+    if (query.oauth_token && query.oauth_token === requestTokenInfo.requestToken) {
 
       // Prepare the login results before returning.  This way the
       // subsequent call to the `login` method will be immediate.
 
       // Get the access token for signing requests
-      oauthBinding.prepareAccessToken(query, requestTokenSecret);
+      oauthBinding.prepareAccessToken(query, requestTokenInfo.requestTokenSecret);
 
       // Run service-specific handler.
       var oauthResult = service.handleOauthRequest(oauthBinding);
 
-      // Add the login result to the result map
-      Oauth._loginResultForCredentialToken[query.state] = {
+      // Store the login result so it can be retrieved in another
+      // browser tab by the result handler
+      OAuth._storePendingCredential(query.state, {
         serviceName: service.serviceName,
         serviceData: oauthResult.serviceData,
         options: oauthResult.options
-      };
+      });
     }
 
     // Either close the window, redirect, or render nothing
     // if all else fails
-    Oauth._renderOauthResults(res, query);
+    OAuth._renderOauthResults(res, query);
   }
 };
diff --git a/packages/oauth1/oauth1_tests.js b/packages/oauth1/oauth1_tests.js
index 272e0cb123..3820a337e8 100644
--- a/packages/oauth1/oauth1_tests.js
+++ b/packages/oauth1/oauth1_tests.js
@@ -1,4 +1,4 @@
-Tinytest.add("oauth1 - loginResultForCredentialToken is stored", function (test) {
+var testPendingCredential = function (test) {
   var http = Npm.require('http');
   var twitterfooId = Random.id();
   var twitterfooName = 'nickname' + Random.id();
@@ -25,13 +25,13 @@ Tinytest.add("oauth1 - loginResultForCredentialToken is stored", function (test)
 
   try {
     // register a fake login service
-    Oauth.registerService(serviceName, 1, urls, function (query) {
+    OAuth.registerService(serviceName, 1, urls, function (query) {
       return {
         serviceData: {
           id: twitterfooId,
           screenName: twitterfooName,
-          accessToken: twitterfooAccessToken,
-          accessTokenSecret: twitterfooAccessTokenSecret
+          accessToken: OAuth.sealSecret(twitterfooAccessToken),
+          accessTokenSecret: OAuth.sealSecret(twitterfooAccessTokenSecret)
         },
         options: {
           option1: twitterOption1
@@ -40,9 +40,7 @@ Tinytest.add("oauth1 - loginResultForCredentialToken is stored", function (test)
     });
 
     // simulate logging in using twitterfoo
-    OAuth1Test.requestTokens[credentialToken] = {
-      requestToken: twitterfooAccessToken
-    };
+    Oauth._storeRequestToken(credentialToken, twitterfooAccessToken);
 
     var req = {
       method: "POST",
@@ -52,24 +50,61 @@ Tinytest.add("oauth1 - loginResultForCredentialToken is stored", function (test)
         oauth_token: twitterfooAccessToken
       }
     };
-    OauthTest.middleware(req, new http.ServerResponse(req));
+    OAuthTest.middleware(req, new http.ServerResponse(req));
 
-    // Test that right data is placed on the loginResult map
-    test.equal(
-      Oauth._loginResultForCredentialToken[credentialToken].serviceName, serviceName);
-    test.equal(
-      Oauth._loginResultForCredentialToken[credentialToken].serviceData.id, twitterfooId);
-    test.equal(
-      Oauth._loginResultForCredentialToken[credentialToken].serviceData.screenName, twitterfooName);
-    test.equal(
-      Oauth._loginResultForCredentialToken[credentialToken].serviceData.accessToken, twitterfooAccessToken);
-    test.equal(
-      Oauth._loginResultForCredentialToken[credentialToken].serviceData.accessTokenSecret, twitterfooAccessTokenSecret);
-    test.equal(
-      Oauth._loginResultForCredentialToken[credentialToken].options.option1, twitterOption1);
+    // Test that the result for the token is available
+    var result = OAuth._retrievePendingCredential(credentialToken);
+    var serviceData = OAuth.openSecrets(result.serviceData);
+    test.equal(result.serviceName, serviceName);
+    test.equal(serviceData.id, twitterfooId);
+    test.equal(serviceData.screenName, twitterfooName);
+    test.equal(serviceData.accessToken, twitterfooAccessToken);
+    test.equal(serviceData.accessTokenSecret, twitterfooAccessTokenSecret);
+    test.equal(result.options.option1, twitterOption1);
+
+    // Test that pending credential is removed after being retrieved
+    result = OAuth._retrievePendingCredential(credentialToken);
+    test.isUndefined(result);
 
   } finally {
-    OauthTest.unregisterService(serviceName);
+    OAuthTest.unregisterService(serviceName);
+  }
+};
+
+Tinytest.add("oauth1 - pendingCredential is stored and can be retrieved (without oauth encryption)", function (test) {
+  OAuthEncryption.loadKey(null);
+  testPendingCredential(test);
+});
+
+Tinytest.add("oauth1 - pendingCredential is stored and can be retrieved (with oauth encryption)", function (test) {
+  try {
+    OAuthEncryption.loadKey(new Buffer([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]).toString("base64"));
+    testPendingCredential(test);
+  } finally {
+    OAuthEncryption.loadKey(null);
   }
 });
 
+Tinytest.add("oauth1 - duplicate key for request token", function (test) {
+  var key = Random.id();
+  var token = Random.id();
+  var secret = Random.id();
+  OAuth._storeRequestToken(key, token, secret);
+  var newToken = Random.id();
+  var newSecret = Random.id();
+  OAuth._storeRequestToken(key, newToken, newSecret);
+  var result = OAuth._retrieveRequestToken(key);
+  test.equal(result.requestToken, newToken);
+  test.equal(result.requestTokenSecret, newSecret);
+});
+
+Tinytest.add("oauth1 - null, undefined key for request token", function (test) {
+  var token = Random.id();
+  var secret = Random.id();
+  test.throws(function () {
+    OAuth._storeRequestToken(null, token, secret);
+  });
+  test.throws(function () {
+    OAuth._storeRequestToken(undefined, token, secret);
+  });
+});
diff --git a/packages/oauth1/package.js b/packages/oauth1/package.js
index cb8437d62a..b46e9fe4d2 100644
--- a/packages/oauth1/package.js
+++ b/packages/oauth1/package.js
@@ -18,12 +18,14 @@ Package.on_use(function (api) {
 
   api.add_files('oauth1_binding.js', 'server');
   api.add_files('oauth1_server.js', 'server');
+  api.add_files('oauth1_pending_request_tokens.js', 'server');
 });
 
 Package.on_test(function (api) {
   api.use('tinytest');
   api.use('random');
   api.use('service-configuration', 'server');
+  api.use('oauth-encryption', 'server');
   api.use('oauth1', 'server');
   api.use('oauth', 'server');
   api.add_files("oauth1_tests.js", 'server');
diff --git a/packages/oauth2/oauth2_server.js b/packages/oauth2/oauth2_server.js
index f788727799..a02f3cb8d8 100644
--- a/packages/oauth2/oauth2_server.js
+++ b/packages/oauth2/oauth2_server.js
@@ -1,22 +1,22 @@
 // connect middleware
-Oauth._requestHandlers['2'] = function (service, query, res) {
+OAuth._requestHandlers['2'] = function (service, query, res) {
   // check if user authorized access
   if (!query.error) {
-    // Prepare the login results before returning.  This way the
-    // subsequent call to the `login` method will be immediate.
+    // Prepare the login results before returning.
 
     // Run service-specific handler.
     var oauthResult = service.handleOauthRequest(query);
 
-    // Add the login result to the result map
-    Oauth._loginResultForCredentialToken[query.state] = {
-          serviceName: service.serviceName,
-          serviceData: oauthResult.serviceData,
-          options: oauthResult.options
-        };
+    // Store the login result so it can be retrieved in another
+    // browser tab by the result handler
+    OAuth._storePendingCredential(query.state, {
+      serviceName: service.serviceName,
+      serviceData: oauthResult.serviceData,
+      options: oauthResult.options
+    });
   }
 
   // Either close the window, redirect, or render nothing
   // if all else fails
-  Oauth._renderOauthResults(res, query);
+  OAuth._renderOauthResults(res, query);
 };
diff --git a/packages/oauth2/oauth2_tests.js b/packages/oauth2/oauth2_tests.js
index 00cd88e7d3..5dc9c4fce3 100644
--- a/packages/oauth2/oauth2_tests.js
+++ b/packages/oauth2/oauth2_tests.js
@@ -1,4 +1,4 @@
-Tinytest.add("oauth2 - loginResultForCredentialToken is stored", function (test) {
+var testPendingCredential = function (test) {
   var http = Npm.require('http');
   var foobookId = Random.id();
   var foobookOption1 = Random.id();
@@ -9,9 +9,12 @@ Tinytest.add("oauth2 - loginResultForCredentialToken is stored", function (test)
 
   try {
     // register a fake login service
-    Oauth.registerService(serviceName, 2, null, function (query) {
+    OAuth.registerService(serviceName, 2, null, function (query) {
       return {
-        serviceData: {id: foobookId},
+        serviceData: {
+          id: foobookId,
+          secretStuff: OAuth.sealSecret("confidential")
+        },
         options: {option1: foobookOption1}
       };
     });
@@ -20,17 +23,35 @@ Tinytest.add("oauth2 - loginResultForCredentialToken is stored", function (test)
     var req = {method: "POST",
                url: "/_oauth/" + serviceName + "?close",
                query: {state: credentialToken}};
-    OauthTest.middleware(req, new http.ServerResponse(req));
+    OAuthTest.middleware(req, new http.ServerResponse(req));
 
-    // Test that the login result for that user is prepared
-    test.equal(
-      Oauth._loginResultForCredentialToken[credentialToken].serviceName, serviceName);
-    test.equal(
-      Oauth._loginResultForCredentialToken[credentialToken].serviceData.id, foobookId);
-    test.equal(
-      Oauth._loginResultForCredentialToken[credentialToken].options.option1, foobookOption1);
+    // Test that the result for the token is available
+    var result = OAuth._retrievePendingCredential(credentialToken);
+    var serviceData = OAuth.openSecrets(result.serviceData);
+    test.equal(result.serviceName, serviceName);
+    test.equal(serviceData.id, foobookId);
+    test.equal(serviceData.secretStuff, 'confidential');
+    test.equal(result.options.option1, foobookOption1);
+
+    // Test that pending credential is removed after being retrieved
+    result = OAuth._retrievePendingCredential(credentialToken);
+    test.isUndefined(result);
 
   } finally {
-    OauthTest.unregisterService(serviceName);
+    OAuthTest.unregisterService(serviceName);
+  }
+};
+
+Tinytest.add("oauth2 - pendingCredential is stored and can be retrieved (without oauth encryption)", function (test) {
+  OAuthEncryption.loadKey(null);
+  testPendingCredential(test);
+});
+
+Tinytest.add("oauth2 - pendingCredential is stored and can be retrieved (with oauth encryption)", function (test) {
+  try {
+    OAuthEncryption.loadKey(new Buffer([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]).toString("base64"));
+    testPendingCredential(test);
+  } finally {
+    OAuthEncryption.loadKey(null);
   }
 });
diff --git a/packages/oauth2/package.js b/packages/oauth2/package.js
index 75e695ec24..09cec405b2 100644
--- a/packages/oauth2/package.js
+++ b/packages/oauth2/package.js
@@ -14,7 +14,7 @@ Package.on_use(function (api) {
 });
 
 Package.on_test(function (api) {
-  api.use(['tinytest', 'random', 'oauth2', 'oauth', 'service-configuration'],
+  api.use(['tinytest', 'random', 'oauth2', 'oauth', 'service-configuration', 'oauth-encryption'],
           'server');
   api.add_files("oauth2_tests.js", 'server');
 });
diff --git a/packages/madewith/.gitignore b/packages/observe-sequence/.gitignore
similarity index 100%
rename from packages/madewith/.gitignore
rename to packages/observe-sequence/.gitignore
diff --git a/packages/observe-sequence/observe_sequence.js b/packages/observe-sequence/observe_sequence.js
new file mode 100644
index 0000000000..7af183f084
--- /dev/null
+++ b/packages/observe-sequence/observe_sequence.js
@@ -0,0 +1,307 @@
+var warn = function () {
+  if (ObserveSequence._suppressWarnings) {
+    ObserveSequence._suppressWarnings--;
+  } else {
+    if (typeof console !== 'undefined' && console.warn)
+      console.warn.apply(console, arguments);
+
+    ObserveSequence._loggedWarnings++;
+  }
+};
+
+var idStringify = LocalCollection._idStringify;
+var idParse = LocalCollection._idParse;
+
+ObserveSequence = {
+  _suppressWarnings: 0,
+  _loggedWarnings: 0,
+
+  // A mechanism similar to cursor.observe which receives a reactive
+  // function returning a sequence type and firing appropriate callbacks
+  // when the value changes.
+  //
+  // @param sequenceFunc {Function} a reactive function returning a
+  //     sequence type. The currently supported sequence types are:
+  //     'null', arrays and cursors.
+  //
+  // @param callbacks {Object} similar to a specific subset of
+  //     callbacks passed to `cursor.observe`
+  //     (http://docs.meteor.com/#observe), with minor variations to
+  //     support the fact that not all sequences contain objects with
+  //     _id fields.  Specifically:
+  //
+  //     * addedAt(id, item, atIndex, beforeId)
+  //     * changedAt(id, newItem, oldItem, atIndex)
+  //     * removedAt(id, oldItem, atIndex)
+  //     * movedTo(id, item, fromIndex, toIndex, beforeId)
+  //
+  // @returns {Object(stop: Function)} call 'stop' on the return value
+  //     to stop observing this sequence function.
+  //
+  // We don't make any assumptions about our ability to compare sequence
+  // elements (ie, we don't assume EJSON.equals works; maybe there is extra
+  // state/random methods on the objects) so unlike cursor.observe, we may
+  // sometimes call changedAt() when nothing actually changed.
+  // XXX consider if we *can* make the stronger assumption and avoid
+  //     no-op changedAt calls (in some cases?)
+  //
+  // XXX currently only supports the callbacks used by our
+  // implementation of {{#each}}, but this can be expanded.
+  //
+  // XXX #each doesn't use the indices (though we'll eventually need
+  // a way to get them when we support `@index`), but calling
+  // `cursor.observe` causes the index to be calculated on every
+  // callback using a linear scan (unless you turn it off by passing
+  // `_no_indices`).  Any way to avoid calculating indices on a pure
+  // cursor observe like we used to?
+  observe: function (sequenceFunc, callbacks) {
+    var lastSeq = null;
+    var activeObserveHandle = null;
+
+    // 'lastSeqArray' contains the previous value of the sequence
+    // we're observing. It is an array of objects with '_id' and
+    // 'item' fields.  'item' is the element in the array, or the
+    // document in the cursor.
+    //
+    // '_id' is whichever of the following is relevant, unless it has
+    // already appeared -- in which case it's randomly generated.
+    //
+    // * if 'item' is an object:
+    //   * an '_id' field, if present
+    //   * otherwise, the index in the array
+    //
+    // * if 'item' is a number or string, use that value
+    //
+    // XXX this can be generalized by allowing {{#each}} to accept a
+    // general 'key' argument which could be a function, a dotted
+    // field name, or the special @index value.
+    var lastSeqArray = []; // elements are objects of form {_id, item}
+    var computation = Deps.autorun(function () {
+      var seq = sequenceFunc();
+
+      Deps.nonreactive(function () {
+        var seqArray; // same structure as `lastSeqArray` above.
+
+        // If we were previously observing a cursor, replace lastSeqArray with
+        // more up-to-date information (specifically, the state of the observe
+        // before it was stopped, which may be older than the DB).
+        if (activeObserveHandle) {
+          lastSeqArray = _.map(activeObserveHandle._fetch(), function (doc) {
+            return {_id: doc._id, item: doc};
+          });
+          activeObserveHandle.stop();
+          activeObserveHandle = null;
+        }
+
+        if (!seq) {
+          seqArray = [];
+          diffArray(lastSeqArray, seqArray, callbacks);
+        } else if (seq instanceof Array) {
+          var idsUsed = {};
+          seqArray = _.map(seq, function (item, index) {
+            var id;
+            if (typeof item === 'string') {
+              // ensure not empty, since other layers (eg DomRange) assume this as well
+              id = "-" + item;
+            } else if (typeof item === 'number' ||
+                       typeof item === 'boolean' ||
+                       item === undefined) {
+              id = item;
+            } else if (typeof item === 'object') {
+              id = (item && item._id) || index;
+            } else {
+              throw new Error("{{#each}} doesn't support arrays with " +
+                              "elements of type " + typeof item);
+            }
+
+            var idString = idStringify(id);
+            if (idsUsed[idString]) {
+              warn("duplicate id " + id + " in", seq);
+              id = Random.id();
+            } else {
+              idsUsed[idString] = true;
+            }
+
+            return { _id: id, item: item };
+          });
+
+          diffArray(lastSeqArray, seqArray, callbacks);
+        } else if (isMinimongoCursor(seq)) {
+          var cursor = seq;
+          seqArray = [];
+
+          var initial = true; // are we observing initial data from cursor?
+          activeObserveHandle = cursor.observe({
+            addedAt: function (document, atIndex, before) {
+              if (initial) {
+                // keep track of initial data so that we can diff once
+                // we exit `observe`.
+                if (before !== null)
+                  throw new Error("Expected initial data from observe in order");
+                seqArray.push({ _id: document._id, item: document });
+              } else {
+                callbacks.addedAt(document._id, document, atIndex, before);
+              }
+            },
+            changedAt: function (newDocument, oldDocument, atIndex) {
+              callbacks.changedAt(newDocument._id, newDocument, oldDocument,
+                                  atIndex);
+            },
+            removedAt: function (oldDocument, atIndex) {
+              callbacks.removedAt(oldDocument._id, oldDocument, atIndex);
+            },
+            movedTo: function (document, fromIndex, toIndex, before) {
+              callbacks.movedTo(
+                document._id, document, fromIndex, toIndex, before);
+            }
+          });
+          initial = false;
+
+          // diff the old sequnce with initial data in the new cursor. this will
+          // fire `addedAt` callbacks on the initial data.
+          diffArray(lastSeqArray, seqArray, callbacks);
+
+        } else {
+          throw badSequenceError();
+        }
+
+        lastSeq = seq;
+        lastSeqArray = seqArray;
+      });
+    });
+
+    return {
+      stop: function () {
+        computation.stop();
+        if (activeObserveHandle)
+          activeObserveHandle.stop();
+      }
+    };
+  },
+
+  // Fetch the items of `seq` into an array, where `seq` is of one of the
+  // sequence types accepted by `observe`.  If `seq` is a cursor, a
+  // dependency is established.
+  fetch: function (seq) {
+    if (!seq) {
+      return [];
+    } else if (seq instanceof Array) {
+      return seq;
+    } else if (isMinimongoCursor(seq)) {
+      return seq.fetch();
+    } else {
+      throw badSequenceError();
+    }
+  }
+};
+
+var badSequenceError = function () {
+  return new Error("{{#each}} currently only accepts " +
+                   "arrays, cursors or falsey values.");
+};
+
+var isMinimongoCursor = function (seq) {
+  var minimongo = Package.minimongo;
+  return !!minimongo && (seq instanceof minimongo.LocalCollection.Cursor);
+};
+
+// Calculates the differences between `lastSeqArray` and
+// `seqArray` and calls appropriate functions from `callbacks`.
+// Reuses Minimongo's diff algorithm implementation.
+var diffArray = function (lastSeqArray, seqArray, callbacks) {
+  var diffFn = Package.minimongo.LocalCollection._diffQueryOrderedChanges;
+  var oldIdObjects = [];
+  var newIdObjects = [];
+  var posOld = {}; // maps from idStringify'd ids
+  var posNew = {}; // ditto
+  var posCur = {};
+  var lengthCur = lastSeqArray.length;
+
+  _.each(seqArray, function (doc, i) {
+    newIdObjects.push({_id: doc._id});
+    posNew[idStringify(doc._id)] = i;
+  });
+  _.each(lastSeqArray, function (doc, i) {
+    oldIdObjects.push({_id: doc._id});
+    posOld[idStringify(doc._id)] = i;
+    posCur[idStringify(doc._id)] = i;
+  });
+
+  // Arrays can contain arbitrary objects. We don't diff the
+  // objects. Instead we always fire 'changedAt' callback on every
+  // object. The consumer of `observe-sequence` should deal with
+  // it appropriately.
+  diffFn(oldIdObjects, newIdObjects, {
+    addedBefore: function (id, doc, before) {
+      var position = before ? posCur[idStringify(before)] : lengthCur;
+
+      _.each(posCur, function (pos, id) {
+        if (pos >= position)
+          posCur[id]++;
+      });
+
+      lengthCur++;
+      posCur[idStringify(id)] = position;
+
+      callbacks.addedAt(
+        id,
+        seqArray[posNew[idStringify(id)]].item,
+        position,
+        before);
+    },
+    movedBefore: function (id, before) {
+      var prevPosition = posCur[idStringify(id)];
+      var position = before ? posCur[idStringify(before)] : lengthCur - 1;
+
+      _.each(posCur, function (pos, id) {
+        if (pos >= prevPosition && pos <= position)
+          posCur[id]--;
+        else if (pos <= prevPosition && pos >= position)
+          posCur[id]++;
+      });
+
+      posCur[idStringify(id)] = position;
+
+      callbacks.movedTo(
+        id,
+        seqArray[posNew[idStringify(id)]].item,
+        prevPosition,
+        position,
+        before);
+    },
+    removed: function (id) {
+      var prevPosition = posCur[idStringify(id)];
+
+      _.each(posCur, function (pos, id) {
+        if (pos >= prevPosition)
+          posCur[id]--;
+      });
+
+      delete posCur[idStringify(id)];
+      lengthCur--;
+
+      callbacks.removedAt(
+        id,
+        lastSeqArray[posOld[idStringify(id)]].item,
+        prevPosition);
+    }
+  });
+
+  _.each(posNew, function (pos, idString) {
+    var id = idParse(idString);
+    if (_.has(posOld, idString)) {
+      // specifically for primitive types, compare equality before
+      // firing the 'changedAt' callback. otherwise, always fire it
+      // because doing a deep EJSON comparison is not guaranteed to
+      // work (an array can contain arbitrary objects, and 'transform'
+      // can be used on cursors). also, deep diffing is not
+      // necessarily the most efficient (if only a specific subfield
+      // of the object is later accessed).
+      var newItem = seqArray[pos].item;
+      var oldItem = lastSeqArray[posOld[idString]].item;
+
+      if (typeof newItem === 'object' || newItem !== oldItem)
+          callbacks.changedAt(id, newItem, oldItem, pos);
+      }
+  });
+};
diff --git a/packages/observe-sequence/observe_sequence_tests.js b/packages/observe-sequence/observe_sequence_tests.js
new file mode 100644
index 0000000000..f950c1492c
--- /dev/null
+++ b/packages/observe-sequence/observe_sequence_tests.js
@@ -0,0 +1,513 @@
+// Run a function named `run` which modifies a sequence. While it
+// executes, observe changes to the sequence and accumulate them in an
+// array, canonicalizing as necessary. Then make sure the results are
+// the same as passed in `expectedCallbacks`. In items in
+// `expectedCallbacks`, allow for special values of the form {NOT:
+// "foo"}, which match anything other than "foo".
+//
+// @param test {Object} as passed to Tinytest.add
+// @param sequenceFunc {Function(): sequence type}
+// @param run {Function()} modify the sequence or cause sequenceFunc
+//     to be recomupted
+// @param expectedCallbacks {Array}
+//     elements are objects eg {addedAt: [array of arguments]}
+// @param numExpectedWarnings {Number}
+runOneObserveSequenceTestCase = function (test, sequenceFunc,
+                                          run, expectedCallbacks,
+                                          numExpectedWarnings) {
+  if (numExpectedWarnings)
+    ObserveSequence._suppressWarnings += numExpectedWarnings;
+
+  var firedCallbacks = [];
+  var handle = ObserveSequence.observe(sequenceFunc, {
+    addedAt: function () {
+      firedCallbacks.push({addedAt: _.toArray(arguments)});
+    },
+    changedAt: function () {
+      var obj = {changedAt: _.toArray(arguments)};
+
+      // Browsers are inconsistent about the order in which 'changedAt'
+      // callbacks fire. To ensure consistent behavior of these tests,
+      // we can't simply push `obj` at the end of `firedCallbacks` as
+      // we do for the other callbacks. Instead, we use insertion sort
+      // to place `obj` in a canonical position within the chunk of
+      // contiguously recently fired 'changedAt' callbacks.
+      for (var i = firedCallbacks.length; i > 0; i--) {
+
+        var compareTo = firedCallbacks[i - 1];
+        if (!compareTo.changedAt)
+          break;
+
+        if (EJSON.stringify(compareTo, {canonical: true}) <
+            EJSON.stringify(obj, {canonical: true}))
+          break;
+      }
+
+      firedCallbacks.splice(i, 0, obj);
+    },
+    removedAt: function () {
+      firedCallbacks.push({removedAt: _.toArray(arguments)});
+    },
+    movedTo: function () {
+      firedCallbacks.push({movedTo: _.toArray(arguments)});
+    }
+  });
+
+  run();
+  Deps.flush();
+  handle.stop();
+
+  test.equal(ObserveSequence._suppressWarnings, 0);
+  test.equal(ObserveSequence._loggedWarnings, 0);
+  ObserveSequence._loggedWarnings = 0;
+
+  // any expected argument this is `{NOT: "foo"}`, should match any
+  // corresponding value in the fired callbacks other than "foo". so,
+  // assert non-equality and then replace the appropriate entries in
+  // the 'firedCallbacks' array with `{NOT: "foo"}` before calling
+  // `test.equal` below.
+  var commonLength = Math.min(firedCallbacks.length, expectedCallbacks.length);
+  for (var i = 0; i < commonLength; i++) {
+    var callback = expectedCallbacks[i];
+    if (_.keys(callback).length !== 1)
+      throw new Error("Callbacks should be objects with one key, eg `addedAt`");
+    var callbackName = _.keys(callback)[0];
+    var args = _.values(callback)[0];
+    _.each(args, function (arg, argIndex) {
+      if (arg && typeof arg === 'object' &&
+          'NOT' in arg &&
+          firedCallbacks[i][callbackName]) {
+        test.notEqual(firedCallbacks[i][callbackName][argIndex],
+                      arg.NOT, "Should be NOT " + arg.NOT);
+        firedCallbacks[i][callbackName][argIndex] = arg;
+      }
+    });
+  }
+
+  var compress = function (str) {
+    return str.replace(/\[\n\s*/gm, "[").replace(/\{\n\s*/gm, "{").
+      replace(/\n\s*\]/gm, "]").replace(/\n\s*\}/gm, "}");
+  };
+
+  test.equal(compress(EJSON.stringify(firedCallbacks, {canonical: true, indent: true})),
+             compress(EJSON.stringify(expectedCallbacks, {canonical: true, indent: true})));
+};
+
+Tinytest.add('observe sequence - initial data for all sequence types', function (test) {
+  runOneObserveSequenceTestCase(test, function () {
+    return null;
+  }, function () {}, []);
+
+  runOneObserveSequenceTestCase(test, function () {
+    return [];
+  }, function () {}, []);
+
+  runOneObserveSequenceTestCase(test, function () {
+    return [{foo: 1}, {bar: 2}];
+  }, function () {}, [
+    {addedAt: [0, {foo: 1}, 0, null]},
+    {addedAt: [1, {bar: 2}, 1, null]}
+  ]);
+
+  runOneObserveSequenceTestCase(test, function () {
+    return [{_id: "13", foo: 1}, {_id: "37", bar: 2}];
+  }, function () {}, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]}
+  ]);
+
+  runOneObserveSequenceTestCase(test, function () {
+    var coll = new Meteor.Collection(null);
+    coll.insert({_id: "13", foo: 1});
+    coll.insert({_id: "37", bar: 2});
+    var cursor = coll.find({}, {sort: {_id: 1}});
+    return cursor;
+  }, function () {}, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]}
+  ]);
+
+  // shouldn't break on array with duplicate _id's, and the ids sent
+  // in the callbacks should be distinct
+  runOneObserveSequenceTestCase(test, function () {
+    return [
+      {_id: "13", foo: 1},
+      {_id: "13", foo: 2}
+    ];
+  }, function () {}, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: [{NOT: "13"}, {_id: "13", foo: 2}, 1, null]}
+  ], /*numExpectedWarnings = */1);
+});
+
+Tinytest.add('observe sequence - array to other array', function (test) {
+  var dep = new Deps.Dependency;
+  var seq = [{_id: "13", foo: 1}, {_id: "37", bar: 2}];
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    seq = [{_id: "13", foo: 1}, {_id: "38", bar: 2}];
+    dep.changed();
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]},
+    {removedAt: ["37", {_id: "37", bar: 2}, 1]},
+    {addedAt: ["38", {_id: "38", bar: 2}, 1, null]},
+    {changedAt: ["13", {_id: "13", foo: 1}, {_id: "13", foo: 1}, 0]}
+  ]);
+});
+
+Tinytest.add('observe sequence - array to other array, strings', function (test) {
+  var dep = new Deps.Dependency;
+  var seq = ["A", "B"];
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    seq = ["B", "C"];
+    dep.changed();
+  }, [
+    {addedAt: ["-A", "A", 0, null]},
+    {addedAt: ["-B", "B", 1, null]},
+    {removedAt: ["-A", "A", 0]},
+    {addedAt: ["-C", "C", 1, null]}
+  ]);
+});
+
+Tinytest.add('observe sequence - array to other array, objects without ids', function (test) {
+  var dep = new Deps.Dependency;
+  var seq = [{foo: 1}, {bar: 2}];
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    seq = [{foo: 2}];
+    dep.changed();
+  }, [
+    {addedAt: [0, {foo: 1}, 0, null]},
+    {addedAt: [1, {bar: 2}, 1, null]},
+    {removedAt: [1, {bar: 2}, 1]},
+    {changedAt: [0, {foo: 2}, {foo: 1}, 0]}
+  ]);
+});
+
+Tinytest.add('observe sequence - array to other array, changes', function (test) {
+  var dep = new Deps.Dependency;
+  var seq = [{_id: "13", foo: 1}, {_id: "37", bar: 2}, {_id: "42", baz: 42}];
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    seq = [{_id: "13", foo: 1}, {_id: "38", bar: 2}, {_id: "42", baz: 43}];
+    dep.changed();
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]},
+    {addedAt: ["42", {_id: "42", baz: 42}, 2, null]},
+    {removedAt: ["37", {_id: "37", bar: 2}, 1]},
+    {addedAt: ["38", {_id: "38", bar: 2}, 1, "42"]},
+    // change fires for all elements, because we don't diff the actual
+    // objects.
+    {changedAt: ["13", {_id: "13", foo: 1}, {_id: "13", foo: 1}, 0]},
+    {changedAt: ["42", {_id: "42", baz: 43}, {_id: "42", baz: 42}, 2]}
+  ]);
+});
+
+Tinytest.add('observe sequence - array to other array, movedTo', function (test) {
+  var dep = new Deps.Dependency;
+  var seq = [{_id: "13", foo: 1}, {_id: "37", bar: 2}, {_id: "42", baz: 42}, {_id: "43", baz: 43}];
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    seq = [{_id: "43", baz: 43}, {_id: "37", bar: 2}, {_id: "42", baz: 42}, {_id: "13", foo: 1}];
+    dep.changed();
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]},
+    {addedAt: ["42", {_id: "42", baz: 42}, 2, null]},
+    {addedAt: ["43", {_id: "43", baz: 43}, 3, null]},
+
+    {movedTo: ["43", {_id: "43", baz: 43}, 3, 1, "37"]},
+    {movedTo: ["13", {_id: "13", foo: 1}, 0, 3, null]},
+
+    {changedAt: ["13", {_id: "13", foo: 1}, {_id: "13", foo: 1}, 3]},
+    {changedAt: ["37", {_id: "37", bar: 2}, {_id: "37", bar: 2}, 1]},
+    {changedAt: ["42", {_id: "42", baz: 42}, {_id: "42", baz: 42}, 2]},
+    {changedAt: ["43", {_id: "43", baz: 43}, {_id: "43", baz: 43}, 0]}
+  ]);
+});
+
+Tinytest.add('observe sequence - array to null', function (test) {
+  var dep = new Deps.Dependency;
+  var seq = [{_id: "13", foo: 1}, {_id: "37", bar: 2}];
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    seq = null;
+    dep.changed();
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]},
+    {removedAt: ["13", {_id: "13", foo: 1}, 0]},
+    {removedAt: ["37", {_id: "37", bar: 2}, 0]}
+  ]);
+});
+
+Tinytest.add('observe sequence - array to cursor', function (test) {
+  var dep = new Deps.Dependency;
+  var seq = [{_id: "13", foo: 1}, {_id: "37", bar: 2}];
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    var coll = new Meteor.Collection(null);
+    coll.insert({_id: "13", foo: 1});
+    coll.insert({_id: "38", bar: 2});
+    var cursor = coll.find({}, {sort: {_id: 1}});
+    seq = cursor;
+    dep.changed();
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]},
+    {removedAt: ["37", {_id: "37", bar: 2}, 1]},
+    {addedAt: ["38", {_id: "38", bar: 2}, 1, null]},
+    {changedAt: ["13", {_id: "13", foo: 1}, {_id: "13", foo: 1}, 0]}
+  ]);
+});
+
+
+Tinytest.add('observe sequence - cursor to null', function (test) {
+  var dep = new Deps.Dependency;
+  var coll = new Meteor.Collection(null);
+  coll.insert({_id: "13", foo: 1});
+  coll.insert({_id: "37", bar: 2});
+  var cursor = coll.find({}, {sort: {_id: 1}});
+  var seq = cursor;
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    seq = null;
+    dep.changed();
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]},
+    {removedAt: ["13", {_id: "13", foo: 1}, 0]},
+    {removedAt: ["37", {_id: "37", bar: 2}, 0]}
+  ]);
+});
+
+Tinytest.add('observe sequence - cursor to array', function (test) {
+  var dep = new Deps.Dependency;
+  var coll = new Meteor.Collection(null);
+  coll.insert({_id: "13", foo: 1});
+  var cursor = coll.find({}, {sort: {_id: 1}});
+  var seq = cursor;
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    coll.insert({_id: "37", bar: 2});
+    seq = [{_id: "13", foo: 1}, {_id: "38", bar: 2}];
+    dep.changed();
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]},
+    {removedAt: ["37", {_id: "37", bar: 2}, 1]},
+    {addedAt: ["38", {_id: "38", bar: 2}, 1, null]},
+    {changedAt: ["13", {_id: "13", foo: 1}, {_id: "13", foo: 1}, 0]}
+  ]);
+});
+
+Tinytest.add('observe sequence - cursor', function (test) {
+  var coll = new Meteor.Collection(null);
+  coll.insert({_id: "13", rank: 1});
+  var cursor = coll.find({}, {sort: {rank: 1}});
+  var seq = cursor;
+
+  runOneObserveSequenceTestCase(test, function () {
+    return seq;
+  }, function () {
+    coll.insert({_id: "37", rank: 2});
+    coll.insert({_id: "77", rank: 3});
+    coll.remove({_id: "37"});                           // should fire a 'removedAt' callback
+    coll.insert({_id: "11", rank: 0});                  // should fire an 'addedAt' callback
+    coll.update({_id: "13"}, {$set: {updated: true}});  // should fire an 'changedAt' callback
+    coll.update({_id: "77"}, {$set: {rank: -1}});       // should fire 'changedAt' and 'movedTo' callback
+  }, [
+    // this case must not fire spurious calls as the array to array
+    // case does. otherwise, the entire power of cursors is lost in
+    // blaze.
+    {addedAt: ["13", {_id: "13", rank: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", rank: 2}, 1, null]},
+    {addedAt: ["77", {_id: "77", rank: 3}, 2, null]},
+    {removedAt: ["37", {_id: "37", rank: 2}, 1]},
+    {addedAt: ["11", {_id: "11", rank: 0}, 0, "13"]},
+    {changedAt: ["13", {_id: "13", rank: 1, updated: true}, {_id: "13", rank: 1}, 1]},
+    {changedAt: ["77", {_id: "77", rank: -1}, {_id: "77", rank: 3}, 2]},
+    {movedTo: ["77", {_id: "77", rank: -1}, 2, 0, "11"]}
+  ]);
+});
+
+Tinytest.add('observe sequence - cursor to other cursor', function (test) {
+  var dep = new Deps.Dependency;
+  var coll = new Meteor.Collection(null);
+  coll.insert({_id: "13", foo: 1});
+  var cursor = coll.find({}, {sort: {_id: 1}});
+  var seq = cursor;
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    coll.insert({_id: "37", bar: 2});
+
+    var newColl = new Meteor.Collection(null);
+    newColl.insert({_id: "13", foo: 1});
+    newColl.insert({_id: "38", bar: 2});
+    var newCursor = newColl.find({}, {sort: {_id: 1}});
+    seq = newCursor;
+    dep.changed();
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2}, 1, null]},
+    {removedAt: ["37", {_id: "37", bar: 2}, 1]},
+    {addedAt: ["38", {_id: "38", bar: 2}, 1, null]},
+    {changedAt: ["13", {_id: "13", foo: 1}, {_id: "13", foo: 1}, 0]}
+  ]);
+});
+
+Tinytest.add('observe sequence - cursor to other cursor with transform', function (test) {
+  var dep = new Deps.Dependency;
+  var transform = function(doc) {
+    return _.extend({idCopy: doc._id}, doc);
+  };
+
+  var coll = new Meteor.Collection(null, {transform: transform});
+  coll.insert({_id: "13", foo: 1});
+  var cursor = coll.find({}, {sort: {_id: 1}});
+  var seq = cursor;
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    coll.insert({_id: "37", bar: 2});
+
+    var newColl = new Meteor.Collection(null, {transform: transform});
+    newColl.insert({_id: "13", foo: 1});
+    newColl.insert({_id: "38", bar: 2});
+    var newCursor = newColl.find({}, {sort: {_id: 1}});
+    seq = newCursor;
+    dep.changed();
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1, idCopy: "13"}, 0, null]},
+    {addedAt: ["37", {_id: "37", bar: 2, idCopy: "37"}, 1, null]},
+    {removedAt: ["37", {_id: "37", bar: 2, idCopy: "37"}, 1]},
+    {addedAt: ["38", {_id: "38", bar: 2, idCopy: "38"}, 1, null]},
+    {changedAt: ["13", {_id: "13", foo: 1, idCopy: "13"}, {_id: "13", foo: 1, idCopy: "13"}, 0]}
+  ]);
+});
+
+Tinytest.add('observe sequence - cursor to same cursor', function (test) {
+  var coll = new Meteor.Collection(null);
+  coll.insert({_id: "13", rank: 1});
+  var cursor = coll.find({}, {sort: {rank: 1}});
+  var seq = cursor;
+  var dep = new Deps.Dependency;
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    coll.insert({_id: "24", rank: 2});
+    dep.changed();
+    Deps.flush();
+    coll.insert({_id: "78", rank: 3});
+  }, [
+    {addedAt: ["13", {_id: "13", rank: 1}, 0, null]},
+    {addedAt: ["24", {_id: "24", rank: 2}, 1, null]},
+    // even if the cursor changes to the same cursor, we diff to see if we
+    // missed anything during the invalidation, which leads to these
+    // 'changedAt' events.
+    {changedAt: ["13", {_id: "13", rank: 1}, {_id: "13", rank: 1}, 0]},
+    {changedAt: ["24", {_id: "24", rank: 2}, {_id: "24", rank: 2}, 1]},
+    {addedAt: ["78", {_id: "78", rank: 3}, 2, null]}
+  ]);
+});
+
+Tinytest.add('observe sequence - string arrays', function (test) {
+  var seq = ['A', 'B'];
+  var dep = new Deps.Dependency;
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    seq = ['B', 'C'];
+    dep.changed();
+  }, [
+    {addedAt: ['-A', 'A', 0, null]},
+    {addedAt: ['-B', 'B', 1, null]},
+    {removedAt: ['-A', 'A', 0]},
+    {addedAt: ['-C', 'C', 1, null]}
+  ]);
+});
+
+Tinytest.add('observe sequence - number arrays', function (test) {
+  var seq = [1, 1, 2];
+  var dep = new Deps.Dependency;
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    seq = [1, 3, 2, 3];
+    dep.changed();
+  }, [
+    {addedAt: [1, 1, 0, null]},
+    {addedAt: [{NOT: 1}, 1, 1, null]},
+    {addedAt: [2, 2, 2, null]},
+    {removedAt: [{NOT: 1}, 1, 1]},
+    {addedAt: [3, 3, 1, 2]},
+    {addedAt: [{NOT: 3}, 3, 3, null]}
+  ], /*numExpectedWarnings = */2);
+});
+
+Tinytest.add('observe sequence - cursor to other cursor, same collection', function (test) {
+  var dep = new Deps.Dependency;
+  var coll = new Meteor.Collection(null);
+  coll.insert({_id: "13", foo: 1});
+  coll.insert({_id: "37", foo: 2});
+  var cursor = coll.find({foo: 1});
+  var seq = cursor;
+
+  runOneObserveSequenceTestCase(test, function () {
+    dep.depend();
+    return seq;
+  }, function () {
+    var newCursor = coll.find({foo: 2});
+    seq = newCursor;
+    dep.changed();
+    Deps.flush();
+    coll.insert({_id: "38", foo: 1});
+    coll.insert({_id: "39", foo: 2});
+  }, [
+    {addedAt: ["13", {_id: "13", foo: 1}, 0, null]},
+    {removedAt: ["13", {_id: "13", foo: 1}, 0]},
+    {addedAt: ["37", {_id: "37", foo: 2}, 0, null]},
+    {addedAt: ["39", {_id: "39", foo: 2}, 1, null]}
+  ]);
+});
diff --git a/packages/observe-sequence/package.js b/packages/observe-sequence/package.js
new file mode 100644
index 0000000000..a0cd1d8ae3
--- /dev/null
+++ b/packages/observe-sequence/package.js
@@ -0,0 +1,22 @@
+Package.describe({
+  name: "observe-sequence",
+  test: "observe-sequence-test",
+  summary: "Observe changes to various sequence types such as arrays, cursors and objects",
+  version: "1.0.0",
+  internal: true
+});
+
+Package.on_use(function (api) {
+  api.use('deps');
+  api.use('minimongo');  // for idStringify
+  api.export('ObserveSequence');
+  api.add_files(['observe_sequence.js']);
+});
+
+Package.on_test(function (api) {
+  api.use('tinytest');
+  api.use('observe-sequence');
+  api.use('underscore');
+  api.use('ejson');
+  api.add_files(['observe_sequence_tests.js'], 'client');
+});
diff --git a/packages/preserve-inputs/deprecated.js b/packages/preserve-inputs/deprecated.js
new file mode 100644
index 0000000000..09457af645
--- /dev/null
+++ b/packages/preserve-inputs/deprecated.js
@@ -0,0 +1 @@
+console.log("The 'preserve-inputs' package is now unnecessary and deprecated.");
diff --git a/packages/preserve-inputs/package.js b/packages/preserve-inputs/package.js
index cd4e2c47f7..f026a1dbc3 100644
--- a/packages/preserve-inputs/package.js
+++ b/packages/preserve-inputs/package.js
@@ -1,9 +1,9 @@
 Package.describe({
-  summary: "Automatically preserve form fields with a unique id",
-  version: "1.0.0"
+  summary: "Deprecated package (now empty)",
+  version: "1.0.0",
+  internal: true
 });
 
 Package.on_use(function (api) {
-  api.use(['underscore', 'spark']);
-  api.add_files("preserve-inputs.js", "client");
+  api.add_files('deprecated.js', 'server');
 });
diff --git a/packages/preserve-inputs/preserve-inputs.js b/packages/preserve-inputs/preserve-inputs.js
deleted file mode 100644
index 8d507049ab..0000000000
--- a/packages/preserve-inputs/preserve-inputs.js
+++ /dev/null
@@ -1,7 +0,0 @@
-var inputTags = 'input textarea button select option'.split(' ');
-
-var selector = _.map(inputTags, function (t) {
-  return t.replace(/^.*$/, '$&[id], $&[name]');
-}).join(', ');
-
-Spark._addGlobalPreserve(selector, Spark._labelFromIdOrName);
diff --git a/packages/random/random.js b/packages/random/random.js
index 0c1397df5b..f0d22f2eb5 100644
--- a/packages/random/random.js
+++ b/packages/random/random.js
@@ -86,6 +86,8 @@ var Alea = function () {
 };
 
 var UNMISTAKABLE_CHARS = "23456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijkmnopqrstuvwxyz";
+var BASE64_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+  "0123456789-_";
 
 // If seeds are provided, then the alea PRNG will be used, since cryptographic
 // PRNGs (Node crypto and window.crypto.getRandomValues) don't allow us to
@@ -139,17 +141,36 @@ RandomGenerator.prototype.hexString = function (digits) {
     return hexDigits.join('');
   }
 };
-RandomGenerator.prototype.id = function () {
-  var digits = [];
+
+RandomGenerator.prototype._randomString = function (charsCount,
+                                                    alphabet) {
   var self = this;
-  // Length of 17 preserves around 96 bits of entropy, which is the
-  // amount of state in the Alea PRNG.
-  for (var i = 0; i < 17; i++) {
-    digits[i] = self.choice(UNMISTAKABLE_CHARS);
+  var digits = [];
+  for (var i = 0; i < charsCount; i++) {
+    digits[i] = self.choice(alphabet);
   }
   return digits.join("");
 };
 
+RandomGenerator.prototype.id = function (charsCount) {
+  var self = this;
+  // 17 characters is around 96 bits of entropy, which is the amount of
+  // state in the Alea PRNG.
+  if (charsCount === undefined)
+    charsCount = 17;
+
+  return self._randomString(charsCount, UNMISTAKABLE_CHARS);
+};
+
+RandomGenerator.prototype.secret = function (charsCount) {
+  var self = this;
+  // Default to 256 bits of entropy, or 43 characters at 6 bits per
+  // character.
+  if (charsCount === undefined)
+    charsCount = 43;
+  return self._randomString(charsCount, BASE64_CHARS);
+};
+
 RandomGenerator.prototype.choice = function (arrayOrString) {
   var index = Math.floor(this.fraction() * arrayOrString.length);
   if (typeof arrayOrString === "string")
diff --git a/packages/random/random_tests.js b/packages/random/random_tests.js
index 436a87daef..c586e5ff8c 100644
--- a/packages/random/random_tests.js
+++ b/packages/random/random_tests.js
@@ -19,6 +19,7 @@ Tinytest.add('random', function (test) {
 Tinytest.add('random - format', function (test) {
   var idLen = 17;
   test.equal(Random.id().length, idLen);
+  test.equal(Random.id(29).length, 29);
   var numDigits = 9;
   var hexStr = Random.hexString(numDigits);
   test.equal(hexStr.length, numDigits);
@@ -26,6 +27,9 @@ Tinytest.add('random - format', function (test) {
   var frac = Random.fraction();
   test.isTrue(frac < 1.0);
   test.isTrue(frac >= 0.0);
+
+  test.equal(Random.secret().length, 43);
+  test.equal(Random.secret(13).length, 13);
 });
 
 Tinytest.add('random - Alea is last resort', function (test) {
diff --git a/packages/service-configuration/service_configuration_common.js b/packages/service-configuration/service_configuration_common.js
index 93e1db0800..a9f6cb64fe 100644
--- a/packages/service-configuration/service_configuration_common.js
+++ b/packages/service-configuration/service_configuration_common.js
@@ -18,8 +18,14 @@ ServiceConfiguration.configurations = new Meteor.Collection(
 
 
 // Thrown when trying to use a login service which is not configured
-ServiceConfiguration.ConfigError = function(description) {
-  this.message = description;
+ServiceConfiguration.ConfigError = function (serviceName) {
+  if (Meteor.isClient && !Accounts.loginServicesConfigured()) {
+    this.message = "Login service configuration not yet loaded";
+  } else if (serviceName) {
+    this.message = "Service " + serviceName + " not configured";
+  } else {
+    this.message = "Service not configured";
+  }
 };
 ServiceConfiguration.ConfigError.prototype = new Error();
 ServiceConfiguration.ConfigError.prototype.name = 'ServiceConfiguration.ConfigError';
diff --git a/packages/showdown/package.js b/packages/showdown/package.js
index 0e094c1f47..07fb6bab02 100644
--- a/packages/showdown/package.js
+++ b/packages/showdown/package.js
@@ -7,13 +7,14 @@ Package.describe({
   version: "1.0.0"
 });
 
-var _ = Npm.require('underscore');
-
 Package.on_use(function (api) {
   api.add_files("showdown.js");
   api.export('Showdown');
 
-  // Define {{markdown}} if handlebars got included.
-  api.use("handlebars", "client", {weak: true});
-  api.add_files("template-integration.js", "client");
+  api.use("ui", "client", {weak: true});
+  api.add_files('template-integration.js', 'client');
+});
+
+Package.on_test(function (api) {
+  api.use("ui", "client");
 });
diff --git a/packages/showdown/showdown.js b/packages/showdown/showdown.js
index 198acc5df7..f5590cb861 100644
--- a/packages/showdown/showdown.js
+++ b/packages/showdown/showdown.js
@@ -65,7 +65,28 @@
 // Showdown namespace
 //
 // METEOR CHANGE: remove "var" so that this isn't file-local.
-Showdown = {};
+Showdown = { extensions: {} };
+
+//
+// forEach
+//
+var forEach = Showdown.forEach = function(obj, callback) {
+	if (typeof obj.forEach === 'function') {
+		obj.forEach(callback);
+	} else {
+		var i, len = obj.length;
+		for (i = 0; i < len; i++) {
+			callback(obj[i], i, obj);
+		}
+	}
+};
+
+//
+// Standard extension naming
+//
+var stdExtName = function(s) {
+	return s.replace(/[_-]||\s/g, '').toLowerCase();
+};
 
 //
 // converter
@@ -73,7 +94,7 @@ Showdown = {};
 // Wraps all "globals" so that the only thing
 // exposed is makeHtml().
 //
-Showdown.converter = function() {
+Showdown.converter = function(converter_options) {
 
 //
 // Globals:
@@ -88,6 +109,32 @@ var g_html_blocks;
 // (see _ProcessListItems() for details):
 var g_list_level = 0;
 
+// Global extensions
+var g_lang_extensions = [];
+var g_output_modifiers = [];
+
+
+//
+// Automatic Extension Loading (node only):
+//
+
+if (typeof module !== 'undefind' && typeof exports !== 'undefined' && typeof require !== 'undefind') {
+	var fs = require('fs');
+
+	if (fs) {
+		// Search extensions folder
+		var extensions = fs.readdirSync((__dirname || '.')+'/extensions').filter(function(file){
+			return ~file.indexOf('.js');
+		}).map(function(file){
+			return file.replace(/\.js$/, '');
+		});
+		// Load extensions into Showdown namespace
+		Showdown.forEach(extensions, function(ext){
+			var name = stdExtName(ext);
+			Showdown.extensions[name] = require('./extensions/' + ext);
+		});
+	}
+}
 
 this.makeHtml = function(text) {
 //
@@ -101,14 +148,14 @@ this.makeHtml = function(text) {
 	// from other articles when generating a page which contains more than
 	// one article (e.g. an index page that shows the N most recent
 	// articles):
-	g_urls = new Array();
-	g_titles = new Array();
-	g_html_blocks = new Array();
+	g_urls = {};
+	g_titles = {};
+	g_html_blocks = [];
 
 	// attacklab: Replace ~ with ~T
 	// This lets us use tilde as an escape char to avoid md5 hashes
 	// The choice of character is arbitray; anything that isn't
-    // magic in Markdown will work.
+	// magic in Markdown will work.
 	text = text.replace(/~/g,"~T");
 
 	// attacklab: Replace $ with ~D
@@ -132,6 +179,15 @@ this.makeHtml = function(text) {
 	// contorted like /[ \t]*\n+/ .
 	text = text.replace(/^[ \t]+$/mg,"");
 
+	// Run language extensions
+	Showdown.forEach(g_lang_extensions, function(x){
+		text = _ExecuteExtension(x, text);
+	});
+
+	// Handle github codeblocks prior to running HashHTML so that
+	// HTML contained within the codeblock gets escaped propertly
+	text = _DoGithubCodeBlocks(text);
+
 	// Turn block-level HTML blocks into hash entries
 	text = _HashHTMLBlocks(text);
 
@@ -148,10 +204,61 @@ this.makeHtml = function(text) {
 	// attacklab: Restore tildes
 	text = text.replace(/~T/g,"~");
 
+	// Run output modifiers
+	Showdown.forEach(g_output_modifiers, function(x){
+		text = _ExecuteExtension(x, text);
+	});
+
 	return text;
+};
+//
+// Options:
+//
+
+// Parse extensions options into separate arrays
+if (converter_options && converter_options.extensions) {
+
+  var self = this;
+
+	// Iterate over each plugin
+	Showdown.forEach(converter_options.extensions, function(plugin){
+
+		// Assume it's a bundled plugin if a string is given
+		if (typeof plugin === 'string') {
+			plugin = Showdown.extensions[stdExtName(plugin)];
+		}
+
+		if (typeof plugin === 'function') {
+			// Iterate over each extension within that plugin
+			Showdown.forEach(plugin(self), function(ext){
+				// Sort extensions by type
+				if (ext.type) {
+					if (ext.type === 'language' || ext.type === 'lang') {
+						g_lang_extensions.push(ext);
+					} else if (ext.type === 'output' || ext.type === 'html') {
+						g_output_modifiers.push(ext);
+					}
+				} else {
+					// Assume language extension
+					g_output_modifiers.push(ext);
+				}
+			});
+		} else {
+			throw "Extension '" + plugin + "' could not be loaded.  It was either not found or is not a valid extension.";
+		}
+	});
 }
 
 
+var _ExecuteExtension = function(ext, text) {
+	if (ext.regex) {
+		var re = new RegExp(ext.regex, 'g');
+		return text.replace(re, ext.replace);
+	} else if (ext.filter) {
+		return ext.filter(text);
+	}
+};
+
 var _StripLinkDefinitions = function(text) {
 //
 // Strips link definitions from text, stores the URLs and titles in
@@ -181,7 +288,11 @@ var _StripLinkDefinitions = function(text) {
 			  /gm,
 			  function(){...});
 	*/
-	var text = text.replace(/^[ ]{0,3}\[(.+)\]:[ \t]*\n?[ \t]*<?(\S+?)>?[ \t]*\n?[ \t]*(?:(\n*)["(](.+?)[")][ \t]*)?(?:\n+|\Z)/gm,
+
+	// attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
+	text += "~0";
+
+	text = text.replace(/^[ ]{0,3}\[(.+)\]:[ \t]*\n?[ \t]*<?(\S+?)>?[ \t]*\n?[ \t]*(?:(\n*)["(](.+?)[")][ \t]*)?(?:\n+|(?=~0))/gm,
 		function (wholeMatch,m1,m2,m3,m4) {
 			m1 = m1.toLowerCase();
 			g_urls[m1] = _EncodeAmpsAndAngles(m2);  // Link IDs are case-insensitive
@@ -192,12 +303,15 @@ var _StripLinkDefinitions = function(text) {
 			} else if (m4) {
 				g_titles[m1] = m4.replace(/"/g,"&quot;");
 			}
-			
+
 			// Completely remove the definition from the text
 			return "";
 		}
 	);
 
+	// attacklab: strip sentinel
+	text = text.replace(/~0/,"");
+
 	return text;
 }
 
@@ -212,8 +326,8 @@ var _HashHTMLBlocks = function(text) {
 	// "paragraphs" that are wrapped in non-block-level tags, such as anchors,
 	// phrase emphasis, and spans. The list of tags we're looking for is
 	// hard-coded:
-	var block_tags_a = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del"
-	var block_tags_b = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math"
+	var block_tags_a = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del|style|section|header|footer|nav|article|aside";
+	var block_tags_b = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|style|section|header|footer|nav|article|aside";
 
 	// First, look for nested blocks, e.g.:
 	//   <div>
@@ -256,16 +370,16 @@ var _HashHTMLBlocks = function(text) {
 			\b					// word break
 								// attacklab: hack around khtml/pcre bug...
 			[^\r]*?				// any number of lines, minimally matching
-			.*</\2>				// the matching end tag
+			</\2>				// the matching end tag
 			[ \t]*				// trailing spaces/tabs
 			(?=\n+)				// followed by a newline
 		)						// attacklab: there are sentinel newlines at end of document
 		/gm,function(){...}};
 	*/
-	text = text.replace(/^(<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math)\b[^\r]*?.*<\/\2>[ \t]*(?=\n+)\n)/gm,hashElement);
+	text = text.replace(/^(<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|style|section|header|footer|nav|article|aside)\b[^\r]*?<\/\2>[ \t]*(?=\n+)\n)/gm,hashElement);
 
 	// Special case just for <hr />. It was easier to make a special case than
-	// to make the other regex more complicated.  
+	// to make the other regex more complicated.
 
 	/*
 		text = text.replace(/
@@ -274,7 +388,7 @@ var _HashHTMLBlocks = function(text) {
 			[ ]{0,3}
 			(<(hr)				// start tag = $2
 			\b					// word break
-			([^<>])*?			// 
+			([^<>])*?			//
 			\/?>)				// the matching end tag
 			[ \t]*
 			(?=\n{2,})			// followed by a blank line
@@ -332,13 +446,13 @@ var hashElement = function(wholeMatch,m1) {
 	// Undo double lines
 	blockText = blockText.replace(/\n\n/g,"\n");
 	blockText = blockText.replace(/^\n/,"");
-	
+
 	// strip trailing blank lines
 	blockText = blockText.replace(/\n+$/g,"");
-	
+
 	// Replace the element text with a marker ("~KxK" where x is its key)
 	blockText = "\n\n~K" + (g_html_blocks.push(blockText)-1) + "K\n\n";
-	
+
 	return blockText;
 };
 
@@ -367,7 +481,7 @@ var _RunBlockGamut = function(text) {
 	text = _FormParagraphs(text);
 
 	return text;
-}
+};
 
 
 var _RunSpanGamut = function(text) {
@@ -404,7 +518,7 @@ var _EscapeSpecialCharsWithinTagAttributes = function(text) {
 // don't conflict with their use in Markdown for code, italics and strong.
 //
 
-	// Build a regex to find HTML tags and comments.  See Friedl's 
+	// Build a regex to find HTML tags and comments.  See Friedl's
 	// "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
 	var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|<!(--.*?--\s*)+>)/gi;
 
@@ -480,7 +594,7 @@ var _DoAnchors = function(text) {
 		)
 		/g,writeAnchorTag);
 	*/
-	text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\]\([ \t]*()<?(.*?)>?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeAnchorTag);
+	text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\]\([ \t]*()<?(.*?(?:\(.*?\).*?)?)>?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeAnchorTag);
 
 	//
 	// Last, handle reference-style shortcuts: [link text]
@@ -509,14 +623,14 @@ var writeAnchorTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
 	var link_id	 = m3.toLowerCase();
 	var url		= m4;
 	var title	= m7;
-	
+
 	if (url == "") {
 		if (link_id == "") {
 			// lower-case and turn embedded newlines into spaces
 			link_id = link_text.toLowerCase().replace(/ ?\n/g," ");
 		}
 		url = "#"+link_id;
-		
+
 		if (g_urls[link_id] != undefined) {
 			url = g_urls[link_id];
 			if (g_titles[link_id] != undefined) {
@@ -531,19 +645,19 @@ var writeAnchorTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
 				return whole_match;
 			}
 		}
-	}	
-	
+	}
+
 	url = escapeCharacters(url,"*_");
 	var result = "<a href=\"" + url + "\"";
-	
+
 	if (title != "") {
 		title = title.replace(/"/g,"&quot;");
 		title = escapeCharacters(title,"*_");
 		result +=  " title=\"" + title + "\"";
 	}
-	
+
 	result += ">" + link_text + "</a>";
-	
+
 	return result;
 }
 
@@ -614,14 +728,14 @@ var writeImageTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
 	var title	= m7;
 
 	if (!title) title = "";
-	
+
 	if (url == "") {
 		if (link_id == "") {
 			// lower-case and turn embedded newlines into spaces
 			link_id = alt_text.toLowerCase().replace(/ ?\n/g," ");
 		}
 		url = "#"+link_id;
-		
+
 		if (g_urls[link_id] != undefined) {
 			url = g_urls[link_id];
 			if (g_titles[link_id] != undefined) {
@@ -631,8 +745,8 @@ var writeImageTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
 		else {
 			return whole_match;
 		}
-	}	
-	
+	}
+
 	alt_text = alt_text.replace(/"/g,"&quot;");
 	url = escapeCharacters(url,"*_");
 	var result = "<img src=\"" + url + "\" alt=\"" + alt_text + "\"";
@@ -645,9 +759,9 @@ var writeImageTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
 		title = escapeCharacters(title,"*_");
 		result +=  " title=\"" + title + "\"";
 	//}
-	
+
 	result += " />";
-	
+
 	return result;
 }
 
@@ -657,7 +771,7 @@ var _DoHeaders = function(text) {
 	// Setext-style headers:
 	//	Header 1
 	//	========
-	//  
+	//
 	//	Header 2
 	//	--------
 	//
@@ -744,7 +858,7 @@ var _DoLists = function(text) {
 			// paragraph for the last item in a list, if necessary:
 			list = list.replace(/\n{2,}/g,"\n\n\n");;
 			var result = _ProcessListItems(list);
-	
+
 			// Trim any trailing whitespace, to put the closing `</$list_type>`
 			// up on the preceding line, to get it past the current stupid
 			// HTML block parser. This is a hack to work around the terrible
@@ -764,7 +878,7 @@ var _DoLists = function(text) {
 			// paragraph for the last item in a list, if necessary:
 			var list = list.replace(/\n{2,}/g,"\n\n\n");;
 			var result = _ProcessListItems(list);
-			result = runup + "<"+list_type+">\n" + result + "</"+list_type+">\n";	
+			result = runup + "<"+list_type+">\n" + result + "</"+list_type+">\n";
 			return result;
 		});
 	}
@@ -850,7 +964,7 @@ _ProcessListItems = function(list_str) {
 var _DoCodeBlocks = function(text) {
 //
 //  Process Markdown `<pre><code>` blocks.
-//  
+//
 
 	/*
 		text = text.replace(text,
@@ -867,12 +981,12 @@ var _DoCodeBlocks = function(text) {
 
 	// attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
 	text += "~0";
-	
+
 	text = text.replace(/(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g,
 		function(wholeMatch,m1,m2) {
 			var codeblock = m1;
 			var nextChar = m2;
-		
+
 			codeblock = _EncodeCode( _Outdent(codeblock));
 			codeblock = _Detab(codeblock);
 			codeblock = codeblock.replace(/^\n+/g,""); // trim leading newlines
@@ -887,6 +1001,43 @@ var _DoCodeBlocks = function(text) {
 	// attacklab: strip sentinel
 	text = text.replace(/~0/,"");
 
+	return text;
+};
+
+var _DoGithubCodeBlocks = function(text) {
+//
+//  Process Github-style code blocks
+//  Example:
+//  ```ruby
+//  def hello_world(x)
+//    puts "Hello, #{x}"
+//  end
+//  ```
+//
+
+
+	// attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
+	text += "~0";
+
+	text = text.replace(/(?:^|\n)```(.*)\n([\s\S]*?)\n```/g,
+		function(wholeMatch,m1,m2) {
+			var language = m1;
+			var codeblock = m2;
+
+			codeblock = _EncodeCode(codeblock);
+			codeblock = _Detab(codeblock);
+			codeblock = codeblock.replace(/^\n+/g,""); // trim leading newlines
+			codeblock = codeblock.replace(/\n+$/g,""); // trim trailing whitespace
+
+			codeblock = "<pre><code" + (language ? " class=\"" + language + '"' : "") + ">" + codeblock + "\n</code></pre>";
+
+			return hashBlock(codeblock);
+		}
+	);
+
+	// attacklab: strip sentinel
+	text = text.replace(/~0/,"");
+
 	return text;
 }
 
@@ -895,30 +1046,29 @@ var hashBlock = function(text) {
 	return "\n\n~K" + (g_html_blocks.push(text)-1) + "K\n\n";
 }
 
-
 var _DoCodeSpans = function(text) {
 //
 //   *  Backtick quotes are used for <code></code> spans.
-// 
+//
 //   *  You can use multiple backticks as the delimiters if you want to
 //	 include literal backticks in the code span. So, this input:
-//	 
+//
 //		 Just type ``foo `bar` baz`` at the prompt.
-//	 
+//
 //	   Will translate to:
-//	 
+//
 //		 <p>Just type <code>foo `bar` baz</code> at the prompt.</p>
-//	 
+//
 //	There's no arbitrary limit to the number of backticks you
 //	can use as delimters. If you need three consecutive backticks
 //	in your code, use four for delimiters, etc.
 //
 //  *  You can use spaces to get literal backticks at the edges:
-//	 
+//
 //		 ... type `` `bar` `` ...
-//	 
+//
 //	   Turns to:
-//	 
+//
 //		 ... type <code>`bar`</code> ...
 //
 
@@ -947,7 +1097,6 @@ var _DoCodeSpans = function(text) {
 	return text;
 }
 
-
 var _EncodeCode = function(text) {
 //
 // Encode/escape certain characters inside Markdown code runs.
@@ -1021,7 +1170,7 @@ var _DoBlockQuotes = function(text) {
 
 			bq = bq.replace(/^[ \t]+$/gm,"");		// trim whitespace-only lines
 			bq = _RunBlockGamut(bq);				// recurse
-			
+
 			bq = bq.replace(/(^|\n)/g,"$1  ");
 			// These leading spaces screw with <pre> content, so we need to fix that:
 			bq = bq.replace(
@@ -1033,7 +1182,7 @@ var _DoBlockQuotes = function(text) {
 					pre = pre.replace(/~0/g,"");
 					return pre;
 				});
-			
+
 			return hashBlock("<blockquote>\n" + bq + "\n</blockquote>");
 		});
 	return text;
@@ -1051,7 +1200,7 @@ var _FormParagraphs = function(text) {
 	text = text.replace(/\n+$/g,"");
 
 	var grafs = text.split(/\n{2,}/g);
-	var grafsOut = new Array();
+	var grafsOut = [];
 
 	//
 	// Wrap <p> tags.
@@ -1092,14 +1241,14 @@ var _FormParagraphs = function(text) {
 
 var _EncodeAmpsAndAngles = function(text) {
 // Smart processing for ampersands and angle brackets that need to be encoded.
-	
+
 	// Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
 	//   http://bumppo.net/projects/amputator/
 	text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g,"&amp;");
-	
+
 	// Encode naked <'s
 	text = text.replace(/<(?![a-z\/?\$!])/gi,"&lt;");
-	
+
 	return text;
 }
 
@@ -1170,16 +1319,9 @@ var _EncodeEmailAddress = function(addr) {
 //  mailing list: <http://tinyurl.com/yu7ue>
 //
 
-	// attacklab: why can't javascript speak hex?
-	function char2hex(ch) {
-		var hexDigits = '0123456789ABCDEF';
-		var dec = ch.charCodeAt(0);
-		return(hexDigits.charAt(dec>>4) + hexDigits.charAt(dec&15));
-	}
-
 	var encode = [
 		function(ch){return "&#"+ch.charCodeAt(0)+";";},
-		function(ch){return "&#x"+char2hex(ch)+";";},
+		function(ch){return "&#x"+ch.charCodeAt(0).toString(16)+";";},
 		function(ch){return ch;}
 	];
 
@@ -1299,5 +1441,15 @@ var escapeCharacters_callback = function(wholeMatch,m1) {
 
 } // end of Showdown.converter
 
+
 // export
-if (typeof exports != 'undefined') exports.Showdown = Showdown;
\ No newline at end of file
+if (typeof module !== 'undefined') module.exports = Showdown;
+
+// stolen from AMD branch of underscore
+// AMD define happens at the end for compatibility with AMD loaders
+// that don't enforce next-turn semantics on modules.
+if (typeof define === 'function' && define.amd) {
+    define('showdown', function() {
+        return Showdown;
+    });
+}
diff --git a/packages/showdown/template-integration.js b/packages/showdown/template-integration.js
index f33acb084d..ff3dd1c1a7 100644
--- a/packages/showdown/template-integration.js
+++ b/packages/showdown/template-integration.js
@@ -1,6 +1,12 @@
-if (Package.handlebars) {
-  Package.handlebars.Handlebars.registerHelper('markdown', function (options) {
-    var converter = new Showdown.converter();
-    return converter.makeHtml(options.fn(this));
-  });
+if (Package.ui) {
+  var UI = Package.ui.UI;
+  var HTML = Package.htmljs.HTML; // implied by `ui`
+  Package.ui.UI.registerHelper('markdown', UI.block(function () {
+    var self = this;
+    return function () {
+      var text = UI.toRawText(self.__content, self /*parentComponent*/);
+      var converter = new Showdown.converter();
+      return HTML.Raw(converter.makeHtml(text));
+    };
+  }));
 }
diff --git a/packages/spark/.gitignore b/packages/spacebars-compiler/.gitignore
similarity index 100%
rename from packages/spark/.gitignore
rename to packages/spacebars-compiler/.gitignore
diff --git a/packages/spacebars-compiler/compile_tests.js b/packages/spacebars-compiler/compile_tests.js
new file mode 100644
index 0000000000..a881f1e474
--- /dev/null
+++ b/packages/spacebars-compiler/compile_tests.js
@@ -0,0 +1,300 @@
+Tinytest.add("spacebars - compiler output", function (test) {
+
+  var run = function (input, expected) {
+    if (expected.fail) {
+      var expectedMessage = expected.fail;
+      // test for error starting with expectedMessage
+      var msg = '';
+      test.throws(function () {
+        try {
+          Spacebars.compile(input);
+        } catch (e) {
+          msg = e.message;
+          throw e;
+        }
+      });
+      test.equal(msg.slice(0, expectedMessage.length),
+                 expectedMessage);
+    } else {
+      var output = Spacebars.compile(input);
+      var postProcess = function (string) {
+        // remove initial and trailing parens
+        string = string.replace(/^\(([\S\s]*)\)$/, '$1');
+        if (! (Package.minifiers && Package.minifiers.UglifyJSMinify)) {
+          // these tests work a lot better with access to beautification,
+          // but let's at least do some sort of test without it.
+          // These regexes may have to be adjusted if new tests are added.
+
+          // Remove single-line comments, including line nums from build system.
+          string = string.replace(/\/\/.*$/mg, '');
+          string = string.replace(/\s+/g, ''); // kill whitespace
+          // collapse identical consecutive parens
+          string = string.replace(/\(+/g, '(').replace(/\)+/g, ')');
+        }
+        return string;
+      };
+      // compare using Function .toString()!
+      test._stringEqual(
+        postProcess(output.toString()),
+        postProcess(
+          Spacebars._beautify('(' + expected.toString() + ')')),
+        input);
+    }
+  };
+
+
+
+  run("abc",
+      function () {
+        var self = this;
+        return "abc";
+      });
+
+  run("{{foo}}",
+      function() {
+        var self = this;
+        return function() {
+          return Spacebars.mustache(self.lookup("foo"));
+        };
+      });
+
+  run("{{foo bar}}",
+      function() {
+        var self = this;
+        return function() {
+          return Spacebars.mustache(self.lookup("foo"), self.lookup("bar"));
+        };
+      });
+
+  run("{{foo x=bar}}",
+      function() {
+        var self = this;
+        return function() {
+          return Spacebars.mustache(self.lookup("foo"), Spacebars.kw({
+            x: self.lookup("bar")
+          }));
+        };
+      });
+
+  run("{{foo.bar baz}}",
+      function() {
+        var self = this;
+        return function() {
+          return Spacebars.mustache(Spacebars.dot(self.lookup("foo"), "bar"), self.lookup("baz"));
+        };
+      });
+
+  run("{{foo bar.baz}}",
+      function() {
+        var self = this;
+        return function() {
+          return Spacebars.mustache(self.lookup("foo"), Spacebars.dot(self.lookup("bar"), "baz"));
+        };
+      });
+
+  run("{{foo x=bar.baz}}",
+      function() {
+        var self = this;
+        return function() {
+          return Spacebars.mustache(self.lookup("foo"), Spacebars.kw({
+            x: Spacebars.dot(self.lookup("bar"), "baz")
+          }));
+        };
+      });
+
+  run("{{#foo}}abc{{/foo}}",
+      function() {
+        var self = this;
+        return Spacebars.include(self.lookupTemplate("foo"), UI.block(function() {
+          var self = this;
+          return "abc";
+        }));
+      });
+
+  run("{{#if cond}}aaa{{else}}bbb{{/if}}",
+      function() {
+        var self = this;
+        return UI.If(function () {
+          return Spacebars.call(self.lookup("cond"));
+        }, UI.block(function() {
+          var self = this;
+          return "aaa";
+        }), UI.block(function() {
+          var self = this;
+          return "bbb";
+        }));
+      });
+
+  run("{{> foo bar}}",
+      function() {
+        var self = this;
+        return Spacebars.TemplateWith(function() {
+          return Spacebars.call(self.lookup("bar"));
+        }, UI.block(function() {
+          var self = this;
+          return Spacebars.include(self.lookupTemplate("foo"));
+        }));
+      });
+
+  run("{{> foo x=bar}}",
+      function() {
+        var self = this;
+        return Spacebars.TemplateWith(function() {
+          return {
+            x: Spacebars.call(self.lookup("bar"))
+          };
+        }, UI.block(function() {
+          var self = this;
+          return Spacebars.include(self.lookupTemplate("foo"));
+        }));
+      });
+
+  run("{{> foo bar.baz}}",
+      function() {
+        var self = this;
+        return Spacebars.TemplateWith(function() {
+          return Spacebars.call(Spacebars.dot(self.lookup("bar"), "baz"));
+        }, UI.block(function() {
+          var self = this;
+          return Spacebars.include(self.lookupTemplate("foo"));
+        }));
+      });
+
+  run("{{> foo x=bar.baz}}",
+      function() {
+        var self = this;
+        return Spacebars.TemplateWith(function() {
+          return {
+            x: Spacebars.call(Spacebars.dot(self.lookup("bar"), "baz"))
+          };
+        }, UI.block(function() {
+          var self = this;
+          return Spacebars.include(self.lookupTemplate("foo"));
+        }));
+      });
+
+  run("{{> foo bar baz}}",
+      function() {
+        var self = this;
+        return Spacebars.TemplateWith(function() {
+          return Spacebars.dataMustache(self.lookup("bar"), self.lookup("baz"));
+        }, UI.block(function() {
+          var self = this;
+          return Spacebars.include(self.lookupTemplate("foo"));
+        }));
+      });
+
+  run("{{#foo bar baz}}aaa{{/foo}}",
+      function() {
+        var self = this;
+        return Spacebars.TemplateWith(function() {
+          return Spacebars.dataMustache(self.lookup("bar"), self.lookup("baz"));
+        }, UI.block(function() {
+          var self = this;
+          return Spacebars.include(self.lookupTemplate("foo"), UI.block(function() {
+            var self = this;
+            return "aaa";
+          }));
+        }));
+      });
+
+  run("{{#foo p.q r.s}}aaa{{/foo}}",
+      function() {
+        var self = this;
+        return Spacebars.TemplateWith(function() {
+          return Spacebars.dataMustache(Spacebars.dot(self.lookup("p"), "q"), Spacebars.dot(self.lookup("r"), "s"));
+        }, UI.block(function() {
+          var self = this;
+          return Spacebars.include(self.lookupTemplate("foo"), UI.block(function() {
+            var self = this;
+            return "aaa";
+          }));
+        }));
+      });
+
+  run("<a {{b}}></a>",
+      function() {
+        var self = this;
+        return HTML.A({
+          $dynamic: [ function() {
+            return Spacebars.attrMustache(self.lookup("b"));
+          } ]
+        });
+      });
+
+  run("<a {{b}} c=d{{e}}f></a>",
+      function() {
+        var self = this;
+        return HTML.A({
+          c: [ "d", function() {
+            return Spacebars.mustache(self.lookup("e"));
+          }, "f" ],
+          $dynamic: [ function() {
+            return Spacebars.attrMustache(self.lookup("b"));
+          } ]
+        });
+      });
+
+  run("<asdf>{{foo}}</asdf>",
+      function () {
+        var self = this;
+        return HTML.getTag("asdf")(function () {
+          return Spacebars.mustache(self.lookup("foo"));
+        });
+      });
+
+  run("<textarea>{{foo}}</textarea>",
+      function () {
+        var self = this;
+        return HTML.TEXTAREA(function () {
+          return Spacebars.mustache(self.lookup("foo"));
+        });
+      });
+
+});
+
+Tinytest.add("spacebars - compiler errors", function (test) {
+
+  var getError = function (input) {
+    try {
+      Spacebars.compile(input);
+    } catch (e) {
+      return e.message;
+    }
+    test.fail("Didn't throw an error: " + input);
+  };
+
+  var assertStartsWith = function (a, b) {
+    test.equal(a.substring(0, b.length), b);
+  };
+
+  var isError = function (input, errorStart) {
+    assertStartsWith(getError(input), errorStart);
+  };
+
+  isError("<input></input>",
+          "Unexpected HTML close tag.  <input> should have no close tag.");
+  isError("{{#each foo}}<input></input>{{/foo}}",
+          "Unexpected HTML close tag.  <input> should have no close tag.");
+
+  isError("{{#if}}{{/if}}", "#if requires an argument");
+  isError("{{#with}}{{/with}}", "#with requires an argument");
+  isError("{{#each}}{{/each}}", "#each requires an argument");
+  isError("{{#unless}}{{/unless}}", "#unless requires an argument");
+
+  isError("{{0 0}}", "Expected IDENTIFIER");
+
+  isError("{{> foo 0 0}}",
+          "First argument must be a function");
+  isError("{{> foo 0 x=0}}",
+          "First argument must be a function");
+  isError("{{#foo 0 0}}{{/foo}}",
+          "First argument must be a function");
+  isError("{{#foo 0 x=0}}{{/foo}}",
+          "First argument must be a function");
+
+  _.each(['asdf</br>', '{{!foo}}</br>', '{{!foo}} </br>',
+          'asdf</a>', '{{!foo}}</a>', '{{!foo}} </a>'], function (badFrag) {
+            isError(badFrag, "Unexpected HTML close tag");
+          });
+});
diff --git a/packages/spacebars-compiler/package.js b/packages/spacebars-compiler/package.js
new file mode 100644
index 0000000000..4170479ec1
--- /dev/null
+++ b/packages/spacebars-compiler/package.js
@@ -0,0 +1,32 @@
+Package.describe({
+  name: "spacebars-compiler",
+  test: "spacebars-compiler-test",
+  summary: "Compiler for Spacebars template language",
+  version: '1.0.0'
+});
+
+Package.on_use(function (api) {
+  api.use('spacebars');
+  api.imply('spacebars');
+
+  // we attach stuff to the global symbol `HTML`, exported
+  // by `htmljs` via `html-tools`, so we both use and effectively
+  // imply it.
+  api.use('html-tools');
+  api.imply('html-tools');
+
+  api.use('underscore');
+  api.use('ui');
+  api.use('minifiers', ['server']);
+  api.add_files(['tokens.js', 'tojs.js', 'templatetag.js',
+                 'spacebars-compiler.js']);
+});
+
+Package.on_test(function (api) {
+  api.use('underscore');
+  api.use('spacebars-compiler');
+  api.use('tinytest');
+  api.add_files('spacebars_tests.js');
+  api.add_files('compile_tests.js');
+  api.add_files('token_tests.js');
+});
diff --git a/packages/spacebars-compiler/spacebars-compiler.js b/packages/spacebars-compiler/spacebars-compiler.js
new file mode 100644
index 0000000000..b4d6158ec4
--- /dev/null
+++ b/packages/spacebars-compiler/spacebars-compiler.js
@@ -0,0 +1,532 @@
+
+
+
+Spacebars.parse = function (input) {
+
+  var tree = HTMLTools.parseFragment(
+    input,
+    { getSpecialTag: TemplateTag.parseCompleteTag });
+
+  return tree;
+};
+
+// ============================================================
+// Optimizer for optimizing HTMLjs into raw HTML string when
+// it doesn't contain template tags.
+
+var optimize = function (tree) {
+
+  var pushRawHTML = function (array, html) {
+    var N = array.length;
+    if (N > 0 && (array[N-1] instanceof HTML.Raw)) {
+      array[N-1] = HTML.Raw(array[N-1].value + html);
+    } else {
+      array.push(HTML.Raw(html));
+    }
+  };
+
+  var isPureChars = function (html) {
+    return (html.indexOf('&') < 0 && html.indexOf('<') < 0);
+  };
+
+  // Returns `null` if no specials are found in the array, so that the
+  // parent can perform the actual optimization.  Otherwise, returns
+  // an array of parts which have been optimized as much as possible.
+  // `forceOptimize` forces the latter case.
+  var optimizeArrayParts = function (array, optimizePartsFunc, forceOptimize) {
+    var result = null;
+    if (forceOptimize)
+      result = [];
+    for (var i = 0, N = array.length; i < N; i++) {
+      var part = optimizePartsFunc(array[i]);
+      if (part !== null) {
+        // something special found
+        if (result === null) {
+          // This is our first special item.  Stringify the other parts.
+          result = [];
+          for (var j = 0; j < i; j++)
+            pushRawHTML(result, HTML.toHTML(array[j]));
+        }
+        result.push(part);
+      } else {
+        // just plain HTML found
+        if (result !== null) {
+          // we've already found something special, so convert this to Raw
+          pushRawHTML(result, HTML.toHTML(array[i]));
+        }
+      }
+    }
+    if (result !== null) {
+      // clean up unnecessary HTML.Raw wrappers around pure character data
+      for (var j = 0; j < result.length; j++) {
+        if ((result[j] instanceof HTML.Raw) &&
+            isPureChars(result[j].value))
+          // replace HTML.Raw with simple string
+          result[j] = result[j].value;
+      }
+    }
+    return result;
+  };
+
+  var doesAttributeValueHaveSpecials = function (v) {
+    if (v instanceof HTMLTools.Special)
+      return true;
+    if (typeof v === 'function')
+      return true;
+
+    if (v instanceof Array) {
+      for (var i = 0; i < v.length; i++)
+        if (doesAttributeValueHaveSpecials(v[i]))
+          return true;
+      return false;
+    }
+
+    return false;
+  };
+
+  var optimizeParts = function (node) {
+    // If we have nothing special going on, returns `null` (so that the
+    // parent can optimize).  Otherwise returns a replacement for `node`
+    // with optimized parts.
+    if ((node == null) || (typeof node === 'string') ||
+        (node instanceof HTML.CharRef) || (node instanceof HTML.Comment) ||
+        (node instanceof HTML.Raw)) {
+      // not special; let parent decide how whether to optimize
+      return null;
+    } else if (node instanceof HTML.Tag) {
+      var tagName = node.tagName;
+      if (tagName === 'textarea' ||
+          (! (HTML.isKnownElement(tagName) &&
+              ! HTML.isKnownSVGElement(tagName)))) {
+        // optimizing into a TEXTAREA's RCDATA would require being a little
+        // more clever.  foreign elements like SVG can't be stringified for
+        // innerHTML.
+        return node;
+      }
+
+      var mustOptimize = false;
+
+      // Avoid ever producing HTML containing `<table><tr>...`, because the
+      // browser will insert a TBODY.  If we just `createElement("table")` and
+      // `createElement("tr")`, on the other hand, no TBODY is necessary
+      // (assuming IE 8+).
+      if (tagName === 'table')
+        mustOptimize = true;
+
+      if (node.attrs && ! mustOptimize) {
+        var attrs = node.attrs;
+        for (var k in attrs) {
+          if (doesAttributeValueHaveSpecials(attrs[k])) {
+            mustOptimize = true;
+            break;
+          }
+        }
+      }
+
+      var newChildren = optimizeArrayParts(node.children, optimizeParts, mustOptimize);
+
+      if (newChildren === null)
+        return null;
+
+      var newTag = HTML.getTag(node.tagName).apply(null, newChildren);
+      newTag.attrs = node.attrs;
+
+      return newTag;
+
+    } else if (node instanceof Array) {
+      return optimizeArrayParts(node, optimizeParts);
+    } else {
+      return node;
+    }
+  };
+
+  var optTree = optimizeParts(tree);
+  if (optTree !== null)
+    // tree was optimized in parts
+    return optTree;
+
+  optTree = HTML.Raw(HTML.toHTML(tree));
+
+  if (isPureChars(optTree.value))
+    return optTree.value;
+
+  return optTree;
+};
+
+// ============================================================
+// Code-generation of template tags
+
+var builtInBlockHelpers = {
+  'if': 'UI.If',
+  'unless': 'UI.Unless',
+  'with': 'Spacebars.With',
+  'each': 'UI.Each'
+};
+
+// These must be prefixed with `UI.` when you use them in a template.
+var builtInLexicals = {
+  'contentBlock': 'template.__content',
+  'elseBlock': 'template.__elseContent'
+};
+
+// A "reserved name" can't be used as a <template> name.  This
+// function is used by the template file scanner.
+Spacebars.isReservedName = function (name) {
+  return builtInBlockHelpers.hasOwnProperty(name);
+};
+
+var codeGenTemplateTag = function (tag) {
+  if (tag.position === HTMLTools.TEMPLATE_TAG_POSITION.IN_START_TAG) {
+    // only `tag.type === 'DOUBLE'` allowed (by earlier validation)
+    return HTML.EmitCode('function () { return ' +
+                         codeGenMustache(tag.path, tag.args, 'attrMustache')
+                         + '; }');
+  } else {
+    if (tag.type === 'DOUBLE') {
+      return HTML.EmitCode('function () { return ' +
+                           codeGenMustache(tag.path, tag.args) + '; }');
+    } else if (tag.type === 'TRIPLE') {
+      return HTML.EmitCode('function () { return Spacebars.makeRaw(' +
+                           codeGenMustache(tag.path, tag.args) + '); }');
+    } else if (tag.type === 'INCLUSION' || tag.type === 'BLOCKOPEN') {
+      var path = tag.path;
+
+      if (tag.type === 'BLOCKOPEN' &&
+          builtInBlockHelpers.hasOwnProperty(path[0])) {
+        // if, unless, with, each.
+        //
+        // If someone tries to do `{{> if}}`, we don't
+        // get here, but an error is thrown when we try to codegen the path.
+
+        // Note: If we caught these errors earlier, while scanning, we'd be able to
+        // provide nice line numbers.
+        if (path.length > 1)
+          throw new Error("Unexpected dotted path beginning with " + path[0]);
+        if (! tag.args.length)
+          throw new Error("#" + path[0] + " requires an argument");
+
+        var codeParts = codeGenInclusionParts(tag);
+        var dataFunc = codeParts.dataFunc; // must exist (tag.args.length > 0)
+        var contentBlock = codeParts.content; // must exist
+        var elseContentBlock = codeParts.elseContent; // may not exist
+
+        var callArgs = [dataFunc, contentBlock];
+        if (elseContentBlock)
+          callArgs.push(elseContentBlock);
+
+        return HTML.EmitCode(
+          builtInBlockHelpers[path[0]] + '(' + callArgs.join(', ') + ')');
+
+      } else {
+        var compCode = codeGenPath(path, {lookupTemplate: true});
+
+        if (path.length !== 1) {
+          // path code may be reactive; wrap it
+          compCode = 'function () { return ' + compCode + '; }';
+        }
+
+        var codeParts = codeGenInclusionParts(tag);
+        var dataFunc = codeParts.dataFunc;
+        var content = codeParts.content;
+        var elseContent = codeParts.elseContent;
+
+        var includeArgs = [compCode];
+        if (content) {
+          includeArgs.push(content);
+          if (elseContent)
+            includeArgs.push(elseContent);
+        }
+
+        var includeCode =
+              'Spacebars.include(' + includeArgs.join(', ') + ')';
+
+        if (dataFunc) {
+          includeCode =
+            'Spacebars.TemplateWith(' + dataFunc + ', UI.block(' +
+            Spacebars.codeGen(HTML.EmitCode(includeCode)) + '))';
+        }
+
+        if (path[0] === 'UI' &&
+            (path[1] === 'contentBlock' || path[1] === 'elseBlock')) {
+          includeCode = 'UI.InTemplateScope(template, ' + includeCode + ')';
+        }
+
+        return HTML.EmitCode(includeCode);
+      }
+    } else {
+      // Can't get here; TemplateTag validation should catch any
+      // inappropriate tag types that might come out of the parser.
+      throw new Error("Unexpected template tag type: " + tag.type);
+    }
+  }
+};
+
+var makeObjectLiteral = function (obj) {
+  var parts = [];
+  for (var k in obj)
+    parts.push(toObjectLiteralKey(k) + ': ' + obj[k]);
+  return '{' + parts.join(', ') + '}';
+};
+
+// `path` is an array of at least one string.
+//
+// If `path.length > 1`, the generated code may be reactive
+// (i.e. it may invalidate the current computation).
+//
+// No code is generated to call the result if it's a function.
+//
+// Options:
+//
+// - lookupTemplate {Boolean} If true, generated code also looks in
+//   the list of templates. (After helpers, before data context).
+//   Used when generating code for `{{> foo}}` or `{{#foo}}`. Only
+//   used for non-dotted paths.
+var codeGenPath = function (path, opts) {
+  if (builtInBlockHelpers.hasOwnProperty(path[0]))
+    throw new Error("Can't use the built-in '" + path[0] + "' here");
+  // Let `{{#if UI.contentBlock}}` check whether this template was invoked via
+  // inclusion or as a block helper, in addition to supporting
+  // `{{> UI.contentBlock}}`.
+  if (path.length >= 2 &&
+      path[0] === 'UI' && builtInLexicals.hasOwnProperty(path[1])) {
+    if (path.length > 2)
+      throw new Error("Unexpected dotted path beginning with " +
+                      path[0] + '.' + path[1]);
+    return builtInLexicals[path[1]];
+  }
+
+  var args = [toJSLiteral(path[0])];
+  var lookupMethod = 'lookup';
+  if (opts && opts.lookupTemplate && path.length === 1)
+    lookupMethod = 'lookupTemplate';
+  var code = 'self.' + lookupMethod + '(' + args.join(', ') + ')';
+
+  if (path.length > 1) {
+    code = 'Spacebars.dot(' + code + ', ' +
+      _.map(path.slice(1), toJSLiteral).join(', ') + ')';
+  }
+
+  return code;
+};
+
+// Generates code for an `[argType, argValue]` argument spec,
+// ignoring the third element (keyword argument name) if present.
+//
+// The resulting code may be reactive (in the case of a PATH of
+// more than one element) and is not wrapped in a closure.
+var codeGenArgValue = function (arg) {
+  var argType = arg[0];
+  var argValue = arg[1];
+
+  var argCode;
+  switch (argType) {
+  case 'STRING':
+  case 'NUMBER':
+  case 'BOOLEAN':
+  case 'NULL':
+    argCode = toJSLiteral(argValue);
+    break;
+  case 'PATH':
+    argCode = codeGenPath(argValue);
+    break;
+  default:
+    // can't get here
+    throw new Error("Unexpected arg type: " + argType);
+  }
+
+  return argCode;
+};
+
+// Generates a call to `Spacebars.fooMustache` on evaluated arguments.
+// The resulting code has no function literals and must be wrapped in
+// one for fine-grained reactivity.
+var codeGenMustache = function (path, args, mustacheType) {
+  var nameCode = codeGenPath(path);
+  var argCode = codeGenMustacheArgs(args);
+  var mustache = (mustacheType || 'mustache');
+
+  return 'Spacebars.' + mustache + '(' + nameCode +
+    (argCode ? ', ' + argCode.join(', ') : '') + ')';
+};
+
+// returns: array of source strings, or null if no
+// args at all.
+var codeGenMustacheArgs = function (tagArgs) {
+  var kwArgs = null; // source -> source
+  var args = null; // [source]
+
+  // tagArgs may be null
+  _.each(tagArgs, function (arg) {
+    var argCode = codeGenArgValue(arg);
+
+    if (arg.length > 2) {
+      // keyword argument (represented as [type, value, name])
+      kwArgs = (kwArgs || {});
+      kwArgs[arg[2]] = argCode;
+    } else {
+      // positional argument
+      args = (args || []);
+      args.push(argCode);
+    }
+  });
+
+  // put kwArgs in options dictionary at end of args
+  if (kwArgs) {
+    args = (args || []);
+    args.push('Spacebars.kw(' + makeObjectLiteral(kwArgs) + ')');
+  }
+
+  return args;
+};
+
+// Takes an inclusion tag and returns an object containing these properties,
+// all optional, whose values are JS source code:
+//
+// - `dataFunc` - source code of a data function literal
+// - `content` - source code of a content block
+// - `elseContent` - source code of an elseContent block
+//
+// Implements the calling convention for inclusions.
+var codeGenInclusionParts = function (tag) {
+  var ret = {};
+
+  if ('content' in tag) {
+    ret.content = (
+      'UI.block(' + Spacebars.codeGen(tag.content) + ')');
+  }
+  if ('elseContent' in tag) {
+    ret.elseContent = (
+      'UI.block(' + Spacebars.codeGen(tag.elseContent) + ')');
+  }
+
+  var dataFuncCode = null;
+
+  var args = tag.args;
+  if (! args.length) {
+    // e.g. `{{#foo}}`
+    return ret;
+  } else if (args[0].length === 3) {
+    // keyword arguments only, e.g. `{{> point x=1 y=2}}`
+    var dataProps = {};
+    _.each(args, function (arg) {
+      var argKey = arg[2];
+      dataProps[argKey] = 'Spacebars.call(' + codeGenArgValue(arg) + ')';
+    });
+    dataFuncCode = makeObjectLiteral(dataProps);
+  } else if (args[0][0] !== 'PATH') {
+    // literal first argument, e.g. `{{> foo "blah"}}`
+    //
+    // tag validation has confirmed, in this case, that there is only
+    // one argument (`args.length === 1`)
+    dataFuncCode = codeGenArgValue(args[0]);
+  } else if (args.length === 1) {
+    // one argument, must be a PATH
+    dataFuncCode = 'Spacebars.call(' + codeGenPath(args[0][1]) + ')';
+  } else {
+    dataFuncCode = codeGenMustache(args[0][1], args.slice(1),
+                                   'dataMustache');
+  }
+
+  ret.dataFunc = 'function () { return ' + dataFuncCode + '; }';
+
+  return ret;
+};
+
+
+// ============================================================
+// Main compiler
+
+var replaceSpecials = function (node) {
+  if (node instanceof HTML.Tag) {
+    // potential optimization: don't always create a new tag
+    var newChildren = _.map(node.children, replaceSpecials);
+    var newTag = HTML.getTag(node.tagName).apply(null, newChildren);
+    var oldAttrs = node.attrs;
+    var newAttrs = null;
+
+    if (oldAttrs) {
+      _.each(oldAttrs, function (value, name) {
+        if (name.charAt(0) !== '$') {
+          newAttrs = (newAttrs || {});
+          newAttrs[name] = replaceSpecials(value);
+        }
+      });
+
+      if (oldAttrs.$specials && oldAttrs.$specials.length) {
+        newAttrs = (newAttrs || {});
+        newAttrs.$dynamic = _.map(oldAttrs.$specials, function (special) {
+          return codeGenTemplateTag(special.value);
+        });
+      }
+    }
+
+    newTag.attrs = newAttrs;
+    return newTag;
+  } else if (node instanceof Array) {
+    return _.map(node, replaceSpecials);
+  } else if (node instanceof HTMLTools.Special) {
+    return codeGenTemplateTag(node.value);
+  } else {
+    return node;
+  }
+};
+
+Spacebars.compile = function (input, options) {
+  var tree = Spacebars.parse(input);
+  return Spacebars.codeGen(tree, options);
+};
+
+Spacebars.codeGen = function (parseTree, options) {
+  // is this a template, rather than a block passed to
+  // a block helper, say
+  var isTemplate = (options && options.isTemplate);
+
+  var tree = parseTree;
+
+  // The flags `isTemplate` and `isBody` are kind of a hack.
+  if (isTemplate || (options && options.isBody)) {
+    // optimizing fragments would require being smarter about whether we are
+    // in a TEXTAREA, say.
+    tree = optimize(tree);
+  }
+
+  tree = replaceSpecials(tree);
+
+  var code = '(function () { var self = this; ';
+  if (isTemplate) {
+    // support `{{> UI.contentBlock}}` and `{{> UI.elseBlock}}` with
+    // lexical scope by creating a local variable in the
+    // template's render function.
+    code += 'var template = this; ';
+  }
+  code += 'return ';
+  code += HTML.toJS(tree);
+  code += '; })';
+
+  code = beautify(code);
+
+  return code;
+};
+
+var beautify = function (code) {
+  if (Package.minifiers && Package.minifiers.UglifyJSMinify) {
+    var result = UglifyJSMinify(code,
+                                { fromString: true,
+                                  mangle: false,
+                                  compress: false,
+                                  output: { beautify: true,
+                                            indent_level: 2,
+                                            width: 80 } });
+    var output = result.code;
+    // Uglify interprets our expression as a statement and may add a semicolon.
+    // Strip trailing semicolon.
+    output = output.replace(/;$/, '');
+    return output;
+  } else {
+    // don't actually beautify; no UglifyJS
+    return code;
+  }
+};
+
+// expose for compiler output tests
+Spacebars._beautify = beautify;
diff --git a/packages/spacebars-compiler/spacebars_tests.js b/packages/spacebars-compiler/spacebars_tests.js
new file mode 100644
index 0000000000..2ef521d014
--- /dev/null
+++ b/packages/spacebars-compiler/spacebars_tests.js
@@ -0,0 +1,284 @@
+Tinytest.add("spacebars - stache tags", function (test) {
+
+  var run = function (input, expected) {
+    if (typeof expected === "string") {
+      // test for error starting with string `expected`
+      var msg = '';
+      test.throws(function () {
+        try {
+          Spacebars.TemplateTag.parse(input);
+        } catch (e) {
+          msg = e.message;
+          throw e;
+        }
+      });
+      test.equal(msg.slice(0, expected.length), expected);
+    } else {
+      var result = Spacebars.TemplateTag.parse(input);
+      test.equal(result, expected);
+    }
+  };
+
+  run('{{foo}}', {type: 'DOUBLE', path: ['foo'], args: []});
+  run('{{foo3}}', {type: 'DOUBLE', path: ['foo3'], args: []});
+  run('{{{foo}}}', {type: 'TRIPLE', path: ['foo'], args: []});
+  run('{{{foo}}', "Expected `}}}`");
+  run('{{{foo', "Expected");
+  run('{{foo', "Expected");
+  run('{{ {foo}}}', "Unknown stache tag");
+  run('{{{{foo}}}}', "Unknown stache tag");
+  run('{{{>foo}}}', "Unknown stache tag");
+  run('{{>>foo}}', "Unknown stache tag");
+  run('{{! asdf }}', {type: 'COMMENT', value: ' asdf '});
+  run('{{ ! asdf }}', {type: 'COMMENT', value: ' asdf '});
+  run('{{ ! asdf }asdf', "Unclosed");
+  run('{{!-- asdf --}}', {type: 'BLOCKCOMMENT', value: ' asdf '});
+  run('{{ !-- asdf -- }}', {type: 'BLOCKCOMMENT', value: ' asdf '});
+  run('{{ !-- {{asdf}} -- }}', {type: 'BLOCKCOMMENT', value: ' {{asdf}} '});
+  run('{{ !-- {{as--df}} --}}', {type: 'BLOCKCOMMENT', value: ' {{as--df}} '});
+  run('{{ !-- asdf }asdf', "Unclosed");
+  run('{{ !-- asdf --}asdf', "Unclosed");
+  run('{{else}}', {type: 'ELSE'});
+  run('{{ else }}', {type: 'ELSE'});
+  run('{{else x}}', "Expected");
+  run('{{else_x}}', {type: 'DOUBLE', path: ['else_x'], args: []});
+  run('{{/if}}', {type: 'BLOCKCLOSE', path: ['if']});
+  run('{{ / if }}', {type: 'BLOCKCLOSE', path: ['if']});
+  run('{{/if x}}', "Expected");
+  run('{{#if}}', {type: 'BLOCKOPEN', path: ['if'], args: []});
+  run('{{ # if }}', {type: 'BLOCKOPEN', path: ['if'], args: []});
+  run('{{#if_3}}', {type: 'BLOCKOPEN', path: ['if_3'], args: []});
+  run('{{>x}}', {type: 'INCLUSION', path: ['x'], args: []});
+  run('{{ > x }}', {type: 'INCLUSION', path: ['x'], args: []});
+  run('{{>x_3}}', {type: 'INCLUSION', path: ['x_3'], args: []});
+
+
+
+  run('{{foo 3}}', {type: 'DOUBLE', path: ['foo'], args: [['NUMBER', 3]]});
+  run('{{ foo  3 }}', {type: 'DOUBLE', path: ['foo'], args: [['NUMBER', 3]]});
+  run('{{#foo 3}}', {type: 'BLOCKOPEN', path: ['foo'], args: [['NUMBER', 3]]});
+  run('{{ # foo  3 }}', {type: 'BLOCKOPEN', path: ['foo'],
+                         args: [['NUMBER', 3]]});
+  run('{{>foo 3}}', {type: 'INCLUSION', path: ['foo'], args: [['NUMBER', 3]]});
+  run('{{ > foo  3 }}', {type: 'INCLUSION', path: ['foo'],
+                         args: [['NUMBER', 3]]});
+  run('{{{foo 3}}}', {type: 'TRIPLE', path: ['foo'], args: [['NUMBER', 3]]});
+
+  run('{{foo bar ./foo foo/bar a.b.c baz=qux x3=.}}',
+      {type: 'DOUBLE', path: ['foo'],
+       args: [['PATH', ['bar']],
+              ['PATH', ['.', 'foo']],
+              ['PATH', ['foo', 'bar']],
+              ['PATH', ['a', 'b', 'c']],
+              ['PATH', ['qux'], 'baz'],
+              ['PATH', ['.'], 'x3']]});
+
+  run('{{{x 0.3 [0].[3] .4 ./[4]}}}',
+      {type: 'TRIPLE', path: ['x'],
+       args: [['NUMBER', 0.3],
+              ['PATH', ['0', '3']],
+              ['NUMBER', .4],
+              ['PATH', ['.', '4']]]});
+
+  run('{{# foo this this.x null z=null}}',
+      {type: 'BLOCKOPEN', path: ['foo'],
+       args: [['PATH', ['.']],
+              ['PATH', ['.', 'x']],
+              ['NULL', null],
+              ['NULL', null, 'z']]});
+
+  run('{{./foo 3}}', {type: 'DOUBLE', path: ['.', 'foo'], args: [['NUMBER', 3]]});
+  run('{{this/foo 3}}', {type: 'DOUBLE', path: ['.', 'foo'], args: [['NUMBER', 3]]});
+  run('{{../foo 3}}', {type: 'DOUBLE', path: ['..', 'foo'], args: [['NUMBER', 3]]});
+  run('{{../../foo 3}}', {type: 'DOUBLE', path: ['...', 'foo'], args: [['NUMBER', 3]]});
+
+  run('{{foo x/..}}', "Expected");
+  run('{{foo x/.}}', "Expected");
+
+  run('{{#a.b.c}}', {type: 'BLOCKOPEN', path: ['a', 'b', 'c'],
+                     args: []});
+  run('{{> a.b.c}}', {type: 'INCLUSION', path: ['a', 'b', 'c'],
+                      args: []});
+
+  run('{{foo.[]/[]}}', {type: 'DOUBLE', path: ['foo', '', ''],
+                        args: []});
+  run('{{[].foo}}', "Path can't start with empty string");
+
+  run('{{foo null}}', {type: 'DOUBLE', path: ['foo'],
+                       args: [['NULL', null]]});
+  run('{{foo false}}', {type: 'DOUBLE', path: ['foo'],
+                       args: [['BOOLEAN', false]]});
+  run('{{foo true}}', {type: 'DOUBLE', path: ['foo'],
+                       args: [['BOOLEAN', true]]});
+  run('{{foo "bar"}}', {type: 'DOUBLE', path: ['foo'],
+                        args: [['STRING', 'bar']]});
+  run("{{foo 'bar'}}", {type: 'DOUBLE', path: ['foo'],
+                        args: [['STRING', 'bar']]});
+
+  run('{{foo -1 -2}}', {type: 'DOUBLE', path: ['foo'],
+                        args: [['NUMBER', -1], ['NUMBER', -2]]});
+
+  run('{{x "\'"}}', {type: 'DOUBLE', path: ['x'], args: [['STRING', "'"]]});
+  run('{{x \'"\'}}', {type: 'DOUBLE', path: ['x'], args: [['STRING', '"']]});
+
+  run('{{> foo x=1 y=2}}',
+      {type: 'INCLUSION', path: ['foo'],
+       args: [['NUMBER', 1, 'x'],
+              ['NUMBER', 2, 'y']]});
+  // spaces around '=' are fine
+  run('{{> foo x = 1 y = 2}}',
+      {type: 'INCLUSION', path: ['foo'],
+       args: [['NUMBER', 1, 'x'],
+              ['NUMBER', 2, 'y']]});
+  run('{{> foo with-dashes=1 another-one=2}}',
+      {type: 'INCLUSION', path: ['foo'],
+       args: [['NUMBER', 1, 'with-dashes'],
+              ['NUMBER', 2, 'another-one']]});
+  run('{{> foo 1="keyword can start with a number"}}',
+      {type: 'INCLUSION', path: ['foo'],
+       args: [['STRING', 'keyword can start with a number', '1']]});
+  run('{{> foo disallow-dashes-in-posarg}}',
+      "Expected");
+  run('{{> foo disallow-#=1}}',
+      "Expected");
+  run('{{> foo disallow->=1}}',
+      "Expected");
+  run('{{> foo disallow-{=1}}',
+      "Expected");
+  run('{{> foo disallow-(=1}}',
+      "Expected");
+  run('{{> foo disallow-}=1}}',
+      "Expected");
+  run('{{> foo disallow-)=1}}',
+      "Expected");
+  run('{{> foo x=1 y=2 z}}',
+      "Can't have a non-keyword argument");
+
+  run('{{true.foo}}', "Can't use");
+  run('{{foo.this}}', "Can only use");
+  run('{{./this}}', "Can only use");
+  run('{{../this}}', "Can only use");
+
+});
+
+
+Tinytest.add("spacebars - Spacebars.dot", function (test) {
+  test.equal(Spacebars.dot(null, 'foo'), null);
+  test.equal(Spacebars.dot('foo', 'foo'), undefined);
+  test.equal(Spacebars.dot({x:1}, 'x'), 1);
+  test.equal(Spacebars.dot(
+    {x:1, y: function () { return this.x+1; }}, 'y')(), 2);
+  test.equal(Spacebars.dot(
+    function () {
+      return {x:1, y: function () { return this.x+1; }};
+    }, 'y')(), 2);
+
+  var m = 1;
+  var mget = function () {
+    return {
+      answer: m,
+      getAnswer: function () {
+        return this.answer;
+      }
+    };
+  };
+  var mgetDotAnswer = Spacebars.dot(mget, 'answer');
+  test.equal(mgetDotAnswer, 1);
+
+  m = 3;
+  var mgetDotGetAnswer = Spacebars.dot(mget, 'getAnswer');
+  test.equal(mgetDotGetAnswer(), 3);
+  m = 4;
+  test.equal(mgetDotGetAnswer(), 3);
+
+  var closet = {
+    mget: mget,
+    mget2: function () {
+      return this.mget();
+    }
+  };
+
+  m = 5;
+  var f1 = Spacebars.dot(closet, 'mget', 'answer');
+  m = 6;
+  var f2 = Spacebars.dot(closet, 'mget2', 'answer');
+  test.equal(f2, 6);
+  m = 8;
+  var f3 = Spacebars.dot(closet, 'mget2', 'getAnswer');
+  m = 9;
+  test.equal(f3(), 8);
+
+  test.equal(Spacebars.dot(0, 'abc', 'def'), 0);
+  test.equal(Spacebars.dot(function () { return null; }, 'abc', 'def'), null);
+  test.equal(Spacebars.dot(function () { return 0; }, 'abc', 'def'), 0);
+
+  // test that in `foo.bar`, `bar` may be a function that takes arguments.
+  test.equal(Spacebars.dot(
+    { one: 1, inc: function (x) { return this.one + x; } }, 'inc')(6), 7);
+  test.equal(Spacebars.dot(
+    function () {
+      return { one: 1, inc: function (x) { return this.one + x; } };
+    }, 'inc')(8), 9);
+
+});
+
+//////////////////////////////////////////////////
+
+Tinytest.add("spacebars - parse", function (test) {
+  test.equal(HTML.toJS(Spacebars.parse('{{foo}}')),
+             'HTMLTools.Special({type: "DOUBLE", path: ["foo"]})');
+
+  test.equal(HTML.toJS(Spacebars.parse('{{!foo}}')), 'null');
+  test.equal(HTML.toJS(Spacebars.parse('x{{!foo}}y')), '"xy"');
+
+  test.equal(HTML.toJS(Spacebars.parse('{{!--foo--}}')), 'null');
+  test.equal(HTML.toJS(Spacebars.parse('x{{!--foo--}}y')), '"xy"');
+
+  test.equal(HTML.toJS(Spacebars.parse('{{#foo}}x{{/foo}}')),
+             'HTMLTools.Special({type: "BLOCKOPEN", path: ["foo"], content: "x"})');
+
+  test.equal(HTML.toJS(Spacebars.parse('{{#foo}}{{#bar}}{{/bar}}{{/foo}}')),
+             'HTMLTools.Special({type: "BLOCKOPEN", path: ["foo"], content: HTMLTools.Special({type: "BLOCKOPEN", path: ["bar"]})})');
+
+  test.equal(HTML.toJS(Spacebars.parse('<div>hello</div> {{#foo}}<div>{{#bar}}world{{/bar}}</div>{{/foo}}')),
+             '[HTML.DIV("hello"), " ", HTMLTools.Special({type: "BLOCKOPEN", path: ["foo"], content: HTML.DIV(HTMLTools.Special({type: "BLOCKOPEN", path: ["bar"], content: "world"}))})]');
+
+
+  test.throws(function () {
+    Spacebars.parse('<a {{{x}}}></a>');
+  });
+  test.throws(function () {
+    Spacebars.parse('<a {{#if x}}{{/if}}></a>');
+  });
+  test.throws(function () {
+    Spacebars.parse('<a {{k}}={[v}}></a>');
+  });
+  test.throws(function () {
+    Spacebars.parse('<a x{{y}}></a>');
+  });
+  test.throws(function () {
+    Spacebars.parse('<a x{{y}}=z></a>');
+  });
+  test.throws(function () {
+    Spacebars.parse('<a {{> x}}></a>');
+  });
+
+  test.equal(HTML.toJS(Spacebars.parse('<a {{! x--}} b=c{{! x}} {{! x}}></a>')),
+             'HTML.A({b: "c"})');
+
+  test.equal(HTML.toJS(Spacebars.parse('<a {{!-- x--}} b=c{{ !-- x --}} {{!-- x -- }}></a>')),
+             'HTML.A({b: "c"})');
+
+  // currently, if there are only comments, the attribute is truthy.  This is
+  // because comments are stripped during tokenization.  If we include
+  // comments in the token stream, these cases will become falsy for selected.
+  test.equal(HTML.toJS(Spacebars.parse('<input selected={{!foo}}>')),
+             'HTML.INPUT({selected: ""})');
+  test.equal(HTML.toJS(Spacebars.parse('<input selected={{!foo}}{{!bar}}>')),
+             'HTML.INPUT({selected: ""})');
+  test.equal(HTML.toJS(Spacebars.parse('<input selected={{!--foo--}}>')),
+    'HTML.INPUT({selected: ""})');
+  test.equal(HTML.toJS(Spacebars.parse('<input selected={{!--foo--}}{{!--bar--}}>')),
+    'HTML.INPUT({selected: ""})');
+
+});
diff --git a/packages/spacebars-compiler/templatetag.js b/packages/spacebars-compiler/templatetag.js
new file mode 100644
index 0000000000..4616f37970
--- /dev/null
+++ b/packages/spacebars-compiler/templatetag.js
@@ -0,0 +1,463 @@
+// A TemplateTag is the result of parsing a single `{{...}}` tag.
+//
+// The `.type` of a TemplateTag is one of:
+//
+// - `"DOUBLE"` - `{{foo}}`
+// - `"TRIPLE"` - `{{{foo}}}`
+// - `"COMMENT"` - `{{! foo}}`
+// - `"INCLUSION"` - `{{> foo}}`
+// - `"BLOCKOPEN"` - `{{#foo}}`
+// - `"BLOCKCLOSE"` - `{{/foo}}`
+// - `"ELSE"` - `{{else}}`
+//
+// Besides `type`, the mandatory properties of a TemplateTag are:
+//
+// - `path` - An array of one or more strings.  The path of `{{foo.bar}}`
+//   is `["foo", "bar"]`.  Applies to DOUBLE, TRIPLE, INCLUSION, BLOCKOPEN,
+//   and BLOCKCLOSE.
+//
+// - `args` - An array of zero or more argument specs.  An argument spec
+//   is a two or three element array, consisting of a type, value, and
+//   optional keyword name.  For example, the `args` of `{{foo "bar" x=3}}`
+//   are `[["STRING", "bar"], ["NUMBER", 3, "x"]]`.  Applies to DOUBLE,
+//   TRIPLE, INCLUSION, and BLOCKOPEN.
+//
+// - `value` - For COMMENT tags, a string of the comment's text.
+//
+// These additional are typically set during parsing:
+//
+// - `position` - The HTMLTools.TEMPLATE_TAG_POSITION specifying at what sort
+//   of site the TemplateTag was encountered (e.g. at element level or as
+//   part of an attribute value). Its absence implies
+//   TEMPLATE_TAG_POSITION.ELEMENT.
+//
+// - `content` and `elseContent` - When a BLOCKOPEN tag's contents are
+//   parsed, they are put here.  `elseContent` will only be present if
+//   an `{{else}}` was found.
+
+var TEMPLATE_TAG_POSITION = HTMLTools.TEMPLATE_TAG_POSITION;
+
+TemplateTag = Spacebars.TemplateTag = function () {};
+
+var makeStacheTagStartRegex = function (r) {
+  return new RegExp(r.source + /(?![{>!#/])/.source,
+                    r.ignoreCase ? 'i' : '');
+};
+
+var starts = {
+  ELSE: makeStacheTagStartRegex(/^\{\{\s*else(?=[\s}])/i),
+  DOUBLE: makeStacheTagStartRegex(/^\{\{\s*(?!\s)/),
+  TRIPLE: makeStacheTagStartRegex(/^\{\{\{\s*(?!\s)/),
+  BLOCKCOMMENT: makeStacheTagStartRegex(/^\{\{\s*!--/),
+  COMMENT: makeStacheTagStartRegex(/^\{\{\s*!/),
+  INCLUSION: makeStacheTagStartRegex(/^\{\{\s*>\s*(?!\s)/),
+  BLOCKOPEN: makeStacheTagStartRegex(/^\{\{\s*#\s*(?!\s)/),
+  BLOCKCLOSE: makeStacheTagStartRegex(/^\{\{\s*\/\s*(?!\s)/)
+};
+
+var ends = {
+  DOUBLE: /^\s*\}\}/,
+  TRIPLE: /^\s*\}\}\}/
+};
+
+// Parse a tag from the provided scanner or string.  If the input
+// doesn't start with `{{`, returns null.  Otherwise, either succeeds
+// and returns a Spacebars.TemplateTag, or throws an error (using
+// `scanner.fatal` if a scanner is provided).
+TemplateTag.parse = function (scannerOrString) {
+  var scanner = scannerOrString;
+  if (typeof scanner === 'string')
+    scanner = new HTMLTools.Scanner(scannerOrString);
+
+  if (! (scanner.peek() === '{' &&
+         (scanner.rest()).slice(0, 2) === '{{'))
+    return null;
+
+  var run = function (regex) {
+    // regex is assumed to start with `^`
+    var result = regex.exec(scanner.rest());
+    if (! result)
+      return null;
+    var ret = result[0];
+    scanner.pos += ret.length;
+    return ret;
+  };
+
+  var advance = function (amount) {
+    scanner.pos += amount;
+  };
+
+  var scanIdentifier = function (isFirstInPath) {
+    var id = parseIdentifierName(scanner);
+    if (! id)
+      expected('IDENTIFIER');
+    if (isFirstInPath &&
+        (id === 'null' || id === 'true' || id === 'false'))
+      scanner.fatal("Can't use null, true, or false, as an identifier at start of path");
+
+    return id;
+  };
+
+  var scanPath = function () {
+    var segments = [];
+
+    // handle initial `.`, `..`, `./`, `../`, `../..`, `../../`, etc
+    var dots;
+    if ((dots = run(/^[\.\/]+/))) {
+      var ancestorStr = '.'; // eg `../../..` maps to `....`
+      var endsWithSlash = /\/$/.test(dots);
+
+      if (endsWithSlash)
+        dots = dots.slice(0, -1);
+
+      _.each(dots.split('/'), function(dotClause, index) {
+        if (index === 0) {
+          if (dotClause !== '.' && dotClause !== '..')
+            expected("`.`, `..`, `./` or `../`");
+        } else {
+          if (dotClause !== '..')
+            expected("`..` or `../`");
+        }
+
+        if (dotClause === '..')
+          ancestorStr += '.';
+      });
+
+      segments.push(ancestorStr);
+
+      if (!endsWithSlash)
+        return segments;
+    }
+
+    while (true) {
+      // scan a path segment
+
+      if (run(/^\[/)) {
+        var seg = run(/^[\s\S]*?\]/);
+        if (! seg)
+          error("Unterminated path segment");
+        seg = seg.slice(0, -1);
+        if (! seg && ! segments.length)
+          error("Path can't start with empty string");
+        segments.push(seg);
+      } else {
+        var id = scanIdentifier(! segments.length);
+        if (id === 'this') {
+          if (! segments.length) {
+            // initial `this`
+            segments.push('.');
+          } else {
+            error("Can only use `this` at the beginning of a path.\nInstead of `foo.this` or `../this`, just write `foo` or `..`.");
+          }
+        } else {
+          segments.push(id);
+        }
+      }
+
+      var sep = run(/^[\.\/]/);
+      if (! sep)
+        break;
+    }
+
+    return segments;
+  };
+
+  // scan the keyword portion of a keyword argument
+  // (the "foo" portion in "foo=bar").
+  // Result is either the keyword matched, or null
+  // if we're not at a keyword argument position.
+  var scanArgKeyword = function () {
+    var match = /^([^\{\}\(\)\>#=\s]+)\s*=\s*/.exec(scanner.rest());
+    if (match) {
+      scanner.pos += match[0].length;
+      return match[1];
+    } else {
+      return null;
+    }
+  };
+
+  // scan an argument; succeeds or errors.
+  // Result is an array of two or three items:
+  // type , value, and (indicating a keyword argument)
+  // keyword name.
+  var scanArg = function () {
+    var keyword = scanArgKeyword(); // null if not parsing a kwarg
+    var value = scanArgValue();
+    return keyword ? value.concat(keyword) : value;
+  };
+
+  // scan an argument value (for keyword or positional arguments);
+  // succeeds or errors.  Result is an array of type, value.
+  var scanArgValue = function () {
+    var startPos = scanner.pos;
+    var result;
+    if ((result = parseNumber(scanner))) {
+      return ['NUMBER', result.value];
+    } else if ((result = parseStringLiteral(scanner))) {
+      return ['STRING', result.value];
+    } else if (/^[\.\[]/.test(scanner.peek())) {
+      return ['PATH', scanPath()];
+    } else if ((result = parseIdentifierName(scanner))) {
+      var id = result;
+      if (id === 'null') {
+        return ['NULL', null];
+      } else if (id === 'true' || id === 'false') {
+        return ['BOOLEAN', id === 'true'];
+      } else {
+        scanner.pos = startPos; // unconsume `id`
+        return ['PATH', scanPath()];
+      }
+    } else {
+      expected('identifier, number, string, boolean, or null');
+    }
+  };
+
+  var type;
+
+  var error = function (msg) {
+    scanner.fatal(msg);
+  };
+
+  var expected = function (what) {
+    error('Expected ' + what);
+  };
+
+  // must do ELSE first; order of others doesn't matter
+
+  if (run(starts.ELSE)) type = 'ELSE';
+  else if (run(starts.DOUBLE)) type = 'DOUBLE';
+  else if (run(starts.TRIPLE)) type = 'TRIPLE';
+  else if (run(starts.BLOCKCOMMENT)) type = 'BLOCKCOMMENT';
+  else if (run(starts.COMMENT)) type = 'COMMENT';
+  else if (run(starts.INCLUSION)) type = 'INCLUSION';
+  else if (run(starts.BLOCKOPEN)) type = 'BLOCKOPEN';
+  else if (run(starts.BLOCKCLOSE)) type = 'BLOCKCLOSE';
+  else
+    error('Unknown stache tag');
+
+  var tag = new TemplateTag;
+  tag.type = type;
+
+  if (type === 'BLOCKCOMMENT') {
+    var result = run(/^[\s\S]*?--\s*?\}\}/);
+    if (! result)
+      error("Unclosed block comment");
+    tag.value = result.slice(0, result.lastIndexOf('--'));
+  } else if (type === 'COMMENT') {
+    var result = run(/^[\s\S]*?\}\}/);
+    if (! result)
+      error("Unclosed comment");
+    tag.value = result.slice(0, -2);
+  } else if (type === 'BLOCKCLOSE') {
+    tag.path = scanPath();
+    if (! run(ends.DOUBLE))
+      expected('`}}`');
+  } else if (type === 'ELSE') {
+    if (! run(ends.DOUBLE))
+      expected('`}}`');
+  } else {
+    // DOUBLE, TRIPLE, BLOCKOPEN, INCLUSION
+    tag.path = scanPath();
+    tag.args = [];
+    var foundKwArg = false;
+    while (true) {
+      run(/^\s*/);
+      if (type === 'TRIPLE') {
+        if (run(ends.TRIPLE))
+          break;
+        else if (scanner.peek() === '}')
+          expected('`}}}`');
+      } else {
+        if (run(ends.DOUBLE))
+          break;
+        else if (scanner.peek() === '}')
+          expected('`}}`');
+      }
+      var newArg = scanArg();
+      if (newArg.length === 3) {
+        foundKwArg = true;
+      } else {
+        if (foundKwArg)
+          error("Can't have a non-keyword argument after a keyword argument");
+      }
+      tag.args.push(newArg);
+
+      if (run(/^(?=[\s}])/) !== '')
+        expected('space');
+    }
+  }
+
+  return tag;
+};
+
+// Returns a Spacebars.TemplateTag parsed from `scanner`, leaving scanner
+// at its original position.
+//
+// An error will still be thrown if there is not a valid template tag at
+// the current position.
+TemplateTag.peek = function (scanner) {
+  var startPos = scanner.pos;
+  var result = TemplateTag.parse(scanner);
+  scanner.pos = startPos;
+  return result;
+};
+
+// Like `TemplateTag.parse`, but in the case of blocks, parse the complete
+// `{{#foo}}...{{/foo}}` with `content` and possible `elseContent`, rather
+// than just the BLOCKOPEN tag.
+//
+// In addition:
+//
+// - Throws an error if `{{else}}` or `{{/foo}}` tag is encountered.
+//
+// - Returns `null` for a COMMENT.  (This case is distinguishable from
+//   parsing no tag by the fact that the scanner is advanced.)
+//
+// - Takes an HTMLTools.TEMPLATE_TAG_POSITION `position` and sets it as the
+//   TemplateTag's `.position` property.
+//
+// - Validates the tag's well-formedness and legality at in its position.
+TemplateTag.parseCompleteTag = function (scannerOrString, position) {
+  var scanner = scannerOrString;
+  if (typeof scanner === 'string')
+    scanner = new HTMLTools.Scanner(scannerOrString);
+
+  var startPos = scanner.pos; // for error messages
+  var result = TemplateTag.parse(scannerOrString);
+  if (! result)
+    return result;
+
+  if (result.type === 'BLOCKCOMMENT')
+    return null;
+
+  if (result.type === 'COMMENT')
+    return null;
+
+  if (result.type === 'ELSE')
+    scanner.fatal("Unexpected {{else}}");
+
+  if (result.type === 'BLOCKCLOSE')
+    scanner.fatal("Unexpected closing template tag");
+
+  position = (position || TEMPLATE_TAG_POSITION.ELEMENT);
+  if (position !== TEMPLATE_TAG_POSITION.ELEMENT)
+    result.position = position;
+
+  if (result.type === 'BLOCKOPEN') {
+    // parse block contents
+
+    // Construct a string version of `.path` for comparing start and
+    // end tags.  For example, `foo/[0]` was parsed into `["foo", "0"]`
+    // and now becomes `foo,0`.  This form may also show up in error
+    // messages.
+    var blockName = result.path.join(',');
+
+    var textMode = null;
+      if (blockName === 'markdown' ||
+          position === TEMPLATE_TAG_POSITION.IN_RAWTEXT) {
+        textMode = HTML.TEXTMODE.STRING;
+      } else if (position === TEMPLATE_TAG_POSITION.IN_RCDATA ||
+                 position === TEMPLATE_TAG_POSITION.IN_ATTRIBUTE) {
+        textMode = HTML.TEXTMODE.RCDATA;
+      }
+      var parserOptions = {
+        getSpecialTag: TemplateTag.parseCompleteTag,
+        shouldStop: isAtBlockCloseOrElse,
+        textMode: textMode
+      };
+    result.content = HTMLTools.parseFragment(scanner, parserOptions);
+
+    if (scanner.rest().slice(0, 2) !== '{{')
+      scanner.fatal("Expected {{else}} or block close for " + blockName);
+
+    var lastPos = scanner.pos; // save for error messages
+    var tmplTag = TemplateTag.parse(scanner); // {{else}} or {{/foo}}
+
+    if (tmplTag.type === 'ELSE') {
+      // parse {{else}} and content up to close tag
+      result.elseContent = HTMLTools.parseFragment(scanner, parserOptions);
+
+      if (scanner.rest().slice(0, 2) !== '{{')
+        scanner.fatal("Expected block close for " + blockName);
+
+      lastPos = scanner.pos;
+      tmplTag = TemplateTag.parse(scanner);
+    }
+
+    if (tmplTag.type === 'BLOCKCLOSE') {
+      var blockName2 = tmplTag.path.join(',');
+      if (blockName !== blockName2) {
+        scanner.pos = lastPos;
+        scanner.fatal('Expected tag to close ' + blockName + ', found ' +
+                      blockName2);
+      }
+    } else {
+      scanner.pos = lastPos;
+      scanner.fatal('Expected tag to close ' + blockName + ', found ' +
+                    tmplTag.type);
+    }
+  }
+
+  var finalPos = scanner.pos;
+  scanner.pos = startPos;
+  validateTag(result, scanner);
+  scanner.pos = finalPos;
+
+  return result;
+};
+
+var isAtBlockCloseOrElse = function (scanner) {
+  // Detect `{{else}}` or `{{/foo}}`.
+  //
+  // We do as much work ourselves before deferring to `TemplateTag.peek`,
+  // for efficiency (we're called for every input token) and to be
+  // less obtrusive, because `TemplateTag.peek` will throw an error if it
+  // sees `{{` followed by a malformed tag.
+  var rest, type;
+  return (scanner.peek() === '{' &&
+          (rest = scanner.rest()).slice(0, 2) === '{{' &&
+          /^\{\{\s*(\/|else\b)/.test(rest) &&
+          (type = TemplateTag.peek(scanner).type) &&
+          (type === 'BLOCKCLOSE' || type === 'ELSE'));
+};
+
+// Validate that `templateTag` is correctly formed and legal for its
+// HTML position.  Use `scanner` to report errors. On success, does
+// nothing.
+var validateTag = function (ttag, scanner) {
+
+  if (ttag.type === 'INCLUSION' || ttag.type === 'BLOCKOPEN') {
+    var args = ttag.args;
+    if (args.length > 1 && args[0].length === 2 && args[0][0] !== 'PATH') {
+      // we have a positional argument that is not a PATH followed by
+      // other arguments
+      scanner.fatal("First argument must be a function, to be called on the rest of the arguments; found " + args[0][0]);
+    }
+  }
+
+  var position = ttag.position || TEMPLATE_TAG_POSITION.ELEMENT;
+  if (position === TEMPLATE_TAG_POSITION.IN_ATTRIBUTE) {
+    if (ttag.type === 'DOUBLE') {
+      return;
+    } else if (ttag.type === 'BLOCKOPEN') {
+      var path = ttag.path;
+      var path0 = path[0];
+      if (! (path.length === 1 && (path0 === 'if' ||
+                                   path0 === 'unless' ||
+                                   path0 === 'with' ||
+                                   path0 === 'each'))) {
+        scanner.fatal("Custom block helpers are not allowed in an HTML attribute, only built-in ones like #each and #if");
+      }
+    } else {
+      scanner.fatal(ttag.type + " template tag is not allowed in an HTML attribute");
+    }
+  } else if (position === TEMPLATE_TAG_POSITION.IN_START_TAG) {
+    if (! (ttag.type === 'DOUBLE')) {
+      scanner.fatal("Reactive HTML attributes must either have a constant name or consist of a single {{helper}} providing a dictionary of names and values.  A template tag of type " + ttag.type + " is not allowed here.");
+    }
+    if (scanner.peek() === '=') {
+      scanner.fatal("Template tags are not allowed in attribute names, only in attribute values or in the form of a single {{helper}} that evaluates to a dictionary of name=value pairs.");
+    }
+  }
+
+};
diff --git a/packages/spacebars-compiler/tojs.js b/packages/spacebars-compiler/tojs.js
new file mode 100644
index 0000000000..344b4b3a6a
--- /dev/null
+++ b/packages/spacebars-compiler/tojs.js
@@ -0,0 +1,108 @@
+
+// Turns any JSONable value into a JavaScript literal.
+toJSLiteral = function (obj) {
+  // See <http://timelessrepo.com/json-isnt-a-javascript-subset> for `\u2028\u2029`.
+  // Also escape Unicode surrogates.
+  return (JSON.stringify(obj)
+          .replace(/[\u2028\u2029\ud800-\udfff]/g, function (c) {
+            return '\\u' + ('000' + c.charCodeAt(0).toString(16)).slice(-4);
+          }));
+};
+
+
+
+var jsReservedWordSet = (function (set) {
+  _.each("abstract else instanceof super boolean enum int switch break export interface synchronized byte extends let this case false long throw catch final native throws char finally new transient class float null true const for package try continue function private typeof debugger goto protected var default if public void delete implements return volatile do import short while double in static with".split(' '), function (w) {
+    set[w] = 1;
+  });
+  return set;
+})({});
+
+toObjectLiteralKey = function (k) {
+  if (/^[a-zA-Z$_][a-zA-Z$0-9_]*$/.test(k) && jsReservedWordSet[k] !== 1)
+    return k;
+  return toJSLiteral(k);
+};
+
+// This method is generic, i.e. it can be transplanted to non-Tags
+// and it will still work by accessing `this.tagName`, `this.attrs`,
+// and `this.children`.  It's ok if `this.attrs` has content that
+// isn't allowed in an attribute (this feature is used by
+// HTMLTools.Special.prototype.toJS).
+HTML.Tag.prototype.toJS = function (options) {
+  var argStrs = [];
+  if (this.attrs) {
+    var kvStrs = [];
+    for (var k in this.attrs) {
+      if (! HTML.isNully(this.attrs[k]))
+        kvStrs.push(toObjectLiteralKey(k) + ': ' +
+                    HTML.toJS(this.attrs[k], options));
+    }
+    if (kvStrs.length)
+      argStrs.push('{' + kvStrs.join(', ') + '}');
+  }
+
+  for (var i = 0; i < this.children.length; i++) {
+    argStrs.push(HTML.toJS(this.children[i], options));
+  }
+
+  var tagName = this.tagName;
+  var tagSymbol;
+  if (! (this instanceof HTML.Tag))
+    // a CharRef or Comment, say
+    tagSymbol = (tagName.indexOf('.') >= 0 ? tagName : 'HTML.' + tagName);
+  else if (! HTML.isTagEnsured(tagName))
+    tagSymbol = 'HTML.getTag(' + toJSLiteral(tagName) + ')';
+  else
+    tagSymbol = 'HTML.' + HTML.getSymbolName(tagName);
+
+  return tagSymbol + '(' + argStrs.join(', ') + ')';
+};
+
+HTML.CharRef.prototype.toJS = function (options) {
+  return HTML.Tag.prototype.toJS.call({tagName: "CharRef",
+                                       attrs: {html: this.html,
+                                               str: this.str},
+                                       children: []},
+                                      options);
+};
+
+HTML.Comment.prototype.toJS = function (options) {
+  return HTML.Tag.prototype.toJS.call({tagName: "Comment",
+                                       attrs: null,
+                                       children: [this.value]},
+                                      options);
+};
+
+HTML.Raw.prototype.toJS = function (options) {
+  return HTML.Tag.prototype.toJS.call({tagName: "Raw",
+                                       attrs: null,
+                                       children: [this.value]},
+                                      options);
+};
+
+HTML.EmitCode.prototype.toJS = function (options) {
+  return this.value;
+};
+
+HTML.toJS = function (node, options) {
+  if (node == null) {
+    // null or undefined
+    return 'null';
+  } else if ((typeof node === 'string') || (typeof node === 'boolean') || (typeof node === 'number')) {
+    // string (or something that will be rendered as a string)
+    return toJSLiteral(node);
+  } else if (node instanceof Array) {
+    // array
+    var parts = [];
+    for (var i = 0; i < node.length; i++)
+      parts.push(HTML.toJS(node[i], options));
+    return '[' + parts.join(', ') + ']';
+  } else if (node.toJS) {
+    // Tag or something else
+    return node.toJS(options);
+  } else {
+    throw new Error("Expected tag, string, array, null, undefined, or " +
+                    "object with a toJS method; found: " + node);
+  }
+};
diff --git a/packages/spacebars-compiler/token_tests.js b/packages/spacebars-compiler/token_tests.js
new file mode 100644
index 0000000000..c85f0c9f66
--- /dev/null
+++ b/packages/spacebars-compiler/token_tests.js
@@ -0,0 +1,67 @@
+Tinytest.add("spacebars - token parsers", function (test) {
+
+  var run = function (func, input, expected) {
+    var scanner = new HTMLTools.Scanner('z' + input);
+    // make sure the parse function respects `scanner.pos`
+    scanner.pos = 1;
+    var result = func(scanner);
+    if (expected === null) {
+      test.equal(scanner.pos, 1);
+      test.equal(result, null);
+    } else {
+      test.isTrue(scanner.isEOF());
+      test.equal(result, expected);
+    }
+  };
+
+  var runValue = function (func, input, expectedValue) {
+    var expected;
+    if (expectedValue === null)
+      expected = null;
+    else
+      expected = { text: input, value: expectedValue };
+    run(func, input, expected);
+  };
+
+  var parseNumber = Spacebars._$.parseNumber;
+  var parseIdentifierName = Spacebars._$.parseIdentifierName;
+  var parseStringLiteral = Spacebars._$.parseStringLiteral;
+
+  runValue(parseNumber, "0", 0);
+  runValue(parseNumber, "-0", 0);
+  runValue(parseNumber, "-", null);
+  runValue(parseNumber, ".a", null);
+  runValue(parseNumber, ".1", 0.1);
+  runValue(parseNumber, "1.", 1);
+  runValue(parseNumber, "1.1", 1.1);
+  runValue(parseNumber, "0x", null);
+  runValue(parseNumber, "0xa", 10);
+  runValue(parseNumber, "-0xa", -10);
+  runValue(parseNumber, "1e+1", 10);
+
+  run(parseIdentifierName, "a", "a");
+  run(parseIdentifierName, "true", "true");
+  run(parseIdentifierName, "null", "null");
+  run(parseIdentifierName, "if", "if");
+  run(parseIdentifierName, "1", null);
+  run(parseIdentifierName, "1a", null);
+  run(parseIdentifierName, "+a", null);
+  run(parseIdentifierName, "a1", "a1");
+  run(parseIdentifierName, "a1a", "a1a");
+  run(parseIdentifierName, "_a8f_f8d88_", "_a8f_f8d88_");
+
+  runValue(parseStringLiteral, '"a"', 'a');
+  runValue(parseStringLiteral, '"\'"', "'");
+  runValue(parseStringLiteral, '\'"\'', '"');
+  runValue(parseStringLiteral, '"a\\\nb"', 'ab'); // line continuation
+  runValue(parseStringLiteral, '"a\u0062c"', 'abc');
+  // Note: IE 8 doesn't correctly parse '\v' in JavaScript.
+  runValue(parseStringLiteral, '"\\0\\b\\f\\n\\r\\t\\v"', '\0\b\f\n\r\t\u000b');
+  runValue(parseStringLiteral, '"\\x41"', 'A');
+  runValue(parseStringLiteral, '"\\\\"', '\\');
+  runValue(parseStringLiteral, '"\\\""', '\"');
+  runValue(parseStringLiteral, '"\\\'"', '\'');
+  runValue(parseStringLiteral, "'\\\\'", '\\');
+  runValue(parseStringLiteral, "'\\\"'", '\"');
+  runValue(parseStringLiteral, "'\\\''", '\'');
+});
diff --git a/packages/spacebars-compiler/tokens.js b/packages/spacebars-compiler/tokens.js
new file mode 100644
index 0000000000..2a34585944
--- /dev/null
+++ b/packages/spacebars-compiler/tokens.js
@@ -0,0 +1,184 @@
+
+// Adapted from source code of http://xregexp.com/plugins/#unicode
+var unicodeCategories = {
+  Ll: "0061-007A00B500DF-00F600F8-00FF01010103010501070109010B010D010F01110113011501170119011B011D011F01210123012501270129012B012D012F01310133013501370138013A013C013E014001420144014601480149014B014D014F01510153015501570159015B015D015F01610163016501670169016B016D016F0171017301750177017A017C017E-0180018301850188018C018D019201950199-019B019E01A101A301A501A801AA01AB01AD01B001B401B601B901BA01BD-01BF01C601C901CC01CE01D001D201D401D601D801DA01DC01DD01DF01E101E301E501E701E901EB01ED01EF01F001F301F501F901FB01FD01FF02010203020502070209020B020D020F02110213021502170219021B021D021F02210223022502270229022B022D022F02310233-0239023C023F0240024202470249024B024D024F-02930295-02AF037103730377037B-037D039003AC-03CE03D003D103D5-03D703D903DB03DD03DF03E103E303E503E703E903EB03ED03EF-03F303F503F803FB03FC0430-045F04610463046504670469046B046D046F04710473047504770479047B047D047F0481048B048D048F04910493049504970499049B049D049F04A104A304A504A704A904AB04AD04AF04B104B304B504B704B904BB04BD04BF04C204C404C604C804CA04CC04CE04CF04D104D304D504D704D904DB04DD04DF04E104E304E504E704E904EB04ED04EF04F104F304F504F704F904FB04FD04FF05010503050505070509050B050D050F05110513051505170519051B051D051F05210523052505270561-05871D00-1D2B1D6B-1D771D79-1D9A1E011E031E051E071E091E0B1E0D1E0F1E111E131E151E171E191E1B1E1D1E1F1E211E231E251E271E291E2B1E2D1E2F1E311E331E351E371E391E3B1E3D1E3F1E411E431E451E471E491E4B1E4D1E4F1E511E531E551E571E591E5B1E5D1E5F1E611E631E651E671E691E6B1E6D1E6F1E711E731E751E771E791E7B1E7D1E7F1E811E831E851E871E891E8B1E8D1E8F1E911E931E95-1E9D1E9F1EA11EA31EA51EA71EA91EAB1EAD1EAF1EB11EB31EB51EB71EB91EBB1EBD1EBF1EC11EC31EC51EC71EC91ECB1ECD1ECF1ED11ED31ED51ED71ED91EDB1EDD1EDF1EE11EE31EE51EE71EE91EEB1EED1EEF1EF11EF31EF51EF71EF91EFB1EFD1EFF-1F071F10-1F151F20-1F271F30-1F371F40-1F451F50-1F571F60-1F671F70-1F7D1F80-1F871F90-1F971FA0-1FA71FB0-1FB41FB61FB71FBE1FC2-1FC41FC61FC71FD0-1FD31FD61FD71FE0-1FE71FF2-1FF41FF61FF7210A210E210F2113212F21342139213C213D2146-2149214E21842C30-2C5E2C612C652C662C682C6A2C6C2C712C732C742C76-2C7B2C812C832C852C872C892C8B2C8D2C8F2C912C932C952C972C992C9B2C9D2C9F2CA12CA32CA52CA72CA92CAB2CAD2CAF2CB12CB32CB52CB72CB92CBB2CBD2CBF2CC12CC32CC52CC72CC92CCB2CCD2CCF2CD12CD32CD52CD72CD92CDB2CDD2CDF2CE12CE32CE42CEC2CEE2CF32D00-2D252D272D2DA641A643A645A647A649A64BA64DA64FA651A653A655A657A659A65BA65DA65FA661A663A665A667A669A66BA66DA681A683A685A687A689A68BA68DA68FA691A693A695A697A723A725A727A729A72BA72DA72F-A731A733A735A737A739A73BA73DA73FA741A743A745A747A749A74BA74DA74FA751A753A755A757A759A75BA75DA75FA761A763A765A767A769A76BA76DA76FA771-A778A77AA77CA77FA781A783A785A787A78CA78EA791A793A7A1A7A3A7A5A7A7A7A9A7FAFB00-FB06FB13-FB17FF41-FF5A",
+  Lm: "02B0-02C102C6-02D102E0-02E402EC02EE0374037A0559064006E506E607F407F507FA081A0824082809710E460EC610FC17D718431AA71C78-1C7D1D2C-1D6A1D781D9B-1DBF2071207F2090-209C2C7C2C7D2D6F2E2F30053031-3035303B309D309E30FC-30FEA015A4F8-A4FDA60CA67FA717-A71FA770A788A7F8A7F9A9CFAA70AADDAAF3AAF4FF70FF9EFF9F",
+  Lo: "00AA00BA01BB01C0-01C3029405D0-05EA05F0-05F20620-063F0641-064A066E066F0671-06D306D506EE06EF06FA-06FC06FF07100712-072F074D-07A507B107CA-07EA0800-08150840-085808A008A2-08AC0904-0939093D09500958-09610972-09770979-097F0985-098C098F09900993-09A809AA-09B009B209B6-09B909BD09CE09DC09DD09DF-09E109F009F10A05-0A0A0A0F0A100A13-0A280A2A-0A300A320A330A350A360A380A390A59-0A5C0A5E0A72-0A740A85-0A8D0A8F-0A910A93-0AA80AAA-0AB00AB20AB30AB5-0AB90ABD0AD00AE00AE10B05-0B0C0B0F0B100B13-0B280B2A-0B300B320B330B35-0B390B3D0B5C0B5D0B5F-0B610B710B830B85-0B8A0B8E-0B900B92-0B950B990B9A0B9C0B9E0B9F0BA30BA40BA8-0BAA0BAE-0BB90BD00C05-0C0C0C0E-0C100C12-0C280C2A-0C330C35-0C390C3D0C580C590C600C610C85-0C8C0C8E-0C900C92-0CA80CAA-0CB30CB5-0CB90CBD0CDE0CE00CE10CF10CF20D05-0D0C0D0E-0D100D12-0D3A0D3D0D4E0D600D610D7A-0D7F0D85-0D960D9A-0DB10DB3-0DBB0DBD0DC0-0DC60E01-0E300E320E330E40-0E450E810E820E840E870E880E8A0E8D0E94-0E970E99-0E9F0EA1-0EA30EA50EA70EAA0EAB0EAD-0EB00EB20EB30EBD0EC0-0EC40EDC-0EDF0F000F40-0F470F49-0F6C0F88-0F8C1000-102A103F1050-1055105A-105D106110651066106E-10701075-1081108E10D0-10FA10FD-1248124A-124D1250-12561258125A-125D1260-1288128A-128D1290-12B012B2-12B512B8-12BE12C012C2-12C512C8-12D612D8-13101312-13151318-135A1380-138F13A0-13F41401-166C166F-167F1681-169A16A0-16EA1700-170C170E-17111720-17311740-17511760-176C176E-17701780-17B317DC1820-18421844-18771880-18A818AA18B0-18F51900-191C1950-196D1970-19741980-19AB19C1-19C71A00-1A161A20-1A541B05-1B331B45-1B4B1B83-1BA01BAE1BAF1BBA-1BE51C00-1C231C4D-1C4F1C5A-1C771CE9-1CEC1CEE-1CF11CF51CF62135-21382D30-2D672D80-2D962DA0-2DA62DA8-2DAE2DB0-2DB62DB8-2DBE2DC0-2DC62DC8-2DCE2DD0-2DD62DD8-2DDE3006303C3041-3096309F30A1-30FA30FF3105-312D3131-318E31A0-31BA31F0-31FF3400-4DB54E00-9FCCA000-A014A016-A48CA4D0-A4F7A500-A60BA610-A61FA62AA62BA66EA6A0-A6E5A7FB-A801A803-A805A807-A80AA80C-A822A840-A873A882-A8B3A8F2-A8F7A8FBA90A-A925A930-A946A960-A97CA984-A9B2AA00-AA28AA40-AA42AA44-AA4BAA60-AA6FAA71-AA76AA7AAA80-AAAFAAB1AAB5AAB6AAB9-AABDAAC0AAC2AADBAADCAAE0-AAEAAAF2AB01-AB06AB09-AB0EAB11-AB16AB20-AB26AB28-AB2EABC0-ABE2AC00-D7A3D7B0-D7C6D7CB-D7FBF900-FA6DFA70-FAD9FB1DFB1F-FB28FB2A-FB36FB38-FB3CFB3EFB40FB41FB43FB44FB46-FBB1FBD3-FD3DFD50-FD8FFD92-FDC7FDF0-FDFBFE70-FE74FE76-FEFCFF66-FF6FFF71-FF9DFFA0-FFBEFFC2-FFC7FFCA-FFCFFFD2-FFD7FFDA-FFDC",
+  Lt: "01C501C801CB01F21F88-1F8F1F98-1F9F1FA8-1FAF1FBC1FCC1FFC",
+  Lu: "0041-005A00C0-00D600D8-00DE01000102010401060108010A010C010E01100112011401160118011A011C011E01200122012401260128012A012C012E01300132013401360139013B013D013F0141014301450147014A014C014E01500152015401560158015A015C015E01600162016401660168016A016C016E017001720174017601780179017B017D018101820184018601870189-018B018E-0191019301940196-0198019C019D019F01A001A201A401A601A701A901AC01AE01AF01B1-01B301B501B701B801BC01C401C701CA01CD01CF01D101D301D501D701D901DB01DE01E001E201E401E601E801EA01EC01EE01F101F401F6-01F801FA01FC01FE02000202020402060208020A020C020E02100212021402160218021A021C021E02200222022402260228022A022C022E02300232023A023B023D023E02410243-02460248024A024C024E03700372037603860388-038A038C038E038F0391-03A103A3-03AB03CF03D2-03D403D803DA03DC03DE03E003E203E403E603E803EA03EC03EE03F403F703F903FA03FD-042F04600462046404660468046A046C046E04700472047404760478047A047C047E0480048A048C048E04900492049404960498049A049C049E04A004A204A404A604A804AA04AC04AE04B004B204B404B604B804BA04BC04BE04C004C104C304C504C704C904CB04CD04D004D204D404D604D804DA04DC04DE04E004E204E404E604E804EA04EC04EE04F004F204F404F604F804FA04FC04FE05000502050405060508050A050C050E05100512051405160518051A051C051E05200522052405260531-055610A0-10C510C710CD1E001E021E041E061E081E0A1E0C1E0E1E101E121E141E161E181E1A1E1C1E1E1E201E221E241E261E281E2A1E2C1E2E1E301E321E341E361E381E3A1E3C1E3E1E401E421E441E461E481E4A1E4C1E4E1E501E521E541E561E581E5A1E5C1E5E1E601E621E641E661E681E6A1E6C1E6E1E701E721E741E761E781E7A1E7C1E7E1E801E821E841E861E881E8A1E8C1E8E1E901E921E941E9E1EA01EA21EA41EA61EA81EAA1EAC1EAE1EB01EB21EB41EB61EB81EBA1EBC1EBE1EC01EC21EC41EC61EC81ECA1ECC1ECE1ED01ED21ED41ED61ED81EDA1EDC1EDE1EE01EE21EE41EE61EE81EEA1EEC1EEE1EF01EF21EF41EF61EF81EFA1EFC1EFE1F08-1F0F1F18-1F1D1F28-1F2F1F38-1F3F1F48-1F4D1F591F5B1F5D1F5F1F68-1F6F1FB8-1FBB1FC8-1FCB1FD8-1FDB1FE8-1FEC1FF8-1FFB21022107210B-210D2110-211221152119-211D212421262128212A-212D2130-2133213E213F214521832C00-2C2E2C602C62-2C642C672C692C6B2C6D-2C702C722C752C7E-2C802C822C842C862C882C8A2C8C2C8E2C902C922C942C962C982C9A2C9C2C9E2CA02CA22CA42CA62CA82CAA2CAC2CAE2CB02CB22CB42CB62CB82CBA2CBC2CBE2CC02CC22CC42CC62CC82CCA2CCC2CCE2CD02CD22CD42CD62CD82CDA2CDC2CDE2CE02CE22CEB2CED2CF2A640A642A644A646A648A64AA64CA64EA650A652A654A656A658A65AA65CA65EA660A662A664A666A668A66AA66CA680A682A684A686A688A68AA68CA68EA690A692A694A696A722A724A726A728A72AA72CA72EA732A734A736A738A73AA73CA73EA740A742A744A746A748A74AA74CA74EA750A752A754A756A758A75AA75CA75EA760A762A764A766A768A76AA76CA76EA779A77BA77DA77EA780A782A784A786A78BA78DA790A792A7A0A7A2A7A4A7A6A7A8A7AAFF21-FF3A",
+  Mc: "0903093B093E-09400949-094C094E094F0982098309BE-09C009C709C809CB09CC09D70A030A3E-0A400A830ABE-0AC00AC90ACB0ACC0B020B030B3E0B400B470B480B4B0B4C0B570BBE0BBF0BC10BC20BC6-0BC80BCA-0BCC0BD70C01-0C030C41-0C440C820C830CBE0CC0-0CC40CC70CC80CCA0CCB0CD50CD60D020D030D3E-0D400D46-0D480D4A-0D4C0D570D820D830DCF-0DD10DD8-0DDF0DF20DF30F3E0F3F0F7F102B102C10311038103B103C105610571062-10641067-106D108310841087-108C108F109A-109C17B617BE-17C517C717C81923-19261929-192B193019311933-193819B0-19C019C819C91A19-1A1B1A551A571A611A631A641A6D-1A721B041B351B3B1B3D-1B411B431B441B821BA11BA61BA71BAA1BAC1BAD1BE71BEA-1BEC1BEE1BF21BF31C24-1C2B1C341C351CE11CF21CF3302E302FA823A824A827A880A881A8B4-A8C3A952A953A983A9B4A9B5A9BAA9BBA9BD-A9C0AA2FAA30AA33AA34AA4DAA7BAAEBAAEEAAEFAAF5ABE3ABE4ABE6ABE7ABE9ABEAABEC",
+  Mn: "0300-036F0483-04870591-05BD05BF05C105C205C405C505C70610-061A064B-065F067006D6-06DC06DF-06E406E706E806EA-06ED07110730-074A07A6-07B007EB-07F30816-0819081B-08230825-08270829-082D0859-085B08E4-08FE0900-0902093A093C0941-0948094D0951-095709620963098109BC09C1-09C409CD09E209E30A010A020A3C0A410A420A470A480A4B-0A4D0A510A700A710A750A810A820ABC0AC1-0AC50AC70AC80ACD0AE20AE30B010B3C0B3F0B41-0B440B4D0B560B620B630B820BC00BCD0C3E-0C400C46-0C480C4A-0C4D0C550C560C620C630CBC0CBF0CC60CCC0CCD0CE20CE30D41-0D440D4D0D620D630DCA0DD2-0DD40DD60E310E34-0E3A0E47-0E4E0EB10EB4-0EB90EBB0EBC0EC8-0ECD0F180F190F350F370F390F71-0F7E0F80-0F840F860F870F8D-0F970F99-0FBC0FC6102D-10301032-10371039103A103D103E10581059105E-10601071-1074108210851086108D109D135D-135F1712-17141732-1734175217531772177317B417B517B7-17BD17C617C9-17D317DD180B-180D18A91920-19221927192819321939-193B1A171A181A561A58-1A5E1A601A621A65-1A6C1A73-1A7C1A7F1B00-1B031B341B36-1B3A1B3C1B421B6B-1B731B801B811BA2-1BA51BA81BA91BAB1BE61BE81BE91BED1BEF-1BF11C2C-1C331C361C371CD0-1CD21CD4-1CE01CE2-1CE81CED1CF41DC0-1DE61DFC-1DFF20D0-20DC20E120E5-20F02CEF-2CF12D7F2DE0-2DFF302A-302D3099309AA66FA674-A67DA69FA6F0A6F1A802A806A80BA825A826A8C4A8E0-A8F1A926-A92DA947-A951A980-A982A9B3A9B6-A9B9A9BCAA29-AA2EAA31AA32AA35AA36AA43AA4CAAB0AAB2-AAB4AAB7AAB8AABEAABFAAC1AAECAAEDAAF6ABE5ABE8ABEDFB1EFE00-FE0FFE20-FE26",
+  Nd: "0030-00390660-066906F0-06F907C0-07C90966-096F09E6-09EF0A66-0A6F0AE6-0AEF0B66-0B6F0BE6-0BEF0C66-0C6F0CE6-0CEF0D66-0D6F0E50-0E590ED0-0ED90F20-0F291040-10491090-109917E0-17E91810-18191946-194F19D0-19D91A80-1A891A90-1A991B50-1B591BB0-1BB91C40-1C491C50-1C59A620-A629A8D0-A8D9A900-A909A9D0-A9D9AA50-AA59ABF0-ABF9FF10-FF19",
+  Nl: "16EE-16F02160-21822185-218830073021-30293038-303AA6E6-A6EF",
+  Pc: "005F203F20402054FE33FE34FE4D-FE4FFF3F"
+};
+
+var unicodeClass = function (abbrev) {
+  return '[' +
+    unicodeCategories[abbrev].replace(/[0-9A-F]{4}/ig, "\\u$&") + ']';
+};
+
+// See ECMA-262 spec, 3rd edition, Section 7.6
+// Match one or more characters that can start an identifier.
+// This is IdentifierStart+.
+var rIdentifierPrefix = new RegExp(
+  "^([a-zA-Z$_]+|\\\\u[0-9a-fA-F]{4}|" +
+    [unicodeClass('Lu'), unicodeClass('Ll'), unicodeClass('Lt'),
+     unicodeClass('Lm'), unicodeClass('Lo'), unicodeClass('Nl')].join('|') +
+    ")+");
+// Match one or more characters that can continue an identifier.
+// This is (IdentifierPart and not IdentifierStart)+.
+// To match a full identifier, match rIdentifierPrefix, then
+// match rIdentifierMiddle followed by rIdentifierPrefix until they both fail.
+var rIdentifierMiddle = new RegExp(
+  "^([0-9]|" + [unicodeClass('Mn'), unicodeClass('Mc'), unicodeClass('Nd'),
+                unicodeClass('Pc')].join('|') + ")+");
+
+
+// See ECMA-262 spec, 3rd edition, Section 7.8.3
+var rHexLiteral = /^0[xX][0-9a-fA-F]+(?!\w)/;
+var rDecLiteral =
+      /^(((0|[1-9][0-9]*)(\.[0-9]*)?)|\.[0-9]+)([Ee][+-]?[0-9]+)?(?!\w)/;
+
+// Section 7.8.4
+var rStringQuote = /^["']/;
+// Match one or more characters besides quotes, backslashes, or line ends
+var rStringMiddle = /^(?=.)[^"'\\]+?((?!.)|(?=["'\\]))/;
+// Match one escape sequence, including the backslash.
+var rEscapeSequence =
+      /^\\(['"\\bfnrtv]|0(?![0-9])|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|(?=.)[^ux0-9])/;
+// Match one ES5 line continuation
+var rLineContinuation =
+      /^\\(\r\n|[\u000A\u000D\u2028\u2029])/;
+
+
+parseNumber = function (scanner) {
+  var startPos = scanner.pos;
+
+  var isNegative = false;
+  if (scanner.peek() === '-') {
+    scanner.pos++;
+    isNegative = true;
+  }
+  // Note that we allow `"-0xa"`, unlike `Number(...)`.
+
+  var rest = scanner.rest();
+  var match = rDecLiteral.exec(rest) || rHexLiteral.exec(rest);
+  if (! match) {
+    scanner.pos = startPos;
+    return null;
+  }
+  var matchText = match[0];
+  scanner.pos += matchText.length;
+
+  var text = (isNegative ? '-' : '') + matchText;
+  var value = Number(matchText);
+  value = (isNegative ? -value : value);
+  return { text: text, value: value };
+};
+
+parseIdentifierName = function (scanner) {
+  var startPos = scanner.pos;
+  var rest = scanner.rest();
+  var match = rIdentifierPrefix.exec(rest);
+  if (! match)
+    return null;
+  scanner.pos += match[0].length;
+  rest = scanner.rest();
+  var foundMore = true;
+
+  while (foundMore) {
+    foundMore = false;
+
+    match = rIdentifierMiddle.exec(rest);
+    if (match) {
+      foundMore = true;
+      scanner.pos += match[0].length;
+      rest = scanner.rest();
+    }
+
+    match = rIdentifierPrefix.exec(rest);
+    if (match) {
+      foundMore = true;
+      scanner.pos += match[0].length;
+      rest = scanner.rest();
+    }
+  }
+
+  return scanner.input.substring(startPos, scanner.pos);
+};
+
+parseStringLiteral = function (scanner) {
+  var startPos = scanner.pos;
+  var rest = scanner.rest();
+  var match = rStringQuote.exec(rest);
+  if (! match)
+    return null;
+
+  var quote = match[0];
+  scanner.pos++;
+  rest = scanner.rest();
+
+  var jsonLiteral = '"';
+
+  while (match) {
+    match = rStringMiddle.exec(rest);
+    if (match) {
+      jsonLiteral += match[0];
+    } else {
+      match = rEscapeSequence.exec(rest);
+      if (match) {
+        var esc = match[0];
+        // Convert all string escapes to JSON-compatible string escapes, so we
+        // can use JSON.parse for some of the work.  JSON strings are not the
+        // same as JS strings.  They don't support `\0`, `\v`, `\'`, or hex
+        // escapes.
+        if (esc === '\\0')
+          jsonLiteral += '\\u0000';
+        else if (esc === '\\v')
+          // Note: IE 8 doesn't correctly parse '\v' in JavaScript.
+          jsonLiteral += '\\u000b';
+        else if (esc.charAt(1) === 'x')
+          jsonLiteral += '\\u00' + esc.slice(2);
+        else if (esc === '\\\'')
+          jsonLiteral += "'";
+        else
+          jsonLiteral += esc;
+      } else {
+        match = rLineContinuation.exec(rest);
+        if (! match) {
+          match = rStringQuote.exec(rest);
+          if (match) {
+            var c = match[0];
+            if (c !== quote) {
+              if (c === '"')
+                jsonLiteral += '\\';
+              jsonLiteral += c;
+            }
+          }
+        }
+      }
+    }
+    if (match) {
+      scanner.pos += match[0].length;
+      rest = scanner.rest();
+      if (match[0] === quote)
+        break;
+    }
+  }
+
+  if (match[0] !== quote)
+    scanner.fatal("Unterminated string literal");
+
+  jsonLiteral += '"';
+  var text = scanner.input.substring(startPos, scanner.pos);
+  var value = JSON.parse(jsonLiteral);
+  return { text: text, value: value };
+};
+
+// expose for testing
+Spacebars._$ = {
+  parseNumber: parseNumber,
+  parseIdentifierName: parseIdentifierName,
+  parseStringLiteral: parseStringLiteral
+};
diff --git a/packages/universal-events/.gitignore b/packages/spacebars-tests/.gitignore
similarity index 100%
rename from packages/universal-events/.gitignore
rename to packages/spacebars-tests/.gitignore
diff --git a/packages/spacebars-tests/package.js b/packages/spacebars-tests/package.js
new file mode 100644
index 0000000000..bc74b16299
--- /dev/null
+++ b/packages/spacebars-tests/package.js
@@ -0,0 +1,24 @@
+Package.describe({
+  name: "spacebars-tests",
+  test: "spacebars-tests-test",
+  summary: "Additional tests for Spacebars",
+  version: '1.0.0',
+  internal: true
+});
+
+// These tests are in a separate package to avoid a circular dependency
+// between the `spacebars` and `templating` packages.
+Package.on_test(function (api) {
+  api.use('underscore');
+  api.use('spacebars');
+  api.use('tinytest');
+  api.use('jquery');
+  api.use('test-helpers');
+  api.use('showdown');
+
+  api.use('templating', 'client');
+  api.add_files([
+    'template_tests.html',
+    'template_tests.js'
+  ], 'client');
+});
diff --git a/packages/spacebars-tests/template_tests.html b/packages/spacebars-tests/template_tests.html
new file mode 100644
index 0000000000..0f2e733dcd
--- /dev/null
+++ b/packages/spacebars-tests/template_tests.html
@@ -0,0 +1,728 @@
+
+<!-- convenient templates to use in different tests -->
+<template name="spacebars_template_test_aaa">
+  aaa
+</template>
+
+<template name="spacebars_template_test_bbb">
+  bbb
+</template>
+
+<template name="spacebars_template_test_bracketed_this">
+  [{{this}}]
+</template>
+
+<template name="spacebars_template_test_span_this">
+  <span>{{this}}</span>
+</template>
+
+<template name="spacebars_template_test_content">
+  {{> UI.contentBlock}}
+</template>
+
+<template name="spacebars_template_test_elsecontent">
+  {{> UI.elseBlock}}
+</template>
+
+<template name="spacebars_template_test_iftemplate">
+  {{#if condition}}
+    {{> UI.contentBlock}}
+  {{else}}
+    {{> UI.elseBlock}}
+  {{/if}}
+</template>
+
+<!-- -->
+
+
+
+<template name="spacebars_template_test_simple_helper">
+  {{foo bar}}
+</template>
+
+<template name="spacebars_template_test_dynamic_template">
+  {{> foo}}
+</template>
+
+<template name="spacebars_template_test_interpolate_attribute">
+  <div class="aaa{{foo bar}}zzz"></div>
+</template>
+
+<template name="spacebars_template_test_dynamic_attrs">
+  <span {{attrsObj}} {{singleAttr}} {{nonexistent}}>hi</span>
+</template>
+
+<template name="spacebars_template_test_triple">
+  {{{html}}}
+</template>
+
+<template name="spacebars_template_test_triple2">
+  x{{{html}}}{{{html2}}}{{{html3}}}y
+</template>
+
+<template name="spacebars_template_test_inclusion_args">
+  {{> foo bar}}
+</template>
+
+<template name="spacebars_template_test_inclusion_args2">
+  {{> foo bar q=baz}}
+</template>
+
+<template name="spacebars_template_test_inclusion_dotted_args">
+  {{> foo bar.baz}}
+</template>
+
+<template name="spacebars_template_test_inclusion_slashed_args">
+  {{> foo bar/baz}}
+</template>
+
+<template name="spacebars_template_test_block_helper">
+  {{#foo}}
+    bar
+  {{else}}
+    baz
+  {{/foo}}
+</template>
+
+<template name="spacebars_template_test_block_helper_function_one_string_arg">
+  {{#foo "bar"}}
+    content
+  {{/foo}}
+</template>
+
+<template name="spacebars_template_test_block_helper_function_one_helper_arg">
+  {{#foo bar}}
+    content
+  {{/foo}}
+</template>
+
+<template name="spacebars_template_test_block_helper_component_one_helper_arg">
+  {{#if bar}}
+    content
+  {{/if}}
+</template>
+
+<template name="spacebars_template_test_block_helper_component_three_helper_args">
+  {{#if equals bar_or_baz "bar"}}
+    content
+  {{/if}}
+</template>
+
+<template name="spacebars_template_test_block_helper_dotted_arg">
+  {{#foo bar.baz qux}}{{/foo}}
+</template>
+
+<template name="spacebars_template_test_nested_content">
+  {{#spacebars_template_test_iftemplate condition=flag}}
+    hello
+  {{else}}
+    world
+  {{/spacebars_template_test_iftemplate}}
+</template>
+
+<template name="spacebars_template_test_iftemplate2">
+  {{#spacebars_template_test_iftemplate condition=flag}}
+    {{> UI.contentBlock}}
+  {{else}}
+    {{> UI.elseBlock}}
+  {{/spacebars_template_test_iftemplate}}
+</template>
+
+<template name="spacebars_template_test_nested_content2">
+  {{#spacebars_template_test_iftemplate2 flag=x}}
+    hello
+  {{else}}
+    world
+  {{/spacebars_template_test_iftemplate2}}
+</template>
+
+<template name="spacebars_template_test_if">
+  {{#if foo}}
+    {{bar}}
+  {{else}}
+    {{baz}}
+  {{/if}}
+</template>
+
+<template name="spacebars_template_test_if_in_with">
+  {{#with foo}}
+    {{bar}}
+    {{#if true}}
+      {{bar}}
+    {{/if}}
+  {{/with}}
+</template>
+
+<template name="spacebars_template_test_each">
+  {{#each items}}
+    {{text}}
+  {{else}}
+    else-clause
+  {{/each}}
+</template>
+
+<template name="spacebars_template_test_dots">
+  {{#with foo}}
+    A
+    {{#with bar}}
+      B
+      {{! #if shouldn't add a data context }}
+      {{#if true}}
+        C
+        {{#each items}}
+          D
+          {{! inclusion should only add a data context if passed explicitly }}
+          {{> spacebars_template_test_dots_subtemplate}}
+          {{> spacebars_template_test_dots_subtemplate ..}}
+        {{/each}}
+      {{/if}}
+    {{/with}}
+  {{/with}}
+</template>
+
+<template name="spacebars_template_test_dots_subtemplate">
+  TITLE
+  1{{title}}
+  2{{./title}}
+  3{{../title}}
+  4{{../../title}}
+
+  GETTITLE
+  5{{getTitle .}}
+  6{{getTitle ..}}
+  7{{getTitle ../..}}
+</template>
+
+<template name="spacebars_template_test_select_tag">
+  <select>
+    {{#each optgroups}}
+      <optgroup label={{label}}>
+        {{#each options}}
+          <option value={{value}} {{selectedAttr}}>{{label}}</option>
+        {{/each}}
+      </optgroup>
+    {{/each}}
+  </select>
+</template>
+
+<!-- Test for issue #770 - falsy value for with. -->
+<template name="test_template_issue770">
+  {{# with value1}}
+    {{this}}
+  {{else}}
+    xxx
+  {{/with}}
+
+  {{# with value2}}
+    {{this}}
+  {{else}}
+    xxx
+  {{/with}}
+
+  {{# with value1}}
+    {{this}}
+  {{/with}}
+
+  {{# with value2}}
+    {{this}}
+  {{/with}}
+</template>
+
+<template name="spacebars_template_test_tricky_attrs">
+  <input type={{theType}}><input type=checkbox class={{theClass}}>
+</template>
+
+<template name="spacebars_template_test_no_data">
+  {{this.foo}}{{#unless this.bar}}asdf{{/unless}}
+</template>
+
+<template name="spacebars_template_test_isolate">
+  {{#isolate}}hello{{/isolate}}
+</template>
+
+<template name="spacebars_template_test_constant">
+  {{#constant}}hello{{/constant}}
+</template>
+
+<template name="spacebars_template_test_textarea">
+  <textarea>{{foo}}</textarea>
+</template>
+
+<template name="spacebars_template_test_textarea2">
+  <textarea>{{#if foo}}</not a tag>{{else}}<also not a tag>{{/if}}</textarea>
+</template>
+
+<template name="spacebars_template_test_textarea_each">
+  <textarea>{{#each foo}}<not a tag {{.}} {{else}}<>{{/each}}</textarea>
+</template>
+
+<template name="spacebars_template_test_defer_in_rendered">
+  {{#each items}}
+    {{> spacebars_template_test_defer_in_rendered_subtemplate}}
+  {{/each}}
+</template>
+
+<template name="spacebars_template_test_defer_in_rendered_subtemplate">
+  {{! see rendered callback }}
+</template>
+
+<template name="spacebars_template_test_with_someData">
+  {{#with someData}}
+    {{foo}} {{bar}}
+  {{/with}}
+</template>
+
+<template name="spacebars_template_test_each_stops">
+  {{#each items}}
+    x
+  {{/each}}
+</template>
+
+<template name="spacebars_template_test_block_helpers_in_attribute">
+  <div class="{{#each classes}}{{#if startsLowerCase name}}{{name}} {{/if}}{{else}}none{{/each}}">Hello</div>
+</template>
+
+<template name="spacebars_template_test_block_helpers_in_attribute_2">
+  <input value="{{#if foo}}"{{else}}&&lt;></x>{{/if}}">
+</template>
+
+<template name="spacebars_template_test_constant_each_argument">
+  {{#with someData}}
+    {{#each anArray}}
+      {{justReturn this}}
+    {{/each}}
+    {{this}}
+  {{/with}}
+</template>
+
+<template name="spacebars_template_test_markdown_basic">
+  {{#with obj}}
+    {{#markdown}}
+{{hi}}
+/each}}
+
+<b>{{hi}}</b>
+<b>/each}}</b>
+
+* {{hi}}
+* /each}}
+
+* <b>{{hi}}</b>
+* <b>/each}}</b>
+
+some paragraph to fix showdown's four space parsing below.
+
+    {{hi}}
+    /each}}
+
+    <b>{{hi}}</b>
+    <b>/each}}</b>
+
+&gt
+
+* &gt
+
+`&gt`
+
+    &gt
+
+&gt;
+
+* &gt;
+
+`&gt;`
+
+    &gt;
+
+`{{hi}}`
+`/each}}`
+
+`<b>{{hi}}</b>`
+`<b>/each}}`
+
+    {{/markdown}}
+  {{/with}}
+</template>
+
+<template name="spacebars_template_test_markdown_if">
+  {{#markdown}}
+
+{{#if cond}}true{{else}}false{{/if}}
+
+<b>{{#if cond}}true{{else}}false{{/if}}</b>
+
+* {{#if cond}}true{{else}}false{{/if}}
+
+* <b>{{#if cond}}true{{else}}false{{/if}}</b>
+
+some paragraph to fix showdown's four space parsing below.
+
+    {{#if cond}}true{{else}}false{{/if}}
+
+    <b>{{#if cond}}true{{else}}false{{/if}}</b>
+
+`{{#if cond}}true{{else}}false{{/if}}`
+
+`<b>{{#if cond}}true{{else}}false{{/if}}</b>`
+
+  {{/markdown}}
+</template>
+
+<template name="spacebars_template_test_markdown_each">
+  {{#markdown}}
+
+{{#each seq}}{{.}}{{/each}}
+
+<b>{{#each seq}}{{.}}{{/each}}</b>
+
+* {{#each seq}}{{.}}{{/each}}
+
+* <b>{{#each seq}}{{.}}{{/each}}</b>
+
+some paragraph to fix showdown's four space parsing below.
+
+    {{#each seq}}{{.}}{{/each}}
+
+    <b>{{#each seq}}{{.}}{{/each}}</b>
+
+`{{#each seq}}{{.}}{{/each}}`
+
+`<b>{{#each seq}}{{.}}{{/each}}</b>`
+
+  {{/markdown}}
+</template>
+
+<template name="spacebars_template_test_markdown_inclusion">
+  {{#markdown}}
+{{> spacebars_template_test_markdown_inclusion_subtmpl}}
+  {{/markdown}}
+</template>
+
+<template name="spacebars_template_test_markdown_inclusion_subtmpl">
+  <span>{{#if foo}}Foo is {{foo}}.{{/if}}</span>
+</template>
+
+<template name="spacebars_template_test_markdown_block_helpers">
+  {{#markdown}}
+    {{#spacebars_template_test_just_content}}
+Hi there!
+    {{/spacebars_template_test_just_content}}
+  {{/markdown}}
+</template>
+
+<template name="spacebars_template_test_just_content">
+  {{> UI.contentBlock}}
+</template>
+
+<template name="spacebars_template_test_simple_helpers_are_isolated">
+  {{foo}}
+</template>
+
+<template name="spacebars_template_test_attr_helpers_are_isolated">
+  <p attr={{foo}}></p>
+</template>
+
+<template name="spacebars_template_test_attr_object_helpers_are_isolated">
+  <p {{attrs}}></p>
+</template>
+
+<template name="spacebars_template_test_inclusion_helpers_are_isolated">
+  {{> foo}}
+</template>
+
+<template name="spacebars_template_test_inclusion_helpers_are_isolated_subtemplate">
+</template>
+
+<template name="spacebars_template_test_nully_attributes0">
+  <input type="checkbox" checked="" stuff="">
+</template>
+
+<template name="spacebars_template_test_nully_attributes1">
+  <input type="checkbox" checked={{foo}} stuff={{foo}}>
+</template>
+
+<template name="spacebars_template_test_nully_attributes2">
+  <input type="checkbox" checked={{foo}}{{bar}} stuff={{foo}}{{bar}}>
+</template>
+
+<template name="spacebars_template_test_nully_attributes3">
+  <input type="checkbox" checked={{#if foo}}{{/if}} stuff={{#if foo}}{{/if}}>
+</template>
+
+<template name="spacebars_template_test_double">
+  {{foo}}
+</template>
+
+<template name="spacebars_template_test_inclusion_lookup">
+  {{> spacebars_template_test_inclusion_lookup_subtmpl}}
+  {{> dataContextSubtmpl}}
+</template>
+
+<template name="spacebars_template_test_inclusion_lookup_subtmpl">
+  This is the template.
+</template>
+
+<template name="spacebars_template_test_inclusion_lookup_subtmpl2">
+  This is generated by a helper with the same name.
+</template>
+
+<template name="spacebars_template_test_inclusion_lookup_subtmpl3">
+  This is a template passed in the data context.
+</template>
+
+<template name="spacebars_template_test_content_context">
+  {{#with foo}}
+    {{#with bar}}
+      {{#spacebars_template_test_iftemplate condition=cond}}
+        {{firstLetter}}{{../secondLetter}}
+      {{else}}
+        {{../firstLetter}}{{secondLetter}}
+      {{/spacebars_template_test_iftemplate}}
+    {{/with}}
+  {{/with}}
+</template>
+
+<template name="spacebars_test_control_input">
+  <input type={{type}} value={{value}}>
+</template>
+
+<template name="spacebars_test_control_textarea">
+  <textarea>{{value}}</textarea>
+</template>
+
+<template name="spacebars_test_control_select">
+  <select>
+    {{#each options}}
+      <option selected={{selected}}>{{.}}</option>
+    {{/each}}
+  </select>
+</template>
+
+<template name="spacebars_test_control_radio">
+  Band:
+
+  {{#each bands}}
+    <input name="bands" type="radio" value={{.}} checked={{isChecked}} />
+  {{/each}}
+
+  {{band}}
+</template>
+
+<template name="spacebars_test_control_checkbox">
+  {{#each labels}}
+    <input type="checkbox" value={{.}} checked={{isChecked}} />
+  {{/each}}
+</template>
+
+<template name="spacebars_test_nonexistent_template">
+  {{> this_template_lives_in_outer_space}}
+</template>
+
+<template name="spacebars_test_if_helper">
+  {{#if foo}}
+    true
+  {{else}}
+    false
+  {{/if}}
+</template>
+
+<template name="spacebars_test_block_helper_function">
+  {{#foo}}
+  {{/foo}}
+</template>
+
+<template name="spacebars_test_helpers_stop_onetwo">
+  {{#if showOne}}
+    {{> one}}
+  {{else}}
+    {{> two}}
+  {{/if}}
+</template>
+
+<template name="spacebars_test_helpers_stop_onetwo_attribute">
+  <br data-stuff=
+  {{#if showOne}}
+    {{> one}}
+  {{else}}
+    {{> two}}
+  {{/if}}>
+</template>
+
+<template name="spacebars_test_helpers_stop_with1">
+  {{#with options}}
+    one
+  {{/with}}
+</template>
+
+<template name="spacebars_test_helpers_stop_with2">
+  {{#with options}}
+    two
+  {{/with}}
+</template>
+
+<template name="spacebars_test_helpers_stop_each1">
+  {{#each options}}
+    one
+  {{/each}}
+</template>
+
+<template name="spacebars_test_helpers_stop_each2">
+  {{#each options}}
+    two
+  {{/each}}
+</template>
+
+<template name="spacebars_test_helpers_stop_with_each1">
+  {{#with options}}
+    {{> spacebars_test_helpers_stop_with_each3}}
+  {{/with}}
+</template>
+
+<template name="spacebars_test_helpers_stop_with_each2">
+  {{#with options}}
+    {{> spacebars_test_helpers_stop_with_each3}}
+  {{/with}}
+</template>
+
+<template name="spacebars_test_helpers_stop_with_each3">
+  {{#each this}}
+  {{/each}}
+</template>
+
+<template name="spacebars_test_helpers_stop_if1">
+  {{#if options}}
+    one
+  {{/if}}
+</template>
+
+<template name="spacebars_test_helpers_stop_if2">
+  {{#if options}}
+    two
+  {{/if}}
+</template>
+
+<template name="spacebars_test_helpers_stop_inclusion1">
+  {{> options}}
+</template>
+
+<template name="spacebars_test_helpers_stop_inclusion2">
+  {{> options}}
+</template>
+
+<template name="spacebars_test_helpers_stop_inclusion3">
+  blah
+</template>
+
+<template name="spacebars_test_helpers_stop_with_callbacks1">
+  {{#with options}}
+    {{> spacebars_test_helpers_stop_with_callbacks3}}
+  {{/with}}
+</template>
+
+<template name="spacebars_test_helpers_stop_with_callbacks2">
+  {{#with options}}
+    {{> spacebars_test_helpers_stop_with_callbacks3}}
+  {{/with}}
+</template>
+
+<template name="spacebars_test_helpers_stop_with_callbacks3">
+  blah
+</template>
+
+<template name="spacebars_test_helpers_stop_unless1">
+  {{#unless options}}
+    one
+  {{/unless}}
+</template>
+
+<template name="spacebars_test_helpers_stop_unless2">
+  {{#unless options}}
+    two
+  {{/unless}}
+</template>
+
+<template name="spacebars_test_no_data_context">
+  <button></button>
+  {{foo}}
+</template>
+
+<template name="spacebars_test_falsy_with">
+  {{#with obj}}
+    {{greekLetter}}
+  {{/with}}
+</template>
+
+<template name="spacebars_test_helpers_dont_leak">
+  {{> spacebars_test_helpers_dont_leak2 foo="correct"}}
+</template>
+
+<template name="spacebars_test_helpers_dont_leak2">
+  {{foo}}{{bar}} {{#spacebars_template_test_content}}{{bonus}}{{/spacebars_template_test_content}}
+</template>
+
+<template name="spacebars_test_event_returns_false">
+  <a href="#bad-url" id="spacebars_test_event_returns_false_link">click me</a>
+</template>
+
+<template name="spacebars_test_tables1">
+  <table><tr><td>Foo</td></tr></table>
+</template>
+
+<template name="spacebars_test_tables2">
+  <table><tr><td>{{foo}}</td></tr></table>
+</template>
+
+<template name="spacebars_test_jquery_events">
+  <button type="button">button</button>
+</template>
+
+<template name="spacebars_test_tohtml_basic">
+  {{foo}}
+</template>
+
+<template name="spacebars_test_tohtml_if">
+  {{#if true}}
+    {{foo}}
+  {{/if}}
+</template>
+
+<template name="spacebars_test_tohtml_with">
+  {{#with foo}}
+    {{.}}
+  {{/with}}
+</template>
+
+<template name="spacebars_test_tohtml_each">
+  {{#each foos}}
+    {{.}}
+  {{/each}}
+</template>
+
+<template name="spacebars_test_tohtml_include_with">
+  {{> spacebars_test_tohtml_with}}
+</template>
+
+<template name="spacebars_test_tohtml_include_each">
+  {{> spacebars_test_tohtml_each}}
+</template>
+
+<template name="spacebars_test_block_comment">
+  {{!-- foo --}}
+  {{!--
+    {{bar}}
+  --}}
+</template>
+
+<template name="spacebars_test_with_mutated_data_context">
+  {{#with foo}}
+    {{value}}
+  {{/with}}
+</template>
+
+<template name="spacebars_test_url_attribute">
+  <a href="{{foo}}"></a>
+  <a hReF="{{foo}}"></a>
+  <form action="{{foo}}"></form>
+  <img src="{{foo}}" />
+  <input value="{{foo}}" />
+</template>
diff --git a/packages/spacebars-tests/template_tests.js b/packages/spacebars-tests/template_tests.js
new file mode 100644
index 0000000000..5163676d24
--- /dev/null
+++ b/packages/spacebars-tests/template_tests.js
@@ -0,0 +1,1996 @@
+var renderToDiv = function (comp) {
+  var div = document.createElement("DIV");
+  UI.materialize(comp, div);
+  return div;
+};
+
+var divRendersTo = function (test, div, html) {
+  Deps.flush({_throwFirstError: true});
+  var actual = canonicalizeHtml(div.innerHTML);
+  test.equal(actual, html);
+};
+
+var nodesToArray = function (array) {
+  // Starting in underscore 1.4, _.toArray does not work right on a node
+  // list in IE8. This is a workaround to support IE8.
+  return _.map(array, _.identity);
+};
+
+var clickIt = function (elem) {
+  // jQuery's bubbling change event polyfill for IE 8 seems
+  // to require that the element in question have focus when
+  // it receives a simulated click.
+  if (elem.focus)
+    elem.focus();
+  clickElement(elem);
+};
+
+Tinytest.add("spacebars - templates - simple helper", function (test) {
+  var tmpl = Template.spacebars_template_test_simple_helper;
+  var R = ReactiveVar(1);
+  tmpl.foo = function (x) {
+    return x + R.get();
+  };
+  tmpl.bar = function () {
+    return 123;
+  };
+  var div = renderToDiv(tmpl);
+
+  test.equal(canonicalizeHtml(div.innerHTML), "124");
+  R.set(2);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "125");
+
+  // Test that `{{foo bar}}` throws if `foo` is missing or not a function.
+  tmpl.foo = 3;
+  test.throws(function () {
+    renderToDiv(tmpl);
+  });
+
+  delete tmpl.foo;
+  // We'd like this to throw, but it doesn't because of how self.lookup
+  // works.  D'oh.  Fix this as part of "new this".
+  //test.throws(function () {
+    renderToDiv(tmpl);
+  //});
+
+  tmpl.foo = function () {};
+  // doesn't throw
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), '');
+});
+
+Tinytest.add("spacebars - templates - dynamic template", function (test) {
+  var tmpl = Template.spacebars_template_test_dynamic_template;
+  var aaa = Template.spacebars_template_test_aaa;
+  var bbb = Template.spacebars_template_test_bbb;
+  var R = ReactiveVar("aaa");
+  tmpl.foo = function () {
+    return R.get() === 'aaa' ? aaa : bbb;
+  };
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), "aaa");
+
+  R.set('bbb');
+  Deps.flush();
+
+  test.equal(canonicalizeHtml(div.innerHTML), "bbb");
+});
+
+Tinytest.add("spacebars - templates - interpolate attribute", function (test) {
+  var tmpl = Template.spacebars_template_test_interpolate_attribute;
+  tmpl.foo = function (x) {
+    return x+1;
+  };
+  tmpl.bar = function () {
+    return 123;
+  };
+  var div = renderToDiv(tmpl);
+
+  test.equal($(div).find('div')[0].className, "aaa124zzz");
+});
+
+Tinytest.add("spacebars - templates - dynamic attrs", function (test) {
+  var tmpl = Template.spacebars_template_test_dynamic_attrs;
+
+  var R2 = ReactiveVar({x: "X"});
+  var R3 = ReactiveVar('selected');
+  tmpl.attrsObj = function () { return R2.get(); };
+  tmpl.singleAttr = function () { return R3.get(); };
+
+  var div = renderToDiv(tmpl);
+  var span = $(div).find('span')[0];
+  test.equal(span.innerHTML, 'hi');
+  test.isTrue(span.hasAttribute('selected'));
+  test.equal(span.getAttribute('x'), 'X');
+
+  R2.set({y: "Y", z: "Z"});
+  R3.set('');
+  Deps.flush();
+  test.equal(canonicalizeHtml(span.innerHTML), 'hi');
+  test.isFalse(span.hasAttribute('selected'));
+  test.isFalse(span.hasAttribute('x'));
+  test.equal(span.getAttribute('y'), 'Y');
+  test.equal(span.getAttribute('z'), 'Z');
+});
+
+Tinytest.add("spacebars - templates - triple", function (test) {
+  var tmpl = Template.spacebars_template_test_triple;
+
+  var R = ReactiveVar('<span class="hi">blah</span>');
+  tmpl.html = function () { return R.get(); };
+
+  var div = renderToDiv(tmpl);
+  var elems = $(div).find("> *");
+  test.equal(elems.length, 1);
+  test.equal(elems[0].nodeName, 'SPAN');
+  var span = elems[0];
+  test.equal(span.className, 'hi');
+  test.equal(span.innerHTML, 'blah');
+
+  R.set('asdf');
+  Deps.flush();
+  elems = $(div).find("> *");
+  test.equal(elems.length, 0);
+  test.equal(canonicalizeHtml(div.innerHTML), 'asdf');
+
+  R.set('<span class="hi">blah</span>');
+  Deps.flush();
+  elems = $(div).find("> *");
+  test.equal(elems.length, 1);
+  test.equal(elems[0].nodeName, 'SPAN');
+  span = elems[0];
+  test.equal(span.className, 'hi');
+  test.equal(canonicalizeHtml(span.innerHTML), 'blah');
+
+  var tmpl = Template.spacebars_template_test_triple2;
+  tmpl.html = function () {};
+  tmpl.html2 = function () { return null; };
+  // no tmpl.html3
+  div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), 'xy');
+});
+
+Tinytest.add("spacebars - templates - inclusion args", function (test) {
+  var tmpl = Template.spacebars_template_test_inclusion_args;
+
+  var R = ReactiveVar(Template.spacebars_template_test_aaa);
+  tmpl.foo = function () { return R.get(); };
+
+  var div = renderToDiv(tmpl);
+  // `{{> foo bar}}`, with `foo` resolving to Template.aaa,
+  // which consists of "aaa"
+  test.equal(canonicalizeHtml(div.innerHTML), 'aaa');
+  R.set(Template.spacebars_template_test_bbb);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), 'bbb');
+
+  ////// Ok, now `foo` *is* Template.aaa
+  tmpl.foo = Template.spacebars_template_test_aaa;
+  div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), 'aaa');
+
+  ////// Ok, now `foo` is a template that takes an argument; bar is a string.
+  tmpl.foo = Template.spacebars_template_test_bracketed_this;
+  tmpl.bar = 'david';
+  div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), '[david]');
+
+  ////// Now `foo` is a template that takes an arg; bar is a function.
+  tmpl.foo = Template.spacebars_template_test_span_this;
+  R = ReactiveVar('david');
+  tmpl.bar = function () { return R.get(); };
+  div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), '<span>david</span>');
+  var span1 = div.querySelector('span');
+  R.set('avi');
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), '<span>avi</span>');
+  var span2 = div.querySelector('span');
+  test.isTrue(span1 === span2);
+});
+
+Tinytest.add("spacebars - templates - inclusion args 2", function (test) {
+  // `{{> foo bar q=baz}}`
+  var tmpl = Template.spacebars_template_test_inclusion_args2;
+
+  tmpl.foo = Template.spacebars_template_test_span_this;
+  tmpl.bar = function (options) {
+    return options.hash.q;
+  };
+
+  var R = ReactiveVar('david!');
+  tmpl.baz = function () { return R.get().slice(0,5); };
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), '<span>david</span>');
+  var span1 = div.querySelector('span');
+  R.set('brillo');
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), '<span>brill</span>');
+  var span2 = div.querySelector('span');
+  test.isTrue(span1 === span2);
+});
+
+Tinytest.add("spacebars - templates - inclusion dotted args", function (test) {
+  // `{{> foo bar.baz}}`
+  var tmpl = Template.spacebars_template_test_inclusion_dotted_args;
+
+  var initCount = 0;
+  tmpl.foo = Template.spacebars_template_test_bracketed_this.extend({
+    init: function () { initCount++; }
+  });
+  var R = ReactiveVar('david');
+  tmpl.bar = function () {
+    // make sure `this` is bound correctly
+    return { baz: this.symbol + R.get() };
+  };
+
+  var div = renderToDiv(tmpl.extend({data: {symbol:'%'}}));
+  test.equal(initCount, 1);
+  test.equal(canonicalizeHtml(div.innerHTML), '[%david]');
+
+  R.set('avi');
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), '[%avi]');
+  // check that invalidating the argument to `foo` doesn't require
+  // creating a new `foo`.
+  test.equal(initCount, 1);
+});
+
+Tinytest.add("spacebars - templates - inclusion slashed args", function (test) {
+  // `{{> foo bar/baz}}`
+  var tmpl = Template.spacebars_template_test_inclusion_dotted_args;
+
+  var initCount = 0;
+  tmpl.foo = Template.spacebars_template_test_bracketed_this.extend({
+    init: function () { initCount++; }
+  });
+  var R = ReactiveVar('david');
+  tmpl.bar = function () {
+    // make sure `this` is bound correctly
+    return { baz: this.symbol + R.get() };
+  };
+
+  var div = renderToDiv(tmpl.extend({data: {symbol:'%'}}));
+  test.equal(initCount, 1);
+  test.equal(canonicalizeHtml(div.innerHTML), '[%david]');
+});
+
+Tinytest.add("spacebars - templates - block helper", function (test) {
+  // test the case where `foo` is a calculated template that changes
+  // reactively.
+  // `{{#foo}}bar{{else}}baz{{/foo}}`
+  var tmpl = Template.spacebars_template_test_block_helper;
+  var R = ReactiveVar(Template.spacebars_template_test_content);
+  tmpl.foo = function () {
+    return R.get();
+  };
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), "bar");
+
+  R.set(Template.spacebars_template_test_elsecontent);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "baz");
+});
+
+Tinytest.add("spacebars - templates - block helper function with one string arg", function (test) {
+  // `{{#foo "bar"}}content{{/foo}}`
+  var tmpl = Template.spacebars_template_test_block_helper_function_one_string_arg;
+  tmpl.foo = function () {
+    if (String(this) === "bar")
+      return Template.spacebars_template_test_content;
+    else
+      return null;
+  };
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), "content");
+});
+
+Tinytest.add("spacebars - templates - block helper function with one helper arg", function (test) {
+  var tmpl = Template.spacebars_template_test_block_helper_function_one_helper_arg;
+  var R = ReactiveVar("bar");
+  tmpl.bar = function () { return R.get(); };
+  tmpl.foo = function () {
+    if (String(this) === "bar")
+      return Template.spacebars_template_test_content;
+    else
+      return null;
+  };
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), "content");
+
+  R.set("baz");
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "");
+});
+
+Tinytest.add("spacebars - templates - block helper component with one helper arg", function (test) {
+  var tmpl = Template.spacebars_template_test_block_helper_component_one_helper_arg;
+  var R = ReactiveVar(true);
+  tmpl.bar = function () { return R.get(); };
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), "content");
+
+  R.set(false);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "");
+});
+
+Tinytest.add("spacebars - templates - block helper component with three helper args", function (test) {
+  var tmpl = Template.spacebars_template_test_block_helper_component_three_helper_args;
+  var R = ReactiveVar("bar");
+  tmpl.bar_or_baz = function () {
+    return R.get();
+  };
+  tmpl.equals = function (x, y) {
+    return x === y;
+  };
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), "content");
+
+  R.set("baz");
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "");
+});
+
+Tinytest.add("spacebars - templates - block helper with dotted arg", function (test) {
+  var tmpl = Template.spacebars_template_test_block_helper_dotted_arg;
+  var R1 = ReactiveVar(1);
+  var R2 = ReactiveVar(10);
+  var R3 = ReactiveVar(100);
+
+  var initCount = 0;
+  tmpl.foo = Template.spacebars_template_test_bracketed_this.extend({
+    init: function () { initCount++; }
+  });
+  tmpl.bar = function () {
+    return {
+      r1: R1.get(),
+      baz: function (r3) {
+        return this.r1 + R2.get() + r3;
+      }
+    };
+  };
+  tmpl.qux = function () { return R3.get(); };
+
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), "[111]");
+  test.equal(initCount, 1);
+
+  R1.set(2);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "[112]");
+  test.equal(initCount, 1);
+
+  R2.set(20);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "[122]");
+  test.equal(initCount, 1);
+
+  R3.set(200);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "[222]");
+  test.equal(initCount, 1);
+
+  R2.set(30);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "[232]");
+  test.equal(initCount, 1);
+
+  R1.set(3);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "[233]");
+  test.equal(initCount, 1);
+
+  R3.set(300);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), "[333]");
+  test.equal(initCount, 1);
+});
+
+Tinytest.add("spacebars - templates - nested content", function (test) {
+  // Test that `{{> UI.contentBlock}}` in an `{{#if}}` works.
+
+  // ```
+  // <template name="spacebars_template_test_iftemplate">
+  //   {{#if condition}}
+  //     {{> UI.contentBlock}}
+  //   {{else}}
+  //     {{> UI.elseBlock}}
+  //   {{/if}}
+  // </template>
+  // ```
+
+  // ```
+  //  {{#spacebars_template_test_iftemplate flag}}
+  //    hello
+  //  {{else}}
+  //    world
+  //  {{/spacebars_template_test_iftemplate}}
+  // ```
+
+  var tmpl = Template.spacebars_template_test_nested_content;
+  var R = ReactiveVar(true);
+  tmpl.flag = function () {
+    return R.get();
+  };
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), 'hello');
+  R.set(false);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), 'world');
+  R.set(true);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), 'hello');
+
+  // Also test that `{{> UI.contentBlock}}` in a custom block helper works.
+  tmpl = Template.spacebars_template_test_nested_content2;
+  R = ReactiveVar(true);
+  tmpl.x = function () {
+    return R.get();
+  };
+  div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), 'hello');
+  R.set(false);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), 'world');
+  R.set(true);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), 'hello');
+});
+
+Tinytest.add("spacebars - template - if", function (test) {
+  var tmpl = Template.spacebars_template_test_if;
+  var R = ReactiveVar(true);
+  tmpl.foo = function () {
+    return R.get();
+  };
+  tmpl.bar = 1;
+  tmpl.baz = 2;
+
+  var div = renderToDiv(tmpl);
+  var rendersTo = function (html) { divRendersTo(test, div, html); };
+
+  rendersTo("1");
+  R.set(false);
+  rendersTo("2");
+});
+
+Tinytest.add("spacebars - template - if in with", function (test) {
+  var tmpl = Template.spacebars_template_test_if_in_with;
+  tmpl.foo = {bar: "bar"};
+
+  var div = renderToDiv(tmpl);
+  divRendersTo(test, div, "bar bar");
+});
+
+Tinytest.add("spacebars - templates - each on cursor", function (test) {
+  var tmpl = Template.spacebars_template_test_each;
+  var coll = new Meteor.Collection(null);
+  tmpl.items = function () {
+    return coll.find({}, {sort: {pos: 1}});
+  };
+
+  var div = renderToDiv(tmpl);
+  var rendersTo = function (html) { divRendersTo(test, div, html); };
+
+  rendersTo("else-clause");
+  coll.insert({text: "one", pos: 1});
+  rendersTo("one");
+  coll.insert({text: "two", pos: 2});
+  rendersTo("one two");
+  coll.update({text: "two"}, {$set: {text: "three"}});
+  rendersTo("one three");
+  coll.update({text: "three"}, {$set: {pos: 0}});
+  rendersTo("three one");
+  coll.remove({});
+  rendersTo("else-clause");
+});
+
+Tinytest.add("spacebars - templates - each on array", function (test) {
+  var tmpl = Template.spacebars_template_test_each;
+  var R = new ReactiveVar([]);
+  tmpl.items = function () {
+    return R.get();
+  };
+  tmpl.text = function () {
+    return this;
+  };
+
+  var div = renderToDiv(tmpl);
+  var rendersTo = function (html) { divRendersTo(test, div, html); };
+
+  rendersTo("else-clause");
+  R.set([""]);
+  rendersTo("");
+  R.set(["x", "", "toString"]);
+  rendersTo("x toString");
+  R.set(["toString"]);
+  rendersTo("toString");
+  R.set([]);
+  rendersTo("else-clause");
+  R.set([0, 1, 2]);
+  rendersTo("0 1 2");
+  R.set([]);
+  rendersTo("else-clause");
+});
+
+Tinytest.add("spacebars - templates - ..", function (test) {
+  var tmpl = Template.spacebars_template_test_dots;
+  Template.spacebars_template_test_dots_subtemplate.getTitle = function (from) {
+    return from.title;
+  };
+
+  tmpl.foo = {title: "foo"};
+  tmpl.foo.bar = {title: "bar"};
+  tmpl.foo.bar.items = [{title: "item"}];
+  var div = renderToDiv(tmpl);
+
+  test.equal(canonicalizeHtml(div.innerHTML), [
+    "A", "B", "C", "D",
+    // {{> spacebars_template_test_dots_subtemplate}}
+    "TITLE", "1item", "2item", "3bar", "4foo", "GETTITLE", "5item", "6bar", "7foo",
+    // {{> spacebars_template_test_dots_subtemplate ..}}
+    "TITLE", "1bar", "2bar", "3item", "4bar", "GETTITLE", "5bar", "6item", "7bar"].join(" "));
+});
+
+Tinytest.add("spacebars - templates - select tags", function (test) {
+  var tmpl = Template.spacebars_template_test_select_tag;
+
+  // {label: (string)}
+  var optgroups = new Meteor.Collection(null);
+
+  // {optgroup: (id), value: (string), selected: (boolean), label: (string)}
+  var options = new Meteor.Collection(null);
+
+  tmpl.optgroups = function () { return optgroups.find(); };
+  tmpl.options = function () { return options.find({optgroup: this._id}); };
+  tmpl.selectedAttr = function () { return this.selected ? {selected: true} : {}; };
+
+  var div = renderToDiv(tmpl);
+  var selectEl = $(div).find('select')[0];
+
+  // returns canonicalized contents of `div` in the form eg
+  // ["<select>", "</select>"]. strip out selected attributes -- we
+  // verify correctness by observing the `selected` property
+  var divContent = function () {
+    return canonicalizeHtml(
+      div.innerHTML.replace(/selected="[^"]*"/g, '').replace(/selected/g, ''))
+          .replace(/\>\s*\</g, '>\n<')
+          .split('\n');
+  };
+
+  test.equal(divContent(), ["<select>", "</select>"]);
+
+  var optgroup1 = optgroups.insert({label: "one"});
+  var optgroup2 = optgroups.insert({label: "two"});
+  test.equal(divContent(), [
+    '<select>',
+    '<optgroup label="one">',
+    '</optgroup>',
+    '<optgroup label="two">',
+    '</optgroup>',
+    '</select>'
+  ]);
+
+  options.insert({optgroup: optgroup1, value: "value1", selected: false, label: "label1"});
+  options.insert({optgroup: optgroup1, value: "value2", selected: true, label: "label2"});
+  test.equal(divContent(), [
+    '<select>',
+    '<optgroup label="one">',
+    '<option value="value1">label1</option>',
+    '<option value="value2">label2</option>',
+    '</optgroup>',
+    '<optgroup label="two">',
+    '</optgroup>',
+    '</select>'
+  ]);
+  test.equal(selectEl.value, "value2");
+  test.equal($(selectEl).find('option')[0].selected, false);
+  test.equal($(selectEl).find('option')[1].selected, true);
+
+  // swap selection
+  options.update({value: "value1"}, {$set: {selected: true}});
+  options.update({value: "value2"}, {$set: {selected: false}});
+  Deps.flush();
+
+  test.equal(divContent(), [
+    '<select>',
+    '<optgroup label="one">',
+    '<option value="value1">label1</option>',
+    '<option value="value2">label2</option>',
+    '</optgroup>',
+    '<optgroup label="two">',
+    '</optgroup>',
+    '</select>'
+  ]);
+  test.equal(selectEl.value, "value1");
+  test.equal($(selectEl).find('option')[0].selected, true);
+  test.equal($(selectEl).find('option')[1].selected, false);
+
+  // change value and label
+  options.update({value: "value1"}, {$set: {value: "value1.0"}});
+  options.update({value: "value2"}, {$set: {label: "label2.0"}});
+  Deps.flush();
+
+  test.equal(divContent(), [
+    '<select>',
+    '<optgroup label="one">',
+    '<option value="value1.0">label1</option>',
+    '<option value="value2">label2.0</option>',
+    '</optgroup>',
+    '<optgroup label="two">',
+    '</optgroup>',
+    '</select>'
+  ]);
+  test.equal(selectEl.value, "value1.0");
+  test.equal($(selectEl).find('option')[0].selected, true);
+  test.equal($(selectEl).find('option')[1].selected, false);
+
+  // unselect and then select both options. normally, the second is
+  // selected (since it got selected later). then switch to <select
+  // multiple="">. both should be selected.
+  options.update({}, {$set: {selected: false}}, {multi: true});
+  Deps.flush();
+  options.update({}, {$set: {selected: true}}, {multi: true});
+  Deps.flush();
+  test.equal($(selectEl).find('option')[0].selected, false);
+  test.equal($(selectEl).find('option')[1].selected, true);
+
+  selectEl.multiple = true; // allow multiple selection
+  options.update({}, {$set: {selected: false}}, {multi: true});
+  Deps.flush();
+  options.update({}, {$set: {selected: true}}, {multi: true});
+  window.avital = true;
+  Deps.flush();
+  test.equal($(selectEl).find('option')[0].selected, true);
+  test.equal($(selectEl).find('option')[1].selected, true);
+});
+
+Tinytest.add('spacebars - templates - {{#with}} falsy; issue #770', function (test) {
+  Template.test_template_issue770.value1 = function () { return "abc"; };
+  Template.test_template_issue770.value2 = function () { return false; };
+  var div = renderToDiv(Template.test_template_issue770);
+  test.equal(canonicalizeHtml(div.innerHTML),
+             "abc xxx abc");
+});
+
+Tinytest.add("spacebars - templates - tricky attrs", function (test) {
+  var tmpl = Template.spacebars_template_test_tricky_attrs;
+  tmpl.theType = function () { return 'text'; };
+  var R = ReactiveVar('foo');
+  tmpl.theClass = function () { return R.get(); };
+
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML).slice(0, 30),
+             '<input type="text"><input class="foo" type="checkbox">'.slice(0, 30));
+
+  R.set('bar');
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML),
+             '<input type="text"><input class="bar" type="checkbox">');
+
+});
+
+Tinytest.add('spacebars - templates - no data context', function (test) {
+  var tmpl = Template.spacebars_template_test_no_data;
+
+  // failure is if an exception is thrown here
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), 'asdf');
+});
+
+// test that #isolate is a no-op, for back compat
+Tinytest.add('spacebars - templates - isolate', function (test) {
+  var tmpl = Template.spacebars_template_test_isolate;
+
+  Meteor._suppress_log(1); // we print a deprecation notice
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), 'hello');
+
+});
+
+// test that #constant is a no-op, for back compat
+Tinytest.add('spacebars - templates - constant', function (test) {
+  var tmpl = Template.spacebars_template_test_constant;
+
+  Meteor._suppress_log(1); // we print a deprecation notice
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), 'hello');
+
+});
+
+Tinytest.add('spacebars - templates - textarea', function (test) {
+  var tmpl = Template.spacebars_template_test_textarea;
+
+  var R = ReactiveVar('hello');
+
+  tmpl.foo = function () {
+    return R.get();
+  };
+
+  var div = renderToDiv(tmpl);
+  var textarea = div.querySelector('textarea');
+  test.equal(textarea.value, 'hello');
+
+  R.set('world');
+  Deps.flush();
+  test.equal(textarea.value, 'world');
+
+});
+
+Tinytest.add('spacebars - templates - textarea 2', function (test) {
+  var tmpl = Template.spacebars_template_test_textarea2;
+
+  var R = ReactiveVar(true);
+
+  tmpl.foo = function () {
+    return R.get();
+  };
+
+  var div = renderToDiv(tmpl);
+  var textarea = div.querySelector('textarea');
+  test.equal(textarea.value, '</not a tag>');
+
+  R.set(false);
+  Deps.flush();
+  test.equal(textarea.value, '<also not a tag>');
+
+  R.set(true);
+  Deps.flush();
+  test.equal(textarea.value, '</not a tag>');
+
+});
+
+Tinytest.add('spacebars - templates - textarea each', function (test) {
+  var tmpl = Template.spacebars_template_test_textarea_each;
+
+  var R = ReactiveVar(['APPLE', 'BANANA']);
+
+  tmpl.foo = function () {
+    return R.get();
+  };
+
+  var div = renderToDiv(tmpl);
+  var textarea = div.querySelector('textarea');
+  test.equal(textarea.value, '<not a tag APPLE <not a tag BANANA ');
+
+  R.set([]);
+  Deps.flush();
+  test.equal(textarea.value, '<>');
+
+  R.set(['CUCUMBER']);
+  Deps.flush();
+  test.equal(textarea.value, '<not a tag CUCUMBER ');
+
+});
+
+// Ensure that one can call `Meteor.defer` within a rendered callback
+// triggered by a document insertion that happend in a method stub.
+testAsyncMulti('spacebars - template - defer in rendered callbacks', [function (test, expect) {
+  var tmpl = Template.spacebars_template_test_defer_in_rendered;
+  var coll = new Meteor.Collection("test-defer-in-rendered--client-only");
+  tmpl.items = function () {
+    return coll.find();
+  };
+
+  var subtmpl = Template.spacebars_template_test_defer_in_rendered_subtemplate;
+  subtmpl.rendered = expect(function () {
+    // will throw if called in a method stub
+    Meteor.defer(function () {
+    });
+  });
+
+  var div = renderToDiv(tmpl);
+
+  // `coll` is not defined on the server so we'll get an error.  We
+  // can't make this a client-only collection since then we won't be
+  // running in a stub and the error won't fire.
+  Meteor._suppress_log(1);
+  // cause a new instance of `subtmpl` to be placed in the DOM. verify
+  // that it's not fired directly within a method stub, in which
+  // `Meteor.defer` is not allowed.
+  coll.insert({});
+}]);
+
+testAsyncMulti('spacebars - template - rendered template is DOM in rendered callbacks', [
+  function (test, expect) {
+    var tmpl = Template.spacebars_template_test_aaa;
+    tmpl.rendered = expect(function () {
+      test.equal(canonicalizeHtml(div.innerHTML), "aaa");
+    });
+    var div = renderToDiv(tmpl);
+    Deps.flush();
+  }
+]);
+
+// Test that in:
+//
+// ```
+// {{#with someData}}
+//   {{foo}} {{bar}}
+// {{/with}}
+// ```
+//
+// ... we run `someData` once even if `foo` re-renders.
+Tinytest.add('spacebars - templates - with someData', function (test) {
+  var tmpl = Template.spacebars_template_test_with_someData;
+
+  var foo = ReactiveVar('AAA');
+  var someDataRuns = 0;
+
+  tmpl.someData = function () {
+    someDataRuns++;
+    return {};
+  };
+  tmpl.foo = function () {
+    return foo.get();
+  };
+  tmpl.bar = function () {
+    return 'YO';
+  };
+
+  var div = renderToDiv(tmpl);
+
+  test.equal(someDataRuns, 1);
+  test.equal(canonicalizeHtml(div.innerHTML), 'AAA YO');
+
+  foo.set('BBB');
+  Deps.flush();
+  test.equal(someDataRuns, 1);
+  test.equal(canonicalizeHtml(div.innerHTML), 'BBB YO');
+
+  foo.set('CCC');
+  Deps.flush();
+  test.equal(someDataRuns, 1);
+  test.equal(canonicalizeHtml(div.innerHTML), 'CCC YO');
+});
+
+Tinytest.add('spacebars - template - #each stops when rendered element is removed', function (test) {
+  var tmpl = Template.spacebars_template_test_each_stops;
+  var coll = new Meteor.Collection(null);
+  coll.insert({});
+  tmpl.items = function () { return coll.find(); };
+
+  var div = renderToDiv(tmpl);
+  divRendersTo(test, div, 'x');
+
+  // trigger #each component destroyed
+  $(div).remove();
+
+  // insert another document. cursor should no longer be observed so
+  // should have no effect.
+  coll.insert({});
+  divRendersTo(test, div, 'x');
+});
+
+Tinytest.add('spacebars - templates - block helpers in attribute', function (test) {
+  var tmpl = Template.spacebars_template_test_block_helpers_in_attribute;
+
+  var coll = new Meteor.Collection(null);
+  tmpl.classes = function () {
+    return coll.find({}, {sort: {name: 1}});
+  };
+  tmpl.startsLowerCase = function (name) {
+    return /^[a-z]/.test(name);
+  };
+  coll.insert({name: 'David'});
+  coll.insert({name: 'noodle'});
+  coll.insert({name: 'donut'});
+  coll.insert({name: 'frankfurter'});
+  coll.insert({name: 'Steve'});
+
+  var containerDiv = renderToDiv(tmpl);
+  var div = containerDiv.querySelector('div');
+
+  var shouldBe = function (className) {
+    Deps.flush();
+    test.equal(div.innerHTML, "Hello");
+    test.equal(div.className, className);
+    var result = canonicalizeHtml(containerDiv.innerHTML);
+    if (result === '<div>Hello</div>')
+      result = '<div class="">Hello</div>'; // e.g. IE 9 and 10
+    test.equal(result, '<div class="' + className + '">Hello</div>');
+  };
+
+  shouldBe('donut frankfurter noodle');
+  coll.remove({name: 'frankfurter'}); // (it was kind of a mouthful)
+  shouldBe('donut noodle');
+  coll.remove({name: 'donut'});
+  shouldBe('noodle');
+  coll.remove({name: 'noodle'});
+  shouldBe(''); // 'David' and 'Steve' appear in the #each but fail the #if
+  coll.remove({});
+  shouldBe('none'); // now the `{{else}}` case kicks in
+  coll.insert({name: 'bubblegum'});
+  shouldBe('bubblegum');
+});
+
+Tinytest.add('spacebars - templates - block helpers in attribute 2', function (test) {
+  var tmpl = Template.spacebars_template_test_block_helpers_in_attribute_2;
+
+  var R = ReactiveVar(true);
+
+  tmpl.foo = function () { return R.get(); };
+
+  var div = renderToDiv(tmpl);
+  var input = div.querySelector('input');
+
+  test.equal(input.value, '"');
+  R.set(false);
+  Deps.flush();
+  test.equal(input.value, '&<></x>');
+});
+
+
+// Test that if the argument to #each is a constant, it doesn't establish a
+// dependency on the data context, so when the context changes, items of
+// the #each are not "changed" and helpers do not rerun.
+Tinytest.add('spacebars - templates - constant #each argument', function (test) {
+  var tmpl = Template.spacebars_template_test_constant_each_argument;
+
+  var justReturnRuns = 0; // how many times `justReturn` is called
+  var R = ReactiveVar(1);
+
+  tmpl.someData = function () {
+    return R.get();
+  };
+  tmpl.anArray = ['foo', 'bar'];
+  tmpl.justReturn = function (x) {
+    justReturnRuns++;
+    return String(x);
+  };
+
+  var div = renderToDiv(tmpl);
+
+  test.equal(justReturnRuns, 2);
+  test.equal(canonicalizeHtml(div.innerHTML).replace(/\s+/g, ' '),
+             'foo bar 1');
+
+  R.set(2);
+  Deps.flush();
+
+  test.equal(justReturnRuns, 2); // still 2, no new runs!
+  test.equal(canonicalizeHtml(div.innerHTML).replace(/\s+/g, ' '),
+             'foo bar 2');
+});
+
+// extract a multi-line string from a comment within a function.
+// @param f {Function} eg function () { /* [[[...content...]]] */ }
+// @returns {String} eg "content"
+var textFromFunction = function(f) {
+  var str = f.toString().match(/\[\[\[([\S\s]*)\]\]\]/m)[1];
+  // remove line number comments added by linker
+  str = str.replace(/[ ]*\/\/ \d+$/gm, '');
+  return str;
+};
+
+Tinytest.add('spacebars - templates - #markdown - basic', function (test) {
+  var tmpl = Template.spacebars_template_test_markdown_basic;
+  tmpl.obj = {snippet: "<i>hi</i>"};
+  tmpl.hi = function () {
+    return this.snippet;
+  };
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), canonicalizeHtml(textFromFunction(function () { /*
+[[[<p><i>hi</i>
+/each}}</p>
+
+<p><b><i>hi</i></b>
+<b>/each}}</b></p>
+
+<ul>
+<li><i>hi</i></li>
+<li><p>/each}}</p></li>
+<li><p><b><i>hi</i></b></p></li>
+<li><b>/each}}</b></li>
+</ul>
+
+<p>some paragraph to fix showdown's four space parsing below.</p>
+
+<pre><code>&lt;i&gt;hi&lt;/i&gt;
+/each}}
+
+&lt;b&gt;&lt;i&gt;hi&lt;/i&gt;&lt;/b&gt;
+&lt;b&gt;/each}}&lt;/b&gt;
+</code></pre>
+
+<p>&amp;gt</p>
+
+<ul>
+<li>&amp;gt</li>
+</ul>
+
+<p><code>&amp;gt</code></p>
+
+<pre><code>&amp;gt
+</code></pre>
+
+<p>&gt;</p>
+
+<ul>
+<li>&gt;</li>
+</ul>
+
+<p><code>&amp;gt;</code></p>
+
+<pre><code>&amp;gt;
+</code></pre>
+
+<p><code>&lt;i&gt;hi&lt;/i&gt;</code>
+<code>/each}}</code></p>
+
+<p><code>&lt;b&gt;&lt;i&gt;hi&lt;/i&gt;&lt;/b&gt;</code>
+<code>&lt;b&gt;/each}}</code></p>]]] */
+  })));
+});
+
+Tinytest.add('spacebars - templates - #markdown - if', function (test) {
+  var tmpl = Template.spacebars_template_test_markdown_if;
+  var R = new ReactiveVar(false);
+  tmpl.cond = function () { return R.get(); };
+
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), canonicalizeHtml(textFromFunction(function () { /*
+[[[<p>false</p>
+
+<p><b>false</b></p>
+
+<ul>
+<li><p>false</p></li>
+<li><p><b>false</b></p></li>
+</ul>
+
+<p>some paragraph to fix showdown's four space parsing below.</p>
+
+<pre><code>false
+
+&lt;b&gt;false&lt;/b&gt;
+</code></pre>
+
+<p><code>false</code></p>
+
+<p><code>&lt;b&gt;false&lt;/b&gt;</code></p>]]] */
+  })));
+  R.set(true);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), canonicalizeHtml(textFromFunction(function () { /*
+[[[<p>true</p>
+
+<p><b>true</b></p>
+
+<ul>
+<li><p>true</p></li>
+<li><p><b>true</b></p></li>
+</ul>
+
+<p>some paragraph to fix showdown's four space parsing below.</p>
+
+<pre><code>true
+
+&lt;b&gt;true&lt;/b&gt;
+</code></pre>
+
+<p><code>true</code></p>
+
+<p><code>&lt;b&gt;true&lt;/b&gt;</code></p>]]] */
+  })));
+});
+
+Tinytest.add('spacebars - templates - #markdown - each', function (test) {
+  var tmpl = Template.spacebars_template_test_markdown_each;
+  var R = new ReactiveVar([]);
+  tmpl.seq = function () { return R.get(); };
+
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), canonicalizeHtml(textFromFunction(function () { /*
+[[[<p><b></b></p>
+
+<ul>
+<li></li>
+<li><b></b></li>
+</ul>
+
+<p>some paragraph to fix showdown's four space parsing below.</p>
+
+<pre><code>&lt;b&gt;&lt;/b&gt;
+</code></pre>
+
+<p>``</p>
+
+<p><code>&lt;b&gt;&lt;/b&gt;</code></p>]]] */
+    })));
+
+  R.set(["item"]);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), canonicalizeHtml(textFromFunction(function () { /*
+[[[<p>item</p>
+
+<p><b>item</b></p>
+
+<ul>
+<li><p>item</p></li>
+<li><p><b>item</b></p></li>
+</ul>
+
+<p>some paragraph to fix showdown's four space parsing below.</p>
+
+<pre><code>item
+
+&lt;b&gt;item&lt;/b&gt;
+</code></pre>
+
+<p><code>item</code></p>
+
+<p><code>&lt;b&gt;item&lt;/b&gt;</code></p>]]] */
+    })));
+});
+
+Tinytest.add('spacebars - templates - #markdown - inclusion', function (test) {
+  var tmpl = Template.spacebars_template_test_markdown_inclusion;
+  var subtmpl = Template.spacebars_template_test_markdown_inclusion_subtmpl;
+  subtmpl.foo = "bar";
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), "<p><span>Foo is bar.</span></p>");
+});
+
+Tinytest.add('spacebars - templates - #markdown - block helpers', function (test) {
+  var tmpl = Template.spacebars_template_test_markdown_block_helpers;
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), "<p>Hi there!</p>");
+});
+
+// Test that when a simple helper re-runs due to a dependency changing
+// but the return value is the same, the DOM text node is not
+// re-rendered.
+Tinytest.add('spacebars - templates - simple helpers are isolated', function (test) {
+  var runs = [{
+    helper: function () { return "foo"; },
+    nodeValue: "foo"
+  }, {
+    helper: function () { return new Spacebars.SafeString("bar"); },
+    nodeValue: "bar"
+  }];
+
+  _.each(runs, function (run) {
+    var tmpl = Template.spacebars_template_test_simple_helpers_are_isolated;
+    var dep = new Deps.Dependency;
+    tmpl.foo = function () {
+      dep.depend();
+      return run.helper();
+    };
+    var div = renderToDiv(tmpl);
+    var fooTextNode = _.find(div.childNodes, function (node) {
+      return node.nodeValue === run.nodeValue;
+    });
+
+    test.isTrue(fooTextNode);
+
+    dep.changed();
+    Deps.flush();
+    var newFooTextNode = _.find(div.childNodes, function (node) {
+      return node.nodeValue === run.nodeValue;
+    });
+
+    test.equal(fooTextNode, newFooTextNode);
+  });
+});
+
+// Test that when a helper in an element attribute re-runs due to a
+// dependency changing but the return value is the same, the attribute
+// value is not set.
+Tinytest.add('spacebars - templates - attribute helpers are isolated', function (test) {
+  var tmpl = Template.spacebars_template_test_attr_helpers_are_isolated;
+  var dep = new Deps.Dependency;
+  tmpl.foo = function () {
+    dep.depend();
+    return "foo";
+  };
+  var div = renderToDiv(tmpl);
+  var pElement = div.querySelector('p');
+
+  test.equal(pElement.getAttribute('attr'), 'foo');
+
+  // set the attribute to something else, afterwards check that it
+  // hasn't been updated back to the correct value.
+  pElement.setAttribute('attr', 'not-foo');
+  dep.changed();
+  Deps.flush();
+  test.equal(pElement.getAttribute('attr'), 'not-foo');
+});
+
+// A helper can return an object with a set of element attributes via
+// `<p {{attrs}}>`. When it re-runs due to a dependency changing the
+// value for a given attribute might stay the same. Test that the
+// attribute is not set on the DOM element.
+Tinytest.add('spacebars - templates - attribute object helpers are isolated', function (test) {
+  var tmpl = Template.spacebars_template_test_attr_object_helpers_are_isolated;
+  var dep = new Deps.Dependency;
+  tmpl.attrs = function () {
+    dep.depend();
+    return {foo: "bar"};
+  };
+  var div = renderToDiv(tmpl);
+  var pElement = div.querySelector('p');
+
+  test.equal(pElement.getAttribute('foo'), 'bar');
+
+  // set the attribute to something else, afterwards check that it
+  // hasn't been updated back to the correct value.
+  pElement.setAttribute('foo', 'not-bar');
+  dep.changed();
+  Deps.flush();
+  test.equal(pElement.getAttribute('foo'), 'not-bar');
+});
+
+// Test that when a helper in an inclusion directive (`{{> foo }}`)
+// re-runs due to a dependency changing but the return value is the
+// same, the template is not re-rendered.
+//
+// Also, verify that an error is thrown if the return value from such
+// a helper is not a component.
+Tinytest.add('spacebars - templates - inclusion helpers are isolated', function (test) {
+  var tmpl = Template.spacebars_template_test_inclusion_helpers_are_isolated;
+  var dep = new Deps.Dependency;
+  var subtmpl = Template.
+        spacebars_template_test_inclusion_helpers_are_isolated_subtemplate
+        .extend({}); // fresh instance
+  var R = new ReactiveVar(subtmpl);
+  tmpl.foo = function () {
+    dep.depend();
+    return R.get();
+  };
+
+  var div = renderToDiv(tmpl);
+  subtmpl.rendered = function () {
+    test.fail("shouldn't re-render when same value returned from helper");
+  };
+
+  dep.changed();
+  Deps.flush({_throwFirstError: true}); // `subtmpl.rendered` not called
+
+  R.set(null);
+  Deps.flush({_throwFirstError: true}); // no error thrown
+
+  R.set("neither a component nor null");
+
+  test.throws(function () {
+    Deps.flush({_throwFirstError: true});
+  }, /Expected null or template/);
+});
+
+Tinytest.add('spacebars - templates - nully attributes', function (test) {
+  var tmpls = {
+    0: Template.spacebars_template_test_nully_attributes0,
+    1: Template.spacebars_template_test_nully_attributes1,
+    2: Template.spacebars_template_test_nully_attributes2,
+    3: Template.spacebars_template_test_nully_attributes3,
+    4: Template.spacebars_template_test_nully_attributes4,
+    5: Template.spacebars_template_test_nully_attributes5,
+    6: Template.spacebars_template_test_nully_attributes6
+  };
+
+  var run = function (whichTemplate, data, expectTrue) {
+    var templateWithData = tmpls[whichTemplate].extend({data: function () {
+      return data; }});
+    var div = renderToDiv(templateWithData);
+    var input = div.querySelector('input');
+    var descr = JSON.stringify([whichTemplate, data, expectTrue]);
+    if (expectTrue) {
+      test.isTrue(input.checked, descr);
+      test.equal(typeof input.getAttribute('stuff'), 'string', descr);
+    } else {
+      test.isFalse(input.checked);
+      test.equal(JSON.stringify(input.getAttribute('stuff')), 'null', descr);
+    }
+
+    var html = HTML.toHTML(templateWithData);
+    test.equal(/ checked="[^"]*"/.test(html), !! expectTrue);
+    test.equal(/ stuff="[^"]*"/.test(html), !! expectTrue);
+  };
+
+  run(0, {}, true);
+
+  var truthies = [true, ''];
+  var falsies = [false, null, undefined];
+
+  _.each(truthies, function (x) {
+    run(1, {foo: x}, true);
+  });
+  _.each(falsies, function (x) {
+    run(1, {foo: x}, false);
+  });
+
+  _.each(truthies, function (x) {
+    _.each(truthies, function (y) {
+      run(2, {foo: x, bar: y}, true);
+    });
+    _.each(falsies, function (y) {
+      run(2, {foo: x, bar: y}, true);
+    });
+  });
+  _.each(falsies, function (x) {
+    _.each(truthies, function (y) {
+      run(2, {foo: x, bar: y}, true);
+    });
+    _.each(falsies, function (y) {
+      run(2, {foo: x, bar: y}, false);
+    });
+  });
+
+  run(3, {foo: true}, false);
+  run(3, {foo: false}, false);
+});
+
+Tinytest.add("spacebars - templates - double", function (test) {
+  var tmpl = Template.spacebars_template_test_double;
+
+  var run = function (foo, expectedResult) {
+    tmpl.foo = foo;
+    var div = renderToDiv(tmpl);
+    test.equal(canonicalizeHtml(div.innerHTML), expectedResult);
+  };
+
+  run('asdf', 'asdf');
+  run(1.23, '1.23');
+  run(0, '0');
+  run(true, 'true');
+  run(false, '');
+  run(null, '');
+  run(undefined, '');
+});
+
+Tinytest.add("spacebars - templates - inclusion lookup order", function (test) {
+  // test that {{> foo}} looks for a helper named 'foo', then a
+  // template named 'foo', then a 'foo' field in the data context.
+  var tmpl = Template.spacebars_template_test_inclusion_lookup;
+  tmpl.data = function () {
+    return {
+      // shouldn't have an effect since we define a helper with the
+      // same name.
+      spacebars_template_test_inclusion_lookup_subtmpl: Template.
+        spacebars_template_test_inclusion_lookup_subtmpl3,
+      dataContextSubtmpl: Template.
+        spacebars_template_test_inclusion_lookup_subtmpl3};
+  };
+
+  tmpl.spacebars_template_test_inclusion_lookup_subtmpl =
+    Template.spacebars_template_test_inclusion_lookup_subtmpl2;
+
+  test.equal(canonicalizeHtml(renderToDiv(tmpl).innerHTML),
+    ["This is generated by a helper with the same name.",
+     "This is a template passed in the data context."].join(' '));
+});
+
+Tinytest.add("spacebars - templates - content context", function (test) {
+  var tmpl = Template.spacebars_template_test_content_context;
+  var R = ReactiveVar(true);
+  tmpl.foo = {
+    firstLetter: 'F',
+    secondLetter: 'O',
+    bar: {
+      cond: function () { return R.get(); },
+      firstLetter: 'B',
+      secondLetter: 'A'
+    }
+  };
+
+  var div = renderToDiv(tmpl);
+  test.equal(canonicalizeHtml(div.innerHTML), 'BO');
+  R.set(false);
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML), 'FA');
+});
+
+_.each(['textarea', 'text', 'password', 'submit', 'button',
+        'reset', 'select', 'hidden'], function (type) {
+  Tinytest.add("spacebars - controls - " + type, function(test) {
+    var R = ReactiveVar({x:"test"});
+    var R2 = ReactiveVar("");
+    var tmpl;
+
+    if (type === 'select') {
+      tmpl = Template.spacebars_test_control_select;
+      tmpl.options = ['This is a test', 'This is a fridge',
+                      'This is a frog', 'This is a new frog', 'foobar',
+                      'This is a photograph', 'This is a monkey',
+                      'This is a donkey'];
+      tmpl.selected = function () {
+        R2.get();  // Re-render when R2 is changed, even though it
+                   // doesn't affect HTML.
+        return ('This is a ' + R.get().x) === this.toString();
+      };
+    } else if (type === 'textarea') {
+      tmpl = Template.spacebars_test_control_textarea;
+      tmpl.value = function () {
+        R2.get();  // Re-render when R2 is changed, even though it
+                   // doesn't affect HTML.
+        return 'This is a ' + R.get().x;
+      };
+    } else {
+      tmpl = Template.spacebars_test_control_input;
+      tmpl.value = function () {
+        R2.get();  // Re-render when R2 is changed, even though it
+                   // doesn't affect HTML.
+        return 'This is a ' + R.get().x;
+      };
+      tmpl.type = type;
+    };
+
+    var div = renderToDiv(tmpl);
+    document.body.appendChild(div);
+    var canFocus = (type !== 'hidden');
+
+    // find first element child, ignoring any marker nodes
+    var input = div.firstChild;
+    while (input.nodeType !== 1)
+      input = input.nextSibling;
+
+    if (type === 'textarea' || type === 'select') {
+      test.equal(input.nodeName, type.toUpperCase());
+    } else {
+      test.equal(input.nodeName, 'INPUT');
+      test.equal(input.type, type);
+    }
+    test.equal(DomUtils.getElementValue(input), "This is a test");
+
+    // value updates reactively
+    R.set({x:"fridge"});
+    Deps.flush();
+    test.equal(DomUtils.getElementValue(input), "This is a fridge");
+
+    if (canFocus) {
+      // ...unless focused
+      focusElement(input);
+      R.set({x:"frog"});
+
+      Deps.flush();
+      test.equal(DomUtils.getElementValue(input), "This is a fridge");
+
+      // blurring and re-setting works
+      blurElement(input);
+      Deps.flush();
+      test.equal(DomUtils.getElementValue(input), "This is a fridge");
+    }
+    R.set({x:"new frog"});
+    Deps.flush();
+
+    test.equal(DomUtils.getElementValue(input), "This is a new frog");
+
+    // Setting a value (similar to user typing) should prevent value from being
+    // reverted if the div is re-rendered but the rendered value (ie, R) does
+    // not change.
+    DomUtils.setElementValue(input, "foobar");
+    R2.set("change");
+    Deps.flush();
+    test.equal(DomUtils.getElementValue(input), "foobar");
+
+    // ... but if the actual rendered value changes, that should take effect.
+    R.set({x:"photograph"});
+    Deps.flush();
+    test.equal(DomUtils.getElementValue(input), "This is a photograph");
+
+    document.body.removeChild(div);
+  });
+});
+
+Tinytest.add("spacebars - controls - radio", function(test) {
+  var R = ReactiveVar("");
+  var R2 = ReactiveVar("");
+  var change_buf = [];
+  var tmpl = Template.spacebars_test_control_radio;
+  tmpl.bands = ["AM", "FM", "XM"];
+  tmpl.isChecked = function () {
+    return R.get() === this.toString();
+  };
+  tmpl.band = function () {
+    return R.get();
+  };
+  tmpl.events({
+    'change input': function (event) {
+      var btn = event.target;
+      var band = btn.value;
+      change_buf.push(band);
+      R.set(band);
+    }
+  });
+
+  var div = renderToDiv(tmpl);
+  document.body.appendChild(div);
+
+  // get the three buttons; they should not change identities!
+  var btns = nodesToArray(div.getElementsByTagName("INPUT"));
+  var text = function () {
+    var text = div.innerText || div.textContent;
+    return text.replace(/[ \n\r]+/g, " ");
+  };
+
+  test.equal(_.pluck(btns, 'checked'), [false, false, false]);
+  test.equal(text(), "Band: ");
+
+  clickIt(btns[0]);
+  test.equal(change_buf, ['AM']);
+  change_buf.length = 0;
+  Deps.flush();
+  test.equal(_.pluck(btns, 'checked'), [true, false, false]);
+  test.equal(text(), "Band: AM");
+
+  R2.set("change");
+  Deps.flush();
+  test.length(change_buf, 0);
+  test.equal(_.pluck(btns, 'checked'), [true, false, false]);
+  test.equal(text(), "Band: AM");
+
+  clickIt(btns[1]);
+  test.equal(change_buf, ['FM']);
+  change_buf.length = 0;
+  Deps.flush();
+  test.equal(_.pluck(btns, 'checked'), [false, true, false]);
+  test.equal(text(), "Band: FM");
+
+  clickIt(btns[2]);
+  test.equal(change_buf, ['XM']);
+  change_buf.length = 0;
+  Deps.flush();
+  test.equal(_.pluck(btns, 'checked'), [false, false, true]);
+  test.equal(text(), "Band: XM");
+
+  clickIt(btns[1]);
+  test.equal(change_buf, ['FM']);
+  change_buf.length = 0;
+  Deps.flush();
+  test.equal(_.pluck(btns, 'checked'), [false, true, false]);
+  test.equal(text(), "Band: FM");
+
+  document.body.removeChild(div);
+});
+
+Tinytest.add("spacebars - controls - checkbox", function(test) {
+  var tmpl = Template.spacebars_test_control_checkbox;
+  tmpl.labels = ["Foo", "Bar", "Baz"];
+  var Rs = {};
+  _.each(tmpl.labels, function (label) {
+    Rs[label] = ReactiveVar(false);
+  });
+  tmpl.isChecked = function () {
+    return Rs[this.toString()].get();
+  };
+  var changeBuf = [];
+
+  var div = renderToDiv(tmpl);
+  document.body.appendChild(div);
+
+  var boxes = nodesToArray(div.getElementsByTagName("INPUT"));
+
+  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
+
+  // Re-render with first one checked.
+  Rs.Foo.set(true);
+  Deps.flush();
+  test.equal(_.pluck(boxes, 'checked'), [true, false, false]);
+
+  // Re-render with first one unchecked again.
+  Rs.Foo.set(false);
+  Deps.flush();
+  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
+
+  // User clicks the second one.
+  clickElement(boxes[1]);
+  test.equal(_.pluck(boxes, 'checked'), [false, true, false]);
+  Deps.flush();
+  test.equal(_.pluck(boxes, 'checked'), [false, true, false]);
+
+  // Re-render with third one checked. Second one should stay checked because
+  // it's a user update!
+  Rs.Baz.set(true);
+  Deps.flush();
+  test.equal(_.pluck(boxes, 'checked'), [false, true, true]);
+
+  // User turns second and third off.
+  clickElement(boxes[1]);
+  clickElement(boxes[2]);
+  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
+  Deps.flush();
+  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
+
+  // Re-render with first one checked. Third should stay off because it's a user
+  // update!
+  Rs.Foo.set(true);
+  Deps.flush();
+  test.equal(_.pluck(boxes, 'checked'), [true, false, false]);
+
+  // Re-render with first one unchecked. Third should still stay off.
+  Rs.Foo.set(false);
+  Deps.flush();
+  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
+
+  document.body.removeChild(div);
+});
+
+Tinytest.add('spacebars - template - unfound template', function (test) {
+  test.throws(function () {
+    renderToDiv(Template.spacebars_test_nonexistent_template);
+  }, /Can't find template/);
+});
+
+Tinytest.add('spacebars - template - helper passed to #if called exactly once when invalidated', function (test) {
+  var tmpl = Template.spacebars_test_if_helper;
+
+  var count = 0;
+  var d = new Deps.Dependency;
+  tmpl.foo = function () {
+    d.depend();
+    count++;
+    return foo;
+  };
+
+  foo = false;
+  var div = renderToDiv(tmpl);
+  divRendersTo(test, div, "false");
+  test.equal(count, 1);
+
+  foo = true;
+  d.changed();
+  divRendersTo(test, div, "true");
+  test.equal(count, 2);
+});
+
+Tinytest.add('spacebars - template - custom block helper functions called exactly once when invalidated', function (test) {
+  var tmpl = Template.spacebars_test_block_helper_function;
+
+  var count = 0;
+  var d = new Deps.Dependency;
+  tmpl.foo = function () {
+    d.depend();
+    count++;
+    return UI.block(function () { return []; });
+  };
+
+  foo = false;
+  renderToDiv(tmpl);
+  Deps.flush();
+  test.equal(count, 1);
+
+  foo = true;
+  d.changed();
+  Deps.flush();
+  test.equal(count, 2);
+});
+
+var runOneTwoTest = function (test, subTemplateName, optionsData) {
+  _.each([Template.spacebars_test_helpers_stop_onetwo,
+          Template.spacebars_test_helpers_stop_onetwo_attribute],
+         function (tmpl) {
+
+           tmpl.one = Template[subTemplateName + '1'];
+           tmpl.two = Template[subTemplateName + '2'];
+
+           var buf = '';
+
+           var showOne = ReactiveVar(true);
+           var dummy = ReactiveVar(0);
+
+           tmpl.showOne = function () { return showOne.get(); };
+           tmpl.one.options = function () {
+             var x = dummy.get();
+             buf += '1';
+             if (optionsData)
+               return optionsData[x];
+             else
+               return ['something'];
+           };
+           tmpl.two.options = function () {
+             var x = dummy.get();
+             buf += '2';
+             if (optionsData)
+               return optionsData[x];
+             else
+               return ['something'];
+           };
+
+           var div = renderToDiv(tmpl);
+           Deps.flush();
+           test.equal(buf, '1');
+
+           showOne.set(false);
+           dummy.set(1);
+           Deps.flush();
+           test.equal(buf, '12');
+
+           showOne.set(true);
+           dummy.set(2);
+           Deps.flush();
+           test.equal(buf, '121');
+
+           // clean up the div
+           $(div).remove();
+           test.equal(showOne.numListeners(), 0);
+           test.equal(dummy.numListeners(), 0);
+         });
+};
+
+Tinytest.add('spacebars - template - with stops without re-running helper', function (test) {
+  runOneTwoTest(test, 'spacebars_test_helpers_stop_with');
+});
+
+Tinytest.add('spacebars - template - each stops without re-running helper', function (test) {
+  runOneTwoTest(test, 'spacebars_test_helpers_stop_each');
+});
+
+Tinytest.add('spacebars - template - each inside with stops without re-running helper', function (test) {
+  runOneTwoTest(test, 'spacebars_test_helpers_stop_with_each');
+});
+
+Tinytest.add('spacebars - template - if stops without re-running helper', function (test) {
+  runOneTwoTest(test, 'spacebars_test_helpers_stop_if', ['a', 'b', 'a']);
+});
+
+Tinytest.add('spacebars - template - unless stops without re-running helper', function (test) {
+  runOneTwoTest(test, 'spacebars_test_helpers_stop_unless', ['a', 'b', 'a']);
+});
+
+Tinytest.add('spacebars - template - inclusion stops without re-running function', function (test) {
+  var t = Template.spacebars_test_helpers_stop_inclusion3;
+  runOneTwoTest(test, 'spacebars_test_helpers_stop_inclusion', [t, t, t]);
+});
+
+Tinytest.add('spacebars - template - template with callbacks inside with stops without recalculating data', function (test) {
+  var tmpl = Template.spacebars_test_helpers_stop_with_callbacks3;
+  tmpl.created = function () {};
+  tmpl.rendered = function () {};
+  tmpl.destroyed = function () {};
+  runOneTwoTest(test, 'spacebars_test_helpers_stop_with_callbacks');
+});
+
+Tinytest.add('spacebars - template - no data context is seen as an empty object', function (test) {
+  var tmpl = Template.spacebars_test_no_data_context;
+
+  var dataInHelper = 'UNSET';
+  var dataInRendered = 'UNSET';
+  var dataInCreated = 'UNSET';
+  var dataInDestroyed = 'UNSET';
+  var dataInEvent = 'UNSET';
+
+  tmpl.foo = function () {
+    dataInHelper = this;
+  };
+  tmpl.created = function () {
+    dataInCreated = this.data;
+  };
+  tmpl.rendered = function () {
+    dataInRendered = this.data;
+  };
+  tmpl.destroyed = function () {
+    dataInDestroyed = this.data;
+  };
+  tmpl.events({
+    'click': function () {
+      dataInEvent = this;
+    }
+  });
+
+  var div = renderToDiv(tmpl);
+  document.body.appendChild(div);
+  clickElement(div.querySelector('button'));
+  Deps.flush(); // rendered gets called afterFlush
+  $(div).remove();
+
+  test.isFalse(dataInHelper === window);
+  test.equal(dataInHelper, {});
+  test.equal(dataInCreated, null);
+  test.equal(dataInRendered, null);
+  test.equal(dataInDestroyed, null);
+  test.isFalse(dataInEvent === window);
+  test.equal(dataInEvent, {});
+});
+
+Tinytest.add('spacebars - template - falsy with', function (test) {
+  var tmpl = Template.spacebars_test_falsy_with;
+  var R = ReactiveVar(null);
+  tmpl.obj = function () { return R.get(); };
+
+  var div = renderToDiv(tmpl);
+  divRendersTo(test, div, "");
+
+  R.set({greekLetter: 'alpha'});
+  divRendersTo(test, div, "alpha");
+
+  R.set(null);
+  divRendersTo(test, div, "");
+
+  R.set({greekLetter: 'alpha'});
+  divRendersTo(test, div, "alpha");
+});
+
+Tinytest.add("spacebars - template - helpers don't leak", function (test) {
+  var tmpl = Template.spacebars_test_helpers_dont_leak;
+  tmpl.foo = "wrong";
+  tmpl.bar = function () { return "WRONG"; };
+
+  // Also test that custom block helpers (implemented as templates) do NOT
+  // interfere with helper lookup in the current template
+  Template.spacebars_test_helpers_dont_leak2.bonus =
+    function () { return 'BONUS'; };
+
+  var div = renderToDiv(tmpl);
+  divRendersTo(test, div, "correct BONUS");
+});
+
+Tinytest.add(
+  "spacebars - template - event handler returns false",
+  function (test) {
+    var tmpl = Template.spacebars_test_event_returns_false;
+    var elemId = "spacebars_test_event_returns_false_link";
+    tmpl.events({
+      'click a': function (evt) { return false; }
+    });
+
+    var div = renderToDiv(tmpl);
+    document.body.appendChild(div);
+    clickIt(document.getElementById(elemId));
+    test.isFalse(/#bad-url/.test(window.location.hash));
+    document.body.removeChild(div);
+  }
+);
+
+Tinytest.add("spacebars - template - tables", function (test) {
+  var tmpl1 = Template.spacebars_test_tables1;
+
+  var div = renderToDiv(tmpl1);
+  test.equal(_.pluck(div.querySelectorAll('*'), 'tagName'),
+             ['TABLE', 'TR', 'TD']);
+  divRendersTo(test, div, '<table><tr><td>Foo</td></tr></table>');
+
+  var tmpl2 = Template.spacebars_test_tables2;
+  tmpl2.foo = 'Foo';
+  div = renderToDiv(tmpl2);
+  test.equal(_.pluck(div.querySelectorAll('*'), 'tagName'),
+             ['TABLE', 'TR', 'TD']);
+  divRendersTo(test, div, '<table><tr><td>Foo</td></tr></table>');
+});
+
+Tinytest.add(
+  "spacebars - template - jQuery.trigger extraParameters are passed to the event callback",
+  function (test) {
+    var tmpl = Template.spacebars_test_jquery_events;
+    var captured = false;
+    var args = ["param1", "param2", {option: 1}, 1, 2, 3];
+
+    tmpl.events({
+      'someCustomEvent': function (event, template) {
+        var i;
+        for (i=0; i<args.length; i++) {
+          // expect the arguments to be just after template
+          test.equal(arguments[i+2], args[i]);
+        }
+        captured = true;
+      }
+    });
+
+    tmpl.rendered = function () {
+      $(this.find('button')).trigger('someCustomEvent', args);
+    };
+
+    renderToDiv(tmpl);
+    Deps.flush();
+    test.equal(captured, true);
+  }
+);
+
+Tinytest.add("spacebars - template - UI.toHTML", function (test) {
+  // run once, verifying that autoruns are stopped
+  var once = function (tmplToRender, tmplForHelper, helper, val) {
+    var count = 0;
+    var R = new ReactiveVar;
+    var getR = function () {
+      count++;
+      return R.get();
+    };
+
+    R.set(val);
+    tmplForHelper[helper] = getR;
+    test.equal(canonicalizeHtml(UI.toHTML(tmplToRender)), "bar");
+    test.equal(count, 1);
+    R.set("");
+    Deps.flush();
+    test.equal(count, 1); // all autoruns stopped
+  };
+
+  once(Template.spacebars_test_tohtml_basic,
+       Template.spacebars_test_tohtml_basic, "foo", "bar");
+  once(Template.spacebars_test_tohtml_if,
+       Template.spacebars_test_tohtml_if, "foo", "bar");
+  once(Template.spacebars_test_tohtml_with,
+       Template.spacebars_test_tohtml_with, "foo", "bar");
+  once(Template.spacebars_test_tohtml_each,
+       Template.spacebars_test_tohtml_each, "foos", ["bar"]);
+
+  once(Template.spacebars_test_tohtml_include_with,
+       Template.spacebars_test_tohtml_with, "foo", "bar");
+  once(Template.spacebars_test_tohtml_include_each,
+       Template.spacebars_test_tohtml_each, "foos", ["bar"]);
+});
+
+Tinytest.add(
+  "spacebars - template - block comments should not be displayed",
+  function (test) {
+    var tmpl = Template.spacebars_test_block_comment;
+    var div = renderToDiv(tmpl);
+    test.equal(canonicalizeHtml(div.innerHTML), '');
+  }
+);
+
+// Originally reported at https://github.com/meteor/meteor/issues/2046
+Tinytest.add(
+  "spacebars - template - {{#with}} with mutated data context",
+  function (test) {
+    var tmpl = Template.spacebars_test_with_mutated_data_context;
+    var foo = {value: 0};
+    var dep = new Deps.Dependency;
+    tmpl.foo = function () {
+      dep.depend();
+      return foo;
+    };
+
+    var div = renderToDiv(tmpl);
+    test.equal(canonicalizeHtml(div.innerHTML), '0');
+
+    foo.value = 1;
+    dep.changed();
+    Deps.flush();
+    test.equal(canonicalizeHtml(div.innerHTML), '1');
+  });
+
+Tinytest.add(
+  "spacebars - template - javascript scheme urls",
+  function (test) {
+    var tmpl = Template.spacebars_test_url_attribute;
+    var sessionKey = "foo-" + Random.id();
+    tmpl.foo = function () {
+      return Session.get(sessionKey);
+    };
+
+    var div = renderToDiv(tmpl);
+
+    var checkAttrs = function (url, isJavascriptProtocol) {
+      Session.set(sessionKey, url);
+      Deps.flush();
+      _.each(
+        // [tag name, attr name, is a url attribute]
+        [["A", "href", true], ["FORM", "action", true],
+         ["IMG", "src", true], ["INPUT", "value", false]],
+        function (attrInfo) {
+
+          var normalizedUrl;
+          var elem = document.createElement(attrInfo[0]);
+          elem[attrInfo[1]] = url;
+          document.body.appendChild(elem);
+          normalizedUrl = elem[attrInfo[1]];
+          document.body.removeChild(elem);
+
+          _.each(
+            div.getElementsByTagName(attrInfo[0]),
+            function (elem) {
+              test.equal(
+                elem[attrInfo[1]],
+                isJavascriptProtocol && attrInfo[2] ? "" : normalizedUrl
+              );
+            }
+          );
+        }
+      );
+    };
+
+    test.equal(UI._javascriptUrlsAllowed(), false);
+    checkAttrs("http://www.meteor.com", false);
+    checkAttrs("javascript:alert(1)", true);
+    checkAttrs("jAvAsCrIpT:alert(1)", true);
+    checkAttrs("    javascript:alert(1)", true);
+    UI._allowJavascriptUrls();
+    test.equal(UI._javascriptUrlsAllowed(), true);
+    checkAttrs("http://www.meteor.com", false);
+    checkAttrs("javascript:alert(1)", false);
+    checkAttrs("jAvAsCrIpT:alert(1)", false);
+    checkAttrs("    javascript:alert(1)", false);
+  }
+);
diff --git a/packages/spacebars/.gitignore b/packages/spacebars/.gitignore
new file mode 100644
index 0000000000..677a6fc263
--- /dev/null
+++ b/packages/spacebars/.gitignore
@@ -0,0 +1 @@
+.build*
diff --git a/packages/spacebars/README.md b/packages/spacebars/README.md
new file mode 100644
index 0000000000..94365a54fb
--- /dev/null
+++ b/packages/spacebars/README.md
@@ -0,0 +1,385 @@
+# Spacebars
+
+Spacebars is a Meteor template language inspired by [Handlebars](http://handlebarsjs.com/).  It shares some of the spirit and syntax of Handlebars, but it has been tailored to produce reactive Meteor templates when compiled.
+
+## Getting Started
+
+A Spacebars template consists of HTML interspersed with template tags, which are delimited by `{{` and `}}` (two curly braces).
+
+```
+<template name="myPage">
+  <h1>{{pageTitle}}</h1>
+
+  {{> nav}}
+
+  {{#each posts}}
+    <div class="post">
+      <h3>{{title}}</h3>
+      <div class="post-content">
+        {{{content}}}
+      </div>
+    </div>
+  {{/each}}
+</template>
+```
+
+As illustrated by the above example, there are four major types of template tags:
+
+* `{{pageTitle}}` - Double-braced template tags are used to insert a string of text.  The text is automatically made safe.  It may contain any characters (like `<`) and will never produce HTML tags.
+
+* `{{> nav}}` - Inclusion template tags are used to insert another template by name.
+
+* `{{#each}}` - Block template tags are notable for having a block of content.  The block tags `#if`, `#each`, `#with`, and `#unless` are built in, and it is also possible define custom ones.  Some block tags, like `#each` and `#with`, establish a new data context for evaluating their contents.  In the above example, `{{title}}` and `{{content}}` most likely refer to properties of the current post (though they could also refer to template helpers).
+
+* `{{{content}}}` - Triple-braced template tags are used to insert raw HTML.  Be careful with these!  It's your job to make sure the HTML is safe, either by generating it yourself or sanitizing it if it came from a user input.
+
+## Reactivity Model
+
+Spacebars templates update reactively at a fine-grained level in response to changing data.
+
+Each template tag's DOM is updated automatically when it evaluates to a new value, while avoiding unnecessary re-rendering as much as possible.  For example, a double-braced tag replace its text node when its text value changes.  An `#if` re-renders its contents only when the condition changes from truthy to falsy or vice versa.
+
+## Identifiers and Paths
+
+A Spacebars identifier is either a JavaScript identifier name or any string enclosed in square brackets (`[` and `]`).  There are also the special identifiers `this` (or equivalently, `.`) and `..`.  Brackets are required to use one of the following as the first element of a path: `else`, `this`, `true`, `false`, and `null`.  Brackets are not required around JavaScript keywords and reserved words like `var` and `for`.
+
+A Spacebars path is a series of one or more identifiers separated by either `.` or `/`, such as `foo`, `foo.bar`, `this.name`, `../title`, or `foo.[0]`.
+
+### Name Resolution
+
+The first identifier in a path is resolved in one of two ways:
+
+* Indexing the current data context.  The identifier `foo` refers to the `foo` property of the current data context object.
+
+* As a template helper.  The identifier `foo` refers to a helper function (or constant value) that is accessible from the current template.
+
+Template helpers take priority over properties of the data context.
+
+If a path starts with `..`, then the *enclosing* data context is used instead of the current one.  The enclosing data context might be the one outside the current `#each`, `#with`, or template inclusion.
+
+### Path Evaluation
+
+When evaluating a path, identifiers after the first are used to index into the object so far, like JavaScript's `.`.  However, an error is never thrown when trying to index into a non-object or an undefined value.
+
+In addition, Spacebars will call functions for you, so `{{foo.bar}}` may be taken to mean `foo().bar`, `foo.bar()`, or `foo().bar()` as appropriate.
+
+## Helper Arguments
+
+An argument to a helper can be any path or identifier, or a string, boolean, or number literal, or null.
+
+Double-braced and triple-braced template tags take any number of positional and keyword arguments:
+
+```
+{{frob a b c verily=true}}
+
+calls: frob(a, b, c, Spacebars.kw({verily: true}))
+```
+
+`Spacebars.kw` constructs an object that is `instanceof Spacebars.kw` and whose `.hash` property is equal to its argument.
+
+The helper's implementation can access the current data context as `this`.
+
+## Inclusion and Block Arguments
+
+Inclusion tags (`{{> foo}}`) and block tags (`{{#foo}}`) take a single
+data argument, or no argument.  Any other form of arguments will be interpreted as an *object specification* or a *nested helper*:
+
+* **Object specification**: If there are only keyword arguments, as in `{{#with x=1 y=2}}` or `{{> prettyBox color=red}}`, the keyword arguments will be assembled into a data object with properties named after the keywords.
+
+* **Nested Helper**: If there is a positional argument followed by other (positional or keyword arguments), the first argument is called on the others using the normal helper argument calling convention.
+
+## Template Tag Placement Limitations
+
+Unlike purely string-based template systems, Spacebars is HTML-aware and designed to update the DOM automatically.  As a result, you can't use a template tag to insert strings of HTML that don't stand on their own, such as a lone HTML start tag or end tag, or that can't be easily modified, such as the name of an HTML element.
+
+There are three main locations in the HTML where template tags are allowed:
+
+* At element level (i.e. anywhere an HTML tag could go)
+* In an attribute value
+* In a start tag in place of an attribute name/value pair
+
+The behavior of a template tag is affected by where it is located in the HTML, and not all tags are allowed at all locations.
+
+## Double-braced Tags
+
+A double-braced tag at element level or in an attribute value typically evalutes to a string.  If it evalutes to something else, the value will be cast to a string, unless the value is `null`, `undefined`, or `false`, which results in nothing being displayed.
+
+Values returned from helpers must be pure text, not HTML.  (That is, strings should have `<`, not `&lt;`.)  Spacebars will perform any necessary escaping if a template is rendered to HTML.
+
+### SafeString
+
+If a double-braced tag at element level evalutes to an object created with `Spacebars.SafeString("<span>Some HTML</span>")`, the HTML is inserted at the current location.  The code that calls `SafeString` is asserting that this HTML is safe to insert.
+
+### In Attribute Values
+
+A double-braced tag may be part of, or all of, an HTML attribute value:
+
+```
+<input type="checkbox" class="checky {{moreClasses}}" checked={{isChecked}}>
+```
+
+An attribute value that consists entirely of template tags that return `null`, `undefined`, or `false` is considered absent; otherwise, the attribute is considered present, even if its value is empty.
+
+### Dynamic Attributes
+
+A double-braced tag can be used in an HTML start tag to specify an arbitrary set of attributes:
+
+```
+<div {{attrs}}>...</div>
+
+<input type=checkbox {{isChecked}}>
+```
+
+The tag must evaluate to an object that serves as a dictionary of attribute name and value strings.  For convenience, the value may also be a string or null.  An empty string or null expands to `{}`.  A non-empty string must be an attribute name, and expands to an attribute with an empty value; for example, `"checked"` expands to `{checked: ""}` (which, as far as HTML is concerned, means the checkbox is checked).
+
+To summarize:
+
+|Return Value|Equivalent HTML|
+|------------|---------------|
+|`""` or `null` or `{}`| |
+|`"checked"` or `{checked: ""}`|`checked`|
+|`{checked: "", 'class': "foo"}`|`checked class=foo`|
+|`"checked class=foo"`|ERROR, string is not an attribute name|
+
+You can combine multiple dynamic attributes tags with other attributes:
+
+```
+<div id=foo class={{myClass}} {{attrs1}} {{attrs2}}>...</div>
+```
+
+Attributes from dynamic attribute tags are combined from left to right, after normal attributes, with later attribute values overwriting previous ones.  Multiple values for the same attribute are not merged in any way, so if `attrs1` specifies a value for the `class` attribute, it will overwrite `{{myClass}}`.  As always, Spacebars takes care of recalculating the element's attributes if any of `myClass`, `attrs1`, or `attrs2` changes reactively.
+
+
+## Triple-braced Tags
+
+Triple-braced tags are used to insert raw HTML into a template:
+
+```
+<div class="snippet">
+  {{{snippetBody}}}
+</div>
+```
+
+The inserted HTML must consist of balanced HTML tags.  You can't, for example, insert `"</div><div>"` to close an existing div and open a new one.
+
+This template tag cannot be used in attributes or in an HTML start tag.
+
+## Inclusion Tags
+
+An inclusion tag takes the form `{{> templateName}}` or `{{> templateName dataObj}}`.  Other argument forms are syntactic sugar for constructing a data object (see Inclusion and Block Arguments).
+
+An inclusion tag inserts an instantiation of the given template at the current location.  If there is an argument, it becomes the data context, much as if the following code were used:
+
+```
+{{#with dataObj}}
+  {{> templateName}}
+{{/with}}
+```
+
+Instead of simply naming a template, an inclusion tag can also specify a path that evalutes to a template object, or to a function that returns a template object.
+
+### Function Returning a Template
+
+If an inclusion tag resolves to a function, the function must return a template object or `null`.  The function is reactively re-run, and if its return value changes, the template will be replaced.
+
+## Block Tags
+
+Block tags invoke built-in directives or custom block helpers, passing a block of template content that may be instantiated once, more than once, or not at all by the directive or helper.
+
+```
+{{#block}}
+  <p>Hello</p>
+{{/block}}
+```
+
+Block tags may also have specify "else" content, separated from the main content by the special template tag `{{else}}`. 
+
+A block tag's content must consist of HTML with balanced tags.
+
+Block tags can be used inside attribute values:
+
+```
+<div class="{{#if done}}done{{else}}notdone{{/if}}">
+  ...
+</div>
+```
+
+## If/Unless
+
+An `#if` template tag renders either its main content or its "else" content, depending on the value of its data argument.  Any falsy JavaScript value (including `null`, `undefined`, `0`, `""`, and `false`) is considered false, as well as the empty array, while any other value is considered true.
+
+```
+{{#if something}}
+  <p>It's true</p>
+{{else}}
+  <p>It's false</p>
+{{/if}}
+```
+
+`#unless` is just `#if` with the condition inverted.
+
+## With
+
+A `#with` template tag establishes a new data context object for its contents.  The properties of the data context object are where Spacebars looks when resolving template tag names.
+
+```
+{{#with employee}}
+  <div>Name: {{name}}</div>
+  <div>Age: {{age}}</div>
+{{/with}}
+```
+
+We can take advantage of the object specification form of a block tag to define an object with properties we name:
+
+```
+{{#with x=1 y=2}}
+  {{{getHTMLForPoint this}}}
+{{/with}}
+```
+
+If the argument to `#with` is falsy (by the same rules as for `#if`), the content is not rendered.  An "else" block may be provided, which will be rendered instead.
+
+If the argument to `#with` is a string or other non-object value, it may be promoted to a JavaScript wrapper object (also known as a boxed value) when passed to helpers, because JavaScript traditionally only allows an object for `this`.  Use `String(this)` to get an unboxed string value or `Number(this)` to get an unboxed number value.
+
+## Each
+
+An `#each` template tag takes a sequence argument and inserts its content for each item in the sequence, setting the data context to the value of that item:
+
+```
+<ul>
+{{#each people}}
+  <li>{{name}}</li>
+{{/each}}
+</ul>
+```
+
+The argument is typically a Meteor cursor (the result of `collection.find()`, for example), but it may also be a plain JavaScript array, `null`, or `undefined`.
+
+An "else" section may be provided, which is used (with no new data
+context) if there are zero items in the sequence at any time.
+
+### Reactivity Model for Each
+
+When the argument to `#each` changes, the DOM is always updated to reflect the new sequence, but it's sometimes significant exactly how that is achieved.  When the argument is a Meteor live cursor, the `#each` has access to fine-grained updates to the sequence -- add, remove, move, and change callbacks -- and the items are all documents identified by unique ids.  As long as the cursor itself remains constant (i.e. the query doesn't change), it is very easy to reason about how the DOM will be updated as the contents of the cursor change.  The rendered content for each document persists as long as the document is in the cursor, and when documents are re-ordered, the DOM is re-ordered.
+
+Things are more complicated if the argument to the `#each` reactively changes between different cursor objects, or between arrays of plain JavaScript objects that may not be identified clearly.  The implementation of `#each` tries to be intelligent without doing too much expensive work. Specifically, it tries to identify items between the old and new array or cursor with the following strategy:
+
+1. For objects with an `_id` field, use that field as the identification key
+2. For objects with no `_id` field, use the array index as the identification key. In this case, appends are fast but prepends are slower.
+3. For numbers or strings, use their value as the identification key.
+
+Regardless of the strategy used, keys are deduplicated so that arrays with repeating items work fine.
+
+## Custom Block Helpers
+
+To define your own block helper, simply declare a template, and then invoke it using `{{#someTemplate}}` (block) instead of `{{> someTemplate}}` (inclusion) syntax.
+
+When a template is invoked as a block helper, it can use `{{> UI.contentBlock}}` and `{{> UI.elseBlock}}` to include the block content it was passed.
+
+Here is a simple block helper that wraps its content in a div:
+
+```
+<template name="note">
+  <div class="note">
+    {{> UI.contentBlock}}
+  </div>
+</template>
+```
+
+You would invoke it as:
+
+```
+{{#note}}
+  Any content here
+{{/note}}
+```
+
+Here is an example of implementing `#unless` in terms of `#if` (ignoring for the moment that `unless` is a built-in directive):
+
+```
+<template name="unless">
+  {{#if this}}
+    {{> UI.elseBlock}}
+  {{else}}
+    {{> UI.contentBlock}}
+  {{/if}}
+</template>
+```
+
+Note that the argument to `#unless` (the condition) becomes the data
+context in the `unless` template and is accessed via `this`.  However,
+it would not work very well if this data context was visible to
+`UI.contentBlock`, which is supplied by the user of `unless`.
+
+Therefore, when you include `{{> UI.contentBlock}}`, Spacebars hides the data
+context of the calling template, and any data contexts established in
+the template by `#each` and `#with`.  They are not visible to the
+content block, even via `..`.  Put another way, it's as if the `{{>
+UI.contentBlock}}` inclusion occurred at the location where `{{#unless}}` was
+invoked, as far as the data context stack is concerned.
+
+You can pass an argument to `{{> UI.contentBlock}}` or `{{> UI.elseBlock}}` to
+invoke it with a data context of your choice.  You can also use `{{#if
+UI.contentBlock}}` to see if the current template was invoked as a block
+helper rather than an inclusion.
+
+## Comment Tags
+
+Comment template tags begin with `{{!` and can contain any characters
+except for `}}`.  Comments are removed upon compilation and never
+appear in the compiled template code or the generated HTML.
+
+```
+{{! Start of a section}}
+<div class="section">
+  ...
+</div>
+```
+
+Comment tags can be used wherever other template tags are allowed.
+
+## HTML Dialect
+
+Spacebars templates are written in [standard
+HTML](http://developers.whatwg.org/syntax.html) extended with
+additional syntax (i.e. template tags).
+
+Spacebars validates your HTML as it goes and will throw a compile-time
+error if you violate basic HTML syntax in a way that prevents it from
+determining the structure of your code.
+
+Spacebars is not lenient about malformed markup the way a web browser
+is.  While the latest HTML spec standardizes how browsers should
+recover from parse errors, these cases are still not valid HTML.  For
+example, a browser may recover from a bare `<` that does not begin a
+well-formed HTML tag, while Spacebars will not.  However, gone are the
+restrictions of the XHTML days; attribute values do not have to
+quoted, and tags are not case-sensitive, for example.
+
+You must close all HTML tags except the ones specified to have no end
+tag, like BR, HR, IMG and INPUT.  You can write these tags as `<br>`
+or equivalently `<br/>`.
+
+The HTML spec allows omitting some additional end tags, such as P and
+LI, but Spacebars doesn't currently support this.
+
+## Top-level Elements in a `.html` file
+
+Technically speaking, the `<template>` element is not part of the Spacebars
+language. A `foo.html` template file in Meteor consists of one or more of the
+following elements:
+
+* `<template name="myName">` - The `<template>` element contains a Spacebars
+  template (as defined in the rest of this file) which will be compiled to the
+  `Template.myName` component.
+
+* `<head>` - Static HTML that will be inserted into the `<head>` element of the
+  default HTML boilerplate page. Cannot contain template tags. If `<head>` is
+  used multiple times (perhaps in different files), the contents of all of the
+  `<head>` elements are concatenated.
+
+* `<body>` - A template that will be inserted into the `<body>` of the main
+  page.  It will be compiled to the `UI.body` component. If `<body>` is used
+  multiple times (perhaps in different files), the contents of all of the
+  `<body>` elements are concatenated.
+
diff --git a/packages/spacebars/package.js b/packages/spacebars/package.js
new file mode 100644
index 0000000000..6826c13b6d
--- /dev/null
+++ b/packages/spacebars/package.js
@@ -0,0 +1,23 @@
+Package.describe({
+  name: "spacebars",
+  test: "spacebars-test",
+  summary: "Handlebars-like template language for Meteor",
+  version: '1.0.0',
+  internal: true
+});
+
+// For more, see package `spacebars-compiler`, which is used by
+// the build plugin and not shipped to the client unless you
+// ask for it by name.
+//
+// The Spacebars build plugin is in package `templating`.
+//
+// Additional tests are in `spacebars-tests`.
+
+Package.on_use(function (api) {
+  api.export('Spacebars');
+
+  api.use('htmljs');
+  api.use('ui');
+  api.add_files(['spacebars-runtime.js']);
+});
diff --git a/packages/spacebars/spacebars-runtime.js b/packages/spacebars/spacebars-runtime.js
new file mode 100644
index 0000000000..59c2f37a47
--- /dev/null
+++ b/packages/spacebars/spacebars-runtime.js
@@ -0,0 +1,243 @@
+Spacebars = {};
+
+// * `templateOrFunction` - template (component) or function returning a template
+// or null
+Spacebars.include = function (templateOrFunction, contentBlock, elseContentBlock) {
+  if (contentBlock && ! UI.isComponent(contentBlock))
+    throw new Error('Second argument to Spacebars.include must be a template or UI.block if present');
+  if (elseContentBlock && ! UI.isComponent(elseContentBlock))
+    throw new Error('Third argument to Spacebars.include must be a template or UI.block if present');
+
+  var props = null;
+  if (contentBlock) {
+    props = (props || {});
+    props.__content = contentBlock;
+  }
+  if (elseContentBlock) {
+    props = (props || {});
+    props.__elseContent = elseContentBlock;
+  }
+
+  if (UI.isComponent(templateOrFunction))
+    return templateOrFunction.extend(props);
+
+  var func = templateOrFunction;
+
+  var f = function () {
+    var emboxedFunc = UI.namedEmboxValue('Spacebars.include', func);
+    f.stop = function () {
+      emboxedFunc.stop();
+    };
+    var tmpl = emboxedFunc();
+
+    if (tmpl === null)
+      return null;
+    if (! UI.isComponent(tmpl))
+      throw new Error("Expected null or template in return value from inclusion function, found: " + tmpl);
+
+    return tmpl.extend(props);
+  };
+
+  return f;
+};
+
+// Executes `{{foo bar baz}}` when called on `(foo, bar, baz)`.
+// If `bar` and `baz` are functions, they are called before
+// `foo` is called on them.
+//
+// This is the shared part of Spacebars.mustache and
+// Spacebars.attrMustache, which differ in how they post-process the
+// result.
+Spacebars.mustacheImpl = function (value/*, args*/) {
+  var args = arguments;
+  // if we have any arguments (pos or kw), add an options argument
+  // if there isn't one.
+  if (args.length > 1) {
+    var kw = args[args.length - 1];
+    if (! (kw instanceof Spacebars.kw)) {
+      kw = Spacebars.kw();
+      // clone arguments into an actual array, then push
+      // the empty kw object.
+      args = Array.prototype.slice.call(arguments);
+      args.push(kw);
+    } else {
+      // For each keyword arg, call it if it's a function
+      var newHash = {};
+      for (var k in kw.hash) {
+        var v = kw.hash[k];
+        newHash[k] = (typeof v === 'function' ? v() : v);
+      }
+      args[args.length - 1] = Spacebars.kw(newHash);
+    }
+  }
+
+  return Spacebars.call.apply(null, args);
+};
+
+Spacebars.mustache = function (value/*, args*/) {
+  var result = Spacebars.mustacheImpl.apply(null, arguments);
+
+  if (result instanceof Spacebars.SafeString)
+    return HTML.Raw(result.toString());
+  else
+    // map `null`, `undefined`, and `false` to null, which is important
+    // so that attributes with nully values are considered absent.
+    // stringify anything else (e.g. strings, booleans, numbers including 0).
+    return (result == null || result === false) ? null : String(result);
+};
+
+Spacebars.attrMustache = function (value/*, args*/) {
+  var result = Spacebars.mustacheImpl.apply(null, arguments);
+
+  if (result == null || result === '') {
+    return null;
+  } else if (typeof result === 'object') {
+    return result;
+  } else if (typeof result === 'string' && HTML.isValidAttributeName(result)) {
+    var obj = {};
+    obj[result] = '';
+    return obj;
+  } else {
+    throw new Error("Expected valid attribute name, '', null, or object");
+  }
+};
+
+Spacebars.dataMustache = function (value/*, args*/) {
+  var result = Spacebars.mustacheImpl.apply(null, arguments);
+
+  return result;
+};
+
+// Idempotently wrap in `HTML.Raw`.
+//
+// Called on the return value from `Spacebars.mustache` in case the
+// template uses triple-stache (`{{{foo bar baz}}}`).
+Spacebars.makeRaw = function (value) {
+  if (value == null) // null or undefined
+    return null;
+  else if (value instanceof HTML.Raw)
+    return value;
+  else
+    return HTML.Raw(value);
+};
+
+// If `value` is a function, called it on the `args`, after
+// evaluating the args themselves (by calling them if they are
+// functions).  Otherwise, simply return `value` (and assert that
+// there are no args).
+Spacebars.call = function (value/*, args*/) {
+  if (typeof value === 'function') {
+    // evaluate arguments if they are functions (by calling them)
+    var newArgs = [];
+    for (var i = 1; i < arguments.length; i++) {
+      var arg = arguments[i];
+      newArgs[i-1] = (typeof arg === 'function' ? arg() : arg);
+    }
+
+    return value.apply(null, newArgs);
+  } else {
+    if (arguments.length > 1)
+      throw new Error("Can't call non-function: " + value);
+
+    return value;
+  }
+};
+
+// Call this as `Spacebars.kw({ ... })`.  The return value
+// is `instanceof Spacebars.kw`.
+Spacebars.kw = function (hash) {
+  if (! (this instanceof Spacebars.kw))
+    // called without new; call with new
+    return new Spacebars.kw(hash);
+
+  this.hash = hash || {};
+};
+
+// Call this as `Spacebars.SafeString("some HTML")`.  The return value
+// is `instanceof Spacebars.SafeString` (and `instanceof Handlebars.SafeString).
+Spacebars.SafeString = function (html) {
+  if (! (this instanceof Spacebars.SafeString))
+    // called without new; call with new
+    return new Spacebars.SafeString(html);
+
+  return new Handlebars.SafeString(html);
+};
+Spacebars.SafeString.prototype = Handlebars.SafeString.prototype;
+
+// `Spacebars.dot(foo, "bar", "baz")` performs a special kind
+// of `foo.bar.baz` that allows safe indexing of `null` and
+// indexing of functions (which calls the function).  If the
+// result is a function, it is always a bound function (e.g.
+// a wrapped version of `baz` that always uses `foo.bar` as
+// `this`).
+//
+// In `Spacebars.dot(foo, "bar")`, `foo` is assumed to be either
+// a non-function value or a "fully-bound" function wrapping a value,
+// where fully-bound means it takes no arguments and ignores `this`.
+//
+// `Spacebars.dot(foo, "bar")` performs the following steps:
+//
+// * If `foo` is falsy, return `foo`.
+//
+// * If `foo` is a function, call it (set `foo` to `foo()`).
+//
+// * If `foo` is falsy now, return `foo`.
+//
+// * Return `foo.bar`, binding it to `foo` if it's a function.
+Spacebars.dot = function (value, id1/*, id2, ...*/) {
+  if (arguments.length > 2) {
+    // Note: doing this recursively is probably less efficient than
+    // doing it in an iterative loop.
+    var argsForRecurse = [];
+    argsForRecurse.push(Spacebars.dot(value, id1));
+    argsForRecurse.push.apply(argsForRecurse,
+                              Array.prototype.slice.call(arguments, 2));
+    return Spacebars.dot.apply(null, argsForRecurse);
+  }
+
+  if (typeof value === 'function')
+    value = value();
+
+  if (! value)
+    return value; // falsy, don't index, pass through
+
+  var result = value[id1];
+  if (typeof result !== 'function')
+    return result;
+  // `value[id1]` (or `value()[id1]`) is a function.
+  // Bind it so that when called, `value` will be placed in `this`.
+  return function (/*arguments*/) {
+    return result.apply(value, arguments);
+  };
+};
+
+// Implement Spacebars's #with, which renders its else case (or nothing)
+// if the argument is falsy.
+Spacebars.With = function (argFunc, contentBlock, elseContentBlock) {
+  return UI.Component.extend({
+    init: function () {
+      this.v = UI.emboxValue(argFunc, UI.safeEquals);
+    },
+    render: function () {
+      return UI.If(this.v, UI.With(this.v, contentBlock), elseContentBlock);
+    },
+    materialized: (function () {
+      var f = function () {
+        var self = this;
+        if (Deps.active) {
+          Deps.onInvalidate(function () {
+            self.v.stop();
+          });
+        }
+      };
+      f.isWith = true;
+      return f;
+    })()
+  });
+};
+
+Spacebars.TemplateWith = function (argFunc, contentBlock) {
+  var w = UI.With(argFunc, contentBlock);
+  w.__isTemplateWith = true;
+  return w;
+};
diff --git a/packages/spark/convenience.js b/packages/spark/convenience.js
deleted file mode 100644
index a8e5a82fb6..0000000000
--- a/packages/spark/convenience.js
+++ /dev/null
@@ -1,22 +0,0 @@
-Meteor.render = function (htmlFunc) {
-  return Spark.render(function () {
-    return Spark.isolate(
-      typeof htmlFunc === 'function' ? htmlFunc : function() {
-        // non-function argument becomes a constant (non-reactive) string
-        return String(htmlFunc);
-      });
-  });
-};
-
-Meteor.renderList = function (cursor, itemFunc, elseFunc) {
-  return Spark.render(function () {
-    return Spark.list(cursor, function (item) {
-      var label = item._id ? idStringify(item._id) : null;
-      return Spark.labelBranch(label, function () {
-        return Spark.isolate(_.bind(itemFunc, null, item));
-      });
-    }, function () {
-      return elseFunc ? Spark.isolate(elseFunc) : '';
-    });
-  });
-};
diff --git a/packages/spark/package.js b/packages/spark/package.js
deleted file mode 100644
index 73b817a7ec..0000000000
--- a/packages/spark/package.js
+++ /dev/null
@@ -1,36 +0,0 @@
-Package.describe({
-  name: "spark",
-  test: "spark-test",
-  summary: "Toolkit for live-updating HTML interfaces",
-  version: '1.0.0',
-  internal: true
-});
-
-Package.on_use(function (api) {
-  api.use(['underscore', 'random', 'domutils', 'liverange', 'universal-events',
-           'ordered-dict', 'deps', 'ejson'],
-          'client');
-
-  // If we have minimongo available, use its idStringify function.
-  api.use('minimongo', 'client', {weak: true});
-
-  api.export('Spark', 'client');
-  api.export('SparkTest', 'client', {testOnly: true});
-
-  api.add_files(['spark.js', 'patch.js', 'convenience.js',
-                 'utils.js'], 'client');
-});
-
-Package.on_test(function (api) {
-  api.use('webapp', 'server');
-  api.use(['tinytest', 'underscore', 'liverange', 'deps', 'domutils',
-           'minimongo', 'random']);
-  api.use(['spark', 'test-helpers', 'jquery'], 'client');
-
-  api.add_files('test_form_responder.js', 'server');
-
-  api.add_files([
-    'spark_tests.js',
-    'patch_tests.js'
-  ], 'client');
-});
diff --git a/packages/spark/patch.js b/packages/spark/patch.js
deleted file mode 100644
index 7fcfbeb72f..0000000000
--- a/packages/spark/patch.js
+++ /dev/null
@@ -1,574 +0,0 @@
-patch = function(tgtParent, srcParent, tgtBefore, tgtAfter, preservations,
-                 results) {
-
-  var copyFunc = function(t, s) {
-    LiveRange.transplantTag(TAG, t, s);
-  };
-
-  var patcher = new Patcher(
-    tgtParent, srcParent, tgtBefore, tgtAfter);
-
-
-  var visitNodes = function(parent, before, after, func) {
-    for(var n = before ? before.nextSibling : parent.firstChild;
-        n && n !== after;
-        n = n.nextSibling) {
-      if (func(n) !== false && n.firstChild)
-        visitNodes(n, null, null, func);
-    }
-  };
-
-  // results arg is optional; it is mutated if provided; returned either way
-  results = (results || {});
-  // array of LiveRanges that were successfully preserved from
-  // the region preservations
-  var regionPreservations = (results.regionPreservations =
-                             results.regionPreservations || []);
-
-  var lastTgtMatch = null;
-
-  visitNodes(srcParent, null, null, function(src) {
-    // XXX inefficient to scan for match for every node!
-    // We could at least skip non-element nodes, except for "range matches"
-    // used for constant chunks, which may begin on a non-element.
-    // But really this shouldn't be a linear search.
-    var pres = _.find(preservations, function (p) {
-      // find preserved region starting at `src`, if any
-      return p.type === 'region' && p.newRange.firstNode() === src;
-    }) || _.find(preservations, function (p) {
-      // else, find preservation of `src`
-      return p.type === 'node' && p.to === src;
-    });
-
-    if (pres) {
-      var tgt = (pres.type === 'region' ? pres.fromStart : pres.from);
-      if (! lastTgtMatch ||
-          DomUtils.compareElementIndex(lastTgtMatch, tgt) < 0) {
-        if (pres.type === 'region') {
-          // preserved region for constant landmark
-          if (patcher.match(pres.fromStart, pres.newRange.firstNode(),
-                            copyFunc, true)) {
-            patcher.skipToSiblings(pres.fromEnd, pres.newRange.lastNode());
-            // without knowing or caring what DOM nodes are in pres.newRange,
-            // transplant the range data to pres.fromStart and pres.fromEnd
-            // (including references to enclosing ranges).
-            LiveRange.transplantRange(
-              pres.fromStart, pres.fromEnd, pres.newRange);
-            regionPreservations.push(pres.newRange);
-          }
-        } else if (pres.type === 'node') {
-          if (patcher.match(tgt, src, copyFunc)) {
-            // match succeeded
-            lastTgtMatch = tgt;
-            if (tgt.firstChild || src.firstChild) {
-              if (tgt.nodeName !== "TEXTAREA" && tgt.nodeName !== "SELECT") {
-                // Don't patch contents of TEXTAREA tag (which are only the
-                // initial contents but may affect the tag's .value in IE) or of
-                // SELECT (which is specially handled in _copyAttributes).
-                // Otherwise recurse!
-                patch(tgt, src, null, null, preservations);
-              }
-            }
-            return false; // tell visitNodes not to recurse
-          }
-        }
-      }
-    }
-    return true;
-  });
-
-  patcher.finish();
-
-  return results;
-};
-
-
-// A Patcher manages the controlled replacement of a region of the DOM.
-// The target region is changed in place to match the source region.
-//
-// The target region consists of the children of tgtParent, extending from
-// the child after tgtBefore to the child before tgtAfter.  A null
-// or absent tgtBefore or tgtAfter represents the beginning or end
-// of tgtParent's children.  The source region consists of all children
-// of srcParent, which may be a DocumentFragment.
-//
-// To use a new Patcher, call `match` zero or more times followed by
-// `finish`.
-//
-// A match is a correspondence between an old node in the target region
-// and a new node in the source region that will replace it.  Based on
-// this correspondence, the target node is preserved and the attributes
-// and children of the source node are copied over it.  The `match`
-// method declares such a correspondence.  A Patcher that makes no matches,
-// for example, just removes the target nodes and inserts the source nodes
-// in their place.
-//
-// Constructor:
-Patcher = function(tgtParent, srcParent, tgtBefore, tgtAfter) {
-  this.tgtParent = tgtParent;
-  this.srcParent = srcParent;
-
-  this.tgtBefore = tgtBefore;
-  this.tgtAfter = tgtAfter;
-
-  this.lastKeptTgtNode = null;
-  this.lastKeptSrcNode = null;
-};
-
-
-// Advances the patching process up to tgtNode in the target tree,
-// and srcNode in the source tree.  tgtNode will be preserved, with
-// the attributes of srcNode copied over it, in essence identifying
-// the two nodes with each other.  The same treatment is given to
-// any parents of the nodes that are newly implicated as corresponding.
-// In the process of traversing from the last matched nodes to these
-// ones, all nodes "in between" in the target document, at any level,
-// are removed, and all nodes "in between" in the source document
-// are copied over to their appropriate positions.
-//
-// For example, if match() is called only once, and then finish()
-// is called, the effect is to preserve tgtNode, its children,
-// and its ancestors (parent chain), while swapping out all its
-// siblings and the siblings of its ancestors, so that the target
-// tree is mutated to look like the source tree did.
-//
-// The caller is responsible for ensuring the precondition that
-// subsequent tgtNodes and subsequent srcNodes are strictly "in order."
-// The ordering referred to here is a partial order in which A comes
-// before B if their tags would be disjoint in HTML, i.e. the end of
-// A comes before the beginning of B.  Put another way, there is some
-// ancestor of A and some ancestor of B that have the same parent,
-// are different, and are in order.
-//
-// There are other requirements for two nodes to be "matched,"
-// but match() can detect them and exit gracefully returning false.
-// For example, the tag-names must be the same, and the tag-names
-// of their parents.  More subtly, it may be impossible to match
-// the parents of tgtNode or srcNode because they have been
-// previously matched.  If we are to match a series of P tags
-// that are each inside one DIV, for example, is it the same DIV
-// or not?  If the source and target disagree, we will have to
-// reparent one of the Ps.  Users should not be moving identified
-// nodes, but we want to still be correct (fall back on replacement)
-// if they do.
-//
-// If false is returned, the match was impossible, but patching
-// can continue and will still be otherwise correct.  The next call
-// to match() must still obey the order constraint, as the patcher
-// internally only moves forwards and patches as it goes.
-//
-// copyCallback is called on every new matched (tgt, src) pair
-// right after copying attributes.  It's a good time to transplant
-// liveranges and patch children.
-Patcher.prototype.match = function(
-  tgtNode, srcNode, copyCallback, onlyAdvance) {
-
-  // last nodes "kept" (matched/identified with each other)
-  var lastKeptTgt = this.lastKeptTgtNode;
-  var lastKeptSrc = this.lastKeptSrcNode;
-  // nodes to match and keep, this time around
-  var tgt = tgtNode;
-  var src = srcNode;
-
-  if ((! tgt) != (! src)) {
-    return false; // truthinesses don't match
-  }
-
-  var starting = ! lastKeptTgt;
-  var finishing = ! tgt;
-
-  if (! starting) {
-    // move lastKeptTgt/lastKeptSrc forward and out,
-    // until they are siblings of tgt/src or of an ancestor of tgt/src,
-    // replacing as we go.  If tgt/src is falsy, we make it to the
-    // top level.
-    while (lastKeptTgt.parentNode !== this.tgtParent &&
-           ! (tgt && DomUtils.elementContains(lastKeptTgt.parentNode, tgt))) {
-      // Last-kept nodes are inside parents that are not
-      // parents of the newly matched nodes.  Must finish
-      // replacing their contents and back out.
-      this._replaceNodes(lastKeptTgt, null, lastKeptSrc, null);
-      lastKeptTgt = lastKeptTgt.parentNode;
-      lastKeptSrc = lastKeptSrc.parentNode;
-    }
-
-    // update instance vars; there's no going back inside these nodes
-    this.lastKeptTgtNode = lastKeptTgt;
-    this.lastKeptSrcNode = lastKeptSrc;
-
-    // Make sure same number of levels of "moving up" are
-    // appropriate for src as well, i.e. we aren't trying
-    // to match <c> in (<a><b/><c/></a>, <a><b/></a><a><c/></a>)
-    // after matching <b>, or vice versa.  In other words,
-    // if tag names and depths match, but identities of parents
-    // are inconsistent relative to previous matches, we catch it
-    // here.  In the example, lastKeptTgt would be the <b/> node
-    // on the left, which is not sibling of <c/> or of an ancestor
-    // of <c/> on the right.  If the example were reversed,
-    // lastKeptTgt would be the first <a> node, which is an
-    // ancestor of <c/> on the left rather than a sibling of an
-    // ancestor.
-    if (! finishing &&
-        (DomUtils.elementContains(lastKeptSrc, src) ||
-         ! (lastKeptSrc.parentNode === this.srcParent ||
-            DomUtils.elementContains(lastKeptSrc.parentNode, src)))) {
-      return false;
-    }
-  }
-
-  if (finishing) {
-    this._replaceNodes(lastKeptTgt, null, lastKeptSrc, null,
-                       this.tgtParent, this.srcParent);
-  } else {
-    // Compare tag names and depths to make sure we can match nodes...
-    if (! onlyAdvance) {
-      if (tgt.nodeName !== src.nodeName)
-        return false;
-    }
-
-    // Look at tags of parents until we hit parent of last-kept,
-    // which we know is ok.
-    for(var a=tgt.parentNode, b=src.parentNode;
-        a !== (starting ? this.tgtParent : lastKeptTgt.parentNode);
-        a = a.parentNode, b = b.parentNode) {
-      if (b === (starting ? this.srcParent : lastKeptSrc.parentNode))
-        return false; // src is shallower, b hit top first
-      if (a.nodeName !== b.nodeName)
-        return false; // tag names don't match
-    }
-    if (b !== (starting ? this.srcParent : lastKeptSrc.parentNode)) {
-      return false; // src is deeper, b didn't hit top when a did
-    }
-
-    var firstIter = true;
-    // move tgt and src backwards and out, replacing as we go
-    while (true) {
-      if (! (firstIter && onlyAdvance)) {
-        if (tgt.nodeType === 1) /* ELEMENT */
-          Patcher._copyAttributes(tgt, src);
-        if (copyCallback)
-          copyCallback(tgt, src);
-      }
-
-      firstIter = false;
-
-      if ((starting ? this.tgtParent : lastKeptTgt.parentNode)
-          === tgt.parentNode) {
-        // we've worked our way up to the same level as the last-kept nodes
-        this._replaceNodes(lastKeptTgt, tgt, lastKeptSrc, src);
-        break;
-      } else {
-        this._replaceNodes(null, tgt, null, src);
-        // move up to keep (match) parents as well
-        tgt = tgt.parentNode;
-        src = src.parentNode;
-      }
-    }
-  }
-
-  this.lastKeptTgtNode = tgtNode;
-  this.lastKeptSrcNode = srcNode;
-
-  return true;
-};
-
-// After a match, skip ahead to later siblings of the last kept nodes,
-// without performing any replacements.
-Patcher.prototype.skipToSiblings = function(tgt, src) {
-  var lastTgt = this.lastKeptTgtNode;
-  var lastSrc = this.lastKeptSrcNode;
-
-  if (! (lastTgt && lastTgt.parentNode === tgt.parentNode))
-    return false;
-
-  if (! (lastSrc && lastSrc.parentNode === src.parentNode))
-    return false;
-
-  this.lastKeptTgtNode = tgt;
-  this.lastKeptSrcNode = src;
-
-  return true;
-};
-
-// Completes patching assuming no more matches.
-//
-// Patchers are single-use, so no more methods can be called
-// on the Patcher.
-Patcher.prototype.finish = function() {
-  return this.match(null, null);
-};
-
-// Replaces the siblings between tgtBefore and tgtAfter (exclusive on both
-// sides) with the siblings between srcBefore and srcAfter (exclusive on both
-// sides).  Falsy values indicate start or end of siblings as appropriate.
-//
-// Precondition: tgtBefore and tgtAfter have same parent; either may be falsy,
-// but not both, unless optTgtParent is provided.  Same with srcBefore/srcAfter.
-Patcher.prototype._replaceNodes = function(
-  tgtBefore, tgtAfter, srcBefore, srcAfter, optTgtParent, optSrcParent)
-{
-  var tgtParent = optTgtParent || (tgtBefore || tgtAfter).parentNode;
-  var srcParent = optSrcParent || (srcBefore || srcAfter).parentNode;
-
-  // deal with case where top level is a range
-  if (tgtParent === this.tgtParent) {
-    tgtBefore = tgtBefore || this.tgtBefore;
-    tgtAfter = tgtAfter || this.tgtAfter;
-  }
-  if (srcParent === this.srcParent) {
-    srcBefore = srcBefore || this.srcBefore;
-    srcAfter = srcAfter || this.srcAfter;
-  }
-
-
-  // remove old children
-  var n;
-  while ((n = tgtBefore ? tgtBefore.nextSibling : tgtParent.firstChild)
-         && n !== tgtAfter) {
-    tgtParent.removeChild(n);
-  }
-
-  // add new children
-  var m;
-  while ((m = srcBefore ? srcBefore.nextSibling : srcParent.firstChild)
-         && m !== srcAfter) {
-    tgtParent.insertBefore(m, tgtAfter || null);
-  }
-};
-
-// Copy HTML attributes of node `src` onto node `tgt`.
-//
-// The effect we are trying to achieve is best expresed in terms of
-// HTML.  Whatever HTML generated `tgt`, we want to mutate the DOM element
-// so that it is as if it were the HTML that generated `src`.
-// We want to preserve JavaScript properties in general (tgt.foo),
-// while syncing the HTML attributes (tgt.getAttribute("foo")).
-//
-// This is complicated by form controls and the fact that old IE
-// can't keep the difference straight between properties and attributes.
-Patcher._copyAttributes = function(tgt, src) {
-  var srcAttrs = src.attributes;
-  var tgtAttrs = tgt.attributes;
-
-  // Determine whether tgt has focus; works in all browsers
-  // as of FF3, Safari4
-  var targetFocused = (tgt === document.activeElement);
-
-  ///// Clear current attributes
-
-  if (tgt.style.cssText)
-    tgt.style.cssText = '';
-
-  var isRadio = false;
-  var finalChecked = null;
-  if (tgt.nodeName === "INPUT") {
-    // Record for later whether this is a radio button.
-    isRadio = (tgt.type === 'radio');
-
-    // Figure out whether this should be checked or not. If the re-rendering
-    // changed its idea of checkedness, go with that; otherwsie go with whatever
-    // the control's current setting is.
-    if (isRadio || tgt.type === 'checkbox') {
-      var tgtOriginalChecked = !!tgt._sparkOriginalRenderedChecked &&
-            tgt._sparkOriginalRenderedChecked[0];
-      var srcOriginalChecked = !!src._sparkOriginalRenderedChecked &&
-            src._sparkOriginalRenderedChecked[0];
-      // For radio buttons, we previously saved the checkedness in an expando
-      // property before doing some DOM operations that could wipe it out. For
-      // checkboxes, we can just use the checked property directly.
-      var tgtCurrentChecked = tgt._currentChecked ?
-            tgt._currentChecked[0] : tgt.checked;
-      if (tgtOriginalChecked === srcOriginalChecked) {
-        finalChecked = tgtCurrentChecked;
-      } else {
-        finalChecked = srcOriginalChecked;
-        tgt._sparkOriginalRenderedChecked = [finalChecked];
-      }
-    }
-  }
-
-  for(var i=tgtAttrs.length-1; i>=0; i--) {
-    var attr = tgtAttrs[i];
-    // In old IE, attributes that are possible on a node
-    // but not actually present will show up in this loop
-    // with specified=false.  All other browsers support
-    // 'specified' (because it's part of the spec) and
-    // set it to true.
-    if (! attr.specified)
-      continue;
-    var name = attr.name;
-    // Filter out attributes that are indexable by number
-    // but not by name.  This kills the weird "propdescname"
-    // attribute in IE 8.
-    if (! tgtAttrs[name])
-      continue;
-    // Some properties don't mutate well, and we simply
-    // don't try to patch them.  For example, you can't
-    // change a control's type in IE.
-    if (name === "id" || name === "type")
-      continue;
-    // Removing a radio button's "name" property and restoring
-    // it is harmless in most browsers but breaks in IE 7.
-    // It seems unlikely enough that a radio button will
-    // sometimes have a group and sometimes not.
-    if (isRadio && name === "name")
-      continue;
-    // Never delete the "value" attribute: we have special three-way diff logic
-    // for it at the end.
-    if (name === "value")
-      continue;
-    // Removing 'src' (e.g. in an iframe) can only be bad.
-    if (name === "src")
-      continue;
-
-    // We want to patch any HTML attributes that were specified in the
-    // source, but preserve DOM properties set programmatically.
-    // Old IE makes this difficult by exposing properties as attributes.
-    // Expando properties will even appear in innerHTML, though not if the
-    // value is an object rather than a primitive.
-    //
-    // We use a heuristic to determine if we are looking at a programmatic
-    // property (an expando) rather than a DOM attribute.
-    //
-    // Losing jQuery's expando (whose value is a number) is very bad,
-    // because it points to event handlers that only jQuery can detach,
-    // and only if the expando is in place.
-    var possibleExpando = tgt[name];
-    if (possibleExpando &&
-        (typeof possibleExpando === "object" ||
-         /^jQuery/.test(name)))
-      continue; // for object properties that surface attributes only in IE
-    tgt.removeAttributeNode(attr);
-  }
-
-  ///// Copy over src's attributes
-
-  if (tgt.mergeAttributes) {
-    // IE code path:
-    //
-    // Only IE (all versions) has mergeAttributes.
-    // It's probably a good bit faster in old IE than
-    // iterating over all the attributes, and the treatment
-    // of form controls is sufficiently different in IE from
-    // other browsers that we keep the special cases separate.
-
-    // Don't copy _sparkOriginalRenderedValue, though.
-    var srcExpando = src._sparkOriginalRenderedValue;
-    src.removeAttribute('_sparkOriginalRenderedValue');
-
-    tgt.mergeAttributes(src);
-    if (srcExpando)
-      src._sparkOriginalRenderedValue = srcExpando;
-
-    if (src.name)
-      tgt.name = src.name;
-
-  } else {
-    // Non-IE code path:
-
-    for(var i=0, L=srcAttrs.length; i<L; i++) {
-      var srcA = srcAttrs.item(i);
-      if (srcA.specified) {
-        var name = srcA.name.toLowerCase();
-        var value = String(srcA.value);
-        if (name === "type") {
-        // can't change type of INPUT in IE; don't support it
-        } else if (name === "checked") {
-          // handled specially below
-        } else if (name === "style") {
-          tgt.style.cssText = src.style.cssText;
-        } else if (name === "class") {
-          tgt.className = src.className;
-        } else if (name === "value") {
-          // don't set attribute, just overwrite property
-          // (in next phase)
-        } else if (name === "src") {
-          // only set if different.  protects iframes
-          if (src.src !== tgt.src)
-            tgt.src = src.src;
-        } else {
-          try {
-            tgt.setAttribute(name, value);
-          } catch (e) {
-            throw new Error("Error copying attribute '" + name + "': " + e);
-          }
-        }
-      }
-    }
-  }
-
-  var originalRenderedValue = function (node) {
-    if (!node._sparkOriginalRenderedValue)
-      return null;
-    return node._sparkOriginalRenderedValue[0];
-  };
-  var srcOriginalRenderedValue = originalRenderedValue(src);
-  var tgtOriginalRenderedValue = originalRenderedValue(tgt);
-
-  // Save the target's current value.
-  var tgtCurrentValue = DomUtils.getElementValue(tgt);
-
-  if (tgt.nodeName === "SELECT") {
-    // Copy over the descendents of the tag (eg, OPTIONs, OPTGROUPs, etc) so
-    // that we get the new version's OPTIONs. (We don't look for any more nested
-    // preserved regions inside the element.)
-    while (tgt.firstChild)
-      tgt.removeChild(tgt.firstChild);
-    while (src.firstChild)
-      tgt.insertBefore(src.firstChild, null);
-    // ... but preserve the original <SELECT>'s value if possible (ie, ignore
-    // any <OPTION SELECTED>s that we may have copied over).
-    DomUtils.setElementValue(tgt, tgtCurrentValue);
-  }
-
-  // We preserve the old element's value unless both of the following are true:
-  //   - The newly rendered value is different from the old rendered value: ie,
-  //     something has actually changed on the server.
-  //   - It's unfocused. If it's focused, the user might be editing it, and
-  //     we don't want to update what the user is currently editing (and lose
-  //     the selection, etc).
-  //
-  // After updating the element's value, we update its
-  // _sparkOriginalRenderedValue to match.
-  //
-  // There's a case where we choose to update _sparkOriginalRenderedValue even
-  // though we're not updating the visible value. That's when the element is
-  // focused (preventing us from updating the visible value), but the newly
-  // rendered value matches the visible value. In this case, updating the
-  // visible value would have been a no-op, so we can do the matching
-  // _sparkOriginalRenderedValue update.
-  //
-  // Note that we expect src._sparkOriginalRenderedValue[0] to be equal to
-  // src.value. For <LI>'s, though, there is a value property (the ordinal in
-  // the list) even though there is no value attribute (and thus no saved
-  // _sparkOriginalRenderedValue), so we do have to be sure to do the comparison
-  // with src._sparkOriginalRenderedValue[0] rather than with src.value.
-  if (srcOriginalRenderedValue !== tgtOriginalRenderedValue &&
-      (tgtCurrentValue === srcOriginalRenderedValue || !targetFocused)) {
-    // Update the on-screen value to the newly rendered value, but only if it's
-    // an actual change (a seemingly "no-op" value update resets the selection,
-    // so don't do that!)
-    if (tgtCurrentValue !== srcOriginalRenderedValue)
-      DomUtils.setElementValue(tgt, srcOriginalRenderedValue);
-    // ... and overwrite the saved rendered value too, so that the next time
-    // around we'll be comparing to this rendered value instead of the old one.
-    tgt._sparkOriginalRenderedValue = [srcOriginalRenderedValue];
-  }
-
-  // Deal with checkboxes and radios.
-  if (finalChecked !== null) {
-    // Don't do a no-op write to 'checked', since in some browsers that triggers
-    // events.
-    if (tgt.checked !== finalChecked)
-      tgt.checked = finalChecked;
-
-    // Set various other fields related to checkedness.
-    tgt.defaultChecked = finalChecked;
-    if (finalChecked)
-      tgt.setAttribute("checked", "checked");
-    else
-      tgt.removeAttribute("checked");
-  }
-};
-
-SparkTest.Patcher = Patcher;
diff --git a/packages/spark/patch_tests.js b/packages/spark/patch_tests.js
deleted file mode 100644
index a5360b4c5f..0000000000
--- a/packages/spark/patch_tests.js
+++ /dev/null
@@ -1,251 +0,0 @@
-Tinytest.add("spark - patch - basic", function(test) {
-
-  var Patcher = SparkTest.Patcher;
-
-  var div = function(html) {
-    var n = document.createElement("DIV");
-    n.innerHTML = html;
-    return n;
-  };
-  var tag = function(node, tagName, which) {
-    return node.getElementsByTagName(tagName)[which || 0];
-  };
-  var assert_html = function(actual, expected) {
-    actual = (typeof actual === "string" ? actual : actual.innerHTML);
-    expected = (typeof expected === "string" ? expected : expected.innerHTML);
-    test.equal(actual.toLowerCase(), expected.toLowerCase());
-  };
-
-  var x,y,p,ret;
-
-  x = div("<b><i>foo</i><u>bar</u></b>");
-  y = div("<b><u>qux</u><s>baz</s></b>");
-  p = new Patcher(x, y);
-  ret = p.match(tag(x, 'u'), tag(y, 'u'));
-  test.isTrue(ret);
-  assert_html(x, "<b><u>bar</u></b>");
-  ret = p.finish();
-  test.isTrue(ret);
-  assert_html(x, "<b><u>bar</u><s>baz</s></b>");
-
-  x = div("<b><i>foo</i><u>bar</u></b>");
-  y = div("<b><u>qux</u><s>baz</s></b>");
-  p = new Patcher(x, y);
-  ret = p.finish();
-  test.isTrue(ret);
-  assert_html(x, "<b><u>qux</u><s>baz</s></b>");
-
-  x = div("<b><i><u>foo</u></i></b><b><i><u><s>bar</s></u></i></b>");
-  y = div(
-    "1<b>2<i>3<u>foo</u>4</i>5</b>6<b>7<i>8<u>9<s>bar</s>10</u>11</i>12</b>13");
-  p = new Patcher(x, y);
-  ret = p.match(tag(x, 'u'), tag(y, 'u'));
-  test.isTrue(ret);
-  assert_html(x, "1<b>2<i>3<u>foo</u></i></b><b><i><u><s>bar</s></u></i></b>");
-  ret = p.match(tag(x, 's'), tag(y, 's'));
-  test.isTrue(ret);
-  assert_html(
-    x,
-    "1<b>2<i>3<u>foo</u>4</i>5</b>6<b>7<i>8<u>9<s>bar</s></u></i></b>");
-  ret = p.finish();
-  test.isTrue(ret);
-  assert_html(
-    x,
-    "1<b>2<i>3<u>foo</u>4</i>5</b>6<b>7<i>8<u>9<s>bar</s>10</u>11</i>12</b>13");
-
-  // mismatched parents, detection and recovery
-
-  x = div("<b><i>foo</i><u>bar</u></b>");
-  y = div("<b><i>foo</i></b><b><u>bar</u></b>");
-  p = new Patcher(x,y);
-  ret = p.match(tag(x, 'i'), tag(y, 'i'));
-  test.isTrue(ret);
-  assert_html(x, "<b><i>foo</i><u>bar</u></b>");
-  ret = p.match(tag(x, 'u'), tag(y, 'u'));
-  test.isFalse(ret);
-  assert_html(x, "<b><i>foo</i><u>bar</u></b>");
-  ret = p.finish();
-  test.isTrue(ret);
-  assert_html(x,"<b><i>foo</i></b><b><u>bar</u></b>");
-
-  x = div("<b><i>foo</i></b><b><u>bar</u></b>");
-  y = div("<b><i>foo</i><u>bar</u></b>");
-  p = new Patcher(x,y);
-  ret = p.match(tag(x, 'i'), tag(y, 'i'));
-  test.isTrue(ret);
-  assert_html(x, "<b><i>foo</i></b><b><u>bar</u></b>");
-  ret = p.match(tag(x, 'u'), tag(y, 'u'));
-  test.isFalse(ret);
-  assert_html(x, "<b><i>foo</i><u>bar</u></b><b><u>bar</u></b>");
-  ret = p.finish();
-  test.isTrue(ret);
-  assert_html(x, "<b><i>foo</i><u>bar</u></b>");
-
-  // mismatched tag name, detection and recovery
-  x = div("<b><i>foo</i><u>bar</u></b>");
-  y = div("<i><u>bar</u><s>baz</s></i>");
-  p = new Patcher(x, y);
-  ret = p.match(tag(x, 'u'), tag(y, 'u'));
-  test.isFalse(ret);
-  ret = p.finish();
-  test.isTrue(ret);
-  assert_html(x, "<i><u>bar</u><s>baz</s></i>");
-
-  var t = "_foo";
-  var liverange = function(start, end, inner) {
-    return new LiveRange(t, start, end, inner);
-  };
-
-  var rangeTest = function(extras) {
-    var aaa = extras[0], zzz = extras[1];
-    x = div(aaa+"<b><i>foo</i><u>bar</u></b>"+zzz);
-    y = div("<b><u>bar</u><s>baz</s></b>");
-    var rng = liverange(tag(y, 'u'));
-    var tgt = liverange(tag(x, 'b'));
-    p = new Patcher(tgt.containerNode(), y,
-                    tgt.firstNode().previousSibling,
-                    tgt.lastNode().nextSibling);
-    var copyCallback = function(tgt, src) {
-      LiveRange.transplantTag(t, tgt, src);
-    };
-    ret = p.match(tag(x, 'u'), tag(y, 'u'), copyCallback);
-    test.isTrue(ret);
-    assert_html(x, aaa+"<b><u>bar</u></b>"+zzz);
-    ret = p.finish();
-    test.isTrue(ret);
-    assert_html(x, aaa+"<b><u>bar</u><s>baz</s></b>"+zzz);
-    test.equal(rng.firstNode(), tag(x, 'u'));
-  };
-
-  _.each([["aaa","zzz"], ["",""], ["aaa",""], ["","zzz"]], rangeTest);
-});
-
-Tinytest.add("spark - patch - copyAttributes", function(test) {
-
-  var attrTester = function(tagName, initial) {
-    var node;
-    var allAttrNames = {};
-    var lastAttrs;
-    var self = {
-      copy: function(kv) {
-        var buf = [];
-        buf.push('<', tagName);
-        _.each(kv, function(v,k) {
-          allAttrNames[k] = true;
-          buf.push(' ', k);
-          if (v !== 'NO_VALUE')
-            buf.push('="', v, '"');
-        });
-        buf.push('></', tagName, '>');
-        var nodeHtml = buf.join('');
-        var frag = DomUtils.htmlToFragment(nodeHtml);
-        var n = frag.firstChild;
-        n._sparkOriginalRenderedChecked = [n.checked];
-        if (! node) {
-          node = n;
-        } else {
-          SparkTest.Patcher._copyAttributes(node, n);
-        }
-        lastAttrs = {};
-        _.each(allAttrNames, function(v,k) {
-          lastAttrs[k] = false;
-        });
-        _.each(kv, function(v,k) {
-          if (k === "style") {
-            lastAttrs[k] = n.style.cssText;
-          } else {
-            lastAttrs[k] = String(v);
-          }
-        });
-        return self;
-      },
-      check: function() {
-        _.each(lastAttrs, function(v,k) {
-          var actualAttr;
-          var expectedAttr = v || "";
-          if (k === "style") {
-            actualAttr = node.style.cssText;
-          } else if (k === "class") {
-            actualAttr = node.className;
-          } else if (k === "checked") {
-            actualAttr = String(node.getAttribute(k) || "");
-            if (expectedAttr === "NO_VALUE")
-              expectedAttr = "checked";
-            if (actualAttr === "true")
-              actualAttr = "checked"; // save IE's butt
-          } else {
-            actualAttr = String(node.getAttribute(k) || "");
-          }
-          test.equal(actualAttr, expectedAttr, k);
-        });
-      },
-      node: function() { return node; }
-    };
-    if (initial)
-      self.copy(initial);
-    return self;
-  };
-
-  var a = attrTester('div',
-                     {id:'foo', 'class':'bar',
-                      style:'border:1px solid blue;', name:'baz'});
-  a.check();
-  test.equal(a.node().style.borderLeftColor, "blue");
-
-  a.copy({id: "foo", style:'border:1px solid red'});
-  a.check();
-  test.equal(a.node().style.borderLeftColor, "red");
-
-  a.copy({id: "foo", 'class':'ha'});
-  a.check();
-  test.equal(a.node().style.borderColor, "");
-  test.equal(a.node().className, "ha");
-
-  var obj = {};
-  a.node().nifty = obj;
-  a.copy({id: "foo", 'class':'ha hee'});
-  a.check();
-  test.equal(a.node().nifty, obj, 'nifty'); // test object property preservation
-
-
-  var c = attrTester('input', {type:'checkbox', name:'foo', checked:'checked'});
-  c.check();
-  test.equal(c.node().checked, true);
-  c.copy({type:'checkbox', name:'foo'});
-  c.check();
-  test.equal(c.node().checked, false);
-  c.copy({type:'checkbox', name:'foo', checked:'checked'});
-  c.check();
-  test.equal(c.node().checked, true);
-  c.copy({type:'checkbox', name:'foo'});
-  c.check();
-  test.equal(c.node().checked, false);
-
-  var d = attrTester('input', {type:'checkbox', name:'foo'});
-  test.equal(c.node().checked, false);
-  c.copy({type:'checkbox', name:'foo', checked:'checked'});
-  c.check();
-  test.equal(c.node().checked, true);
-  c.copy({type:'checkbox', name:'foo'});
-  c.check();
-  test.equal(c.node().checked, false);
-  c.copy({type:'checkbox', name:'foo', checked:'checked'});
-  c.check();
-  test.equal(c.node().checked, true);
-  c.copy({type:'checkbox', name:'foo'});
-  c.check();
-  test.equal(c.node().checked, false);
-  c.copy({type:'checkbox', name:'foo', checked:'NO_VALUE'});
-  c.check();
-  test.equal(c.node().checked, true);
-
-  c.copy({type:'checkbox', name:'bar'});
-  test.expect_fail(); // changing "name" on a form control won't take in IE
-  test.equal(c.node().getAttribute("name"), 'bar');
-
-  c.copy({type:'radio', name:'foo'});
-  test.expect_fail(); // changing "type" on a form control won't take in IE
-  test.equal(c.node().getAttribute("type"), 'radio');
-
-
-});
diff --git a/packages/spark/spark.js b/packages/spark/spark.js
deleted file mode 100644
index 13dfc7f5ff..0000000000
--- a/packages/spark/spark.js
+++ /dev/null
@@ -1,1244 +0,0 @@
-// XXX adjust Spark API so that the modules (eg, list, events) could
-// have been written by third parties on top of the public API?
-
-// XXX rename isolate to reflect that it is the only root of
-// deps-based reactivity ('track'? 'compute'? 'sync'?)
-
-// XXX specify flush order someday (context dependencies? is this in
-// the domain of spark -- overdraw concerns?)
-
-// XXX if not on IE6-8, don't do the extra work (traversals for event
-// setup) those browsers require
-
-// XXX flag errors if you have two landmarks with the same branch
-// path, or if you have multiple preserve nodes in a landmark with the
-// same selector and label
-
-// XXX should functions with an htmlFunc use try/finally inside?
-
-// XXX test that non-Spark.render case works for each function (eg,
-// list() returns the expected HTML, Spark.createLandmark creates and
-// then destroys a landmark -- may already be tested?)
-
-// XXX in landmark-demo, if Template.timer.created throws an exception,
-// then it is never called again, even if you push the 'create a
-// timer' button again. the problem is almost certainly in afterFlush
-// (not hard to see what it is.)
-
-Spark = {};
-SparkTest = {};
-
-var currentRenderer = (function () {
-  var current = null;
-  return {
-    get: function () {
-      return current;
-    },
-    withValue: function (v, func) {
-      var previous = current;
-      current = v;
-      try { return func(); }
-      finally { current = previous; }
-    }
-  };
-})();
-
-TAG = "_spark_" + Random.id();
-SparkTest.TAG = TAG;
-
-// We also export this as Spark._TAG due to a historical accident. I
-// don't know if anything uses it (possibly some of Chris Mather's
-// stuff?)  but let's keep exporting it since without it it would be
-// very difficult for code outside the spark package to, eg, walk
-// spark's liverange hierarchy.
-Spark._TAG = TAG;
-
-// XXX document contract for each type of annotation?
-var ANNOTATION_NOTIFY = "notify";
-var ANNOTATION_DATA = "data";
-var ANNOTATION_ISOLATE = "isolate";
-var ANNOTATION_EVENTS = "events";
-var ANNOTATION_WATCH = "watch";
-var ANNOTATION_LABEL = "label";
-var ANNOTATION_LANDMARK = "landmark";
-var ANNOTATION_LIST = "list";
-var ANNOTATION_LIST_ITEM = "item";
-// XXX why do we need, eg, _ANNOTATION_ISOLATE? it has no semantics?
-
-// Use from tests to turn on extra UniversalEventListener sanity checks
-var checkIECompliance = false;
-SparkTest.setCheckIECompliance = function (value) {
-  checkIECompliance = value;
-};
-
-// Private interface to 'preserve-inputs' package
-var globalPreserves = {};
-Spark._addGlobalPreserve = function (selector, value) {
-  globalPreserves[selector] = value;
-};
-
-
-var makeRange = function (type, start, end, inner) {
-  var range = new LiveRange(TAG, start, end, inner);
-  range.type = type;
-  return range;
-};
-
-var findRangeOfType = function (type, node) {
-  var range = LiveRange.findRange(TAG, node);
-  while (range && range.type !== type)
-    range = range.findParent();
-
-  return range;
-};
-
-var findParentOfType = function (type, range) {
-  do {
-    range = range.findParent();
-  } while (range && range.type !== type);
-
-  return range;
-};
-
-var notifyWatchers = function (start, end) {
-  var tempRange = new LiveRange(TAG, start, end, true /* innermost */);
-  for (var walk = tempRange; walk; walk = walk.findParent())
-    if (walk.type === ANNOTATION_WATCH)
-      walk.notify();
-  tempRange.destroy();
-};
-
-var eventGuardActive = false;
-// Spark does DOM manipulation inside an event guard to prevent events
-// like "blur" from firing.  It would be nice to deliver these events
-// in some cases, but running fresh event handling code on an invalid
-// LiveRange tree can easily produce errors.
-// This guard was motivated by seeing errors in Todos when switching
-// windows while an input field is focused.
-var withEventGuard = function (func) {
-  var previous = eventGuardActive;
-  eventGuardActive = true;
-  try { return func(); }
-  finally { eventGuardActive = previous; }
-};
-
-Renderer = function () {
-  // Map from annotation ID to an annotation function, which is called
-  // at render time and receives (startNode, endNode).
-  this.annotations = {};
-
-  // Map from branch path to "notes" object, organized as a tree.
-  // Each node in the tree has child pointers named ('_'+label).
-  // Properties that don't start with '_' are arbitrary notes.
-  // For example, the "happiness" of the branch path consisting
-  // of labels "foo" and then "bar" would be
-  // `this._branchNotes._foo._bar.happiness`.
-  // Access to these notes is provided by LabelStack objects, of
-  // which `this.currentBranch` is one.
-  this._branchNotes = {};
-
-  // The label stack representing the current branch path we
-  // are in (based on calls to `Spark.labelBranch(label, htmlFunc)`).
-  this.currentBranch = this.newLabelStack();
-
-  // All landmark ranges created during this rendering.
-  this.landmarkRanges = [];
-
-  // Assembles the preservation information for patching.
-  this.pc = new PreservationController;
-};
-
-_.extend(Renderer.prototype, {
-  // `what` can be a function that takes a LiveRange, or just a set of
-  // attributes to add to the liverange.  type and what are optional.
-  // if no type is passed, no liverange will be created.
-  // If what is a function, it will be called no matter what, even
-  // if the annotated HTML was not used and no LiveRange was created,
-  // in which case it gets null as an argument.
-  annotate: function (html, type, what) {
-    if (typeof what !== 'function') {
-      var attribs = what;
-      what = function (range) {
-        if (range)
-          _.extend(range, attribs);
-      };
-    }
-    // The annotation tags that we insert into HTML strings must be
-    // unguessable in order to not create potential cross-site scripting
-    // attack vectors, so we use random strings.  Even a well-written app
-    // that avoids XSS vulnerabilities might, for example, put
-    // unescaped < and > in HTML attribute values, where they are normally
-    // safe.  We can't assume that a string like '<1>' came from us
-    // and not arbitrary user-entered data.
-    var id = (type || '') + ":" + Random.id();
-    this.annotations[id] = function (start, end) {
-      if ((! start) || (! type)) {
-        // ! start: materialize called us with no args because this
-        // annotation wasn't used
-        // ! type: no type given, don't generate a LiveRange
-        what(null);
-        return;
-      }
-      var range = makeRange(type, start, end);
-      what(range);
-    };
-
-    return "<$" + id + ">" + html + "</$" + id + ">";
-  },
-
-  // A LabelStack is a mutable branch path that you can modify
-  // by pushing or popping labels.  At any time, you can ask for
-  // this Renderer's notes for the current branch path.
-  // Renderer's `currentBranch` field is a LabelStack, but you
-  // can create your own for the purpose of walking the branches
-  // and accessing notes.
-  newLabelStack: function () {
-    var stack = [this._branchNotes];
-    return {
-      pushLabel: function (label) {
-        var top = stack[stack.length - 1];
-        var key = '_' + label;
-        stack.push(top[key] = (top[key] || {}));
-      },
-      popLabel: function () {
-        stack.pop();
-      },
-      getNotes: function () {
-        var top = stack[stack.length - 1];
-        return top;
-      },
-      // Mark this branch with `getNotes()[prop] = true` and also
-      // walk up the stack marking parent branches (until an
-      // existing truthy value for `prop` is found).
-      // This makes it easy to test whether any descendent of a
-      // branch has the mark.
-      mark: function (prop) {
-        for (var i = stack.length - 1;
-             i >= 0 && ! stack[i][prop];
-             i--)
-          stack[i][prop] = true;
-      }
-    };
-  },
-
-  // Turn the `html` string into a fragment, applying the annotations
-  // from 'renderer' in the process.
-  materialize: function (htmlFunc) {
-    var self = this;
-
-    var html = currentRenderer.withValue(self, htmlFunc);
-    html = self.annotate(html); // wrap with an anonymous annotation
-
-    var fragById = {};
-    var replaceInclusions = function (container) {
-      var n = container.firstChild;
-      while (n) {
-        var next = n.nextSibling;
-        if (n.nodeType === 8) { // COMMENT
-          var frag = fragById[n.nodeValue];
-          if (frag === false) {
-            // id already used!
-            throw new Error("Spark HTML fragments may only be used once. " +
-                            "Second use in " +
-                            DomUtils.fragmentToHtml(container));
-          } else if (frag) {
-            fragById[n.nodeValue] = false; // mark as used
-            DomUtils.wrapFragmentForContainer(frag, n.parentNode);
-            n.parentNode.replaceChild(frag, n);
-          }
-        } else if (n.nodeType === 1) { // ELEMENT
-          replaceInclusions(n);
-        }
-        n = next;
-      }
-    };
-
-    var bufferStack = [[]];
-    var idStack = [];
-    var ret;
-
-    var regex = /<(\/?)\$([^<>]+)>|<|[^<]+/g;
-    regex.lastIndex = 0;
-    var parts;
-    while ((parts = regex.exec(html))) {
-      var isOpen = ! parts[1];
-      var id = parts[2];
-      var annotationFunc = self.annotations[id];
-      if (annotationFunc === false) {
-        throw new Error("Spark HTML fragments may be used only once. " +
-                        "Second use of: " +
-                        DomUtils.fragmentToHtml(fragById[id]));
-      } else if (! annotationFunc) {
-        bufferStack[bufferStack.length - 1].push(parts[0]);
-      } else if (isOpen) {
-        idStack.push(id);
-        bufferStack.push([]);
-      } else {
-        var idOnStack = idStack.pop();
-        if (idOnStack !== id)
-          throw new Error("Range mismatch: " + idOnStack + " / " + id);
-        var frag = DomUtils.htmlToFragment(bufferStack.pop().join(''));
-        replaceInclusions(frag);
-        // empty frag becomes HTML comment <!--empty--> so we have start/end
-        // nodes to pass to the annotation function
-        if (! frag.firstChild)
-          frag.appendChild(document.createComment("empty"));
-        annotationFunc(frag.firstChild, frag.lastChild);
-        self.annotations[id] = false; // mark as used
-        if (! idStack.length) {
-          // we're done; we just rendered the contents of the top-level
-          // annotation that we wrapped around htmlFunc ourselves.
-          // there may be unused fragments in fragById that include
-          // LiveRanges, but only if the user broke the rules by including
-          // an annotation somewhere besides element level, like inside
-          // an attribute (which is not allowed).
-          ret = frag;
-          break;
-        }
-        fragById[id] = frag;
-        bufferStack[bufferStack.length - 1].push('<!--' + id + '-->');
-      }
-    }
-
-    scheduleOnscreenSetup(ret, self.landmarkRanges);
-    self.landmarkRanges = [];
-
-    _.each(self.annotations, function(annotationFunc) {
-      if (annotationFunc)
-        // call annotation func with no arguments to mean "you weren't used"
-        annotationFunc();
-    });
-    self.annotations = {};
-
-    // Save original versions of every 'value' property. We want elements that
-    // have a value *attribute*, as well as form elements that have a value
-    // property but no value attribute (textarea and select).
-    //
-    // We save it in a one-element array expando. We use the array because IE8
-    // gets confused by expando properties with scalar values and exposes them
-    // as HTML attributes.
-    //
-    // We also save the values of CHECKED for radio and checkboxes.
-    _.each(DomUtils.findAll(ret, '[value], textarea, select'), function (node) {
-      node._sparkOriginalRenderedValue = [DomUtils.getElementValue(node)];
-    });
-    _.each(DomUtils.findAll(ret, 'input[type=checkbox], input[type=radio]'),
-           function (node) {
-      node._sparkOriginalRenderedChecked = [!!node.checked];
-    });
-
-    return ret;
-  }
-
-});
-
-// Decorator for Spark annotations that take `html` and are
-// pass-through without a renderer.  With this decorator,
-// the annotation routine gets the current renderer, and
-// if there isn't one returns `html` (the last argument).
-var withRenderer = function (f) {
-  return function (/* arguments */) {
-    var renderer = currentRenderer.get();
-    var args = _.toArray(arguments);
-    if (!renderer)
-      return args.pop();
-    args.push(renderer);
-    return f.apply(null, args);
-  };
-};
-
-/******************************************************************************/
-/* Render and finalize                                                        */
-/******************************************************************************/
-
-// Schedule setup tasks to run at the next flush, which is when the
-// newly rendered fragment must be on the screen (if it doesn't want
-// to get garbage-collected.)
-//
-// 'landmarkRanges' is a list of the landmark ranges in 'frag'. It may be
-// omitted if frag doesn't contain any landmarks.
-//
-// XXX expose in the public API, eg as Spark.introduce(), so the user
-// can call it when manually inserting nodes? (via, eg, jQuery?) -- of
-// course in that case 'landmarkRanges' would be empty.
-var scheduleOnscreenSetup = function (frag, landmarkRanges) {
-  var renderedRange = new LiveRange(TAG, frag);
-  var finalized = false;
-  renderedRange.finalize = function () {
-    finalized = true;
-  };
-
-  Deps.afterFlush(function () {
-    if (finalized)
-      return;
-
-    if (!DomUtils.isInDocument(renderedRange.firstNode())) {
-      // We've detected that some nodes were taken off the screen
-      // without calling Spark.finalize(). This could be because the
-      // user rendered them, but didn't insert them in the document
-      // before the next flush(). Or it could be because they used to
-      // be onscreen, but they were manually taken offscreen (eg, with
-      // jQuery) and the user neglected to call finalize() on the
-      // removed nodes. Help the user out by finalizing the entire
-      // subtree that is offscreen.
-      var node = renderedRange.firstNode();
-      while (node.parentNode)
-        node = node.parentNode;
-      if (node["_protect"]) {
-        // test code can use this property to mark a root-level node
-        // (such as a DocumentFragment) as immune from
-        // autofinalization. effectively, the DocumentFragment is
-        // considered to be a first-class peer of `document`.
-      } else {
-        Spark.finalize(node);
-        return;
-      }
-    }
-
-    // Deliver render callbacks to all landmarks that are now
-    // onscreen (possibly not for the first time.)
-    _.each(landmarkRanges, function (landmarkRange) {
-      if (! landmarkRange.isPreservedConstant)
-        landmarkRange.rendered.call(landmarkRange.landmark);
-    });
-
-    // Deliver render callbacks to all landmarks that enclose the
-    // updated region.
-    //
-    // XXX unify with notifyWatchers. maybe remove _ANNOTATION_WATCH
-    // and just give everyone a contentsModified callback (sibling to
-    // 'finalize')
-    //
-    // future: include an argument in the callback to distinguish this
-    // case from the previous
-    var walk = renderedRange;
-    while ((walk = findParentOfType(ANNOTATION_LANDMARK, walk)))
-      walk.rendered.call(walk.landmark);
-
-    // This code can run several times on the same nodes (if the
-    // output of a render is included in a render), so it must be
-    // idempotent. This is not the best, asymptotically. There are
-    // things we could do to improve it.
-    notifyWatchers(renderedRange.firstNode(), renderedRange.lastNode());
-    renderedRange.destroy();
-  });
-};
-
-Spark.render = function (htmlFunc) {
-  var renderer = new Renderer;
-  var frag = renderer.materialize(htmlFunc);
-  return frag;
-};
-
-
-// Find all of all nodes and regions that should be preserved in
-// patching. Return a list of objects. There are two kinds of objects
-// in the list:
-//
-// A preserved node:
-//   {type: "node", from: Node, to: Node}
-//
-// A preserved (constant) region:
-//   {type: "region", fromStart: Node, fromEnd: Node,
-//      newRange: LiveRange}
-//
-// `existingRange` is the range in the document whose contents are to
-// be replaced. `newRange` holds the new contents and is not part of
-// the document DOM tree.  The implementation will temporarily reparent
-// the nodes in `newRange` into the document to check for selector matches.
-var PreservationController = function () {
-  this.roots = []; // keys 'landmarkRange', 'fromRange', 'toRange'
-  this.regionPreservations = [];
-};
-
-_.extend(PreservationController.prototype, {
-  // Specify preservations that should be in effect on a fromRange/toRange
-  // pair.  If specified, `optContextNode` should be an ancestor node of
-  // fromRange that selectors are to be considered relative to.
-  addRoot: function (preserve, fromRange, toRange, optContextNode) {
-    var self = this;
-    self.roots.push({ context: optContextNode, preserve: preserve,
-                      fromRange: fromRange, toRange: toRange});
-  },
-
-  addConstantRegion: function (from, to) {
-    var self = this;
-    self.regionPreservations.push({
-      type: "region",
-      fromStart: from.firstNode(), fromEnd: from.lastNode(),
-      newRange: to
-    });
-  },
-
-  computePreservations: function (existingRange, newRange) {
-    var self = this;
-    var preservations = _.clone(self.regionPreservations);
-
-    var visitLabeledNodes = function (context, clipRange, nodeLabeler, selector, func) {
-      context = (context || clipRange.containerNode());
-      var nodes = DomUtils.findAllClipped(
-        context, selector, clipRange.firstNode(), clipRange.lastNode());
-
-      _.each(nodes, function (n) {
-        var label = nodeLabeler(n);
-        label && func(n, label);
-      });
-    };
-
-    // Find the old incarnation of each of the preserved nodes
-    _.each(self.roots, function (root) {
-      root.fromNodesByLabel = {};
-      _.each(root.preserve, function (nodeLabeler, selector) {
-        root.fromNodesByLabel[selector] = {};
-        visitLabeledNodes(
-          root.context, root.fromRange, nodeLabeler, selector,
-          function (n, label) {
-            root.fromNodesByLabel[selector][label] = n;
-          });
-      });
-    });
-
-    // Temporarily put newRange into the document so that we can do
-    // properly contextualized selector queries against it.
-    //
-    // Create a temporary range around newRange, and also around any enclosing
-    // ranges that happen to also start and end on those nodes.  It is ok
-    // to temporarily put these in the document as well, because CSS selectors
-    // don't care and we will put them back.  `tempRange` will hold our place
-    // in the tree `newRange` came from.
-    var tempRange = new LiveRange(TAG, newRange.firstNode(), newRange.lastNode());
-    var commentFrag = document.createDocumentFragment();
-    commentFrag.appendChild(document.createComment(""));
-    var newRangeFrag = tempRange.replaceContents(commentFrag);
-    // `wrapperRange` will mark where we inserted newRange into the document.
-    var wrapperRange = new LiveRange(TAG, newRangeFrag);
-    existingRange.insertBefore(newRangeFrag);
-
-    _.each(self.roots, function (root) {
-      _.each(root.preserve, function (nodeLabeler, selector) {
-        visitLabeledNodes(root.context, root.toRange, nodeLabeler, selector, function (n, label) {
-          var match = root.fromNodesByLabel[selector][label];
-          if (match) {
-            preservations.push({ type: "node", from: match, to: n });
-            root.fromNodesByLabel[selector][label] = null;
-          }
-        });
-      });
-    });
-
-    // Extraction is legal because we're just taking the document
-    // back to the state it was in before insertBefore.
-    var extractedFrag = wrapperRange.extract();
-    wrapperRange.destroy();
-    tempRange.replaceContents(extractedFrag);
-    tempRange.destroy();
-
-    return preservations;
-  }
-});
-
-
-// XXX debugging
-var pathForRange = function (r) {
-  var path = [], r;
-  while ((r = findParentOfType(ANNOTATION_LABEL, r)))
-    path.unshift(r.label);
-  return path.join(' :: ');
-};
-
-// `range` is a region of `document`. Modify it in-place so that it
-// matches the result of Spark.render(htmlFunc), preserving landmarks.
-//
-Spark.renderToRange = function (range, htmlFunc) {
-  // `range` may be out-of-document and we don't check here.
-  // XXX should we?
-  //
-  // Explicit finalization of ranges (done within Spark or by a call to
-  // Spark.finalize) prevents us from being called in the first place.
-  // The newly rendered material will be checked to see if it's in the
-  // document by scheduleOnscreenSetUp's scheduled setup.
-  // However, if range is not valid, bail out now before running
-  // htmlFunc.
-  var startNode = range.firstNode();
-  if (! startNode || ! startNode.parentNode)
-    return;
-
-  var renderer = new Renderer();
-
-  // Call 'func' for each landmark in 'range'. Pass two arguments to
-  // 'func', the range, and an extra "notes" object such that two
-  // landmarks receive the same (===) notes object iff they have the
-  // same branch path. 'func' can write to the notes object so long as
-  // it limits itself to attributes that do not start with '_'.
-  var visitLandmarksInRange = function (range, func) {
-    var stack = renderer.newLabelStack();
-
-    range.visit(function (isStart, r) {
-      if (r.type === ANNOTATION_LABEL) {
-        if (isStart)
-          stack.pushLabel(r.label);
-        else
-          stack.popLabel();
-      } else if (r.type === ANNOTATION_LANDMARK && isStart) {
-        func(r, stack.getNotes());
-      }
-    });
-  };
-
-  // Find all of the landmarks in the old contents of the range
-  visitLandmarksInRange(range, function (landmarkRange, notes) {
-    notes.originalRange = landmarkRange;
-  });
-
-  // Once we render the new fragment, as soon as it is placed into the DOM (even
-  // temporarily), if any radio buttons in the new framgent are checked, any
-  // radio buttons with the same name in the entire document will be unchecked
-  // (since only one radio button of a given name can be checked at a time). So
-  // we save the current checked value of all radio buttons in an expando.
-  var radios = DomUtils.findAllClipped(
-    range.containerNode(), 'input[type=radio]',
-    range.firstNode(), range.lastNode());
-  _.each(radios, function (node) {
-    node._currentChecked = [!!node.checked];
-  });
-
-  var frag = renderer.materialize(htmlFunc);
-
-  DomUtils.wrapFragmentForContainer(frag, range.containerNode());
-
-  var tempRange = new LiveRange(TAG, frag);
-
-  // find preservation roots from matched landmarks inside the
-  // rerendered region
-  var pc = renderer.pc;
-  visitLandmarksInRange(
-    tempRange, function (landmarkRange, notes) {
-      if (notes.originalRange) {
-        if (landmarkRange.constant)
-          pc.addConstantRegion(notes.originalRange, landmarkRange);
-
-        pc.addRoot(landmarkRange.preserve,
-                   notes.originalRange, landmarkRange);
-      }
-    });
-
-  // find preservation roots that come from landmarks enclosing the
-  // updated region
-  var walk = range;
-  while ((walk = walk.findParent())) {
-    if (! walk.firstNode().parentNode)
-      // we're in a DOM island with a top-level range (not really
-      // allowed, but could happen if `range` is on nodes that
-      // manually removed.
-      // XXX check for this sooner; hard to reason about this function
-      // on a "malformed" liverange tree
-      break;
-
-    if (walk.type === ANNOTATION_LANDMARK, walk)
-      pc.addRoot(walk.preserve, range, tempRange, walk.containerNode());
-  }
-
-  pc.addRoot(globalPreserves, range, tempRange);
-
-  // compute preservations (must do this before destroying tempRange)
-  var preservations = pc.computePreservations(range, tempRange);
-
-  tempRange.destroy();
-
-  var results = {};
-
-  // Patch! (using preservations)
-  withEventGuard(function () {
-    range.operate(function (start, end) {
-      // XXX this will destroy all liveranges, including ones
-      // inside constant regions whose DOM nodes we are going
-      // to preserve untouched
-      Spark.finalize(start, end);
-      patch(start.parentNode, frag, start.previousSibling,
-            end.nextSibling, preservations, results);
-    });
-  });
-
-  _.each(results.regionPreservations, function (landmarkRange) {
-    // Rely on the fact that computePreservations only emits
-    // region preservations whose ranges are landmarks.
-    // This flag means that landmarkRange is a new constant landmark
-    // range that matched an old one *and* was DOM-preservable by
-    // the patcher.
-    landmarkRange.isPreservedConstant = true;
-  });
-};
-
-// Delete all of the liveranges in the range of nodes between `start`
-// and `end`, and call their 'finalize' function if any. Or instead of
-// `start` and `end` you may pass a fragment in `start`.
-//
-Spark.finalize = function (start, end) {
-  if (! start.parentNode && start.nodeType !== 11 /* DocumentFragment */) {
-    // Workaround for LiveRanges' current inability to contain
-    // a node with no parentNode.
-    var frag = document.createDocumentFragment();
-    frag.appendChild(start);
-    start = frag;
-    end = null;
-  }
-  var wrapper = new LiveRange(TAG, start, end);
-  wrapper.visit(function (isStart, range) {
-    isStart && range.finalize && range.finalize();
-  });
-  wrapper.destroy(true /* recursive */);
-};
-
-/******************************************************************************/
-/* Data contexts                                                              */
-/******************************************************************************/
-
-Spark.setDataContext = withRenderer(function (dataContext, html, _renderer) {
-  return _renderer.annotate(
-    html, ANNOTATION_DATA, { data: dataContext });
-});
-
-Spark.getDataContext = function (node) {
-  var range = findRangeOfType(ANNOTATION_DATA, node);
-  return range && range.data;
-};
-
-/******************************************************************************/
-/* Events                                                                     */
-/******************************************************************************/
-
-var universalListener = null;
-var getListener = function () {
-  if (!universalListener)
-    universalListener = new UniversalEventListener(function (event) {
-      // Handle a currently-propagating event on a particular node.
-      // We walk each enclosing liverange of the node and offer it the
-      // chance to handle the event. It's range.handler's
-      // responsibility to check isImmediatePropagationStopped()
-      // before delivering events to the user. We precompute the list
-      // of enclosing liveranges to defend against the case where user
-      // event handlers change the DOM.
-
-      if (eventGuardActive)
-        // swallow the event
-        return;
-
-      var ranges = [];
-      var walk = findRangeOfType(ANNOTATION_EVENTS,
-                                 event.currentTarget);
-      while (walk) {
-        ranges.push(walk);
-        walk = findParentOfType(ANNOTATION_EVENTS, walk);
-      }
-      _.each(ranges, function (r) {
-        r.handler(event);
-      });
-    }, checkIECompliance);
-
-  return universalListener;
-};
-
-Spark.attachEvents = withRenderer(function (eventMap, html, _renderer) {
-  var listener = getListener();
-
-  var handlerMap = {}; // type -> [{selector, callback}, ...]
-  // iterate over eventMap, which has form {"type selector, ...": callbacks},
-  // callbacks can either be a fn, or an array of fns
-  // and populate handlerMap
-  _.each(eventMap, function(callbacks, spec) {
-    if ('function' === typeof callbacks) {
-      callbacks = [ callbacks ];
-    }
-    var clauses = spec.split(/,\s+/);
-    // iterate over clauses of spec, e.g. ['click .foo', 'click .bar']
-    _.each(clauses, function (clause) {
-      var parts = clause.split(/\s+/);
-      if (parts.length === 0)
-        return;
-
-      var type = parts.shift();
-      var selector = parts.join(' ');
-
-      handlerMap[type] = handlerMap[type] || [];
-      _.each(callbacks, function(callback) {
-        handlerMap[type].push({selector: selector, callback: callback});
-      });
-    });
-  });
-
-  var eventTypes = _.keys(handlerMap);
-
-  var installHandlers = function (range) {
-    _.each(eventTypes, function (t) {
-      for(var n = range.firstNode(),
-              after = range.lastNode().nextSibling;
-          n && n !== after;
-          n = n.nextSibling)
-        listener.installHandler(n, t);
-    });
-  };
-
-  html = _renderer.annotate(
-    html, ANNOTATION_WATCH, {
-      notify: function () {
-        installHandlers(this);
-      }
-    });
-
-  var finalized = false;
-
-  html = _renderer.annotate(
-    html, ANNOTATION_EVENTS, function (range) {
-      if (! range)
-        return;
-
-      _.each(eventTypes, function (t) {
-        listener.addType(t);
-      });
-      installHandlers(range);
-
-      range.finalize = function () {
-        finalized = true;
-      };
-
-      range.handler = function (event) {
-        var handlers = handlerMap[event.type] || [];
-
-        for (var i = 0; i < handlers.length; i++) {
-          if (finalized || event.isImmediatePropagationStopped())
-            return;
-
-          var handler = handlers[i];
-          var callback = handler.callback;
-          var selector = handler.selector;
-
-          if (selector) {
-            if (! DomUtils.matchesSelectorClipped(
-              event.currentTarget, range.containerNode(), selector,
-              range.firstNode(), range.lastNode())) {
-              continue;
-            }
-          } else {
-            // if no selector, only match the event target
-            if (event.currentTarget !== event.target)
-              continue;
-          }
-
-          // Found a matching handler. Call it.
-          var eventData = Spark.getDataContext(event.currentTarget) || {};
-          var landmarkRange =
-                findParentOfType(ANNOTATION_LANDMARK, range);
-          var landmark = (landmarkRange && landmarkRange.landmark);
-
-          // Note that the handler can do arbitrary things, like call
-          // Deps.flush() or otherwise remove and finalize parts of
-          // the DOM.  We can't assume `range` is valid past this point,
-          // and we'll check the `finalized` flag at the top of the loop.
-          var returnValue = callback.call(eventData, event, landmark);
-
-          // allow app to `return false` from event handler, just like
-          // you can in a jquery event handler
-          if (returnValue === false) {
-            event.stopImmediatePropagation();
-            event.preventDefault();
-          }
-        }
-      };
-    });
-
-  return html;
-});
-
-/******************************************************************************/
-/* Isolate                                                                    */
-/******************************************************************************/
-
-Spark.isolate = function (htmlFunc) {
-  var renderer = currentRenderer.get();
-  if (!renderer)
-    return htmlFunc();
-
-  var range;
-  var firstRun = true;
-  var retHtml;
-  Deps.autorun(function (handle) {
-    if (firstRun) {
-      retHtml = renderer.annotate(
-        htmlFunc(), ANNOTATION_ISOLATE,
-        function (r) {
-          if (! r) {
-            // annotation not used; kill this autorun
-            handle.stop();
-          } else {
-            range = r;
-            range.finalize = function () {
-              // Spark.finalize() was called on our range (presumably
-              // because it was removed from the document.)  Kill
-              // this autorun.
-              handle.stop();
-            };
-          }
-        });
-      firstRun = false;
-    } else {
-      Spark.renderToRange(range, htmlFunc);
-    }
-  });
-
-  return retHtml;
-};
-
-/******************************************************************************/
-/* Lists                                                                      */
-/******************************************************************************/
-
-// XXX duplicated code from minimongo.js.  It's small though.
-var applyChanges = function (doc, changeFields) {
-  _.each(changeFields, function (value, key) {
-    if (value === undefined)
-      delete doc[key];
-    else
-      doc[key] = value;
-  });
-};
-
-
-// If minimongo is available (it's a weak dependency) use its ID stringifier (so
-// that, eg, ObjectId and strings don't overlap). Otherwise just use the
-// identity function.
-// This is also used in convenience.js.
-idStringify = Package.minimongo
-  ? Package.minimongo.LocalCollection._idStringify
-  : function (id) { return id; };
-
-Spark.list = function (cursor, itemFunc, elseFunc) {
-  elseFunc = elseFunc || function () { return ''; };
-
-  // Create a level of indirection around our cursor callbacks so we
-  // can change them later
-  var callbacks = {};
-  var observerCallbacks = {};
-  _.each(["addedBefore", "removed", "movedBefore", "changed"], function (name) {
-    observerCallbacks[name] = function () {
-      return callbacks[name].apply(null, arguments);
-    };
-  });
-
-  // Get the current contents of the cursor.
-
-  var itemDict = new OrderedDict(idStringify);
-  _.extend(callbacks, {
-    addedBefore: function (id, item, before) {
-      var doc = EJSON.clone(item);
-      doc._id = id;
-      var elt = {doc: doc, liveRange: null};
-      itemDict.putBefore(id, elt, before);
-    }
-  });
-  var handle = cursor.observeChanges(observerCallbacks);
-
-  // Get the renderer, if any
-  var renderer = currentRenderer.get();
-  var maybeAnnotate = renderer ?
-        _.bind(renderer.annotate, renderer) :
-    function (html) { return html; };
-
-  // Templates should have access to data and methods added by the
-  // transformer, but observeChanges doesn't transform, so we have to do
-  // it here.
-  //
-  // NOTE: this is a little bit of an abstraction violation. Ideally,
-  // the only thing Spark should know about Minimongo is the contract of
-  // observeChanges. In theory, anything that implements observeChanges
-  // could be passed to Spark.list. But meh.
-  var transformedDoc = function (doc) {
-    if (cursor.getTransform && cursor.getTransform())
-      return cursor.getTransform()(EJSON.clone(doc));
-    return doc;
-  };
-
-  // Render the initial contents. If we have a renderer, create a
-  // range around each item as well as around the list, and save them
-  // off for later.
-  var html = '';
-  var outerRange;
-  if (itemDict.empty())
-    html = elseFunc();
-  else {
-    itemDict.forEach(function (elt) {
-        html += maybeAnnotate(
-          itemFunc(transformedDoc(elt.doc)),
-          ANNOTATION_LIST_ITEM,
-          function (range) {
-            elt.liveRange = range;
-          });
-    });
-  }
-  var stopped = false;
-  var cleanup = function () {
-    handle.stop();
-    stopped = true;
-  };
-  html = maybeAnnotate(html, ANNOTATION_LIST, function (range) {
-    if (! range) {
-      // We never ended up on the screen (caller discarded our return
-      // value)
-      cleanup();
-    } else {
-      outerRange = range;
-      outerRange.finalize = cleanup;
-    }
-  });
-
-  // No renderer? Then we have no way to update the returned html and
-  // we can close the observer.
-  if (! renderer)
-    cleanup();
-
-  // Called by `removed` and `moved` in order to cause render callbacks on
-  // parent landmarks.
-  // XXX This is not the final solution.  1) This code should be unified
-  // with the code in scheduleOnscreenSetup.  2) In general, lists are
-  // going to cause a lot of callbacks (one per collection callback).
-  // Maybe that will make sense if we give render callbacks subrange info.
-  var notifyParentsRendered = function () {
-    var walk = outerRange;
-    while ((walk = findParentOfType(ANNOTATION_LANDMARK, walk)))
-      walk.rendered.call(walk.landmark);
-  };
-
-  var later = function (f) {
-    Deps.afterFlush(function () {
-      if (! stopped)
-        withEventGuard(f);
-    });
-  };
-
-  // The DOM update callbacks.
-  _.extend(callbacks, {
-    addedBefore: function (id, fields, before) {
-      later(function () {
-        var doc = EJSON.clone(fields);
-        doc._id = id;
-        var frag = Spark.render(_.bind(itemFunc, null, transformedDoc(doc)));
-        DomUtils.wrapFragmentForContainer(frag, outerRange.containerNode());
-        var range = makeRange(ANNOTATION_LIST_ITEM, frag);
-
-        if (itemDict.empty()) {
-          Spark.finalize(outerRange.replaceContents(frag));
-        } else if (before === null) {
-          itemDict.lastValue().liveRange.insertAfter(frag);
-        } else {
-          itemDict.get(before).liveRange.insertBefore(frag);
-        }
-        itemDict.putBefore(id, {doc: doc, liveRange: range}, before);
-      });
-    },
-
-    removed: function (id) {
-      later(function () {
-        if (itemDict.first() === itemDict.last()) {
-          var frag = Spark.render(elseFunc);
-          DomUtils.wrapFragmentForContainer(frag, outerRange.containerNode());
-          Spark.finalize(outerRange.replaceContents(frag));
-        } else
-          Spark.finalize(itemDict.get(id).liveRange.extract());
-
-        itemDict.remove(id);
-
-        notifyParentsRendered();
-      });
-    },
-
-    movedBefore: function (id, before) {
-      later(function () {
-        var frag = itemDict.get(id).liveRange.extract();
-        if (before === null) {
-          itemDict.lastValue().liveRange.insertAfter(frag);
-        } else {
-          itemDict.get(before).liveRange.insertBefore(frag);
-        }
-        itemDict.moveBefore(id, before);
-        notifyParentsRendered();
-      });
-    },
-
-    changed: function (id, fields) {
-      later(function () {
-        var elt = itemDict.get(id);
-        if (!elt)
-          throw new Error("Unknown id for changed: " + id);
-        applyChanges(elt.doc, fields);
-        Spark.renderToRange(elt.liveRange,
-                            _.bind(itemFunc, null, transformedDoc(elt.doc)));
-      });
-    }
-  });
-
-  return html;
-};
-
-/******************************************************************************/
-/* Labels and landmarks                                                       */
-/******************************************************************************/
-
-var nextLandmarkId = 1;
-
-Spark.Landmark = function () {
-  this.id = nextLandmarkId++;
-  this._range = null; // will be set when put onscreen
-};
-
-_.extend(Spark.Landmark.prototype, {
-  firstNode: function () {
-    return this._range.firstNode();
-  },
-  lastNode: function () {
-    return this._range.lastNode();
-  },
-  find: function (selector) {
-    var r = this._range;
-    return DomUtils.findClipped(r.containerNode(), selector,
-                                r.firstNode(), r.lastNode());
-  },
-  findAll: function (selector) {
-    var r = this._range;
-    return DomUtils.findAllClipped(r.containerNode(), selector,
-                                   r.firstNode(), r.lastNode());
-  },
-  hasDom: function () {
-    return !! this._range;
-  }
-});
-
-Spark.UNIQUE_LABEL = ['UNIQUE_LABEL'];
-
-// label must be a string.
-// or pass label === null to not drop a label after all (meaning that
-// this function is a noop)
-//
-Spark.labelBranch = function (label, htmlFunc) {
-  var renderer = currentRenderer.get();
-  if (! renderer || label === null)
-    return htmlFunc();
-
-  if (label === Spark.UNIQUE_LABEL)
-    label = Random.id();
-
-  renderer.currentBranch.pushLabel(label);
-  var html = htmlFunc();
-  var occupied = renderer.currentBranch.getNotes().occupied;
-  renderer.currentBranch.popLabel();
-
-  if (! occupied)
-    // don't create annotation if branch doesn't contain any landmarks.
-    // if this label isn't on an element-level HTML boundary, then that
-    // is certainly the case.
-    return html;
-
-  return renderer.annotate(
-    html, ANNOTATION_LABEL, { label: label });
-
-  // XXX what happens if the user doesn't use the return value, or
-  // doesn't use it directly, eg, swaps the branches of the tree
-  // around? "that's an error?" the result would be that the apparent
-  // branch path of a landmark at render time would be different from
-  // its apparent branch path in the actual document. seems like the
-  // answer is to have labelBranch not drop an annotation, and keep
-  // the branch label info outside of the DOM in a parallel tree of
-  // labels and landmarks (likely similar to the one we're already
-  // keeping?) a little tricky since not every node in the label tree
-  // is actually populated with a landmark? (though we could change
-  // that I guess -- they would be landmarks without any specific DOM
-  // nodes?)
-};
-
-Spark.createLandmark = function (options, htmlFunc) {
-  var renderer = currentRenderer.get();
-  if (! renderer) {
-    // no renderer -- create and destroy Landmark inline
-    var landmark = new Spark.Landmark;
-    options.created && options.created.call(landmark);
-    var html = htmlFunc(landmark);
-    options.destroyed && options.destroyed.call(landmark);
-    return html;
-  }
-
-  // Normalize preserve map
-  var preserve = {};
-  if (_.isArray(options.preserve))
-    _.each(options.preserve, function (selector) {
-      preserve[selector] = true;
-    });
-  else
-    preserve = options.preserve || {};
-  for (var selector in preserve)
-    if (typeof preserve[selector] !== 'function')
-      preserve[selector] = function () { return true; };
-
-  renderer.currentBranch.mark('occupied');
-  var notes = renderer.currentBranch.getNotes();
-  var landmark;
-  if (notes.originalRange) {
-    if (notes.originalRange.superceded)
-      throw new Error("Can't create second landmark in same branch");
-    notes.originalRange.superceded = true; // prevent destroyed(), second match
-    landmark = notes.originalRange.landmark; // the old Landmark
-  } else {
-    landmark = new Spark.Landmark;
-    if (options.created) {
-      // Run callback outside the current Spark.isolate's deps context.
-      Deps.nonreactive(function () {
-        options.created.call(landmark);
-      });
-    }
-  }
-  notes.landmark = landmark;
-
-  var html = htmlFunc(landmark);
-  return renderer.annotate(
-    html, ANNOTATION_LANDMARK, function (range) {
-      if (! range) {
-        // annotation not used
-        options.destroyed && options.destroyed.call(landmark);
-        return;
-      }
-
-      _.extend(range, {
-        preserve: preserve,
-        constant: !! options.constant,
-        rendered: options.rendered || function () {},
-        destroyed: options.destroyed || function () {},
-        landmark: landmark,
-        finalize: function () {
-          if (! this.superceded) {
-            this.landmark._range = null;
-            this.destroyed.call(this.landmark);
-          }
-        }
-      });
-
-      landmark._range = range;
-      renderer.landmarkRanges.push(range);
-      // Help GC avoid an actual memory leak (#1157) by nulling the
-      // `renderer` local variable, which holds data structures about
-      // the preservation and patching performed during this rendering
-      // pass, including references to the old LiveRanges.  If
-      // `renderer` is retained by the LiveRange we initialize here,
-      // it creates a chain linking the new LiveRanges to the
-      // renderer, to the old LiveRanges, to the old renderer, etc.
-      //
-      // The reason the new LiveRange might retains `renderer` has to
-      // do with how V8 implements closures.  V8 considers
-      // `range.finalize` to close over `renderer`, even though it
-      // doesn't use it.  Because `renderer` is used by *some* nested
-      // closure, it apparently is retained by all nested closures as
-      // part of `Spark.createLandmark`'s function context.
-      renderer = null;
-    });
-};
-
-SparkTest.getEnclosingLandmark = function (node) {
-  var range = findRangeOfType(ANNOTATION_LANDMARK, node);
-  return range ? range.landmark : null;
-};
diff --git a/packages/spark/spark_tests.js b/packages/spark/spark_tests.js
deleted file mode 100644
index e543ade932..0000000000
--- a/packages/spark/spark_tests.js
+++ /dev/null
@@ -1,3887 +0,0 @@
-// XXX make sure that when tests use id="..." to trigger patching, "preserve" happens
-// XXX test that events inside constant regions still work after patching
-// XXX test arguments to landmark rendered callback
-// XXX test variable wrapping (eg TR vs THEAD) inside each branch of Spark.list?
-
-
-SparkTest.setCheckIECompliance(true);
-
-// Tests can use {preserve: idNameLabels} or renderWithPreservation
-// to cause any element with an id or name to be preserved.  This effect
-// is similar to what the preserve-inputs package does, though it applies
-// to all elements, not just inputs.
-
-var idNameLabels = {
-  '*[id], *[name]': Spark._labelFromIdOrName
-};
-
-var renderWithPreservation = function (htmlFunc) {
-  return Meteor.render(function () {
-    return Spark.createLandmark({ preserve: idNameLabels}, htmlFunc);
-  });
-};
-
-var eventmap = function (/*args*/) {
-  // support event_buf as final argument
-  var event_buf = null;
-  if (arguments.length && _.isArray(arguments[arguments.length-1])) {
-    event_buf = arguments[arguments.length-1];
-    arguments.length--;
-  }
-  var events = {};
-  _.each(arguments, function (esel) {
-    var etyp = esel.split(' ')[0];
-    events[esel] = function (evt) {
-      if (evt.type !== etyp)
-        throw new Error(etyp+" event arrived as "+evt.type);
-      (event_buf || this).push(esel);
-    };
-  });
-  return events;
-};
-
-var nodesToArray = function (array) {
-  // Starting in underscore 1.4, _.toArray does not work right on a node
-  // list in IE8. This is a workaround to support IE8.
-  return _.map(array, _.identity);
-};
-
-Tinytest.add("spark - assembly", function (test) {
-
-  var furtherCanon = function(str) {
-    // further canonicalize innerHTML in IE by adding close
-    // li tags to "<ul><li>one<li>two<li>three</li></ul>"
-    return str.replace(/<li>(\w*)(?=<li>)/g, function(s) {
-      return s+"</li>";
-    });
-  };
-
-  var doTest = function (calc) {
-    var frag = Spark.render(function () {
-      return calc(function (str, expected) {
-        return Spark.setDataContext(null, str);
-      });
-    });
-    var groups = [];
-    var html = calc(function (str, expected, noRange) {
-      if (arguments.length > 1)
-        str = expected;
-      if (! noRange)
-        groups.push(str);
-      return str;
-    });
-    var f = WrappedFrag(frag);
-    test.equal(furtherCanon(f.html()), html);
-
-    var actualGroups = [];
-    var tempRange = new LiveRange(SparkTest.TAG, frag);
-    tempRange.visit(function (isStart, rng) {
-      if (! isStart && rng.type === "data" /* Spark._ANNOTATION_DATA */)
-        actualGroups.push(furtherCanon(canonicalizeHtml(
-          DomUtils.rangeToHtml(rng.firstNode(), rng.lastNode()))));
-    });
-    test.equal(actualGroups.join(','), groups.join(','));
-  };
-
-  doTest(function (A) { return "<p>Hello</p>"; });
-  doTest(function (A) { return "<td>Hello</td><td>World</td>"; });
-  doTest(function (A) { return "<td>"+A("Hello")+"</td>"; });
-  doTest(function (A) { return A("<td>"+A("Hello")+"</td>"); });
-  doTest(function (A) { return A(A(A(A(A(A("foo")))))); });
-  doTest(
-    function (A) { return "<div>Yo"+A("<p>Hello "+A(A("World")),"<p>Hello World</p>")+
-                  "</div>"; });
-  doTest(function (A) {
-    return A("<ul>"+A("<li>one","<li>one</li>")+
-             A("<li>two","<li>two</li>")+
-             A("<li>three","<li>three</li>"),
-             "<ul><li>one</li><li>two</li><li>three</li></ul>"); });
-
-  doTest(function (A) {
-    return A("<table>"+A("<tr>"+A("<td>"+A("Hi")+"</td>")+"</tr>")+"</table>",
-             "<table><tbody><tr><td>Hi</td></tr></tbody></table>");
-  });
-
-  test.throws(function () {
-    doTest(function (A) {
-      var z = A("Hello");
-      return z+z;
-    });
-  });
-
-  var frag = Spark.render(function () {
-    return '<div foo="abc' +
-      Spark.setDataContext(null, "bar") +
-      'xyz">Hello</div>';
-  });
-  var div = frag.firstChild;
-  test.equal(div.nodeName, "DIV");
-  var attrValue = div.getAttribute('foo');
-  test.isTrue(attrValue.indexOf('abc<!--') === 0, attrValue);
-  test.isTrue(attrValue.indexOf('-->xyz') >= 0, attrValue);
-});
-
-
-Tinytest.add("spark - repeat inclusion", function(test) {
-  test.throws(function() {
-    var frag = Spark.render(function() {
-      var x = Spark.setDataContext({}, "abc");
-      return x + x;
-    });
-  });
-});
-
-
-Tinytest.add("spark - replace tag contents", function (test) {
-
-  // adapted from nateps / metamorph
-
-  var do_onscreen = function (f) {
-    var div = OnscreenDiv();
-    var stuff = {
-      div: div,
-      node: _.bind(div.node, div),
-      render: function (rfunc) {
-        div.node().appendChild(Meteor.render(rfunc));
-      }
-    };
-
-    f.call(stuff);
-
-    div.kill();
-  };
-
-  var R, div;
-
-  // basic text replace
-
-  do_onscreen(function () {
-    R = ReactiveVar("one two three");
-    this.render(function () {
-      return R.get();
-    });
-    R.set("three four five six");
-    Deps.flush();
-    test.equal(this.div.html(), "three four five six");
-  });
-
-  // work inside a table
-
-  do_onscreen(function () {
-    R = ReactiveVar("<tr><td>HI!</td></tr>");
-    this.render(function () {
-      return "<table id='morphing'>" + R.get() + "</table>";
-    });
-
-    test.equal($(this.node()).find("#morphing td").text(), "HI!");
-    R.set("<tr><td>BUH BYE!</td></tr>");
-    Deps.flush();
-    test.equal($(this.node()).find("#morphing td").text(), "BUH BYE!");
-  });
-
-  // work inside a tbody
-
-  do_onscreen(function () {
-    R = ReactiveVar("<tr><td>HI!</td></tr>");
-    this.render(function () {
-      return "<table id='morphing'><tbody>" + R.get() + "</tbody></table>";
-    });
-
-    test.equal($(this.node()).find("#morphing td").text(), "HI!");
-    R.set("<tr><td>BUH BYE!</td></tr>");
-    Deps.flush();
-    test.equal($(this.node()).find("#morphing td").text(), "BUH BYE!");
-  });
-
-  // work inside a tr
-
-  do_onscreen(function () {
-    R = ReactiveVar("<td>HI!</td>");
-    this.render(function () {
-      return "<table id='morphing'><tr>" + R.get() + "</tr></table>";
-    });
-
-    test.equal($(this.node()).find("#morphing td").text(), "HI!");
-    R.set("<td>BUH BYE!</td>");
-    Deps.flush();
-    test.equal($(this.node()).find("#morphing td").text(), "BUH BYE!");
-  });
-
-  // work inside a ul
-
-  do_onscreen(function () {
-    R = ReactiveVar("<li>HI!</li>");
-    this.render(function () {
-      return "<ul id='morphing'>" + R.get() + "</ul>";
-    });
-
-    test.equal($(this.node()).find("#morphing li").text(), "HI!");
-    R.set("<li>BUH BYE!</li>");
-    Deps.flush();
-    test.equal($(this.node()).find("#morphing li").text(), "BUH BYE!");
-  });
-
-  // work inside a select
-
-  do_onscreen(function () {
-    R = ReactiveVar("<option>HI!</option>");
-    this.render(function () {
-      return "<select id='morphing'>" + R.get() + "</select>";
-    });
-
-    test.equal($(this.node()).find("#morphing option").text(), "HI!");
-    R.set("<option>BUH BYE!</option>");
-    Deps.flush();
-    test.equal($(this.node()).find("#morphing option").text(), "BUH BYE!");
-  });
-
-  // list of select options
-
-  do_onscreen(function () {
-    var c = new LocalCollection();
-    c.insert({name: 'Hamburger', value: 1});
-    c.insert({name: 'Cheeseburger', value: 2});
-    this.render(function () {
-      return "<select id='morphing' name='fred'>" +
-        Spark.list(c.find({}, {sort: ['value']}), function (doc) {
-          return '<option value="' + doc.value + '">' + doc.name + '</option>';
-        }) +
-        "</select>";
-    });
-
-    var furtherCanon = function (html) {
-      return html.replace(/\s*selected="selected"/g, '');
-    };
-
-    test.equal(furtherCanon(this.div.html()),
-               '<select id="morphing" name="fred">' +
-               '<option value="1">Hamburger</option>' +
-               '<option value="2">Cheeseburger</option>' +
-               '</select>');
-    c.insert({name: 'Chicken Snickers', value: 8});
-    Deps.flush();
-    test.equal(furtherCanon(this.div.html()),
-               '<select id="morphing" name="fred">' +
-               '<option value="1">Hamburger</option>' +
-               '<option value="2">Cheeseburger</option>' +
-               '<option value="8">Chicken Snickers</option>' +
-               '</select>');
-    c.remove({value: 1});
-    c.remove({value: 2});
-    Deps.flush();
-    test.equal(furtherCanon(this.div.html()),
-               '<select id="morphing" name="fred">' +
-               '<option value="8">Chicken Snickers</option>' +
-               '</select>');
-    c.remove({});
-    Deps.flush();
-    test.equal(furtherCanon(this.div.html()),
-               '<select id="morphing" name="fred">' +
-               '<!---->' +
-               '</select>');
-    c.insert({name: 'Hamburger', value: 1});
-    c.insert({name: 'Cheeseburger', value: 2});
-    Deps.flush();
-    test.equal(furtherCanon(this.div.html()),
-               '<select id="morphing" name="fred">' +
-               '<option value="1">Hamburger</option>' +
-               '<option value="2">Cheeseburger</option>' +
-               '</select>');
-  });
-
-});
-
-
-Tinytest.add("spark - basic isolate", function (test) {
-
-  var R = ReactiveVar('foo');
-
-  var div = OnscreenDiv(Spark.render(function () {
-    return '<div>' + Spark.isolate(function () {
-      return '<span>' + R.get() + '</span>';
-    }) + '</div>';
-  }));
-
-  test.equal(div.html(), '<div><span>foo</span></div>');
-  R.set('bar');
-  test.equal(div.html(), '<div><span>foo</span></div>');
-  Deps.flush();
-  test.equal(div.html(), '<div><span>bar</span></div>');
-  R.set('baz');
-  Deps.flush();
-  test.equal(div.html(), '<div><span>baz</span></div>');
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("spark - one render", function (test) {
-
-  var R = ReactiveVar("foo");
-
-  var frag = WrappedFrag(Meteor.render(function () {
-    return R.get();
-  })).hold();
-
-  test.equal(R.numListeners(), 1);
-
-  // frag should be "foo" initially
-  test.equal(frag.html(), "foo");
-  R.set("bar");
-  // haven't flushed yet, so update won't have happened
-  test.equal(frag.html(), "foo");
-  Deps.flush();
-  // flushed now, frag should say "bar"
-  test.equal(frag.html(), "bar");
-  frag.release(); // frag is now considered offscreen
-  Deps.flush();
-  R.set("baz");
-  Deps.flush();
-  // no update should have happened, offscreen range dep killed
-  test.equal(frag.html(), "bar");
-
-  // should be back to no listeners
-  test.equal(R.numListeners(), 0);
-
-  // empty return value should work, and show up as a comment
-  frag = WrappedFrag(Meteor.render(function () {
-    return "";
-  }));
-  test.equal(frag.html(), "<!---->");
-
-  // nodes coming and going at top level of fragment
-  R.set(true);
-  frag = WrappedFrag(Meteor.render(function () {
-    return R.get() ? "<div>hello</div><div>world</div>" : "";
-  })).hold();
-  test.equal(frag.html(), "<div>hello</div><div>world</div>");
-  R.set(false);
-  Deps.flush();
-  test.equal(frag.html(), "<!---->");
-  R.set(true);
-  Deps.flush();
-  test.equal(frag.html(), "<div>hello</div><div>world</div>");
-  test.equal(R.numListeners(), 1);
-  frag.release();
-  Deps.flush();
-  test.equal(R.numListeners(), 0);
-
-  // more complicated changes
-  R.set(1);
-  frag = WrappedFrag(Meteor.render(function () {
-    var result = [];
-    for(var i=0; i<R.get(); i++) {
-      result.push('<div id="x'+i+'" class="foo" name="bar"><p><b>'+
-                  R.get()+'</b></p></div>');
-    }
-    return result.join('');
-  })).hold();
-  test.equal(frag.html(),
-               '<div class="foo" id="x0" name="bar"><p><b>1</b></p></div>');
-  R.set(3);
-  Deps.flush();
-  test.equal(frag.html(),
-               '<div class="foo" id="x0" name="bar"><p><b>3</b></p></div>'+
-               '<div class="foo" id="x1" name="bar"><p><b>3</b></p></div>'+
-               '<div class="foo" id="x2" name="bar"><p><b>3</b></p></div>');
-  R.set(2);
-  Deps.flush();
-  test.equal(frag.html(),
-               '<div class="foo" id="x0" name="bar"><p><b>2</b></p></div>'+
-               '<div class="foo" id="x1" name="bar"><p><b>2</b></p></div>');
-  frag.release();
-  Deps.flush();
-  test.equal(R.numListeners(), 0);
-
-  // caller violating preconditions
-  test.equal(WrappedFrag(Meteor.render("foo")).html(), "foo");
-});
-
-Tinytest.add("spark - heuristic finalize", function (test) {
-
-  var R = ReactiveVar(123);
-
-  var div = OnscreenDiv(Meteor.render(function () {
-    return "<p>The number is "+R.get()+".</p><hr><br><br><u>underlined</u>";
-  }));
-
-  test.equal(div.html(), "<p>The number is 123.</p><hr><br><br><u>underlined</u>");
-  test.equal(R.numListeners(), 1);
-  Deps.flush();
-  R.set(456); // won't take effect until flush()
-  test.equal(div.html(), "<p>The number is 123.</p><hr><br><br><u>underlined</u>");
-  test.equal(R.numListeners(), 0); // listener already gone
-  Deps.flush();
-  test.equal(div.html(), "<p>The number is 456.</p><hr><br><br><u>underlined</u>");
-  test.equal(R.numListeners(), 1);
-
-  div.remove();
-  R.set(789); // update should force div dependency to be GCed when div is updated
-  Deps.flush();
-  test.equal(R.numListeners(), 0);
-});
-
-Tinytest.add("spark - isolate", function (test) {
-
-  var inc = function (v) {
-    v.set(v.get() + 1); };
-
-  var R1 = ReactiveVar(0);
-  var R2 = ReactiveVar(0);
-  var R3 = ReactiveVar(0);
-  var count1 = 0, count2 = 0, count3 = 0;
-
-  var frag = WrappedFrag(Meteor.render(function () {
-    return R1.get() + "," + (count1++) + " " +
-      Spark.isolate(function () {
-        return R2.get() + "," + (count2++) + " " +
-          Spark.isolate(function () {
-            return R3.get() + "," + (count3++);
-          });
-      });
-  })).hold();
-
-  test.equal(frag.html(), "0,0 0,0 0,0");
-
-  inc(R1); Deps.flush();
-  test.equal(frag.html(), "1,1 0,1 0,1");
-
-  inc(R2); Deps.flush();
-  test.equal(frag.html(), "1,1 1,2 0,2");
-
-  inc(R3); Deps.flush();
-  test.equal(frag.html(), "1,1 1,2 1,3");
-
-  inc(R2); Deps.flush();
-  test.equal(frag.html(), "1,1 2,3 1,4");
-
-  inc(R1); Deps.flush();
-  test.equal(frag.html(), "2,2 2,4 1,5");
-
-  frag.release();
-  Deps.flush();
-  test.equal(R1.numListeners(), 0);
-  test.equal(R2.numListeners(), 0);
-  test.equal(R3.numListeners(), 0);
-
-  R1.set(0);
-  R2.set(0);
-  R3.set(0);
-
-  frag = WrappedFrag(Meteor.render(function () {
-    var buf = [];
-    buf.push('<div class="foo', R1.get(), '">');
-    buf.push(Spark.isolate(function () {
-      var buf = [];
-      for(var i=0; i<R2.get(); i++) {
-        buf.push(Spark.isolate(function () {
-          return '<div>'+R3.get()+'</div>';
-        }));
-      }
-      return buf.join('');
-    }));
-    buf.push('</div>');
-    return buf.join('');
-  })).hold();
-
-  test.equal(frag.html(), '<div class="foo0"><!----></div>');
-  R2.set(3); Deps.flush();
-  test.equal(frag.html(), '<div class="foo0">'+
-               '<div>0</div><div>0</div><div>0</div>'+
-               '</div>');
-
-  R3.set(5); Deps.flush();
-  test.equal(frag.html(), '<div class="foo0">'+
-               '<div>5</div><div>5</div><div>5</div>'+
-               '</div>');
-
-  R1.set(7); Deps.flush();
-  test.equal(frag.html(), '<div class="foo7">'+
-               '<div>5</div><div>5</div><div>5</div>'+
-               '</div>');
-
-  R2.set(1); Deps.flush();
-  test.equal(frag.html(), '<div class="foo7">'+
-               '<div>5</div>'+
-               '</div>');
-
-  R1.set(11); Deps.flush();
-  test.equal(frag.html(), '<div class="foo11">'+
-               '<div>5</div>'+
-               '</div>');
-
-  R2.set(2); Deps.flush();
-  test.equal(frag.html(), '<div class="foo11">'+
-               '<div>5</div><div>5</div>'+
-               '</div>');
-
-  R3.set(4); Deps.flush();
-  test.equal(frag.html(), '<div class="foo11">'+
-               '<div>4</div><div>4</div>'+
-               '</div>');
-
-  frag.release();
-
-  // calling isolate() outside of render mode
-  test.equal(Spark.isolate(function () { return "foo"; }), "foo");
-
-  // caller violating preconditions
-
-  test.throws(function () {
-    Meteor.render(function () {
-      return Spark.isolate("foo");
-    });
-  });
-
-
-  // unused isolate
-
-  var Q = ReactiveVar("foo");
-  Meteor.render(function () {
-    // create an isolate, in render mode,
-    // but don't use it.
-    Spark.isolate(function () {
-      return Q.get();
-    });
-    return "";
-  });
-  Q.set("bar");
-  // might get an error on flush() if implementation
-  // deals poorly with unused isolates, or a listener
-  // still existing after flush.
-  Deps.flush();
-  test.equal(Q.numListeners(), 0);
-
-  // nesting
-
-  var stuff = ReactiveVar(true);
-  var div = OnscreenDiv(Meteor.render(function () {
-    return Spark.isolate(function () {
-      return "x"+(stuff.get() ? 'y' : '') + Spark.isolate(function () {
-        return "hi";
-      });
-    });
-  }));
-  test.equal(div.html(), "xyhi");
-  stuff.set(false);
-  Deps.flush();
-  test.equal(div.html(), "xhi");
-  div.kill();
-  Deps.flush();
-
-  // more nesting
-
-  var num1 = ReactiveVar(false);
-  var num2 = ReactiveVar(false);
-  var num3 = ReactiveVar(false);
-  var numset = function (n) {
-    _.each([num1, num2, num3], function (v, i) {
-      v.set((i+1) === n);
-    });
-  };
-  numset(1);
-
-  var div = OnscreenDiv(Meteor.render(function () {
-    return Spark.isolate(function () {
-      return (num1.get() ? '1' : '')+
-        Spark.isolate(function () {
-          return (num2.get() ? '2' : '')+
-            Spark.isolate(function () {
-              return (num3.get() ? '3' : '')+'x';
-            });
-        });
-    });
-  }));
-  test.equal(div.html(), "1x");
-  numset(2);
-  Deps.flush();
-  test.equal(div.html(), "2x");
-  numset(3);
-  Deps.flush();
-  test.equal(div.html(), "3x");
-  numset(1);
-  Deps.flush();
-  test.equal(div.html(), "1x");
-  numset(3);
-  Deps.flush();
-  test.equal(div.html(), "3x");
-  numset(2);
-  Deps.flush();
-  test.equal(div.html(), "2x");
-  div.remove();
-  Deps.flush();
-
-  // the real test for slow-path GC finalization:
-  num2.set(! num2.get());
-  Deps.flush();
-  test.equal(num1.numListeners(), 0);
-  test.equal(num2.numListeners(), 0);
-  test.equal(num3.numListeners(), 0);
-});
-
-Tinytest.add("spark - data context", function (test) {
-  var d1 = {x: 1};
-  var d2 = {x: 2};
-  var d3 = {x: 3};
-  var d4 = {x: 4};
-  var d5 = {x: 5};
-
-  var traverse = function (frag) {
-    var out = '';
-    var walkChildren = function (parent) {
-      for (var node = parent.firstChild; node; node = node.nextSibling) {
-        if (node.nodeType !== 8 /* COMMENT */)  {
-          var data = Spark.getDataContext(node);
-          out += (data === null) ? "_" : data.x;
-        }
-        if (node.nodeType === 1 /* ELEMENT */)
-          walkChildren(node);
-      }
-    };
-    walkChildren(frag);
-    return out;
-  };
-
-  var testData = function (serialized, htmlFunc) {
-    test.equal(traverse(Spark.render(htmlFunc)), serialized);
-  };
-
-  testData("_", function () {
-    return "hi";
-  });
-
-  testData("__", function () {
-    return "<div>hi</div>";
-  });
-
-  testData("_1", function () {
-    return "<div>" + Spark.setDataContext(d1, "hi") + "</div>";
-  });
-
-  testData("21", function () {
-    return Spark.setDataContext(
-      d2, "<div>" + Spark.setDataContext(d1, "hi") + "</div>");
-  });
-
-  testData("21", function () {
-    return Spark.setDataContext(
-      d2, "<div>" +
-        Spark.setDataContext(d3,
-                             Spark.setDataContext(d1, "hi")) +
-        "</div>");
-  });
-
-  testData("23", function () {
-    return Spark.setDataContext(
-      d2, "<div>" +
-        Spark.setDataContext(d1,
-                             Spark.setDataContext(d3, "hi")) +
-        "</div>");
-  });
-
-  testData("23", function () {
-    var html = Spark.setDataContext(
-      d2, "<div>" +
-        Spark.setDataContext(d1,
-                             Spark.setDataContext(d3, "hi")) +
-        "</div>");
-    return Spark.setDataContext(d4, html);
-  });
-
-  testData("1_2", function () {
-    return Spark.setDataContext(d1, "hi") + "-" +
-      Spark.setDataContext(d2, "there");
-  });
-
-  testData("_122_3__45", function () {
-    return "<div>" +
-      Spark.setDataContext(d1, "<div></div>") +
-      Spark.setDataContext(d2, "<div><div></div></div>") +
-      "<div></div>" +
-      Spark.setDataContext(d3, "<div></div>") +
-      "<div><div></div></div>" +
-      Spark.setDataContext(d4, "<div>" +
-                           Spark.setDataContext(d5, "<div></div>") +
-                           "</div>");
-  });
-});
-
-Tinytest.add("spark - tables", function (test) {
-  var R = ReactiveVar(0);
-
-  var table = OnscreenDiv(Meteor.render(function () {
-    var buf = [];
-    buf.push("<table>");
-    for(var i=0; i<R.get(); i++)
-      buf.push("<tr><td>"+(i+1)+"</td></tr>");
-    buf.push("</table>");
-    return buf.join('');
-  }));
-
-  R.set(1);
-  Deps.flush();
-  test.equal(table.html(), "<table><tbody><tr><td>1</td></tr></tbody></table>");
-
-  R.set(10);
-  test.equal(table.html(), "<table><tbody><tr><td>1</td></tr></tbody></table>");
-  Deps.flush();
-  test.equal(table.html(), "<table><tbody>"+
-               "<tr><td>1</td></tr>"+
-               "<tr><td>2</td></tr>"+
-               "<tr><td>3</td></tr>"+
-               "<tr><td>4</td></tr>"+
-               "<tr><td>5</td></tr>"+
-               "<tr><td>6</td></tr>"+
-               "<tr><td>7</td></tr>"+
-               "<tr><td>8</td></tr>"+
-               "<tr><td>9</td></tr>"+
-               "<tr><td>10</td></tr>"+
-               "</tbody></table>");
-
-  R.set(0);
-  Deps.flush();
-  test.equal(table.html(), "<table></table>");
-  table.kill();
-  Deps.flush();
-  test.equal(R.numListeners(), 0);
-
-  var div = OnscreenDiv();
-  div.node().appendChild(document.createElement("TABLE"));
-  div.node().firstChild.appendChild(Meteor.render(function () {
-    var buf = [];
-    for(var i=0; i<R.get(); i++)
-      buf.push("<tr><td>"+(i+1)+"</td></tr>");
-    return buf.join('');
-  }));
-  test.equal(div.html(), "<table><!----></table>");
-  R.set(3);
-  Deps.flush();
-  test.equal(div.html(), "<table><tbody>"+
-               "<tr><td>1</td></tr>"+
-               "<tr><td>2</td></tr>"+
-               "<tr><td>3</td></tr>"+
-               "</tbody></table>");
-  test.equal(div.node().firstChild.rows.length, 3);
-  R.set(0);
-  Deps.flush();
-  test.equal(div.html(), "<table><!----></table>");
-  div.kill();
-  Deps.flush();
-
-  test.equal(R.numListeners(), 0);
-
-  div = OnscreenDiv();
-  div.node().appendChild(DomUtils.htmlToFragment("<table><tr></tr></table>"));
-  R.set(3);
-  div.node().getElementsByTagName("tr")[0].appendChild(Meteor.render(
-    function () {
-      var buf = [];
-      for(var i=0; i<R.get(); i++)
-        buf.push("<td>"+(i+1)+"</td>");
-      return buf.join('');
-    }));
-  test.equal(div.html(),
-               "<table><tbody><tr><td>1</td><td>2</td><td>3</td>"+
-               "</tr></tbody></table>");
-  R.set(1);
-  Deps.flush();
-  test.equal(div.html(),
-               "<table><tbody><tr><td>1</td></tr></tbody></table>");
-  div.kill();
-  Deps.flush();
-  test.equal(R.numListeners(), 0);
-
-  div = OnscreenDiv(renderWithPreservation(function() {
-    return '<table id="my-awesome-table">'+R.get()+'</table>';
-  }));
-  Deps.flush();
-  R.set("<tr><td>Hello</td></tr>");
-  Deps.flush();
-  test.equal(
-    div.html(),
-    '<table id="my-awesome-table"><tbody><tr><td>Hello</td></tr></tbody></table>');
-  div.kill();
-  Deps.flush();
-
-  test.equal(R.numListeners(), 0);
-});
-
-Tinytest.add("spark - event handling", function (test) {
-  var event_buf = [];
-  var getid = function (id) {
-    return document.getElementById(id);
-  };
-
-  var div;
-
-  var chunk = function (htmlFunc, options) {
-    var html = Spark.isolate(htmlFunc);
-    options = options || {};
-    if (options.events)
-      html = Spark.attachEvents(options.events, html);
-    if (options.event_data)
-      html = Spark.setDataContext(options.event_data, html);
-    return html;
-  };
-
-  var render = function (htmlFunc, options) {
-    return Spark.render(function () {
-      return chunk(htmlFunc, options);
-    });
-  };
-
-
-  // clicking on a div at top level
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return '<div id="foozy">Foo</div>';
-  }, {events: eventmap("click"), event_data:event_buf}));
-  clickElement(getid("foozy"));
-  test.equal(event_buf, ['click']);
-  div.kill();
-  Deps.flush();
-
-  // selector that specifies a top-level div
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return '<div id="foozy">Foo</div>';
-  }, {events: eventmap("click div"), event_data:event_buf}));
-  clickElement(getid("foozy"));
-  test.equal(event_buf, ['click div']);
-  div.kill();
-  Deps.flush();
-
-  // selector that specifies a second-level span
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return '<div id="foozy"><span>Foo</span></div>';
-  }, {events: eventmap("click span"), event_data:event_buf}));
-  clickElement(getid("foozy").firstChild);
-  test.equal(event_buf, ['click span']);
-  div.kill();
-  Deps.flush();
-
-  // replaced top-level elements still have event handlers
-  // even if replaced by an isolate above the handlers in the DOM
-  var R = ReactiveVar("p");
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return chunk(function () {
-      return '<'+R.get()+' id="foozy">Hello</'+R.get()+'>';
-    });
-  }, {events: eventmap("click"), event_data:event_buf}));
-  clickElement(getid("foozy"));
-  test.equal(event_buf, ['click']);
-  event_buf.length = 0;
-  R.set("div"); // change tag, which is sure to replace element
-  Deps.flush();
-  clickElement(getid("foozy")); // still clickable?
-  test.equal(event_buf, ['click']);
-  event_buf.length = 0;
-  R.set("p");
-  Deps.flush();
-  clickElement(getid("foozy"));
-  test.equal(event_buf, ['click']);
-  event_buf.length = 0;
-  div.kill();
-  Deps.flush();
-
-  // bubbling from event on descendent of element matched
-  // by selector
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return '<div id="foozy"><span><u><b>Foo</b></u></span>'+
-      '<span>Bar</span></div>';
-  }, {events: eventmap("click span"), event_data:event_buf}));
-  clickElement(
-    getid("foozy").firstChild.firstChild.firstChild);
-  test.equal(event_buf, ['click span']);
-  div.kill();
-  Deps.flush();
-
-  // bubbling order (for same event, same render node, different selector nodes)
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return '<div id="foozy"><span><u><b>Foo</b></u></span>'+
-      '<span>Bar</span></div>';
-  }, {events: eventmap("click span", "click b"), event_data:event_buf}));
-  clickElement(
-    getid("foozy").firstChild.firstChild.firstChild);
-  test.equal(event_buf, ['click b', 'click span']);
-  div.kill();
-  Deps.flush();
-
-  // "bubbling" order for handlers at same level
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return chunk(function () {
-      return chunk(function () {
-        return '<span id="foozy" class="a b c">Hello</span>';
-      }, {events: eventmap("click .c"), event_data:event_buf});
-    }, {events: eventmap("click .b"), event_data:event_buf});
-  }, {events: eventmap("click .a"), event_data:event_buf}));
-  clickElement(getid("foozy"));
-  test.equal(event_buf, ['click .c', 'click .b', 'click .a']);
-  event_buf.length = 0;
-  div.kill();
-  Deps.flush();
-
-  // stopPropagation doesn't prevent other event maps from
-  // handling same node
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return chunk(function () {
-      return chunk(function () {
-        return '<span id="foozy" class="a b c">Hello</span>';
-      }, {events: eventmap("click .c"), event_data:event_buf});
-    }, {events: {"click .b": function (evt) {
-      event_buf.push("click .b"); evt.stopPropagation();}}});
-  }, {events: eventmap("click .a"), event_data:event_buf}));
-  clickElement(getid("foozy"));
-  test.equal(event_buf, ['click .c', 'click .b', 'click .a']);
-  event_buf.length = 0;
-  div.kill();
-  Deps.flush();
-
-  // stopImmediatePropagation DOES
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return chunk(function () {
-      return chunk(function () {
-        return '<span id="foozy" class="a b c">Hello</span>';
-      }, {events: eventmap("click .c"), event_data:event_buf});
-    }, {events: {"click .b": function (evt) {
-      event_buf.push("click .b");
-      evt.stopImmediatePropagation();}}});
-  }, {events: eventmap("click .a"), event_data:event_buf}));
-  clickElement(getid("foozy"));
-  test.equal(event_buf, ['click .c', 'click .b']);
-  event_buf.length = 0;
-  div.kill();
-  Deps.flush();
-
-  // bubbling continues even with DOM change
-  event_buf.length = 0;
-  R = ReactiveVar(true);
-  div = OnscreenDiv(render(function () {
-    return chunk(function () {
-      return '<div id="blarn">'+(R.get()?'<span id="foozy">abcd</span>':'')+'</div>';
-    }, {events: { 'click span': function () {
-      event_buf.push('click span');
-      R.set(false);
-      Deps.flush(); // kill the span
-    }, 'click div': function (evt) {
-      event_buf.push('click div');
-    }}});
-  }));
-  // click on span
-  clickElement(getid("foozy"));
-  test.expect_fail(); // doesn't seem to work in old IE
-  test.equal(event_buf, ['click span', 'click div']);
-  event_buf.length = 0;
-  div.kill();
-  Deps.flush();
-
-  // "deep reach" from high node down to replaced low node.
-  // Tests that events are registered correctly to work in
-  // old IE.  Also tests change event bubbling
-  // and proper interpretation of event maps.
-  event_buf.length = 0;
-  R = ReactiveVar('foo');
-  div = OnscreenDiv(render(function () {
-    return '<div><p><span><b>'+
-      chunk(function () {
-        return '<input type="checkbox">'+R.get();
-      }, {events: eventmap('click input'), event_data:event_buf}) +
-      '</b></span></p></div>';
-  }, { events: eventmap('change b', 'change input'), event_data:event_buf }));
-  R.set('bar');
-  Deps.flush();
-  // click on input
-  clickElement(div.node().getElementsByTagName('input')[0]);
-  event_buf.sort(); // don't care about order
-  test.equal(event_buf, ['change b', 'change input', 'click input']);
-  event_buf.length = 0;
-  div.kill();
-  Deps.flush();
-
-  // test that 'click *' fires on bubble
-  event_buf.length = 0;
-  R = ReactiveVar('foo');
-  div = OnscreenDiv(render(function () {
-    return '<div><p><span><b>'+
-      chunk(function () {
-        return '<input type="checkbox">'+R.get();
-      }, {events: eventmap('click input'), event_data:event_buf}) +
-      '</b></span></p></div>';
-  }, { events: eventmap('click *'), event_data:event_buf }));
-  R.set('bar');
-  Deps.flush();
-  // click on input
-  clickElement(div.node().getElementsByTagName('input')[0]);
-  test.equal(
-    event_buf,
-    ['click input', 'click *', 'click *', 'click *', 'click *', 'click *']);
-  event_buf.length = 0;
-  div.kill();
-  Deps.flush();
-
-  // clicking on a div in a nested chunk (without patching)
-  event_buf.length = 0;
-  R = ReactiveVar('foo');
-  div = OnscreenDiv(render(function () {
-    return R.get() + chunk(function () {
-      return '<span>ism</span>';
-    }, {events: eventmap("click"), event_data:event_buf});
-  }));
-  test.equal(div.text(), 'fooism');
-  clickElement(div.node().getElementsByTagName('SPAN')[0]);
-  test.equal(event_buf, ['click']);
-  event_buf.length = 0;
-  R.set('bar');
-  Deps.flush();
-  test.equal(div.text(), 'barism');
-  clickElement(div.node().getElementsByTagName('SPAN')[0]);
-  test.equal(event_buf, ['click']);
-  event_buf.length = 0;
-  div.kill();
-  Deps.flush();
-
-  // Test that reactive fragments manually inserted inside
-  // a reactive fragment eventually get wired.
-  event_buf.length = 0;
-  div = OnscreenDiv(render(function () {
-    return "<div></div>";
-  }, { events: eventmap("click span", event_buf) }));
-  Deps.flush();
-  div.node().firstChild.appendChild(render(function () {
-    return '<span id="foozy">hello</span>';
-  }));
-  clickElement(getid("foozy"));
-  // implementation has no way to know we've inserted the fragment
-  test.equal(event_buf, []);
-  event_buf.length = 0;
-  Deps.flush();
-  clickElement(getid("foozy"));
-  // now should be wired up
-  test.equal(event_buf, ['click span']);
-  event_buf.length = 0;
-  div.kill();
-  Deps.flush();
-
-  // Event data comes from event.currentTarget, not event.target
-  var data_buf = [];
-  div = OnscreenDiv(render(function () {
-    return "<ul>"+chunk(function () {
-      return '<li id="funyard">Hello</li>';
-    }, { event_data: {x:'listuff'} })+"</ul>";
-  }, { event_data: {x:'ulstuff'},
-       events: { 'click ul': function () { data_buf.push(this); }}}));
-  clickElement(getid("funyard"));
-  test.equal(data_buf, [{x:'ulstuff'}]);
-  div.kill();
-  Deps.flush();
-});
-
-
-Tinytest.add("spark - list event handling", function(test) {
-  var event_buf = [];
-  var div;
-
-  // same thing, but with events wired by listChunk "added" and "removed"
-  event_buf.length = 0;
-  var lst = [];
-  lst.observeChanges = function(callbacks) {
-    lst.callbacks = callbacks;
-    return {
-      stop: function() {
-        lst.callbacks = null;
-      }
-    };
-  };
-  div = OnscreenDiv(Meteor.render(function() {
-    var chkbx = function(doc) {
-      return '<input type="checkbox">'+(doc ? doc._id : 'else');
-    };
-    var html = '<div><p><span><b>' +
-      Spark.setDataContext(
-        event_buf, Spark.attachEvents(
-          eventmap('click input', event_buf), Spark.list(lst, chkbx, chkbx))) +
-      '</b></span></p></div>';
-    html = Spark.setDataContext(event_buf, html);
-    html = Spark.attachEvents(eventmap('change b', 'change input', event_buf),
-                              html);
-    return html;
-  }));
-  Deps.flush();
-  test.equal(div.text().match(/\S+/)[0], 'else');
-  // click on input
-  var doClick = function() {
-    clickElement(div.node().getElementsByTagName('input')[0]);
-    event_buf.sort(); // don't care about order
-    test.equal(event_buf, ['change b', 'change input', 'click input']);
-    event_buf.length = 0;
-  };
-  doClick();
-  // add item
-  lst.push({_id:'foo'});
-  lst.callbacks.addedBefore(lst[0]._id, lst[0], null);
-  Deps.flush();
-  test.equal(div.text().match(/\S+/)[0], 'foo');
-  doClick();
-  // remove item, back to "else" case
-  lst.callbacks.removed(lst[0]._id);
-  lst.pop();
-  Deps.flush();
-  test.equal(div.text().match(/\S+/)[0], 'else');
-  doClick();
-  // cleanup
-  div.kill();
-  Deps.flush();
-
-});
-
-
-Tinytest.add("spark - basic landmarks", function (test) {
-  var R = ReactiveVar("111");
-  var x = [];
-  var expect = function (what) {
-    test.equal(x, what);
-    x = [];
-  };
-
-  var X = {};
-
-  var div = OnscreenDiv(Spark.render(function () {
-    return Spark.isolate(function () {
-      return R.get() +
-        Spark.createLandmark({
-          created: function () {
-            x.push("c");
-            this.a = X;
-          },
-          rendered: function () {
-            x.push("r", this.a);
-          },
-          destroyed: function () {
-            x.push("d", this.a);
-          }
-        }, function() { return "hi"; });
-    });
-  }));
-
-  expect(["c"]);
-  Deps.flush();
-  expect(["r", X]);
-  Deps.flush();
-  expect([]);
-  R.set("222");
-  expect([]);
-  Deps.flush();
-  expect(["r", X]);
-  Deps.flush();
-  expect([]);
-  div.remove();
-  expect([]);
-  Deps.flush();
-  expect([]);
-  div.kill();
-  Deps.flush();
-  expect(["d", X]);
-});
-
-Tinytest.add("spark - labeled landmarks", function (test) {
-  var R = [];
-  for (var i = 0; i < 10; i++)
-    R.push(ReactiveVar(""));
-
-  var x = [];
-  var s = [];
-  var expect = function (what_x, what_s) {
-    test.equal(x, what_x);
-    test.equal(s, what_s);
-    x = [];
-    s = [];
-  };
-
-  var excludeLandmarks = [];
-  for (var i = 0; i < 6; i++)
-    excludeLandmarks.push(ReactiveVar(false));
-
-  var isolateLandmarks = ReactiveVar(false);
-  var serial = 1;
-  var testLandmark = function (id, htmlFunc) {
-    if (excludeLandmarks[id].get())
-      return "";
-
-    var f = function () {
-      var thisSerial = serial++;
-
-      return Spark.createLandmark({
-        created: function () {
-          x.push("c", id);
-          s.push(thisSerial);
-          this.id = id;
-        },
-        rendered: function () {
-          x.push("r", id);
-          s.push(thisSerial);
-          test.equal(this.id, id);
-        },
-        destroyed: function () {
-          x.push("d", id);
-          s.push(thisSerial);
-          test.equal(this.id, id);
-        }
-      }, htmlFunc);
-    };
-
-    if (isolateLandmarks.get())
-      return Spark.isolate(function () { return f(); });
-    else
-      return f();
-  };
-
-  var label = Spark.labelBranch;
-
-  var dep = function (i) {
-    return R[i].get();
-  };
-
-  // this frog is pretty well boiled
-  var div = OnscreenDiv(Spark.render(function () {
-    var html = Spark.isolate(function () {
-      return (
-        dep(0) +
-          testLandmark(1, function () {return "hi" + dep(1); }) +
-          label("a", function () {
-            return dep(2) +
-              testLandmark(2, function () { return "hi" + dep(3);});}) +
-          label("b", function () {
-            return dep(4) +
-              testLandmark(3, function () {
-                return "hi" + dep(5) +                                                                     label("c", function () {
-                  return dep(6) +
-                    testLandmark(4, function () {
-                      return "hi" + dep(7) +
-                        label("d", function () {
-                          return label("e", function () {
-                            return dep(8) +
-                              label("f", function () {
-                                return testLandmark(
-                                  5, function () { return "hi" + dep(9);}
-                                );});});});});});});}));
-    });
-    return html;
-  }));
-
-  // callback order is not specced
-  expect(["c", 1, "c", 2, "c", 3, "c", 4, "c", 5], [1, 2, 3, 4, 5]);
-  Deps.flush();
-  expect(["r", 1, "r", 2, "r", 5, "r", 4, "r", 3], [1, 2, 5, 4, 3]);
-  for (var i = 0; i < 10; i++) {
-    R[i].set(1);
-    expect([], []);
-    Deps.flush();
-    expect(["r", 1, "r", 2, "r", 5, "r", 4, "r", 3],
-           [i*5 + 6, i*5 + 7, i*5 + 10, i*5 + 9, i*5 + 8]);
-  };
-
-  excludeLandmarks[2].set(true);
-  expect([], []);
-  Deps.flush();
-  expect(["d", 2, "r", 1, "r", 5, "r", 4, "r", 3],
-         [52, 56, 59, 58, 57]);
-
-  excludeLandmarks[2].set(false);
-  excludeLandmarks[3].set(true);
-  expect([], []);
-  Deps.flush();
-  expect(["c", 2, "d", 3, "d", 4, "d", 5, "r", 1, "r", 2],
-         [61, 57, 58, 59, 60, 61]);
-
-  excludeLandmarks[2].set(true);
-  excludeLandmarks[3].set(false);
-  expect([], []);
-  Deps.flush();
-  expect(["c", 3, "c", 4, "c", 5, "d", 2, "r", 1, "r", 5, "r", 4, "r", 3],
-         [63, 64, 65, 61, 62, 65, 64, 63]);
-
-  excludeLandmarks[2].set(false);
-  expect([], []);
-  Deps.flush();
-  expect(["c", 2, "r", 1, "r", 2, "r", 5, "r", 4, "r", 3],
-         [67, 66, 67, 70, 69, 68]);
-
-  isolateLandmarks.set(true);
-  expect([], []);
-  Deps.flush();
-  expect(["r", 1, "r", 2, "r", 5, "r", 4, "r", 3],
-         [71, 72, 75, 74, 73]);
-
-  for (var i = 0; i < 10; i++) {
-    var expected = [
-      [["r", 1, "r", 2, "r", 5, "r", 4, "r", 3], [76, 77, 80, 79, 78]],
-      [["r", 1], [81]],
-      [["r", 1, "r", 2, "r", 5, "r", 4, "r", 3], [82, 83, 86, 85, 84]],
-      [["r", 2], [87]],
-      [["r", 1, "r", 2, "r", 5, "r", 4, "r", 3], [88, 89, 92, 91, 90]],
-      [["r", 5, "r", 4, "r", 3], [95, 94, 93]],
-      [["r", 5, "r", 4, "r", 3], [98, 97, 96]],
-      [["r", 5, "r", 4, "r", 3], [100, 99, 96]],
-      [["r", 5, "r", 4, "r", 3], [102, 101, 96]],
-      [["r", 5, "r", 4, "r", 3], [103, 101, 96]]
-    ][i];
-    R[i].set(2);
-    expect([], []);
-    Deps.flush();
-    expect.apply(null, expected);
-  };
-
-  excludeLandmarks[4].set(true);
-  Deps.flush();
-  expect(["d", 4, "d", 5, "r", 3], [101, 103, 104]);
-
-  excludeLandmarks[4].set(false);
-  excludeLandmarks[5].set(true);
-  Deps.flush();
-  expect(["c", 4, "r", 4, "r", 3], [106, 106, 105]);
-
-  excludeLandmarks[5].set(false);
-  Deps.flush();
-  expect(["c", 5, "r", 5, "r", 4, "r", 3], [108, 108, 107, 105]);
-
-  div.kill();
-  Deps.flush();
-});
-
-
-Tinytest.add("spark - preserve copies attributes", function(test) {
-  // make sure attributes are correctly changed (i.e. copied)
-  // when preserving old nodes, either because they are labeled
-  // or because they are a parent of a labeled node.
-
-  var R1 = ReactiveVar("foo");
-  var R2 = ReactiveVar("abcd");
-
-  var frag = WrappedFrag(renderWithPreservation(function() {
-    return '<div puppy="'+R1.get()+'"><div><div><div><input name="blah" kittycat="'+
-      R2.get()+'"></div></div></div></div>';
-  })).hold();
-  var node1 = frag.node().firstChild;
-  var node2 = frag.node().firstChild.getElementsByTagName("input")[0];
-  test.equal(node1.nodeName, "DIV");
-  test.equal(node2.nodeName, "INPUT");
-  test.equal(node1.getAttribute("puppy"), "foo");
-  test.equal(node2.getAttribute("kittycat"), "abcd");
-
-  R1.set("bar");
-  R2.set("efgh");
-  Deps.flush();
-  test.equal(node1.getAttribute("puppy"), "bar");
-  test.equal(node2.getAttribute("kittycat"), "efgh");
-
-  frag.release();
-  Deps.flush();
-  test.equal(R1.numListeners(), 0);
-  test.equal(R2.numListeners(), 0);
-
-  var R;
-  R = ReactiveVar(false);
-  frag = WrappedFrag(renderWithPreservation(function() {
-    return '<input id="foo" type="checkbox"' + (R.get() ? ' checked="checked"' : '') + '>';
-  })).hold();
-  var get_checked = function() { return !! frag.node().firstChild.checked; };
-  test.equal(get_checked(), false);
-  Deps.flush();
-  test.equal(get_checked(), false);
-  R.set(true);
-  test.equal(get_checked(), false);
-  Deps.flush();
-  test.equal(get_checked(), true);
-  R.set(false);
-  test.equal(get_checked(), true);
-  Deps.flush();
-  test.equal(get_checked(), false);
-  R.set(true);
-  Deps.flush();
-  test.equal(get_checked(), true);
-  frag.release();
-  R = ReactiveVar(true);
-  frag = WrappedFrag(renderWithPreservation(function() {
-    return '<input type="checkbox"' + (R.get() ? ' checked="checked"' : '') + '>';
-  })).hold();
-  test.equal(get_checked(), true);
-  Deps.flush();
-  test.equal(get_checked(), true);
-  R.set(false);
-  test.equal(get_checked(), true);
-  Deps.flush();
-  test.equal(get_checked(), false);
-  frag.release();
-
-
-  _.each([false, true], function(with_focus) {
-    R = ReactiveVar("apple");
-    var div = OnscreenDiv(renderWithPreservation(function() {
-      return '<input id="foo" type="text" value="' + R.get() + '">';
-    }));
-    var maybe_focus = function(div) {
-      if (with_focus) {
-        div.show();
-        focusElement(div.node().firstChild);
-      }
-    };
-    maybe_focus(div);
-    var get_value = function() { return div.node().firstChild.value; };
-    var set_value = function(v) { div.node().firstChild.value = v; };
-    var if_blurred = function(v, v2) {
-      return with_focus ? v2 : v; };
-    test.equal(get_value(), "apple");
-    Deps.flush();
-    test.equal(get_value(), "apple");
-    R.set("");
-    test.equal(get_value(), "apple");
-    Deps.flush();
-    test.equal(get_value(), if_blurred("", "apple"));
-    R.set("pear");
-    test.equal(get_value(), if_blurred("", "apple"));
-    Deps.flush();
-    test.equal(get_value(), if_blurred("pear", "apple"));
-    set_value("jerry"); // like user typing
-    R.set("steve");
-    Deps.flush();
-    // should overwrite user typing if blurred
-    test.equal(get_value(), if_blurred("steve", "jerry"));
-    div.kill();
-    R = ReactiveVar("");
-    div = OnscreenDiv(renderWithPreservation(function() {
-      return '<input id="foo" type="text" value="' + R.get() + '">';
-    }));
-    maybe_focus(div);
-    test.equal(get_value(), "");
-    Deps.flush();
-    test.equal(get_value(), "");
-    R.set("tom");
-    test.equal(get_value(), "");
-    Deps.flush();
-    test.equal(get_value(), if_blurred("tom", ""));
-    div.kill();
-    Deps.flush();
-  });
-});
-
-Tinytest.add("spark - bad labels", function(test) {
-  // make sure patching behaves gracefully even when labels violate
-  // the rules that would allow preservation of nodes identity.
-
-  var go = function(html1, html2) {
-    var R = ReactiveVar(true);
-    var frag = WrappedFrag(renderWithPreservation(function() {
-      return R.get() ? html1 : html2;
-    })).hold();
-
-    R.set(false);
-    Deps.flush();
-    test.equal(frag.html(), html2);
-    frag.release();
-  };
-
-  go('hello', 'world');
-
-  // duplicate IDs (bad developer; but should patch correctly)
-  go('<div id="foo">hello</div><b id="foo">world</b>',
-     '<div id="foo">hi</div><b id="foo">there</b>');
-  go('<div id="foo"><b id="foo">hello</b></div>',
-     '<div id="foo"><b id="foo">hi</b></div>');
-  go('<div id="foo">hello</div><b id="foo">world</b>',
-     '<div id="foo"><b id="foo">hi</b></div>');
-
-  // tag name changes
-  go('<div id="foo">abcd</div>',
-     '<p id="foo">efgh</p>');
-
-  // parent chain changes at all
-  go('<div><div><div><p id="foo">test123</p></div></div></div>',
-     '<div><div><p id="foo">test123</p></div></div>');
-  go('<div><div><div><p id="foo">test123</p></div></div></div>',
-     '<div><ins><div><p id="foo">test123</p></div></ins></div>');
-
-  // ambiguous names
-  go('<ul><li name="me">1</li><li name="me">3</li><li name="me">3</li></ul>',
-     '<ul><li name="me">4</li><li name="me">5</li></ul>');
-});
-
-
-Tinytest.add("spark - landmark patching", function(test) {
-
-  var rand;
-
-  var randomNodeList = function(optParentTag, depth) {
-    var atTopLevel = ! optParentTag;
-    var len = rand.nextIntBetween(atTopLevel ? 1 : 0, 6);
-    var buf = [];
-    for(var i=0; i<len; i++)
-      buf.push(randomNode(optParentTag, depth));
-    return buf;
-  };
-
-  var randomNode = function(optParentTag, depth) {
-    var n = {};
-
-    if (rand.nextBoolean()) {
-      // text node
-      n.text = rand.nextIdentifier(2);
-    } else {
-
-      n.tagName = rand.nextChoice((function() {
-        switch (optParentTag) {
-        case "p": return ['b', 'i', 'u'];
-        case "b": return ['i', 'u'];
-        case "i": return ['u'];
-        case "u": case "span": return ['span'];
-        default: return ['div', 'ins', 'center', 'p'];
-        }
-      })());
-
-      if (rand.nextBoolean())
-        n.id = rand.nextIdentifier();
-      if (rand.nextBoolean())
-        n.name = rand.nextIdentifier();
-
-      if (depth === 0) {
-        n.children = [];
-      } else {
-        n.children = randomNodeList(n.tagName, depth-1);
-      }
-    }
-
-    var existence = rand.nextChoice([[true, true], [false, true], [true, false]]);
-    n.existsBefore = existence[0];
-    n.existsAfter = existence[1];
-
-    return n;
-  };
-
-  var nodeListToHtml = function(list, is_after, optBuf) {
-    var buf = (optBuf || []);
-    _.each(list, function(n) {
-      if (is_after ? n.existsAfter : n.existsBefore) {
-        if (n.text) {
-          buf.push(n.text);
-        } else {
-          buf.push('<', n.tagName);
-          if (n.id)
-            buf.push(' id="', n.id, '"');
-          if (n.name)
-            buf.push(' name="', n.name, '"');
-          buf.push('>');
-          nodeListToHtml(n.children, is_after, buf);
-          buf.push('</', n.tagName, '>');
-        }
-      }
-    });
-    return optBuf ? null : buf.join('');
-  };
-
-  var fillInElementIdentities = function(list, parent, is_after) {
-    var elementsInList = _.filter(
-      list,
-      function(x) {
-        return (is_after ? x.existsAfter : x.existsBefore) && x.tagName;
-      });
-    var elementsInDom = _.filter(parent.childNodes,
-                                 function(x) { return x.nodeType === 1; });
-    test.equal(elementsInList.length, elementsInDom.length);
-    for(var i=0; i<elementsInList.length; i++) {
-      elementsInList[i].node = elementsInDom[i];
-      fillInElementIdentities(elementsInList[i].children,
-                              elementsInDom[i]);
-    }
-  };
-
-  var getParentChain = function(node) {
-    var buf = [];
-    while (node) {
-      buf.push(node);
-      node = node.parentNode;
-    }
-    return buf;
-  };
-
-  var isSameElements = function(a, b) {
-    if (a.length !== b.length)
-      return false;
-    for(var i=0; i<a.length; i++) {
-      if (a[i] !== b[i])
-        return false;
-    }
-    return true;
-  };
-
-  var collectLabeledNodeData = function(list, optArray) {
-    var buf = optArray || [];
-
-    _.each(list, function(x) {
-      if (x.tagName && x.existsBefore && x.existsAfter) {
-        if (x.name || x.id) {
-          buf.push({ node: x.node, parents: getParentChain(x.node) });
-        }
-        collectLabeledNodeData(x.children, buf);
-      }
-    });
-
-    return buf;
-  };
-
-  for(var i=0; i<5; i++) {
-    // Use non-deterministic randomness so we can have a shorter fuzz
-    // test (fewer iterations).  For deterministic (fully seeded)
-    // randomness, remove the call to Random.fraction().
-    rand = new SeededRandom("preserved nodes "+i+" "+Random.fraction());
-
-    var R = ReactiveVar(false);
-    var structure = randomNodeList(null, 6);
-    var frag = WrappedFrag(Meteor.render(function () {
-      return Spark.createLandmark({ preserve: idNameLabels }, function () {
-        return nodeListToHtml(structure, R.get());
-      });
-    })).hold();
-    test.equal(frag.html(), nodeListToHtml(structure, false) || "<!---->");
-    fillInElementIdentities(structure, frag.node());
-    var labeledNodes = collectLabeledNodeData(structure);
-    R.set(true);
-    Deps.flush();
-    test.equal(frag.html(), nodeListToHtml(structure, true) || "<!---->");
-    _.each(labeledNodes, function(x) {
-      test.isTrue(isSameElements(x.parents, getParentChain(x.node)));
-    });
-
-    frag.release();
-    Deps.flush();
-    test.equal(R.numListeners(), 0);
-  }
-
-});
-
-Tinytest.add("spark - landmark constant", function(test) {
-
-  var R, div;
-
-  // top-level { constant: true }
-
-  R = ReactiveVar(0);
-  var states = [];
-  div = OnscreenDiv(Meteor.render(function() {
-    R.get(); // create dependency
-    return Spark.createLandmark({
-      constant: true,
-      rendered: function() {
-        states.push(this);
-      }
-    }, function() { return '<b/><i/><u/>'; });
-  }));
-
-  var nodes = nodesToArray(div.node().childNodes);
-  test.equal(nodes.length, 3);
-  Deps.flush();
-  test.equal(states.length, 1);
-  R.set(1);
-  Deps.flush();
-  test.equal(states.length, 1); // no render callback on constant
-  var nodes2 = nodesToArray(div.node().childNodes);
-  test.equal(nodes2.length, 3);
-  test.isTrue(nodes[0] === nodes2[0]);
-  test.isTrue(nodes[1] === nodes2[1]);
-  test.isTrue(nodes[2] === nodes2[2]);
-  div.kill();
-  Deps.flush();
-  test.equal(R.numListeners(), 0);
-
-  // non-top-level
-
-  var i = 1;
-  // run test with and without matching branch label
-  _.each([false, true], function(matchLandmark) {
-    // run test with node before or after, or neither or both
-    _.each([false, true], function(nodeBefore) {
-      _.each([false, true], function(nodeAfter) {
-        var hasSpan = true;
-        var isConstant = true;
-
-        var crd = null; // [createCount, renderCount, destroyCount]
-
-        R = ReactiveVar('foo');
-        div = OnscreenDiv(Meteor.render(function() {
-          R.get(); // create unconditional dependency
-          var brnch = matchLandmark ? 'myBranch' : ('branch'+(++i));
-          return (nodeBefore ? R.get() : '') +
-            Spark.labelBranch(
-              brnch, function () {
-                return Spark.createLandmark(
-                  {
-                    constant: isConstant,
-                    created: function () {
-                      this.crd = [0,0,0];
-                      if (! crd)
-                        crd = this.crd; // capture first landmark's crd
-                      this.crd[0]++;
-                    },
-                    rendered: function () { this.crd[1]++; },
-                    destroyed: function () { this.crd[2]++; }
-                  },
-                  function() { return hasSpan ?
-                               '<span>stuff</span>' : 'blah'; });}) +
-            (nodeAfter ? R.get() : '');
-        }));
-
-        var span = div.node().getElementsByTagName('span')[0];
-        hasSpan = false;
-
-        test.equal(div.text(),
-                   (nodeBefore ? 'foo' : '')+
-                   'stuff'+
-                   (nodeAfter ? 'foo' : ''));
-
-        R.set('bar');
-        Deps.flush();
-
-        // only non-matching landmark should cause the constant
-        // chunk to be re-rendered
-        test.equal(div.text(),
-                   (nodeBefore ? 'bar' : '')+
-                   (matchLandmark ? 'stuff' : 'blah')+
-                   (nodeAfter ? 'bar' : ''));
-        // in non-matching case, first landmark is destroyed.
-        // otherwise, it is kept (and not re-rendered because
-        // it is constant)
-        test.equal(crd, matchLandmark ? [1,1,0] : [1,1,1]);
-
-        R.set('baz');
-        Deps.flush();
-
-        // should be repeatable (liveranges not damaged)
-        test.equal(div.text(),
-                   (nodeBefore ? 'baz' : '')+
-                   (matchLandmark ? 'stuff' : 'blah')+
-                   (nodeAfter ? 'baz' : ''));
-
-        isConstant = false; // no longer constant:true!
-        R.set('qux');
-        Deps.flush();
-        test.equal(div.text(),
-                   (nodeBefore ? 'qux' : '')+
-                   'blah'+
-                   (nodeAfter ? 'qux' : ''));
-
-        // turn constant back on
-        isConstant = true;
-        hasSpan = true;
-        R.set('popsicle');
-        Deps.flush();
-        // we don't get the span, instead old "blah" is preserved
-        test.equal(div.text(),
-                   (nodeBefore ? 'popsicle' : '')+
-                   (matchLandmark ? 'blah' : 'stuff')+
-                   (nodeAfter ? 'popsicle' : ''));
-
-        isConstant = false;
-        R.set('hi');
-        Deps.flush();
-        // now we get the span!
-        test.equal(div.text(),
-                   (nodeBefore ? 'hi' : '')+
-                   'stuff'+
-                   (nodeAfter ? 'hi' : ''));
-
-        div.kill();
-        Deps.flush();
-      });
-    });
-  });
-
-  // test that constant landmark gets rendered callback if it
-  // wasn't preserved.
-
-  var renderCount;
-
-  renderCount = 0;
-  R = ReactiveVar('div');
-  div = OnscreenDiv(Meteor.render(function () {
-    return '<' + R.get() + '>' + Spark.createLandmark(
-      {constant: true, rendered: function () { renderCount++; }},
-      function () {
-        return "hi";
-      }) +
-      '</' + R.get().split(' ')[0] + '>';
-  }));
-  Deps.flush();
-  test.equal(renderCount, 1);
-
-  R.set('div class="hamburger"');
-  Deps.flush();
-  // constant patched around, not re-rendered!
-  test.equal(renderCount, 1);
-
-  R.set('span class="hamburger"');
-  Deps.flush();
-  // can't patch parent to a different tag
-  test.equal(renderCount, 2);
-
-  R.set('span');
-  Deps.flush();
-  // can patch here, renderCount stays the same
-  test.equal(renderCount, 2);
-
-  div.kill();
-  Deps.flush();
-});
-
-_.each(['STRING', 'MONGO'], function (idGeneration) {
-Tinytest.add("spark - leaderboard, " + idGeneration, function(test) {
-  // use a simplified, local leaderboard to test some stuff
-
-  var players = new LocalCollection();
-  var selected_player = ReactiveVar();
-
-  var scores = OnscreenDiv(renderWithPreservation(function() {
-    var html = Spark.list(
-      players.find({}, {sort: {score: -1}}),
-      function(player) {
-        return Spark.labelBranch(player._id.valueOf(), function () {
-          return Spark.isolate(function () {
-            var style;
-            if (_.isEqual(selected_player.get(), player._id))
-              style = "player selected";
-            else
-              style = "player";
-
-            var html = '<div class="' + style + '">' +
-              '<div class="name">' + player.name + '</div>' +
-              '<div name="score">' + player.score + '</div></div>';
-            html = Spark.setDataContext(player, html);
-            html = Spark.createLandmark(
-              {preserve: idNameLabels},
-              function() { return html; });
-            return html;
-          });
-        });
-      });
-    html = Spark.attachEvents({
-      "click": function () {
-        selected_player.set(this._id);
-      }
-    }, html);
-    return html;
-  }));
-  var idGen;
-  if (idGeneration === 'STRING')
-    idGen = _.bind(Random.id, Random);
-  else
-    idGen = function () { return new LocalCollection._ObjectID(); };
-
-  // back before we had scientists we had Vancian hussade players
-  var names = ["Glinnes Hulden", "Shira Hulden", "Denzel Warhound",
-               "Lute Casagave", "Akadie", "Thammas, Lord Gensifer",
-               "Ervil Savat", "Duissane Trevanyi", "Sagmondo Bandolio",
-               "Rhyl Shermatz", "Yalden Wirp", "Tyran Lucho",
-               "Bump Candolf", "Wilmer Guff", "Carbo Gilweg"];
-  for (var i = 0; i < names.length; i++)
-    players.insert({_id: idGen(), name: names[i], score: i*5});
-
-  var bump = function() {
-    players.update(selected_player.get(), {$inc: {score: 5}});
-  };
-
-  var findPlayerNameDiv = function(name) {
-    var divs = scores.node().getElementsByTagName('DIV');
-    return _.find(divs, function(div) {
-      return div.innerHTML === name;
-    });
-  };
-
-  Deps.flush();
-  var glinnesNameNode = findPlayerNameDiv(names[0]);
-  test.isTrue(!! glinnesNameNode);
-  var glinnesScoreNode = glinnesNameNode.nextSibling;
-  test.equal(glinnesScoreNode.getAttribute("name"), "score");
-  clickElement(glinnesNameNode);
-  Deps.flush();
-  glinnesNameNode = findPlayerNameDiv(names[0]);
-  test.isTrue(!! glinnesNameNode);
-  test.equal(glinnesNameNode.parentNode.className, 'player selected');
-  var glinnesId = players.findOne({name: names[0]})._id;
-  test.isTrue(!! glinnesId);
-  test.equal(selected_player.get(), glinnesId);
-  test.equal(
-    canonicalizeHtml(glinnesNameNode.parentNode.innerHTML),
-    '<div class="name">Glinnes Hulden</div><div name="score">0</div>');
-
-  bump();
-  Deps.flush();
-
-  glinnesNameNode = findPlayerNameDiv(names[0], glinnesNameNode);
-  var glinnesScoreNode2 = glinnesNameNode.nextSibling;
-  test.equal(glinnesScoreNode2.getAttribute("name"), "score");
-  // move and patch should leave score node the same, because it
-  // has a name attribute!
-  test.equal(glinnesScoreNode, glinnesScoreNode2);
-  test.equal(glinnesNameNode.parentNode.className, 'player selected');
-  test.equal(
-    canonicalizeHtml(glinnesNameNode.parentNode.innerHTML),
-    '<div class="name">Glinnes Hulden</div><div name="score">5</div>');
-
-  bump();
-  Deps.flush();
-
-  glinnesNameNode = findPlayerNameDiv(names[0], glinnesNameNode);
-  test.equal(
-    canonicalizeHtml(glinnesNameNode.parentNode.innerHTML),
-    '<div class="name">Glinnes Hulden</div><div name="score">10</div>');
-
-  scores.kill();
-  Deps.flush();
-  test.equal(selected_player.numListeners(), 0);
-});
-});
-
-Tinytest.add("spark - list cursor stop", function(test) {
-  // test Spark.list outside of render mode, on custom observable
-
-  var numHandles = 0;
-  var observable = {
-    observeChanges: function(x) {
-      x.addedBefore("123", {}, null);
-      x.addedBefore("456", {}, null);
-      var handle;
-      numHandles++;
-      return handle = {
-        stop: function() {
-          numHandles--;
-        }
-      };
-    }
-  };
-
-  test.equal(numHandles, 0);
-  var result = Spark.list(observable, function(doc) {
-    return "#"+doc._id;
-  });
-  test.equal(result, "#123#456");
-  Deps.flush();
-  // chunk killed because not created inside Spark.render
-  test.equal(numHandles, 0);
-
-
-  var R = ReactiveVar(1);
-  var frag = WrappedFrag(Meteor.render(function() {
-    if (R.get() > 0)
-      return Spark.list(observable, function() { return "*"; });
-    return "";
-  })).hold();
-  test.equal(numHandles, 1);
-  Deps.flush();
-  test.equal(numHandles, 1);
-  R.set(2);
-  Deps.flush();
-  test.equal(numHandles, 1);
-  R.set(-1);
-  Deps.flush();
-  test.equal(numHandles, 0);
-
-  frag.release();
-  Deps.flush();
-});
-
-Tinytest.add("spark - list table", function(test) {
-  var c = new LocalCollection();
-
-  c.insert({value: "fudge", order: "A"});
-  c.insert({value: "sundae", order: "B"});
-
-  var R = ReactiveVar();
-
-  var table = WrappedFrag(Meteor.render(function() {
-    var buf = [];
-    buf.push('<table>');
-    buf.push(Spark.list(
-      c.find({}, {sort: ['order']}),
-      function(doc) {
-        return Spark.labelBranch(doc._id, function () {
-          return Spark.isolate(function () {
-            var html = "<tr><td>"+doc.value + (doc.reactive ? R.get() : '')+
-              "</td></tr>";
-            html = Spark.createLandmark(
-              {preserve: idNameLabels},
-              function() { return html; });
-            return html;
-          });
-        });
-      },
-      function() {
-        return "<tr><td>(nothing)</td></tr>";
-      }));
-    buf.push('</table>');
-    return buf.join('');
-  })).hold();
-
-  var lastHtml;
-
-  var shouldFlushTo = function(html) {
-    // same before flush
-    test.equal(table.html(), lastHtml);
-    Deps.flush();
-    test.equal(table.html(), html);
-    lastHtml = html;
-  };
-  var tableOf = function(/*htmls*/) {
-    if (arguments.length === 0) {
-      return '<table></table>';
-    } else {
-      return '<table><tbody><tr><td>' +
-        _.toArray(arguments).join('</td></tr><tr><td>') +
-        '</td></tr></tbody></table>';
-    }
-  };
-
-  test.equal(table.html(), lastHtml = tableOf('fudge', 'sundae'));
-
-  // switch order
-  c.update({value: "fudge"}, {$set: {order: "BA"}});
-  shouldFlushTo(tableOf('sundae', 'fudge'));
-
-  // change text
-  c.update({value: "fudge"}, {$set: {value: "hello"}});
-  c.update({value: "sundae"}, {$set: {value: "world"}});
-  shouldFlushTo(tableOf('world', 'hello'));
-
-  // remove all
-  c.remove({});
-  shouldFlushTo(tableOf('(nothing)'));
-
-  c.insert({value: "1", order: "A"});
-  c.insert({value: "5", order: "B"});
-  c.insert({value: "3", order: "AB"});
-  c.insert({value: "7", order: "BB"});
-  c.insert({value: "2", order: "AA"});
-  c.insert({value: "4", order: "ABA"});
-  c.insert({value: "6", order: "BA"});
-  c.insert({value: "8", order: "BBA"});
-  shouldFlushTo(tableOf('1', '2', '3', '4', '5', '6', '7', '8'));
-
-  // make one item newly reactive
-  R.set('*');
-  c.update({value: "7"}, {$set: {reactive: true}});
-  shouldFlushTo(tableOf('1', '2', '3', '4', '5', '6', '7*', '8'));
-
-  R.set('!');
-  shouldFlushTo(tableOf('1', '2', '3', '4', '5', '6', '7!', '8'));
-
-  // move it
-  c.update({value: "7"}, {$set: {order: "A0"}});
-  shouldFlushTo(tableOf('1', '7!', '2', '3', '4', '5', '6', '8'));
-
-  // still reactive?
-  R.set('?');
-  shouldFlushTo(tableOf('1', '7?', '2', '3', '4', '5', '6', '8'));
-
-  // go nuts
-  c.update({value: '1'}, {$set: {reactive: true}});
-  c.update({value: '1'}, {$set: {reactive: false}});
-  c.update({value: '2'}, {$set: {reactive: true}});
-  c.update({value: '2'}, {$set: {order: "BBB"}});
-  R.set(';');
-  R.set('.');
-  shouldFlushTo(tableOf('1', '7.', '3', '4', '5', '6', '8', '2.'));
-
-  for(var i=1; i<=8; i++)
-    c.update({value: String(i)},
-             {$set: {reactive: true, value: '='+String(i)}});
-  R.set('!');
-  shouldFlushTo(tableOf('=1!', '=7!', '=3!', '=4!', '=5!', '=6!', '=8!', '=2!'));
-
-  for(var i=1; i<=8; i++)
-    c.update({value: '='+String(i)},
-             {$set: {order: "A"+i}});
-  shouldFlushTo(tableOf('=1!', '=2!', '=3!', '=4!', '=5!', '=6!', '=7!', '=8!'));
-
-  var valueFunc = function(n) { return '<b name="bold">'+n+'</b>'; };
-  for(var i=1; i<=8; i++)
-    c.update({value: '='+String(i)},
-             {$set: {value: valueFunc(i)}});
-  shouldFlushTo(tableOf.apply(
-    null,
-    _.map(_.range(1,9), function(n) { return valueFunc(n)+R.get(); })));
-
-  test.equal(table.node().firstChild.rows.length, 8);
-
-  var bolds = table.node().firstChild.getElementsByTagName('B');
-  test.equal(bolds.length, 8);
-  _.each(bolds, function(b) {
-    b.nifty = {}; // mark the nodes; non-primitive value won't appear in IE HTML
-  });
-
-  R.set('...');
-  shouldFlushTo(tableOf.apply(
-    null,
-    _.map(_.range(1,9), function(n) { return valueFunc(n)+R.get(); })));
-  var bolds2 = table.node().firstChild.getElementsByTagName('B');
-  test.equal(bolds2.length, 8);
-  // make sure patching is actually happening
-  _.each(bolds2, function(b) {
-    test.equal(!! b.nifty, true);
-  });
-
-  // change value func, and still we should be patching
-  var valueFunc2 = function(n) { return '<b name="bold">'+n+'</b><i>yeah</i>'; };
-  for(var i=1; i<=8; i++)
-    c.update({value: valueFunc(i)},
-             {$set: {value: valueFunc2(i)}});
-  shouldFlushTo(tableOf.apply(
-    null,
-    _.map(_.range(1,9), function(n) { return valueFunc2(n)+R.get(); })));
-  var bolds3 = table.node().firstChild.getElementsByTagName('B');
-  test.equal(bolds3.length, 8);
-  _.each(bolds3, function(b) {
-    test.equal(!! b.nifty, true);
-  });
-
-  table.release();
-
-});
-
-
-Tinytest.add("spark - list event data", function(test) {
-  // this is based on a bug
-
-  var lastClicked = null;
-  var R = ReactiveVar(0);
-  var later;
-  var div = OnscreenDiv(Meteor.render(function() {
-    var html = Spark.list(
-      {
-        observeChanges: function(observer) {
-          observer.addedBefore("1", {name: 'Foo'}, null);
-          observer.addedBefore("2", {name: 'Bar'}, null);
-          // exercise callback path
-          later = function() {
-            observer.addedBefore("3", {name: 'Baz'}, null);
-            observer.addedBefore("4", {name: 'Qux'}, null);
-          };
-          return { stop: function() {} };
-        }
-      },
-      function(doc) {
-        var html = Spark.isolate(function () {
-          R.get(); // depend on R
-          return '<div>' + doc.name + '</div>';
-        });
-        html = Spark.setDataContext(doc, html);
-        return html;
-      }
-    );
-    html = Spark.attachEvents({
-      'click': function (event) {
-        lastClicked = this.name;
-        R.set(R.get() + 1); // signal all dependers on R
-      }
-    }, html);
-    return html;
-  }));
-
-  var item = function(name) {
-    return _.find(div.node().getElementsByTagName('div'), function(d) {
-      return d.innerHTML === name; });
-  };
-
-  later();
-  Deps.flush();
-  test.equal(item("Foo").innerHTML, "Foo");
-  test.equal(item("Bar").innerHTML, "Bar");
-  test.equal(item("Baz").innerHTML, "Baz");
-  test.equal(item("Qux").innerHTML, "Qux");
-
-  var doClick = function(name) {
-    clickElement(item(name));
-    test.equal(lastClicked, name);
-    Deps.flush();
-  };
-
-  doClick("Foo");
-  doClick("Bar");
-  doClick("Baz");
-  doClick("Qux");
-  doClick("Bar");
-  doClick("Foo");
-  doClick("Foo");
-  doClick("Foo");
-  doClick("Qux");
-  doClick("Baz");
-  doClick("Baz");
-  doClick("Baz");
-  doClick("Bar");
-  doClick("Baz");
-  doClick("Foo");
-  doClick("Qux");
-  doClick("Foo");
-
-  div.kill();
-  Deps.flush();
-
-});
-
-
-Tinytest.add("spark - events on preserved nodes", function(test) {
-  var count = ReactiveVar(0);
-  var demo = OnscreenDiv(renderWithPreservation(function() {
-    var html = Spark.isolate(function () {
-      return '<div class="button_demo">'+
-        '<input type="button" name="press" value="Press this button">'+
-        '<div>The button has been pressed '+count.get()+' times.</div>'+
-        '</div>';
-    });
-    html = Spark.attachEvents({
-      'click input': function() {
-        count.set(count.get() + 1);
-      }
-    }, html);
-    return html;
-  }));
-
-  var click = function() {
-    clickElement(demo.node().getElementsByTagName('input')[0]);
-  };
-
-  test.equal(count.get(), 0);
-  for(var i=0; i<10; i++) {
-    click();
-    Deps.flush();
-    test.equal(count.get(), i+1);
-  }
-
-  demo.kill();
-  Deps.flush();
-});
-
-
-Tinytest.add("spark - cleanup", function(test) {
-
-  // more exhaustive clean-up testing
-  var stuff = new LocalCollection();
-
-  var add_doc = function() {
-    stuff.insert({foo:'bar'}); };
-  var clear_docs = function() {
-    stuff.remove({}); };
-  var remove_one = function() {
-    stuff.remove(stuff.findOne()._id); };
-
-  add_doc(); // start the collection with a doc
-
-  var R = ReactiveVar("x");
-
-  var div = OnscreenDiv(Spark.render(function() {
-    return Spark.list(
-      stuff.find(),
-      function() {
-        return Spark.isolate(function () { return R.get()+"1"; });
-      },
-      function() {
-        return Spark.isolate(function () { return R.get()+"0"; });
-      });
-  }));
-
-  test.equal(div.text(), "x1");
-  Deps.flush();
-  test.equal(div.text(), "x1");
-  test.equal(R.numListeners(), 1);
-
-  clear_docs();
-  Deps.flush();
-  test.equal(div.text(), "x0");
-  test.equal(R.numListeners(), 1); // test clean-up of doc on remove
-
-  add_doc();
-  Deps.flush();
-  test.equal(div.text(), "x1");
-  test.equal(R.numListeners(), 1); // test clean-up of "else" listeners
-
-  add_doc();
-  Deps.flush();
-  test.equal(div.text(), "x1x1");
-  test.equal(R.numListeners(), 2);
-
-  remove_one();
-  Deps.flush();
-  test.equal(div.text(), "x1");
-  test.equal(R.numListeners(), 1); // test clean-up of doc with other docs
-
-  div.kill();
-  Deps.flush();
-  test.equal(R.numListeners(), 0);
-
-  //// list stopped if not materialized
-
-  var observeCount = 0;
-  var stopCount = 0;
-  var cursor = {
-    observeChanges: function (callbacks) {
-      observeCount++;
-      return {
-        stop: function () {
-          stopCount++;
-        }
-      };
-    }
-  };
-
-  div = OnscreenDiv(Spark.render(function () {
-    var html = Spark.list(cursor,
-                          function () { return ''; });
-    // don't return html
-    return 'hi';
-  }));
-  // we expect that the implementation of Spark.list observed the
-  // cursor in order to generate HTML, and then stopped it when
-  // it saw that the annotation wasn't materialized.  Other acceptable
-  // implementations of Spark.list might avoid observing the cursor
-  // altogether, resulting in [0, 0], or might defer the stopping to
-  // flush time.
-  test.equal([observeCount, stopCount], [1, 1]);
-
-  div.kill();
-  Deps.flush();
-});
-
-
-var make_input_tester = function(render_func, events) {
-  var buf = [];
-
-  if (typeof render_func === "string") {
-    var render_str = render_func;
-    render_func = function() { return render_str; };
-  }
-  if (typeof events === "string") {
-    events = eventmap.apply(null, _.toArray(arguments).slice(1));
-  }
-
-  var R = ReactiveVar(0);
-  var div = OnscreenDiv(
-    renderWithPreservation(function() {
-      R.get(); // create dependency
-      var html = render_func();
-      html = Spark.attachEvents(events, html);
-      html = Spark.setDataContext(buf, html);
-      return html;
-    }));
-  div.show(true);
-
-  var getbuf = function() {
-    var ret = buf.slice();
-    buf.length = 0;
-    return ret;
-  };
-
-  var self;
-  return self = {
-    focus: function(optCallback) {
-      focusElement(self.inputNode());
-
-      if (optCallback)
-        Meteor.defer(function() { optCallback(getbuf()); });
-      else
-        return getbuf();
-    },
-    blur: function(optCallback) {
-      blurElement(self.inputNode());
-
-      if (optCallback)
-        Meteor.defer(function() { optCallback(getbuf()); });
-      else
-        return getbuf();
-    },
-    click: function() {
-      clickElement(self.inputNode());
-      return getbuf();
-    },
-    kill: function() {
-      // clean up
-      div.kill();
-      Deps.flush();
-    },
-    inputNode: function() {
-      return div.node().getElementsByTagName("input")[0];
-    },
-    redraw: function() {
-      R.set(R.get() + 1);
-      Deps.flush();
-    }
-  };
-};
-
-// Note:  These tests MAY FAIL if the browser window doesn't have focus
-// (isn't frontmost) in some browsers, particularly Firefox.
-testAsyncMulti("spark - focus/blur events",
-  (function() {
-
-    var textLevel1 = '<input type="text" />';
-    var textLevel2 = '<span id="spanOfMurder"><input type="text" /></span>';
-
-    var focus_test = function(render_func, events, expected_results) {
-      return function(test, expect) {
-        var tester = make_input_tester(render_func, events);
-        var callback = expect(expected_results);
-        tester.focus(function(buf) {
-          tester.kill();
-          callback(buf);
-        });
-      };
-    };
-
-    var blur_test = function(render_func, events, expected_results) {
-      return function(test, expect) {
-        var tester = make_input_tester(render_func, events);
-        var callback = expect(expected_results);
-        tester.focus();
-        tester.blur(function(buf) {
-          tester.kill();
-          callback(buf);
-        });
-      };
-    };
-
-    return [
-
-      // focus on top-level input
-      focus_test(textLevel1, 'focus input', ['focus input']),
-
-      // focus on second-level input
-      // issue #108
-      focus_test(textLevel2, 'focus input', ['focus input']),
-
-      // focusin
-      focus_test(textLevel1, 'focusin input', ['focusin input']),
-      focus_test(textLevel2, 'focusin input', ['focusin input']),
-
-      // focusin bubbles
-      focus_test(textLevel2, 'focusin span', ['focusin span']),
-
-      // focus doesn't bubble
-      focus_test(textLevel2, 'focus span', []),
-
-      // blur works, doesn't bubble
-      blur_test(textLevel1, 'blur input', ['blur input']),
-      blur_test(textLevel2, 'blur input', ['blur input']),
-      blur_test(textLevel2, 'blur span', []),
-
-      // focusout works, bubbles
-      blur_test(textLevel1, 'focusout input', ['focusout input']),
-      blur_test(textLevel2, 'focusout input', ['focusout input']),
-      blur_test(textLevel2, 'focusout span', ['focusout span'])
-    ];
-  })());
-
-
-Tinytest.add("spark - change events", function(test) {
-
-  var checkboxLevel1 = '<input type="checkbox" />';
-  var checkboxLevel2 = '<span id="spanOfMurder">'+
-    '<input type="checkbox" id="checkboxy" /></span>';
-
-
-  // on top-level
-  var checkbox1 = make_input_tester(checkboxLevel1, 'change input');
-  test.equal(checkbox1.click(), ['change input']);
-  checkbox1.kill();
-
-  // on second-level (should bubble)
-  var checkbox2 = make_input_tester(checkboxLevel2,
-                                    'change input', 'change span');
-  test.equal(checkbox2.click(), ['change input', 'change span']);
-  test.equal(checkbox2.click(), ['change input', 'change span']);
-  checkbox2.redraw();
-  test.equal(checkbox2.click(), ['change input', 'change span']);
-  checkbox2.kill();
-
-  checkbox2 = make_input_tester(checkboxLevel2, 'change input');
-  test.equal(checkbox2.focus(), []);
-  test.equal(checkbox2.click(), ['change input']);
-  test.equal(checkbox2.blur(), []);
-  test.equal(checkbox2.click(), ['change input']);
-  checkbox2.kill();
-
-  var checkbox2 = make_input_tester(
-    checkboxLevel2,
-    'change input', 'change span', 'change div');
-  test.equal(checkbox2.click(), ['change input', 'change span']);
-  checkbox2.kill();
-
-});
-
-
-testAsyncMulti(
-  "spark - submit events",
-  (function() {
-    var hitlist = [];
-    var killLater = function(thing) {
-      hitlist.push(thing);
-    };
-
-    var LIVEUI_TEST_RESPONDER = "/spark_test_responder";
-    var IFRAME_URL_1 = LIVEUI_TEST_RESPONDER + "/";
-    var IFRAME_URL_2 = "about:blank"; // most cross-browser-compatible
-    if (window.opera) // opera doesn't like 'about:blank' form target
-      IFRAME_URL_2 = LIVEUI_TEST_RESPONDER+"/blank";
-
-    return [
-      function(test, expect) {
-
-        // Submit events can be canceled with preventDefault, which prevents the
-        // browser's native form submission behavior.  This behavior takes some
-        // work to ensure cross-browser, so we want to test it.  To detect
-        // a form submission, we target the form at an iframe.  Iframe security
-        // makes this tricky.  What we do is load a page from the server that
-        // calls us back on 'load' and 'unload'.  We wait for 'load', set up the
-        // test, and then see if we get an 'unload' (due to the form submission
-        // going through) or not.
-        //
-        // This is quite a tricky implementation.
-
-        var withIframe = function(onReady1, onReady2) {
-          var frameName = "submitframe"+String(Random.fraction()).slice(2);
-          var iframeDiv = OnscreenDiv(
-            Meteor.render(function() {
-              return '<iframe name="'+frameName+'" '+
-                'src="'+IFRAME_URL_1+'"></iframe>';
-            }));
-          var iframe = iframeDiv.node().firstChild;
-
-          iframe.loadFunc = function() {
-            onReady1(frameName, iframe, iframeDiv);
-            onReady2(frameName, iframe, iframeDiv);
-          };
-          iframe.unloadFunc = function() {
-            iframe.DID_CHANGE_PAGE = true;
-          };
-        };
-        var expectCheckLater = function(options) {
-          var check = expect(function(iframe, iframeDiv) {
-            if (options.shouldSubmit)
-              test.isTrue(iframe.DID_CHANGE_PAGE);
-            else
-              test.isFalse(iframe.DID_CHANGE_PAGE);
-
-            // must do this inside expect() so it happens in time
-            killLater(iframeDiv);
-          });
-          var checkLater = function(frameName, iframe, iframeDiv) {
-            Meteor.setTimeout(function() {
-              check(iframe, iframeDiv);
-            }, 500); // wait for frame to unload
-          };
-          return checkLater;
-        };
-        var buttonFormHtml = function(frameName) {
-          return '<div style="height:0;overflow:hidden">'+
-            '<form action="'+IFRAME_URL_2+'" target="'+
-            frameName+'">'+
-            '<span><input type="submit"></span>'+
-            '</form></div>';
-        };
-
-        // test that form submission by click fires event,
-        // and also actually submits
-        withIframe(function(frameName, iframe) {
-          var form = make_input_tester(
-            buttonFormHtml(frameName), 'submit form');
-          test.equal(form.click(), ['submit form']);
-          killLater(form);
-        }, expectCheckLater({shouldSubmit:true}));
-
-        // submit bubbles up
-        withIframe(function(frameName, iframe) {
-          var form = make_input_tester(
-            buttonFormHtml(frameName), 'submit form', 'submit div');
-          test.equal(form.click(), ['submit form', 'submit div']);
-          killLater(form);
-        }, expectCheckLater({shouldSubmit:true}));
-
-        // preventDefault works, still bubbles
-        withIframe(function(frameName, iframe) {
-          var form = make_input_tester(
-            buttonFormHtml(frameName), {
-              'submit form': function(evt) {
-                test.equal(evt.type, 'submit');
-                test.equal(evt.target.nodeName, 'FORM');
-                this.push('submit form');
-                evt.preventDefault();
-              },
-              'submit div': function(evt) {
-                test.equal(evt.type, 'submit');
-                test.equal(evt.target.nodeName, 'FORM');
-                this.push('submit div');
-              },
-              'submit a': function(evt) {
-                this.push('submit a');
-              }
-            }
-          );
-          test.equal(form.click(), ['submit form', 'submit div']);
-          killLater(form);
-        }, expectCheckLater({shouldSubmit:false}));
-
-      },
-      function(test, expect) {
-        _.each(hitlist, function(thing) {
-          thing.kill();
-        });
-        Deps.flush();
-      }
-    ];
-  })());
-
-
-Tinytest.add("spark - controls - radio", function(test) {
-  var R = ReactiveVar("");
-  var R2 = ReactiveVar("");
-  var change_buf = [];
-  var div = OnscreenDiv(renderWithPreservation(function() {
-    // Re-render when R2 is changed, even though it doesn't affect HTML.
-    R2.get();
-
-    var buf = [];
-    buf.push("Band: ");
-    _.each(["AM", "FM", "XM"], function(band) {
-      var checked = (R.get() === band) ? 'checked="checked"' : '';
-      buf.push('<input type="radio" name="bands" '+
-               'value="'+band+'" '+checked+'/>');
-    });
-    buf.push(R.get());
-    var html = buf.join('');
-
-    html = Spark.attachEvents({
-      'change input': function(event) {
-        // IE 7 is known to fire change events on all
-        // the radio buttons with checked=false, as if
-        // each button were deselected before selecting
-        // the new one.  (Meteor doesn't normalize this
-        // behavior.)
-        // However, browsers are consistent if we are
-        // getting a checked=true notification.
-        var btn = event.target;
-        if (btn.checked) {
-          var band = btn.value;
-          change_buf.push(band);
-          R.set(band);
-        }
-      }
-    }, html);
-    return html;
-  }));
-
-  Deps.flush();
-
-  // get the three buttons; they should be considered 'labeled'
-  // by the patcher and not change identities!
-  var btns = nodesToArray(div.node().getElementsByTagName("INPUT"));
-
-  test.equal(_.pluck(btns, 'checked'), [false, false, false]);
-  test.equal(div.text(), "Band: ");
-
-  clickElement(btns[0]);
-  test.equal(change_buf, ['AM']);
-  change_buf.length = 0;
-  Deps.flush();
-  test.equal(_.pluck(btns, 'checked'), [true, false, false]);
-  test.equal(div.text(), "Band: AM");
-
-  R2.set("change");
-  Deps.flush();
-  test.length(change_buf, 0);
-  test.equal(_.pluck(btns, 'checked'), [true, false, false]);
-  test.equal(div.text(), "Band: AM");
-
-  clickElement(btns[1]);
-  test.equal(change_buf, ['FM']);
-  change_buf.length = 0;
-  Deps.flush();
-  test.equal(_.pluck(btns, 'checked'), [false, true, false]);
-  test.equal(div.text(), "Band: FM");
-
-  clickElement(btns[2]);
-  test.equal(change_buf, ['XM']);
-  change_buf.length = 0;
-  Deps.flush();
-  test.equal(_.pluck(btns, 'checked'), [false, false, true]);
-  test.equal(div.text(), "Band: XM");
-
-  clickElement(btns[1]);
-  test.equal(change_buf, ['FM']);
-  change_buf.length = 0;
-  Deps.flush();
-  test.equal(_.pluck(btns, 'checked'), [false, true, false]);
-  test.equal(div.text(), "Band: FM");
-
-  div.kill();
-});
-
-Tinytest.add("spark - controls - checkbox", function(test) {
-  var labels = ["Foo", "Bar", "Baz"];
-  var Rs = {};
-  _.each(labels, function (label) {
-    Rs[label] = ReactiveVar(false);
-  });
-  var changeBuf = [];
-  var div = OnscreenDiv(renderWithPreservation(function() {
-    var buf = [];
-    _.each(labels, function (label) {
-      var checked = Rs[label].get() ? 'checked="checked"' : '';
-      buf.push('<input type="checkbox" name="checky" '+
-               'value="'+label+'" '+checked+'/>');
-    });
-    return buf.join('');
-  }));
-
-  Deps.flush();
-
-  // get the three boxes; they should be considered 'labeled' by the patcher and
-  // not change identities!
-  var boxes = nodesToArray(div.node().getElementsByTagName("INPUT"));
-
-  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
-
-  // Re-render with first one checked.
-  Rs.Foo.set(true);
-  Deps.flush();
-  test.equal(_.pluck(boxes, 'checked'), [true, false, false]);
-
-  // Re-render with first one unchecked again.
-  Rs.Foo.set(false);
-  Deps.flush();
-  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
-
-  // User clicks the second one.
-  clickElement(boxes[1]);
-  test.equal(_.pluck(boxes, 'checked'), [false, true, false]);
-  Deps.flush();
-  test.equal(_.pluck(boxes, 'checked'), [false, true, false]);
-
-  // Re-render with third one checked. Second one should stay checked because
-  // it's a user update!
-  Rs.Baz.set(true);
-  Deps.flush();
-  test.equal(_.pluck(boxes, 'checked'), [false, true, true]);
-
-  // User turns second and third off.
-  clickElement(boxes[1]);
-  clickElement(boxes[2]);
-  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
-  Deps.flush();
-  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
-
-  // Re-render with first one checked. Third should stay off because it's a user
-  // update!
-  Rs.Foo.set(true);
-  Deps.flush();
-  test.equal(_.pluck(boxes, 'checked'), [true, false, false]);
-
-  // Re-render with first one unchecked. Third should still stay off.
-  Rs.Foo.set(false);
-  Deps.flush();
-  test.equal(_.pluck(boxes, 'checked'), [false, false, false]);
-
-  div.kill();
-});
-
-_.each(['textarea', 'text', 'password', 'submit', 'button',
-        'reset', 'select', 'hidden'], function (type) {
-  Tinytest.add("spark - controls - " + type, function(test) {
-    var R = ReactiveVar({x:"test"});
-    var R2 = ReactiveVar("");
-    var div = OnscreenDiv(renderWithPreservation(function() {
-      // Re-render when R2 is changed, even though it doesn't affect HTML.
-      R2.get();
-      if (type === 'textarea') {
-        return '<textarea id="someId">This is a ' + R.get().x + '</textarea>';
-      } else if (type === 'select') {
-        var options = ['This is a test', 'This is a fridge',
-                       'This is a frog', 'foobar', 'This is a photograph',
-                       'This is a monkey', 'This is a donkey'];
-        return '<select id="someId">' + _.map(options, function (o) {
-          var maybeSel = ('This is a ' + R.get().x) === o ? 'selected' : '';
-          return '<option ' + maybeSel + '>' + o + '</option>';
-        }).join('') + '</select>';
-      } else {
-        return '<input type="' + type + '" id="someId" value="This is a ' +
-          R.get().x + '">';
-      }
-    }));
-    div.show(true);
-    var canFocus = (type !== 'hidden');
-
-    var input = div.node().firstChild;
-    if (type === 'textarea' || type === 'select') {
-      test.equal(input.nodeName, type.toUpperCase());
-    } else {
-      test.equal(input.nodeName, 'INPUT');
-      test.equal(input.type, type);
-    }
-    test.equal(DomUtils.getElementValue(input), "This is a test");
-    test.equal(input._sparkOriginalRenderedValue, ["This is a test"]);
-
-    // value updates reactively
-    R.set({x:"fridge"});
-    Deps.flush();
-    test.equal(DomUtils.getElementValue(input), "This is a fridge");
-    test.equal(input._sparkOriginalRenderedValue, ["This is a fridge"]);
-
-    if (canFocus) {
-      // ...unless focused
-      focusElement(input);
-      R.set({x:"frog"});
-      Deps.flush();
-      test.equal(DomUtils.getElementValue(input), "This is a fridge");
-      test.equal(input._sparkOriginalRenderedValue, ["This is a fridge"]);
-
-      // blurring and re-setting works
-      blurElement(input);
-      Deps.flush();
-      test.equal(DomUtils.getElementValue(input), "This is a fridge");
-      test.equal(input._sparkOriginalRenderedValue, ["This is a fridge"]);
-    }
-    R.set({x:"frog"});
-    Deps.flush();
-    test.equal(DomUtils.getElementValue(input), "This is a frog");
-    test.equal(input._sparkOriginalRenderedValue, ["This is a frog"]);
-
-    // Setting a value (similar to user typing) should prevent value from being
-    // reverted if the div is re-rendered but the rendered value (ie, R) does
-    // not change.
-    DomUtils.setElementValue(input, "foobar");
-    R2.set("change");
-    Deps.flush();
-    test.equal(DomUtils.getElementValue(input), "foobar");
-    test.equal(input._sparkOriginalRenderedValue, ["This is a frog"]);
-
-    // ... but if the actual rendered value changes, that should take effect.
-    R.set({x:"photograph"});
-    Deps.flush();
-    test.equal(DomUtils.getElementValue(input), "This is a photograph");
-    test.equal(input._sparkOriginalRenderedValue, ["This is a photograph"]);
-
-    // If the rendered value and user value change in the same way (eg, the user
-    // changed it and then invoked a menthod that set the database value based
-    // on what they changed), make sure that the _sparkOriginalRenderedValue
-    // gets updated too.
-    DomUtils.setElementValue(input, "This is a monkey");
-    R.set({x:"monkey"});
-    Deps.flush();
-    test.equal(DomUtils.getElementValue(input), "This is a monkey");
-    test.equal(input._sparkOriginalRenderedValue, ["This is a monkey"]);
-
-    if (canFocus) {
-      // The same as the previous test... except make sure that it still works
-      // if the input is focused. ie, imagine that the user edited the field and
-      // hit enter with the field still focused, updating the database to match
-      // the field and keeping the field focused.
-      DomUtils.setElementValue(input, "This is a donkey");
-      focusElement(input);
-      R.set({x:"donkey"});
-      Deps.flush();
-      test.equal(DomUtils.getElementValue(input), "This is a donkey");
-      test.equal(input._sparkOriginalRenderedValue, ["This is a donkey"]);
-    }
-
-    div.kill();
-  });
-});
-
-Tinytest.add("spark - oldschool landmark matching", function(test) {
-
-  // basic created / onscreen / offscreen callback flow
-  // (ported from old chunk-matching API)
-
-  var buf;
-  var counts;
-
-  var testCallbacks = function(theNum /*, extend opts*/) {
-    return _.extend.apply(_, [{
-      created: function() {
-        this.num = String(theNum);
-        var howManyBefore = counts[this.num] || 0;
-        counts[this.num] = howManyBefore + 1;
-        for(var i=0;i<howManyBefore;i++)
-          this.num += "*"; // add stars
-        buf.push("c"+this.num);
-      },
-      rendered: function(start, end, range) {
-        buf.push("r"+this.num);
-      },
-      destroyed: function() {
-        buf.push("d"+this.num);
-      }
-    }].concat(_.toArray(arguments).slice(1)));
-  };
-
-  buf = [];
-  counts = {};
-  var R = ReactiveVar("A");
-  var div = OnscreenDiv(Meteor.render(function() {
-    var html = Spark.createLandmark(testCallbacks(0), function () {
-      return String(R.get());
-    });
-    return html;
-  }, testCallbacks(0)));
-
-  test.equal(buf, ["c0"]);
-
-  test.equal(div.html(), "A");
-  Deps.flush();
-  test.equal(buf, ["c0", "r0"]);
-  test.equal(div.html(), "A");
-
-  R.set("B");
-  Deps.flush();
-  test.equal(buf, ["c0", "r0", "r0"]);
-  test.equal(div.html(), "B");
-
-
-  div.kill();
-  Deps.flush();
-  test.equal(buf, ["c0", "r0", "r0", "d0"]);
-
-  // with a branch
-
-  buf = [];
-  counts = {};
-  R = ReactiveVar("A");
-  div = OnscreenDiv(Meteor.render(function() {
-    R.get();
-    return Spark.createLandmark(testCallbacks(0), function () {
-      var html = Spark.labelBranch("foo", function () {
-        return Spark.createLandmark(testCallbacks(1),
-                                    function () { return "HI"; });
-      });
-      return "<div>" + html + "</div>";
-    });
-  }));
-
-  test.equal(buf, ["c0", "c1"]);
-  Deps.flush();
-  // what order of chunks {0,1} is preferable??
-  // should be consistent but I'm not sure what makes most sense.
-  test.equal(buf, "c0,c1,r1,r0".split(','));
-  buf.length = 0;
-
-  R.set("B");
-  Deps.flush();
-  test.equal(buf, "r1,r0".split(','));
-  buf.length = 0;
-
-  div.kill();
-  Deps.flush();
-  buf.sort();
-  test.equal(buf, "d0,d1".split(','));
-});
-
-
-Tinytest.add("spark - oldschool branch keys", function(test) {
-
-  var R, div;
-
-  // Re-rendered Meteor.render keeps same landmark state
-
-  var objs = [];
-  R = ReactiveVar("foo");
-  div = OnscreenDiv(Meteor.render(function() {
-    return Spark.createLandmark({
-      rendered: function () { objs.push(true); }
-    }, function () { return R.get(); });
-  }));
-
-  Deps.flush();
-  R.set("bar");
-  Deps.flush();
-  R.set("baz");
-  Deps.flush();
-
-  test.equal(objs.length, 3);
-  test.isTrue(objs[0] === objs[1]);
-  test.isTrue(objs[1] === objs[2]);
-
-  div.kill();
-  Deps.flush();
-
-  // track chunk matching / re-rendering in detail
-
-  var buf;
-  var counts;
-
-  var testCallbacks = function(theNum /*, extend opts*/) {
-    return _.extend.apply(_, [{
-      created: function() {
-        this.num = String(theNum);
-        var howManyBefore = counts[this.num] || 0;
-        counts[this.num] = howManyBefore + 1;
-        for(var i=0;i<howManyBefore;i++)
-          this.num += "*"; // add stars
-        buf.push("c"+this.num);
-      },
-      rendered: function(start, end, range) {
-        buf.push("on"+this.num);
-      },
-      destroyed: function() {
-        buf.push("off"+this.num);
-      }
-    }].concat(_.toArray(arguments).slice(1)));
-  };
-
-  var counter = 1;
-  var chunk = function(contents, num, branch) {
-    if (branch === null)
-      branch = "unique_branch_" + (counter++);
-
-    return Spark.labelBranch(branch, function () {
-      return Spark.createLandmark(
-        testCallbacks(num),
-        function () {
-          if (typeof contents === "string")
-            return contents;
-          else if (_.isArray(contents))
-            return _.map(contents, function(x) {
-              if (typeof x === 'string')
-                return x;
-              return chunk(x[0], x[1], x[2]);
-            }).join('');
-          else
-            return contents();
-        });
-    });
-  };
-
-  ///// Chunk 1 contains 2,3,4, all should be matched
-
-  buf = [];
-  counts = {};
-
-  R = ReactiveVar("foo");
-  div = OnscreenDiv(Meteor.render(function() {
-    if (R.get() === 'nothing')
-      return "no chunk!";
-    else
-      return chunk([['<span>apple</span>', 2, 'x'],
-                    ['<span>banana</span>', 3, 'y'],
-                    ['<span>kiwi</span>', 4, 'z']
-                   ], 1, 'fruit');
-  }));
-
-  Deps.flush();
-  buf.sort();
-  test.equal(buf, ['c1', 'c2', 'c3', 'c4', 'on1', 'on2', 'on3', 'on4']);
-  buf.length = 0;
-
-  R.set("bar");
-  Deps.flush();
-  buf.sort();
-  test.equal(buf, ['on1', 'on2', 'on3', 'on4']);
-  buf.length = 0;
-
-  R.set("nothing");
-  Deps.flush();
-  buf.sort();
-  test.equal(buf, ['off1', 'off2', 'off3', 'off4']);
-  buf.length = 0;
-
-  div.kill();
-  Deps.flush();
-
-  ///// Chunk 3 has no branch key, should be recreated
-
-  buf = [];
-  counts = {};
-
-  R = ReactiveVar("foo");
-  div = OnscreenDiv(Meteor.render(function() {
-    if (R.get() === 'nothing')
-      return "no chunk!";
-    else
-      return chunk([['<span>apple</span>', 2, 'x'],
-                    ['<span>banana</span>', 3, null],
-                    ['<span>kiwi</span>', 4, 'z']
-                   ], 1, 'fruit');
-  }));
-
-  Deps.flush();
-  buf.sort();
-  test.equal(buf, ['c1', 'c2', 'c3', 'c4', 'on1', 'on2', 'on3', 'on4']);
-  buf.length = 0;
-
-  R.set("bar");
-  Deps.flush();
-  buf.sort();
-  test.equal(buf, ['c3*', 'off3', 'on1', 'on2', 'on3*', 'on4']);
-  buf.length = 0;
-
-  div.kill();
-  Deps.flush();
-  buf.sort();
-  // killing the div should have given us offscreen calls for 1,2,3*,4
-  test.equal(buf, ['off1', 'off2', 'off3*', 'off4']);
-  buf.length = 0;
-
-
-  // XXX test intermediate unkeyed chunks;
-  // duplicate branch keys; different order
-});
-
-Tinytest.add("spark - isolate inside landmark", function (test) {
-
-  // test that preservation maps from all landmarks are honored when
-  // an isolate is re-rendered, even the landmarks that are outside
-  // the isolate and therefore not involved in the re-render.
-
-  var R = ReactiveVar(1);
-  var d = OnscreenDiv(Spark.render(function () {
-    return Spark.createLandmark(
-      { preserve: ['.foo'] },
-      function () {
-        return Spark.isolate(function () {
-          return '<hr class="foo"/>' + R.get();
-        });
-      });
-  }));
-
-  var foo1 = d.node().firstChild;
-  test.equal(d.node().firstChild.nextSibling.nodeValue, '1');
-  R.set(2);
-  Deps.flush();
-  var foo2 = d.node().firstChild;
-  test.equal(d.node().firstChild.nextSibling.nodeValue, '2');
-  test.isTrue(foo1 === foo2);
-  d.kill();
-  Deps.flush();
-
-  // test that selectors in a landmark preservation map are resolved
-  // relative to the landmark, not relative to the re-rendered
-  // fragment.  the selector may refer to nodes that are outside the
-  // re-rendered fragment, and the selector will still match.
-
-  R = ReactiveVar(1);
-  d = OnscreenDiv(Spark.render(function () {
-    return Spark.createLandmark(
-      { preserve: ['div .foo'] },
-      function () {
-        return "<div>"+Spark.isolate(function () {
-          return '<hr class="foo"/>' + R.get();
-        })+"</div>";
-      });
-  }));
-
-  var foo1 = DomUtils.find(d.node(), '.foo');
-  test.equal(foo1.nodeName, 'HR');
-  test.equal(foo1.nextSibling.nodeValue, '1');
-  R.set(2);
-  Deps.flush();
-  var foo2 = DomUtils.find(d.node(), '.foo');
-  test.equal(foo2.nodeName, 'HR');
-  test.equal(foo2.nextSibling.nodeValue, '2');
-  test.isTrue(foo1 === foo2);
-  d.kill();
-  Deps.flush();
-});
-
-Tinytest.add("spark - nested onscreen processing", function (test) {
-  var cursor = {
-    observeChanges: function () { return { stop: function () {} }; }
-  };
-
-  var x = [];
-  var d = OnscreenDiv(Spark.render(function () {
-    return Spark.list(cursor, function () {}, function () {
-      return Spark.list(cursor, function () {}, function () {
-        return Spark.list(cursor, function () {}, function () {
-          return Spark.createLandmark({
-            created: function () { x.push('c'); },
-            rendered: function () { x.push('r'); },
-            destroyed: function () { x.push('d'); }
-          }, function () { return "hi"; });
-        });
-      });
-    });
-  }));
-
-  Deps.flush();
-  test.equal(x.join(''), 'cr');
-  x = [];
-  d.kill();
-  Deps.flush();
-  test.equal(x.join(''), 'd');
-});
-
-Tinytest.add("spark - current landmark", function (test) {
-  var R = ReactiveVar(1);
-  var callbacks = 0;
-  var d = OnscreenDiv(Meteor.render(function () {
-    var html = Spark.createLandmark({
-      created: function () {
-        this.a = 1;
-        this.renderCount = 0;
-        test.isFalse('b' in this);
-        callbacks++;
-      },
-      rendered: function () {
-        test.equal(this.a, 9);
-        test.equal(this.b, 2);
-        if (this.renderCount === 0)
-          test.isFalse('c' in this);
-        else
-          test.isTrue('c' in this);
-        this.renderCount++;
-        callbacks++;
-      },
-      destroyed: function () {
-        test.equal(this.a, 9);
-        test.equal(this.b, 2);
-        test.equal(this.c, 3);
-        callbacks++;
-      }
-    }, function (lm) {
-      var html = '<span>hi</span>';
-
-      if (R.get() === 1) {
-        test.equal(callbacks, 1);
-        test.equal(lm.a, 1);
-        lm.a = 9;
-        lm.b = 2;
-        test.isFalse('c' in lm);
-        test.equal(callbacks, 1);
-        lm = null;
-      }
-
-      if (R.get() === 2) {
-        test.equal(callbacks, 2);
-        test.equal(lm.a, 9);
-        test.equal(lm.b, 2);
-        test.equal(lm.c, 3);
-        test.equal(lm.renderCount, 1);
-      }
-
-      return html;
-    });
-
-
-    if (R.get() >= 3) {
-      html += Spark.labelBranch('branch', function () {
-        var html = Spark.createLandmark({
-          created: function () {
-            this.outer = true;
-          },
-          rendered: function () {
-            this.renderCount = (this.renderCount || 0) + 1;
-          }
-        }, function (lm) {
-          var html = '<span>outer</span>';
-          test.isTrue(lm.outer);
-          test.equal(R.get() - 3, lm.renderCount || 0);
-          html += Spark.labelBranch("a", function () {
-            var html = Spark.createLandmark({
-              created: function () {
-                this.innerA = true;
-              },
-              rendered: function () {
-                this.renderCount = (this.renderCount || 0) + 1;
-              }
-            }, function (lm) {
-              var html = '<span>innerA</span>';
-              test.isTrue(lm.innerA);
-              return html;
-            });
-            return html;
-          });
-          return html;
-        });
-
-        if (R.get() === 3 || R.get() >= 5) {
-          html += Spark.labelBranch("b", function () {
-            var html = Spark.createLandmark({
-              created: function () {
-                this.innerB = true;
-              },
-              rendered: function () {
-                this.renderCount = (this.renderCount || 0) + 1;
-              }
-            }, function (lm) {
-              var html = '<span>innerB</span>';
-              test.isTrue(lm.innerB);
-              test.equal(R.get() === 3 ? 0 : R.get() - 5,
-                         lm.renderCount || 0);
-              return html;
-            });
-            return html;
-          });
-        }
-        return html;
-      });
-    }
-    return html;
-  }));
-
-  var findOuter = function () {
-    return d.node().firstChild.nextSibling;
-  };
-
-  var findInnerA = function () {
-    return findOuter().nextSibling;
-  };
-
-  var findInnerB = function () {
-    return findInnerA().nextSibling;
-  };
-
-  test.equal(callbacks, 1);
-  Deps.flush();
-  test.equal(callbacks, 2);
-  test.equal(null, SparkTest.getEnclosingLandmark(d.node()));
-  var enc = SparkTest.getEnclosingLandmark(d.node().firstChild);
-  test.equal(enc.a, 9);
-  test.equal(enc.b, 2);
-  test.isFalse('c' in enc);
-  enc.c = 3;
-  Deps.flush();
-  test.equal(callbacks, 2);
-
-  R.set(2)
-  Deps.flush();
-  test.equal(callbacks, 3);
-
-  R.set(3)
-  Deps.flush();
-  test.equal(callbacks, 4);
-
-  test.isTrue(SparkTest.getEnclosingLandmark(findOuter()).outer);
-  test.isTrue(SparkTest.getEnclosingLandmark(findInnerA()).innerA);
-  test.isTrue(SparkTest.getEnclosingLandmark(findInnerB()).innerB);
-  test.equal(1, SparkTest.getEnclosingLandmark(findOuter()).renderCount);
-  test.equal(1, SparkTest.getEnclosingLandmark(findInnerA()).renderCount);
-  test.equal(1, SparkTest.getEnclosingLandmark(findInnerB()).renderCount);
-
-  R.set(4)
-  Deps.flush();
-  test.equal(callbacks, 5);
-  test.equal(2, SparkTest.getEnclosingLandmark(findOuter()).renderCount);
-  test.equal(2, SparkTest.getEnclosingLandmark(findInnerA()).renderCount);
-
-  R.set(5)
-  Deps.flush();
-  test.equal(callbacks, 6);
-  test.equal(3, SparkTest.getEnclosingLandmark(findOuter()).renderCount);
-  test.equal(3, SparkTest.getEnclosingLandmark(findInnerA()).renderCount);
-  test.equal(1, SparkTest.getEnclosingLandmark(findInnerB()).renderCount);
-
-  R.set(6)
-  Deps.flush();
-  test.equal(callbacks, 7);
-  test.equal(4, SparkTest.getEnclosingLandmark(findOuter()).renderCount);
-  test.equal(4, SparkTest.getEnclosingLandmark(findInnerA()).renderCount);
-  test.equal(2, SparkTest.getEnclosingLandmark(findInnerB()).renderCount);
-
-  d.kill();
-  Deps.flush();
-  test.equal(callbacks, 8);
-
-  Deps.flush();
-  test.equal(callbacks, 8);
-});
-
-Tinytest.add("spark - find/findAll on landmark", function (test) {
-  var l1, l2;
-  var R = ReactiveVar(1);
-
-  var d = OnscreenDiv(Spark.render(function () {
-    return "<div id=1>k</div><div id=2>" +
-      Spark.labelBranch("a", function () {
-        return Spark.createLandmark({
-          created: function () {
-            test.instanceOf(this, Spark.Landmark);
-            if (l1)
-              test.equal(l1, this);
-            l1 = this;
-          }
-        }, function () {
-          return "<span class='a' id=3>a" +
-            Spark.labelBranch("b", function () {
-              return Spark.isolate(
-                function () {
-                  R.get();
-                  return Spark.createLandmark(
-                    {
-                      created: function () {
-                        test.instanceOf(this, Spark.Landmark);
-                        if (l2)
-                          test.equal(l2, this);
-                        l2 = this;
-                      }
-                    }, function () {
-                      return "<span class='b' id=4>b4</span>" +
-                        "<span class='b' id=6>b6</span>";
-                    });
-                });
-            }) + "</span>";
-        });
-      }) + "<span class='c' id=5>c</span></div>";
-  }));
-
-  var ids = function (nodes) {
-    if (!(nodes instanceof Array))
-      nodes = nodes ? [nodes] : [];
-    return _.pluck(nodes, 'id').join('');
-  };
-
-  var check = function (all) {
-    var f = all ? 'findAll' : 'find';
-
-    test.equal(ids(l1[f]('.kitten')), '');
-    test.equal(ids(l2[f]('.kitten')), '');
-
-    test.equal(ids(l1[f]('.a')), '3');
-    test.equal(ids(l2[f]('.a')), '');
-
-    test.equal(ids(l1[f]('.b')), all ? '46' : '4');
-    test.equal(ids(l2[f]('.b')), all ? '46' : '4');
-
-    test.equal(ids(l1[f]('.c')), '');
-    test.equal(ids(l2[f]('.c')), '');
-
-    test.equal(ids(l1[f]('.a .b')), all ? '46' : '4');
-    test.equal(ids(l2[f]('.a .b')), '');
-  };
-
-  check(false);
-  check(true);
-  R.set(2);
-  Deps.flush();
-  check(false);
-  check(true);
-
-  d.kill();
-  Deps.flush();
-});
-
-Tinytest.add("spark - landmark clean-up", function (test) {
-
-  var crd;
-  var makeCrd = function () {
-    var crd = [0,0,0];
-    crd.callbacks = {
-      created: function () { crd[0]++; },
-      rendered: function () { crd[1]++; },
-      destroyed: function () { crd[2]++; }
-    };
-    return crd;
-  };
-
-  // not inside render
-  crd = makeCrd();
-  Spark.createLandmark(crd.callbacks, function () { return 'hi'; });
-  test.equal(crd, [1,0,1]);
-
-  // landmark never materialized
-  crd = makeCrd();
-  Spark.render(function() {
-    var html =
-          Spark.createLandmark(crd.callbacks, function () { return 'hi'; });
-    return '';
-  });
-  test.equal(crd, [1,0,1]);
-  Deps.flush();
-  test.equal(crd, [1,0,1]);
-
-  // two landmarks, only one materialized at a time.
-  // one replaces the other
-  var crd1 = makeCrd();
-  var crd2 = makeCrd();
-  var R = ReactiveVar(1);
-  var div = OnscreenDiv(Meteor.render(function() {
-    return (R.get() === 1 ?
-            Spark.createLandmark(crd1.callbacks, function() { return 'hi'; }) :
-            Spark.createLandmark(crd2.callbacks, function() { return 'hi'; }));
-  }));
-  test.equal(crd1, [1,0,0]); // created
-  test.equal(crd2, [0,0,0]);
-  Deps.flush();
-  test.equal(crd1, [1,1,0]); // rendered
-  test.equal(crd2, [0,0,0]);
-  R.set(2);
-  Deps.flush();
-  test.equal(crd1, [1,1,0]); // not destroyed (callback replaced)
-  test.equal(crd2, [0,1,0]); // matched
-
-  div.kill();
-  Deps.flush();
-  test.equal(crd1, [1,1,0]);
-  test.equal(crd2, [0,1,1]); // destroyed
-});
-
-Tinytest.add("spark - bubbling render", function (test) {
-  var makeCrd = function () {
-    var crd = [0,0,0];
-    crd.callbacks = {
-      created: function () { crd[0]++; },
-      rendered: function () { crd[1]++; },
-      destroyed: function () { crd[2]++; }
-    };
-    return crd;
-  };
-
-  var crd1 = makeCrd();
-  var crd2 = makeCrd();
-
-  var R = ReactiveVar('foo');
-  var div = OnscreenDiv(Spark.render(function () {
-    return Spark.createLandmark(crd1.callbacks, function () {
-      return Spark.labelBranch('fred', function () {
-        return Spark.createLandmark(crd2.callbacks, function () {
-          return Spark.isolate(function () {
-            return R.get();
-          });
-        });
-      });
-    });
-  }));
-
-  Deps.flush();
-  test.equal(div.html(), 'foo');
-  test.equal(crd1, [1,1,0]);
-  test.equal(crd2, [1,1,0]);
-
-  R.set('bar');
-  Deps.flush();
-  test.equal(div.html(), 'bar');
-  test.equal(crd1, [1,2,0]);
-  test.equal(crd2, [1,2,0]);
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("spark - landmark arg", function (test) {
-  var div = OnscreenDiv(Spark.render(function () {
-    return Spark.createLandmark({
-      created: function () {
-        test.isFalse(this.hasDom());
-      },
-      rendered: function () {
-        var landmark = this;
-        landmark.firstNode().innerHTML = 'Greetings';
-        landmark.lastNode().innerHTML = 'Line';
-        landmark.find('i').innerHTML =
-          (landmark.findAll('b').length)+"-bold";
-        test.isTrue(landmark.hasDom());
-      },
-      destroyed: function () {
-        test.isFalse(this.hasDom());
-      }
-    }, function () {
-      return Spark.attachEvents({
-        'click': function (event, landmark) {
-          landmark.firstNode().innerHTML = 'Hello';
-          landmark.lastNode().innerHTML = 'World';
-          landmark.find('i').innerHTML =
-            (landmark.findAll('*').length)+"-element";
-        }
-      }, '<b>Foo</b> <i>Bar</i> <u>Baz</u>');
-    });
-  }));
-
-  test.equal(div.text(), "Foo Bar Baz");
-  Deps.flush();
-  test.equal(div.text(), "Greetings 1-bold Line");
-  clickElement(DomUtils.find(div.node(), 'i'));
-  test.equal(div.text(), "Hello 3-element World");
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("spark - landmark preserve", function (test) {
-  var R = ReactiveVar("foo");
-
-  var lmhr = function () {
-    return Spark.createLandmark({preserve:['hr']}, function () {
-      return '<hr/>';
-    });
-  };
-
-  var div = OnscreenDiv(Meteor.render(function () {
-    return "<div><span>" + R.get() + "</span>" +
-      Spark.labelBranch('A', lmhr) + Spark.labelBranch('B', lmhr) +
-      "</div>";
-  }));
-
-  test.equal(div.html(), '<div><span>foo</span><hr><hr></div>');
-  var hrs1 = DomUtils.findAll(div.node(), 'hr');
-  R.set("bar");
-  Deps.flush();
-  test.equal(div.html(), '<div><span>bar</span><hr><hr></div>');
-  var hrs2 = DomUtils.findAll(div.node(), 'hr');
-
-  test.isTrue(hrs1[0] === hrs2[0]);
-  test.isTrue(hrs1[1] === hrs2[1]);
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("spark - branch annotation is optional", function (test) {
-  // test that labelBranch works on HTML that isn't element-balanced
-  // and doesn't fail by trying to emit an annotation when it contains
-  // no landmarks.
-
-  var R = ReactiveVar("foo");
-
-  var Rget = function () { return R.get(); };
-  var cnst = function (c) { return function () { return c; }; };
-  var lmhr = function () {
-    return Spark.createLandmark({preserve:['hr']}, function () {
-      return '<hr/>';
-    });
-  };
-
-  var div = OnscreenDiv(Meteor.render(function () {
-    return '<div class="' + Spark.labelBranch('A', Rget) + '">' +
-      Spark.labelBranch('B', cnst('</div><div>')) +
-      Spark.labelBranch('C', lmhr) + Spark.labelBranch('D', lmhr) +
-      '</div>';
-  }));
-
-  test.equal(div.html(), '<div class="foo"></div><div><hr><hr></div>');
-  var div1 = div.node().firstChild;
-  var hrs1 = DomUtils.findAll(div.node(), 'hr');
-  R.set("bar");
-  Deps.flush();
-  test.equal(div.html(), '<div class="bar"></div><div><hr><hr></div>');
-  var div2 = div.node().firstChild;
-  var hrs2 = DomUtils.findAll(div.node(), 'hr');
-
-  test.isFalse(div1 === div2);
-  test.isTrue(hrs1[0] === hrs2[0]);
-  test.isTrue(hrs1[1] === hrs2[1]);
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("spark - unique label", function (test) {
-  var buf = [];
-  var bufstr = function () {
-    buf.sort();
-    var str = buf.join('');
-    buf.length = 0;
-    return str;
-  };
-
-  var ublm = function () {
-    return Spark.labelBranch(Spark.UNIQUE_LABEL, function () {
-      return Spark.createLandmark({created: function () { buf.push('c'); },
-                                   rendered: function () { buf.push('r'); },
-                                   destroyed: function () { buf.push('d'); }},
-                                  function () { return 'x'; });
-    });
-  };
-
-  var R = ReactiveVar("foo");
-
-  var div = OnscreenDiv(Meteor.render(function () {
-    return ublm() + ublm() + ublm() + R.get();
-  }));
-  Deps.flush();
-  test.equal(bufstr(), 'cccrrr');
-  R.set('bar');
-  Deps.flush();
-  test.equal(bufstr(), 'cccdddrrr');
-
-  div.kill();
-  Deps.flush();
-  test.equal(bufstr(), 'ddd');
-
-});
-
-Tinytest.add("spark - list update", function (test) {
-  var R = ReactiveVar('foo');
-
-  var lst = [];
-  lst.callbacks = [];
-  lst.observeChanges = function(callbacks) {
-    lst.callbacks.push(callbacks);
-    _.each(lst, function(x) {
-      callbacks.addedBefore(x._id, x, null);
-    });
-    return {
-      stop: function() {
-        lst.callbacks = _.without(lst.callbacks, callbacks);
-      }
-    };
-  };
-  lst.another = function () {
-    var i = lst.length;
-    lst.push({_id:'item'+i});
-    _.each(lst.callbacks, function (callbacks) {
-      callbacks.addedBefore(lst[i]._id, lst[i], null);
-    });
-  };
-  var div = OnscreenDiv(Meteor.render(function() {
-    return R.get() + Spark.list(lst, function () {
-      return '<hr>';
-    });
-  }));
-
-  lst.another();
-  Deps.flush();
-  test.equal(div.html(), "foo<hr>");
-
-  lst.another();
-  R.set('bar');
-  Deps.flush();
-  test.equal(div.html(), "bar<hr><hr>");
-
-  R.set('baz');
-  lst.another();
-  Deps.flush();
-  test.equal(div.html(), "baz<hr><hr><hr>");
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("spark - callback context", function (test) {
-  // Test that context in template callbacks is null.
-
-  var cxs = [];
-  var buf = [];
-
-  var R = ReactiveVar("foo");
-  var getCx = function () { return Deps.currentComputation; };
-  var callbackFunc = function (ltr) {
-    return function () {
-      buf.push(ltr);
-      cxs.push(getCx());
-    };
-  };
-  var div = OnscreenDiv(Meteor.render(function () {
-    var cx = getCx();
-    test.isTrue(cx); // sanity check for getCx
-    var makeLandmark = function () {
-      return Spark.createLandmark({created: callbackFunc('c'),
-                                   rendered: callbackFunc('r'),
-                                   destroyed: callbackFunc('d')},
-                                  function () {
-                                    return '<span>'+R.get()+'</span>';
-                                  });
-    };
-    if (R.get() === 'foo')
-      var unused = makeLandmark(); // will cause created/destroyed
-    var html = Spark.labelBranch("foo", makeLandmark);
-    test.isTrue(getCx() === cx); // test that context was restored
-    return html;
-  }));
-  Deps.flush();
-  R.set('bar');
-  Deps.flush();
-  div.kill();
-  Deps.flush();
-
-  test.equal(buf.join(''), 'ccdrrd');
-  test.equal(cxs.length, 6);
-  test.isFalse(cxs[0]);
-  test.isFalse(cxs[1]);
-  test.isFalse(cxs[2]);
-  test.isFalse(cxs[3]);
-  test.isFalse(cxs[4]);
-  test.isFalse(cxs[5]);
-
-});
-
-Tinytest.add("spark - legacy preserve names", function (test) {
-  var R = ReactiveVar("foo");
-  var R2 = ReactiveVar("apple");
-
-  var div = OnscreenDiv(renderWithPreservation(function () {
-    R.get(); // create dependency
-    return ('<div id="aaa"><div><input name="field"></div></div>' +
-            '<div id="bbb"><div><input name="field"></div></div>' +
-            '<div id="ccc"><div>' + Spark.isolate(function () {
-              R2.get();
-              return '<input name="field">'; }) + '</div></div>' +
-            '<input type="text">');
-  }));
-
-
-  var inputs1 = nodesToArray(div.node().getElementsByTagName('input'));
-  R.set('bar');
-  Deps.flush();
-  var inputs2 = nodesToArray(div.node().getElementsByTagName('input'));
-  test.isTrue(inputs1[0] === inputs2[0]);
-  test.isTrue(inputs1[1] === inputs2[1]);
-  test.isTrue(inputs1[2] === inputs2[2]);
-  test.isTrue(inputs1[3] !== inputs2[3]);
-
-  R2.set('banana');
-  Deps.flush();
-  var inputs3 = nodesToArray(div.node().getElementsByTagName('input'));
-  test.isTrue(inputs1[2] === inputs3[2]);
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("spark - update defunct range", function (test) {
-  // Test that Spark doesn't freak out if it tries to update
-  // a LiveRange on nodes that have been taken out of the document.
-  //
-  // See https://github.com/meteor/meteor/issues/392.
-
-  var R = ReactiveVar("foo");
-
-  var div = OnscreenDiv(Spark.render(function () {
-    return "<p>" + Spark.isolate(function() {
-      return R.get();
-    }) + "</p>";
-  }));
-
-  test.equal(div.html(), "<p>foo</p>");
-  R.set("bar");
-  Deps.flush();
-  test.equal(R.numListeners(), 1);
-  test.equal(div.html(), "<p>bar</p>");
-  test.equal(div.node().firstChild.nodeName, "P");
-  div.node().firstChild.innerHTML = '';
-  R.set("baz");
-  Deps.flush(); // should throw no errors
-  // will be 1 if our isolate func was run.
-  test.equal(R.numListeners(), 0);
-
-  /////
-
-  R = ReactiveVar("foo");
-
-  div = OnscreenDiv(Spark.render(function () {
-    return "<p>" + Spark.setDataContext(
-      {},
-      "<span>" + Spark.isolate(function() {
-        return R.get();
-      }) + "</span>") + "</p>";
-  }));
-
-  test.equal(div.html(), "<p><span>foo</span></p>");
-  R.set("bar");
-  Deps.flush();
-  test.equal(R.numListeners(), 1);
-  test.equal(div.html(), "<p><span>bar</span></p>");
-  test.equal(div.node().firstChild.nodeName, "P");
-  div.node().firstChild.innerHTML = '';
-  R.set("baz");
-  Deps.flush(); // should throw no errors
-  // will be 1 if our isolate func was run.
-  test.equal(R.numListeners(), 0);
-
-});
diff --git a/packages/spark/test_form_responder.js b/packages/spark/test_form_responder.js
deleted file mode 100644
index ce39386810..0000000000
--- a/packages/spark/test_form_responder.js
+++ /dev/null
@@ -1,21 +0,0 @@
-var TEST_RESPONDER_ROUTE = "/spark_test_responder";
-
-var respond = function(req, res) {
-
-  res.statusCode = 200;
-  res.setHeader("Content-Type", "text/html");
-  if (req.url === '/blank')
-    res.end();
-  else
-    res.end('<script>'+
-            'window.onload = frameElement.loadFunc;'+
-            'window.onunload = frameElement.unloadFunc;'+
-            '</script>');
-};
-
-var run_responder = function() {
-  WebApp.connectHandlers.stack.unshift(
-    { route: TEST_RESPONDER_ROUTE, handle: respond });
-};
-
-run_responder();
diff --git a/packages/spark/utils.js b/packages/spark/utils.js
deleted file mode 100644
index 5d7d1137c3..0000000000
--- a/packages/spark/utils.js
+++ /dev/null
@@ -1,36 +0,0 @@
-Spark._labelFromIdOrName = function(n) {
-  var label = null;
-
-  if (n.nodeType === 1 /*ELEMENT_NODE*/) {
-    if (n.getAttribute('id')) {
-      label = '#' + n.getAttribute('id');
-    } else if (n.getAttribute("name")) {
-      label = n.getAttribute("name");
-      // Radio button special case:  radio buttons
-      // in a group all have the same name.  Their value
-      // determines their identity.
-      // Checkboxes with the same name and different
-      // values are also sometimes used in apps, so
-      // we treat them similarly.
-      if (n.nodeName === 'INPUT' &&
-          (n.type === 'radio' || n.type === 'checkbox') &&
-          n.value)
-        label = label + ':' + n.value;
-
-      // include parent names and IDs up to enclosing ID
-      // in the label
-      while (n.parentNode &&
-             n.parentNode.nodeType === 1 /*ELEMENT_NODE*/) {
-        n = n.parentNode;
-        if (n.id) {
-          label = '#' + n.id + "/" + label;
-          break;
-        } else if (n.getAttribute('name')) {
-          label = n.getAttribute('name') + "/" + label;
-        }
-      }
-    }
-  }
-
-  return label;
-};
diff --git a/packages/srp/srp.js b/packages/srp/srp.js
index e04860d577..231a1b59b7 100644
--- a/packages/srp/srp.js
+++ b/packages/srp/srp.js
@@ -15,8 +15,8 @@ SRP = {};
 SRP.generateVerifier = function (password, options) {
   var params = paramsFromOptions(options);
 
-  var identity = (options && options.identity) || Random.id();
-  var salt = (options && options.salt) || Random.id();
+  var identity = (options && options.identity) || Random.secret();
+  var salt = (options && options.salt) || Random.secret();
 
   var x = params.hash(salt + params.hash(identity + ":" + password));
   var xi = new BigInteger(x, 16);
diff --git a/packages/standard-app-packages/package.js b/packages/standard-app-packages/package.js
index 099edf0b99..d2ce7e6e31 100644
--- a/packages/standard-app-packages/package.js
+++ b/packages/standard-app-packages/package.js
@@ -28,10 +28,12 @@ Package.on_use(function(api) {
     'livedata',
     // You want to keep your data somewhere? How about MongoDB?
     'mongo-livedata',
-    // You want some views? How about Handlebars-based templating?
+    // Meteor UI!
+    'ui',
+    // A great template language!
+    'spacebars',
+    // Turn templates into views!
     'templating',
-    // What, you want to call Handlebars.registerHandler? Sounds good to me.
-    'handlebars',
     // Easy type assertions? check.
     'check',
     // _.isUseful(true)
diff --git a/packages/star-translate/translator.js b/packages/star-translate/translator.js
index 77d08756de..bff404d034 100644
--- a/packages/star-translate/translator.js
+++ b/packages/star-translate/translator.js
@@ -101,6 +101,9 @@ StarTranslator._writeClientProg = function (bundlePath, clientProgPath) {
   var clientManifest = {
     "format": "browser-program-pre1",
     "manifest": origClientManifest.manifest,
+    // XXX Haven't updated this for the app.html -> head/body change, but
+    //     surely we don't need to because code in pre-star apps doesn't
+    //     even read this file?
     "page": "app.html",
     "static": "static",
     "staticCacheable": "static_cacheable"
diff --git a/packages/stylus/.npm/plugin/compileStylus/npm-shrinkwrap.json b/packages/stylus/.npm/plugin/compileStylus/npm-shrinkwrap.json
index 0215d0284c..f1651f24a7 100644
--- a/packages/stylus/.npm/plugin/compileStylus/npm-shrinkwrap.json
+++ b/packages/stylus/.npm/plugin/compileStylus/npm-shrinkwrap.json
@@ -1,5 +1,27 @@
 {
   "dependencies": {
+    "nib": {
+      "version": "1.0.2",
+      "dependencies": {
+        "stylus": {
+          "version": "0.37.0",
+          "dependencies": {
+            "cssom": {
+              "version": "0.2.5"
+            },
+            "mkdirp": {
+              "version": "0.3.5"
+            },
+            "debug": {
+              "version": "0.7.4"
+            },
+            "sax": {
+              "version": "0.5.8"
+            }
+          }
+        }
+      }
+    },
     "stylus": {
       "version": "0.42.3",
       "dependencies": {
@@ -35,28 +57,6 @@
           }
         }
       }
-    },
-    "nib": {
-      "version": "1.0.2",
-      "dependencies": {
-        "stylus": {
-          "version": "0.37.0",
-          "dependencies": {
-            "cssom": {
-              "version": "0.2.5"
-            },
-            "mkdirp": {
-              "version": "0.3.5"
-            },
-            "debug": {
-              "version": "0.7.4"
-            },
-            "sax": {
-              "version": "0.5.8"
-            }
-          }
-        }
-      }
     }
   }
 }
diff --git a/packages/stylus/package.js b/packages/stylus/package.js
index fad3379afc..ed4e757356 100644
--- a/packages/stylus/package.js
+++ b/packages/stylus/package.js
@@ -15,9 +15,9 @@ Package._transitional_registerBuildPlugin({
 });
 
 Package.on_test(function (api) {
-  api.use(['tinytest', 'stylus', 'test-helpers']);
-  api.use('spark');
+  api.use(['tinytest', 'stylus', 'test-helpers', 'templating']);
   api.add_files([
+    'stylus_tests.html',
     'stylus_tests.styl',
     'stylus_tests.import.styl',
     'stylus_tests.js'
diff --git a/packages/stylus/stylus_tests.html b/packages/stylus/stylus_tests.html
new file mode 100644
index 0000000000..e845cc341b
--- /dev/null
+++ b/packages/stylus/stylus_tests.html
@@ -0,0 +1,8 @@
+<template name="stylus_test_presence">
+  <p class="stylus-dashy-left-border"></p>
+</template>
+
+<template name="stylus_test_import">
+  <p class="stylus-import-dashy-border stylus-overwrite-color"></p>
+</template>
+
diff --git a/packages/stylus/stylus_tests.js b/packages/stylus/stylus_tests.js
index af8d924a04..916f3a3ad7 100644
--- a/packages/stylus/stylus_tests.js
+++ b/packages/stylus/stylus_tests.js
@@ -1,25 +1,27 @@
 
 Tinytest.add("stylus - presence", function(test) {
-  var d = OnscreenDiv(Meteor.render(function() {
-    return '<p class="stylus-dashy-left-border"></p>'; }));
-  d.node().style.display = 'block';
 
-  var p = d.node().firstChild;
+  var div = document.createElement('div');
+  UI.materialize(Template.stylus_test_presence, div);
+  div.style.display = 'block';
+  document.body.appendChild(div);
+
+  var p = div.querySelector('p');
   var leftBorder = getStyleProperty(p, 'border-left-style');
   test.equal(leftBorder, "dashed");
 
-  d.kill();
+  document.body.removeChild(div);
 });
 
 Tinytest.add("stylus - @import", function(test) {
-  var d = OnscreenDiv(Meteor.render(function() {
-    return '<p class="stylus-import-dashy-border stylus-overwrite-color"></p>';
-  }));
-  d.node().style.display = 'block';
+  var div = document.createElement('div');
+  UI.materialize(Template.stylus_test_import, div);
+  div.style.display = 'block';
+  document.body.appendChild(div);
 
-  var p = d.node().firstChild;
+  var p = div.querySelector('p');
   test.equal(getStyleProperty(p, 'font-size'), "20px");
   test.equal(getStyleProperty(p, 'border-left-style'), "dashed");
 
-  d.kill();
+  document.body.removeChild(div);
 });
diff --git a/packages/templating/deftemplate.js b/packages/templating/deftemplate.js
deleted file mode 100644
index 6ad46037f1..0000000000
--- a/packages/templating/deftemplate.js
+++ /dev/null
@@ -1,223 +0,0 @@
-Template = {};
-
-var registeredPartials = {};
-
-// If minimongo is available (it's a weak dependency) use its ID stringifier to
-// label branches (so that, eg, ObjectId and strings don't overlap). Otherwise
-// just use the identity function.
-var idStringify = Package.minimongo
-  ? Package.minimongo.LocalCollection._idStringify
-  : function (id) { return id; };
-
-// XXX Handlebars hooking is janky and gross
-var hookHandlebars = function () {
-  hookHandlebars = function(){}; // install the hook only once
-
-  var orig = Handlebars._default_helpers.each;
-  Handlebars._default_helpers.each = function (arg, options) {
-    var isArgValid = function () {
-      return !arg // falsey
-        || (arg instanceof Array)
-        || (arg instanceof Object && 'observeChanges' in arg);
-    };
-    if (!isArgValid())
-      throw new Error("{{#each}} only accepts arrays, cursors, or falsey "
-                      + "values. You passed: " + arg);
-
-    // if arg isn't an observable (like LocalCollection.Cursor),
-    // don't use this reactive implementation of #each.
-    if (!(arg && 'observeChanges' in arg))
-      return orig.call(this, arg, options);
-
-    return Spark.list(
-      arg,
-      function (item) {
-        return Spark.labelBranch(
-          (item && item._id && idStringify(item._id)) || Spark.UNIQUE_LABEL, function () {
-            var html = Spark.isolate(_.bind(options.fn, null, item));
-            return Spark.setDataContext(item, html);
-          });
-      },
-      function () {
-        return options.inverse ?
-          Spark.isolate(options.inverse) : '';
-      }
-    );
-  };
-
-  _.extend(Handlebars._default_helpers, {
-    isolate: function (options) {
-      var data = this;
-      return Spark.isolate(function () {
-        return options.fn(data);
-      });
-    },
-    constant: function (options) {
-      var data = this;
-      return Spark.createLandmark({ constant: true }, function () {
-        return options.fn(data);
-      });
-    }
-  });
-};
-
-// map from landmark id, to the 'this' object for
-// created/rendered/destroyed callbacks on templates
-var templateInstanceData = {};
-
-var templateObjFromLandmark = function (landmark) {
-  var template = templateInstanceData[landmark.id] || (
-    templateInstanceData[landmark.id] = {
-      // set these once
-      find: function (selector) {
-        if (! landmark.hasDom())
-          throw new Error("Template not in DOM");
-        return landmark.find(selector);
-      },
-      findAll: function (selector) {
-        if (! landmark.hasDom())
-          throw new Error("Template not in DOM");
-        return landmark.findAll(selector);
-      }
-    });
-  // set these each time
-  template.firstNode = landmark.hasDom() ? landmark.firstNode() : null;
-  template.lastNode = landmark.hasDom() ? landmark.lastNode() : null;
-  return template;
-};
-
-// XXX forms hooks into this to add "bind"?
-var templateBase = {
-  // methods store data here (event map, etc.).  initialized per template.
-  _tmpl_data: null,
-  // these functions must be generic (i.e. use `this`)
-  events: function (eventMap) {
-    var events =
-          (this._tmpl_data.events = (this._tmpl_data.events || {}));
-    _.each(eventMap, function(callback, spec) {
-      events[spec] = (events[spec] || []);
-      events[spec].push(callback);
-    });
-  },
-  preserve: function (preserveMap) {
-    var preserve =
-          (this._tmpl_data.preserve = (this._tmpl_data.preserve || {}));
-
-    if (_.isArray(preserveMap))
-      _.each(preserveMap, function (selector) {
-        preserve[selector] = true;
-      });
-    else
-      _.extend(preserve, preserveMap);
-  },
-  helpers: function (helperMap) {
-    var helpers =
-          (this._tmpl_data.helpers = (this._tmpl_data.helpers || {}));
-    for(var h in helperMap)
-      helpers[h] = helperMap[h];
-  }
-};
-
-Template.__define__ = function (name, raw_func) {
-  hookHandlebars();
-
-  if (name === '__define__')
-    throw new Error("Sorry, '__define__' is a special name and " +
-                    "cannot be used as the name of a template");
-
-  // Define the function assigned to Template.<name>.
-
-  var partial = function (data) {
-    var tmpl = name && Template[name] || {};
-    var tmplData = tmpl._tmpl_data || {};
-
-    var html = Spark.labelBranch("Template."+name, function () {
-      var html = Spark.createLandmark({
-        preserve: tmplData.preserve || {},
-        created: function () {
-          var template = templateObjFromLandmark(this);
-          template.data = data;
-          tmpl.created && tmpl.created.call(template);
-        },
-        rendered: function () {
-          var template = templateObjFromLandmark(this);
-          template.data = data;
-          tmpl.rendered && tmpl.rendered.call(template);
-        },
-        destroyed: function () {
-          // template.data is already set from previous callbacks
-          tmpl.destroyed &&
-            tmpl.destroyed.call(templateObjFromLandmark(this));
-          delete templateInstanceData[this.id];
-        }
-      }, function (landmark) {
-        var html = Spark.isolate(function () {
-          // XXX Forms needs to run a hook before and after raw_func
-          // (and receive 'landmark')
-          return raw_func(data, {
-            helpers: _.extend({}, partial, tmplData.helpers || {}),
-            partials: registeredPartials,
-            name: name
-          });
-        });
-
-        // take an event map with `function (event, template)` handlers
-        // and produce one with `function (event, landmark)` handlers
-        // for Spark, by inserting logic to create the template object.
-        var wrapEventMap = function (oldEventMap) {
-          var newEventMap = {};
-          _.each(oldEventMap, function (handlers, key) {
-            if ('function' === typeof handlers) {
-              //Template.foo.events = ... way will give a fn, not an array
-              handlers = [ handlers ];
-            }
-            newEventMap[key] = _.map(handlers, function (handler) {
-              return function (event, landmark) {
-                return handler.call(this, event,
-                                    templateObjFromLandmark(landmark));
-              };
-            });
-          });
-          return newEventMap;
-        };
-
-        // support old Template.foo.events = {...} format
-        var events =
-              (tmpl.events !== templateBase.events ?
-               tmpl.events : tmplData.events);
-        // events need to be inside the landmark, not outside, so
-        // that when an event fires, you can retrieve the enclosing
-        // landmark to get the template data
-        if (tmpl.events)
-          html = Spark.attachEvents(wrapEventMap(events), html);
-        return html;
-      });
-      html = Spark.setDataContext(data, html);
-      return html;
-    });
-
-    return html;
-  };
-
-  // XXX hack.. copy all of Handlebars' built in helpers over to
-  // the partial. it would be better to hook helperMissing (or
-  // something like that?) so that Template.foo is searched only
-  // if it's not a built-in helper.
-  _.extend(partial, Handlebars.helpers);
-
-
-  if (name) {
-    if (Template[name])
-      throw new Error("There are multiple templates named '" + name +
-                      "'. Each template needs a unique name.");
-
-    Template[name] = partial;
-    _.extend(partial, templateBase);
-    partial._tmpl_data = {};
-
-    registeredPartials[name] = partial;
-  }
-
-  // useful for unnamed templates, like body
-  return partial;
-};
diff --git a/packages/templating/global_template_object.js b/packages/templating/global_template_object.js
new file mode 100644
index 0000000000..3e22e9e383
--- /dev/null
+++ b/packages/templating/global_template_object.js
@@ -0,0 +1,14 @@
+// Create an empty template object. Packages and apps add templates on
+// to this object.
+Template = {};
+
+Template.__define__ = function (templateName, renderFunc) {
+  if (Template.hasOwnProperty(templateName))
+    throw new Error("There are multiple templates named '" + templateName + "'. Each template needs a unique name.");
+
+  Template[templateName] = UI.Component.extend({
+    kind: "Template_" + templateName,
+    render: renderFunc,
+    __helperHost: true
+  });
+};
diff --git a/packages/templating/package.js b/packages/templating/package.js
index 641982d454..575e958b15 100644
--- a/packages/templating/package.js
+++ b/packages/templating/package.js
@@ -13,7 +13,7 @@ Package.describe({
 
 Package._transitional_registerBuildPlugin({
   name: "compileTemplates",
-  use: ['handlebars'],
+  use: ['spacebars-compiler'],
   sources: [
     'plugin/html_scanner.js',
     'plugin/compile-templates.js'
@@ -25,31 +25,25 @@ Package.on_use(function (api) {
   // XXX would like to do the following only when the first html file
   // is encountered
 
-  api.use(['underscore', 'spark', 'handlebars'], 'client');
-
+  api.add_files('global_template_object.js', 'client');
   api.export('Template', 'client');
 
-
-  // If we have minimongo available, use its idStringify function.
-  api.use('minimongo', 'client', {weak: true});
-  // provides the runtime logic to instantiate our templates
-  api.add_files('deftemplate.js', 'client');
-
   // html_scanner.js emits client code that calls Meteor.startup and
-  // Spark.render, so anybody using templating (eg apps) need to implicitly use
-  // 'meteor' and 'spark'.
-  api.imply(['meteor', 'spark'], 'client');
+  // UI, so anybody using templating (eg apps) need to implicitly use
+  // 'meteor' and 'ui'.
+  api.use('ui');
+  api.imply(['meteor', 'ui'], 'client');
 });
 
 Package.on_test(function (api) {
   api.use('tinytest');
   api.use('htmljs');
   api.use('templating');
-  api.use('handlebars');
   api.use('underscore');
-  api.use(['test-helpers', 'domutils', 'session', 'deps',
-           'spark', 'minimongo'], 'client');
-  api.use('handlebars', 'server');
+  api.use(['test-helpers', 'session', 'deps',
+           'minimongo'], 'client');
+  api.use('spacebars-compiler');
+
   api.add_files([
     'templating_tests.js',
     'templating_tests.html'
diff --git a/packages/templating/plugin/compile-templates.js b/packages/templating/plugin/compile-templates.js
index 7f22bf6b83..b364737c2e 100644
--- a/packages/templating/plugin/compile-templates.js
+++ b/packages/templating/plugin/compile-templates.js
@@ -1,6 +1,7 @@
 var path = Npm.require('path');
 
-Plugin.registerSourceHandler("html", function (compileStep) {
+var doHTMLScanning = function (compileStep, htmlScanner) {
+
   // XXX use archinfo rather than rolling our own
   if (! compileStep.arch.match(/^browser(\.|$)/))
     // XXX might be nice to throw an error here, but then we'd have to
@@ -14,9 +15,9 @@ Plugin.registerSourceHandler("html", function (compileStep) {
   // religion on that
   var contents = compileStep.read().toString('utf8');
   try {
-    var results = html_scanner.scan(contents, compileStep.inputPath);
+    var results = htmlScanner.scan(contents, compileStep.inputPath);
   } catch (e) {
-    if (e instanceof html_scanner.ParseError) {
+    if (e instanceof htmlScanner.ParseError) {
       compileStep.error({
         message: e.message,
         sourcePath: compileStep.inputPath,
@@ -50,4 +51,11 @@ Plugin.registerSourceHandler("html", function (compileStep) {
       data: results.js
     });
   }
-});
+};
+
+Plugin.registerSourceHandler(
+  "html", {isTemplate: true},
+  function (compileStep) {
+    doHTMLScanning(compileStep, html_scanner);
+  }
+);
diff --git a/packages/templating/plugin/html_scanner.js b/packages/templating/plugin/html_scanner.js
index 3960600094..56331f28a9 100644
--- a/packages/templating/plugin/html_scanner.js
+++ b/packages/templating/plugin/html_scanner.js
@@ -19,19 +19,16 @@ html_scanner = {
       index += amount;
     };
 
-    var throwParseError = function (msg, atIndex, lineOffset) {
-      atIndex = atIndex || index;
-      lineOffset = lineOffset || 0;
-
+    var throwParseError = function (msg, overrideIndex) {
       var ret = new html_scanner.ParseError;
       ret.message = msg || "bad formatting in HTML template";
       ret.file = source_name;
-      ret.line = contents.substring(0, atIndex).split('\n').length + lineOffset;
+      var theIndex = (typeof overrideIndex === 'number' ? overrideIndex : index);
+      ret.line = contents.substring(0, theIndex).split('\n').length;
       throw ret;
     };
 
     var results = html_scanner._initResults();
-
     var rOpenTag = /^((<(template|head|body)\b)|(<!--)|(<!DOCTYPE|{{!)|$)/i;
 
     while (rest) {
@@ -100,12 +97,14 @@ html_scanner = {
         throwParseError("unclosed <"+tagName+">");
       var tagContents = rest.slice(0, end.index);
       var contentsStartIndex = index;
-      advance(end.index + end[0].length);
 
       // act on the tag
       html_scanner._handleTag(results, tagName, tagAttribs, tagContents,
                               throwParseError, contentsStartIndex,
                               tagStartIndex);
+
+      // advance afterwards, so that line numbers in errors are correct
+      advance(end.index + end[0].length);
     }
 
     return results;
@@ -146,39 +145,45 @@ html_scanner = {
 
 
     // <body> or <template>
+
     try {
-      var ast = Handlebars.to_json_ast(contents);
-    } catch (e) {
-      if (e instanceof Handlebars.ParseError) {
-        if (typeof(e.line) === "number")
-          // subtract one from e.line because it is one-based but we
-          // need it to be an offset from contentsStartIndex
-          throwParseError(e.message, contentsStartIndex, e.line - 1);
-        else
-          // No line number available from Handlebars parser, so
-          // generate the parse error at the <template> tag itself
-          throwParseError("error in template: " + e.message, tagStartIndex);
+      if (tag === "template") {
+        var name = attribs.name;
+        if (! name)
+          throwParseError("Template has no 'name' attribute");
+
+        if (Spacebars.isReservedName(name))
+          throwParseError("Template can't be named \"" + name + "\"");
+
+        var renderFuncCode = Spacebars.compile(
+          contents, {
+            isTemplate: true,
+            sourceName: 'Template "' + name + '"'
+          });
+
+        results.js += "\nTemplate.__define__(" + JSON.stringify(name) +
+          ", " + renderFuncCode + ");\n";
+      } else {
+        // <body>
+        if (hasAttribs)
+          throwParseError("Attributes on <body> not supported");
+
+        var renderFuncCode = Spacebars.compile(
+          contents, {
+            isBody: true,
+            sourceName: "<body>"
+          });
+
+        // We may be one of many `<body>` tags.
+        results.js += "\nUI.body.contentParts.push(UI.Component.extend({render: " + renderFuncCode + "}));\nMeteor.startup(function () { if (! UI.body.INSTANTIATED) { UI.body.INSTANTIATED = true; UI.DomRange.insert(UI.render(UI.body).dom, document.body); } });\n";
       }
-      else
+    } catch (e) {
+      if (e.scanner) {
+        // The error came from Spacebars
+        throwParseError(e.message, contentsStartIndex + e.offset);
+      } else {
         throw e;
-    }
-    var code = 'Package.handlebars.Handlebars.json_ast_to_func(' +
-          JSON.stringify(ast) + ')';
-
-    if (tag === "template") {
-      var name = attribs.name;
-      if (! name)
-        throwParseError("Template has no 'name' attribute");
-
-      results.js += "Template.__define__(" + JSON.stringify(name) + ","
-        + code + ");\n";
-    } else {
-      // <body>
-      if (hasAttribs)
-        throwParseError("Attributes on <body> not supported");
-      results.js += "Meteor.startup(function(){" +
-        "document.body.appendChild(Spark.render(" +
-        "Template.__define__(null," + code + ")));});";
+      }
     }
   }
 };
diff --git a/packages/templating/scanner_tests.js b/packages/templating/scanner_tests.js
index e55d7b8962..c03e6c07e7 100644
--- a/packages/templating/scanner_tests.js
+++ b/packages/templating/scanner_tests.js
@@ -22,12 +22,17 @@ Tinytest.add("templating - html scanner", function (test) {
     test.fail("Parse error didn't throw exception");
   };
 
-  var BODY_PREAMBLE = "Meteor.startup(function(){" +
-        "document.body.appendChild(Spark.render(" +
-        "Template.__define__(null,";
-  var BODY_POSTAMBLE = ")));});";
-  var TEMPLATE_PREAMBLE = "Template.__define__(";
-  var TEMPLATE_POSTAMBLE = ");\n";
+  // returns the appropriate code to put content in the body,
+  // where content is something simple like the string "Hello"
+  // (passed in as a source string including the quotes).
+  var simpleBody = function (content) {
+    return "\nUI.body.contentParts.push(UI.Component.extend({render: (function() {\n  var self = this;\n  return " + content + ";\n})}));\nMeteor.startup(function () { if (! UI.body.INSTANTIATED) { UI.body.INSTANTIATED = true; UI.DomRange.insert(UI.render(UI.body).dom, document.body); } });\n";
+  };
+
+  // arguments are quoted strings like '"hello"'
+  var simpleTemplate = function (templateName, content) {
+    return '\nTemplate.__define__(' + templateName + ', (function() {\n  var self = this;\n  var template = this;\n  return ' + content + ';\n}));\n';
+  };
 
   var checkResults = function(results, expectJs, expectHead) {
     test.equal(results.body, '');
@@ -42,73 +47,65 @@ Tinytest.add("templating - html scanner", function (test) {
   // body all on one line
   checkResults(
     html_scanner.scan("<body>Hello</body>"),
-    BODY_PREAMBLE+'Package.handlebars.Handlebars.json_ast_to_func(["Hello"])'+BODY_POSTAMBLE);
+    simpleBody('"Hello"'));
 
   // multi-line body, contents trimmed
   checkResults(
     html_scanner.scan("\n\n\n<body>\n\nHello\n\n</body>\n\n\n"),
-    BODY_PREAMBLE+'Package.handlebars.Handlebars.json_ast_to_func(["Hello"])'+BODY_POSTAMBLE);
+    simpleBody('"Hello"'));
 
   // same as previous, but with various HTML comments
   checkResults(
     html_scanner.scan("\n<!--\n\nfoo\n-->\n<!-- -->\n"+
                       "<body>\n\nHello\n\n</body>\n\n<!----\n>\n\n"),
-    BODY_PREAMBLE+'Package.handlebars.Handlebars.json_ast_to_func(["Hello"])'+BODY_POSTAMBLE);
+    simpleBody('"Hello"'));
 
   // head and body
   checkResults(
     html_scanner.scan("<head>\n<title>Hello</title>\n</head>\n\n<body>World</body>\n\n"),
-    BODY_PREAMBLE+'Package.handlebars.Handlebars.json_ast_to_func(["World"])'+BODY_POSTAMBLE,
+    simpleBody('"World"'),
     "<title>Hello</title>");
 
   // head and body with tag whitespace
   checkResults(
     html_scanner.scan("<head\n>\n<title>Hello</title>\n</head  >\n\n<body>World</body\n\n>\n\n"),
-    BODY_PREAMBLE+'Package.handlebars.Handlebars.json_ast_to_func(["World"])'+BODY_POSTAMBLE,
+    simpleBody('"World"'),
     "<title>Hello</title>");
 
   // head, body, and template
   checkResults(
     html_scanner.scan("<head>\n<title>Hello</title>\n</head>\n\n<body>World</body>\n\n"+
                       '<template name="favoritefood">\n  pizza\n</template>\n'),
-    BODY_PREAMBLE+'Package.handlebars.Handlebars.json_ast_to_func(["World"])'+BODY_POSTAMBLE+
-      TEMPLATE_PREAMBLE+'"favoritefood",Package.handlebars.Handlebars.json_ast_to_func(["pizza"])'+
-      TEMPLATE_POSTAMBLE,
+    simpleBody('"World"') + simpleTemplate('"favoritefood"', '"pizza"'),
     "<title>Hello</title>");
 
   // one-line template
   checkResults(
     html_scanner.scan('<template name="favoritefood">pizza</template>'),
-    TEMPLATE_PREAMBLE+'"favoritefood",Package.handlebars.Handlebars.json_ast_to_func(["pizza"])'+
-      TEMPLATE_POSTAMBLE);
+    simpleTemplate('"favoritefood"', '"pizza"'));
 
   // template with other attributes
   checkResults(
     html_scanner.scan('<template foo="bar" name="favoritefood" baz="qux">'+
                       'pizza</template>'),
-    TEMPLATE_PREAMBLE+'"favoritefood",Package.handlebars.Handlebars.json_ast_to_func(["pizza"])'+
-      TEMPLATE_POSTAMBLE);
+    simpleTemplate('"favoritefood"', '"pizza"'));
 
   // whitespace around '=' in attributes and at end of tag
   checkResults(
     html_scanner.scan('<template foo = "bar" name  ="favoritefood" baz= "qux"  >'+
                       'pizza</template\n\n>'),
-    TEMPLATE_PREAMBLE+'"favoritefood",Package.handlebars.Handlebars.json_ast_to_func(["pizza"])'+
-      TEMPLATE_POSTAMBLE);
+    simpleTemplate('"favoritefood"', '"pizza"'));
 
   // whitespace around template name
   checkResults(
     html_scanner.scan('<template name=" favoritefood  ">pizza</template>'),
-    TEMPLATE_PREAMBLE+'"favoritefood",Package.handlebars.Handlebars.json_ast_to_func(["pizza"])'+
-      TEMPLATE_POSTAMBLE);
+    simpleTemplate('"favoritefood"', '"pizza"'));
 
   // single quotes around template name
   checkResults(
     html_scanner.scan('<template name=\'the "cool" template\'>'+
                       'pizza</template>'),
-    TEMPLATE_PREAMBLE+'"the \\"cool\\" template",'+
-      'Package.handlebars.Handlebars.json_ast_to_func(["pizza"])'+
-      TEMPLATE_POSTAMBLE);
+    simpleTemplate('"the \\"cool\\" template"', '"pizza"'));
 
   // error cases; exact line numbers are not critical, these just reflect
   // the current implementation
@@ -154,12 +151,12 @@ Tinytest.add("templating - html scanner", function (test) {
   // attributes on body not supported
   checkError(function() {
     return html_scanner.scan('<body foo="bar">\n  Hello\n</body>');
-  }, "<body>", 3);
+  }, "<body>", 1);
 
   // attributes on head not supported
   checkError(function() {
     return html_scanner.scan('<head foo="bar">\n  Hello\n</head>');
-  }, "<head>", 3);
+  }, "<head>", 1);
 
   // can't mismatch quotes
   checkError(function() {
diff --git a/packages/templating/templating_tests.html b/packages/templating/templating_tests.html
index 4a6253ce1c..ffa60f92be 100644
--- a/packages/templating/templating_tests.html
+++ b/packages/templating/templating_tests.html
@@ -105,11 +105,27 @@
 </div>
 </template>
 
+<template name="test_capture_events">
+  <video class='video1'>
+    <source id='mp4'
+      src="http://media.w3.org/2010/05/sintel/trailer.mp4"
+      type='video/mp4'>
+  </video>
+  <video class='video2'>
+    <source id='mp4'
+      src="http://media.w3.org/2010/05/sintel/trailer.mp4"
+      type='video/mp4'>
+  </video>
+  <video class='video2'>
+    <source id='mp4'
+      src="http://media.w3.org/2010/05/sintel/trailer.mp4"
+      type='video/mp4'>
+  </video>
+</template>
+
 <template name="test_safestring_a">
   {{foo}} {{{foo}}} {{bar}} {{{bar}}}
-  {{#foo}}{{/foo}} {{#bar}}{{/bar}}
   {{fooprop}} {{{fooprop}}} {{barprop}} {{{barprop}}}
-  {{#fooprop}}{{/fooprop}} {{#barprop}}{{/barprop}}
 </template>
 
 <template name="test_helpers_a">
@@ -178,15 +194,6 @@
   (helperListFour platypus thisTest fancyhelper.currentFruit fancyhelper.currentCountry.unicorns a=platypus b=thisTest c=fancyhelper.currentFruit d=fancyhelper.currentCountry.unicorns={{helperListFour platypus thisTest fancyhelper.currentFruit fancyhelper.currentCountry.unicorns a=platypus b=thisTest c=fancyhelper.currentFruit d=fancyhelper.currentCountry.unicorns}})
 </template>
 
-<template name="test_helpers_i">
-  (uppercase apple={{#uppercase}}apple{{/uppercase}})
-  (altered banana={{#tr a="o" n="d"}}banana{{/tr}})
-  (nokeys={{#arg_and_dict "foo" x="foo"}}{{/arg_and_dict}})
-  (nokeys={{#arg_and_dict tree x="foo"}}{{/arg_and_dict}})
-  (biggie={{#get_arg helperListFour platypus thisTest fancyhelper.currentFruit fancyhelper.currentCountry.unicorns a=platypus b=thisTest c=fancyhelper.currentFruit d=fancyhelper.currentCountry.unicorns}}{{/get_arg}})
-  (twoArgBlock={{#two_args "foo" "foo"}}{{/two_args}})
-</template>
-
 <template name="test_render_a">
   {{foo}}<br><hr>
 </template>
@@ -199,57 +206,10 @@
   <br><hr>
 </template>
 
-<template name="test_branches_a">
-  <span>{{var}}</span>
-  {{#myConstant}}<hr/>{{/myConstant}}
-  {{#if 1}}
-    {{#myConstant}}<hr/>{{/myConstant}}
-  {{/if}}
-  {{#myConstant}}<hr/>{{/myConstant}}
-</template>
-
-<template name="test_listmatching_a0">
-  <span>{{var}}</span>
-  <p>
-    {{#each c}}
-      {{> test_listmatching_a1}}
-    {{/each}}
-  </p>
-</template>
-
-<template name="test_listmatching_a1">
-  {{letter}}
-</template>
-
-<template name="test_isolate_a">
-  {{helper 1}}
-  {{#isolate}}
-    {{helper 2}}
-    {{#isolate}}
-      {{helper 3}}
-      {{#isolate}}
-        {{helper 4}}
-      {{/isolate}}
-    {{/isolate}}
-  {{/isolate}}
-</template>
-
 <template name="test_template_arg_a">
   <b>Foo</b> <i>Bar</i> <u>Baz</u>
 </template>
 
-<template name="test_template_preserve_a">
-  <span class="a">x</span>
-  <span class="b">x</span>
-  <span class="c">x</span>
-  <span class="d">x</span>
-  <span class="y">x</span>
-  <span class="e">x</span>
-  <span class="z">x</span>
-  <span class="f">x</span>
-  <u>{{var}}</u>
-</template>
-
 <template name="test_template_helpers_a">
   {{foo}}{{bar}}{{baz}}
 </template>
@@ -259,7 +219,7 @@
 </template>
 
 <template name="test_template_helpers_c">
-  {{name}}{{arity}}{{toString}}{{length}}{{var}}x
+  {{name}}{{arity}}{{length}}{{var}}x
 </template>
 
 <template name="test_template_events_a">
@@ -274,81 +234,9 @@
   <b>foo</b><u>bar</u><i>baz</i>
 </template>
 
-<template name="test_template_eachrender_a">
-  {{#each entries}}
-    <div>{{x}}</div>
-  {{/each}}
-</template>
-
-<template name="test_template_eachrender_b">
-  {{#each entries}}
-    <div>{{x}}</div>
-  {{/each}}
-</template>
-
-<template name="test_template_landmarks_a">
-  {{LM}}{{{LM}}}{{LM}}{{{LM}}}{{v}}
-</template>
-
-<template name="test_template_bare_each_a">
-  {{#each abc}}
-    {{LM}}
-  {{/each}}
-  {{v}}
-</template>
-
-<template name="test_template_labels_a0">
-  {{{stuff}}}
-</template>
-
-<template name="test_template_labels_a1">
-  <hr>
-</template>
-
-<template name="test_template_labels_a2">
-  <hr>
-</template>
-
-<template name="test_template_labels_a3">
-  <hr>
-</template>
-
-<template name="test_unlabeled_cursor_a0">
-  {{#each this}}{{> test_unlabeled_cursor_a1}}{{/each}}
-</template>
-
-<template name="test_unlabeled_cursor_a1">
-  <div>foo</div>
-</template>
-
-<template name="test_constant_text_a0">
-  <div><p>preserved P:{{v}}</p>{{#constant}}text{{/constant}}</div>
-</template>
-
-
 <!-- Test for Issue 617 - Type casting for helpers -->
 <template name="test_type_casting">
-{{testTypeCasting 'true' 'false' true false 0 1 -1 10 -10 1asdf -1asdf}}
-</template>
-
-<!-- Test for issue #724 - template branches are labeled wrong -->
-
-<template name="test_template_trickylabels_a0">
-  {{#unless loading}}
-    {{> test_template_trickylabels_a1}}
-  {{/unless}}
-</template>
-
-<template name="test_template_trickylabels_a1">
-  {{#isolate}}
-    {{> test_template_trickylabels_a2}}
-    {{v}}
-  {{/isolate}}
-  <div>bar</div>
-</template>
-
-<template name="test_template_trickylabels_a2">
-  <div>foo</div>
+{{testTypeCasting 'true' 'false' true false 0 1 -1 10 -10}}
 </template>
 
 <!-- Test for issue #801 - Each handling of falsy values eg. [1, 2, null, undefined] -->
@@ -356,7 +244,3 @@
 {{#each values}}{{this}}{{/each}}
 </template>
 
-<!-- Test for issue #770 - falsy value for with. (newlines break this test on IE8) -->
-<template name="test_template_issue770">
-{{# with value1}}{{this}}{{else}}xxx{{/with}}{{# with value2}}{{this}}{{else}}xxx{{/with}}{{# with value1}}{{this}}{{/with}}{{# with value2}}{{this}}{{/with}}
-</template>
diff --git a/packages/templating/templating_tests.js b/packages/templating/templating_tests.js
index 634c36368b..c12d0ed37f 100644
--- a/packages/templating/templating_tests.js
+++ b/packages/templating/templating_tests.js
@@ -1,10 +1,27 @@
+// render and put in the document
+var renderToDiv = function (comp) {
+  var div = document.createElement("DIV");
+  UI.materialize(comp, div);
+  return div;
+};
+
+// for events to bubble an element needs to be in the DOM.
+// @return {Function} call this for cleanup
+var addToBody = function (el) {
+  el.style.display = "none";
+  document.body.appendChild(el);
+  return function () {
+    document.body.removeChild(el);
+  };
+};
+
 
 Tinytest.add("templating - assembly", function (test) {
 
   // Test for a bug that made it to production -- after a replacement,
   // we need to also check the newly replaced node for replacements
-  var frag = Meteor.render(Template.test_assembly_a0);
-  test.equal(canonicalizeHtml(DomUtils.fragmentToHtml(frag)),
+  var div = renderToDiv(Template.test_assembly_a0);
+  test.equal(canonicalizeHtml(div.innerHTML),
                "Hi");
 
   // Another production bug -- we must use LiveRange to replace the
@@ -13,14 +30,11 @@ Tinytest.add("templating - assembly", function (test) {
   Template.test_assembly_b1.stuff = function () {
     return Session.get("stuff");
   };
-  var onscreen = DIV({style: "display: none"}, [
-    Meteor.render(Template.test_assembly_b0)]);
-  document.body.appendChild(onscreen);
+  var onscreen = renderToDiv(Template.test_assembly_b0);
   test.equal(canonicalizeHtml(onscreen.innerHTML), "xyhi");
   Session.set("stuff", false);
   Deps.flush();
   test.equal(canonicalizeHtml(onscreen.innerHTML), "xhi");
-  document.body.removeChild(onscreen);
   Deps.flush();
 });
 
@@ -40,8 +54,7 @@ Tinytest.add("templating - table assembly", function(test) {
   };
 
   var table;
-
-  table = childWithTag(Meteor.render(Template.test_table_a0), "TABLE");
+  table = childWithTag(renderToDiv(Template.test_table_a0), "TABLE");
 
   // table.rows is a great test, as it fails not only when TR/TD tags are
   // stripped due to improper html-to-fragment, but also when they are present
@@ -49,28 +62,23 @@ Tinytest.add("templating - table assembly", function(test) {
   test.equal(table.rows.length, 3);
 
   // this time with an explicit TBODY
-  table = childWithTag(Meteor.render(Template.test_table_b0), "TABLE");
+  table = childWithTag(renderToDiv(Template.test_table_b0), "TABLE");
   test.equal(table.rows.length, 3);
 
   var c = new LocalCollection();
   c.insert({bar:'a'});
   c.insert({bar:'b'});
   c.insert({bar:'c'});
-  var onscreen = DIV({style: "display: none;"});
-  onscreen.appendChild(
-    Meteor.render(_.bind(Template.test_table_each, null, {foo: c.find()})));
-  document.body.appendChild(onscreen);
+  var onscreen = renderToDiv(Template.test_table_each.extend({data: {foo: c.find()}}));
   table = childWithTag(onscreen, "TABLE");
 
   test.equal(table.rows.length, 3, table.parentNode.innerHTML);
   var tds = onscreen.getElementsByTagName("TD");
   test.equal(tds.length, 3);
-  test.equal(tds[0].innerHTML, "a");
-  test.equal(tds[1].innerHTML, "b");
-  test.equal(tds[2].innerHTML, "c");
+  test.equal(canonicalizeHtml(tds[0].innerHTML), "a");
+  test.equal(canonicalizeHtml(tds[1].innerHTML), "b");
+  test.equal(canonicalizeHtml(tds[2].innerHTML), "c");
 
-
-  document.body.removeChild(onscreen);
   Deps.flush();
 });
 
@@ -89,13 +97,11 @@ Tinytest.add("templating - event handler this", function(test) {
   });
 
   var event_buf = [];
-  var tmpl = OnscreenDiv(
-    Meteor.render(function () {
-      return Template.test_event_data_with(
-        Template.test_event_data_with.ONE);
-    }));
+  var containerDiv = renderToDiv(Template.test_event_data_with.extend({data:
+    Template.test_event_data_with.ONE}));
+  var cleanupDiv = addToBody(containerDiv);
 
-  var divs = tmpl.node().getElementsByTagName("div");
+  var divs = containerDiv.getElementsByTagName("div");
   test.equal(3, divs.length);
 
   clickElement(divs[0]);
@@ -110,42 +116,99 @@ Tinytest.add("templating - event handler this", function(test) {
   test.equal(event_buf, ['three']);
   event_buf.length = 0;
 
-  tmpl.kill();
+  cleanupDiv();
   Deps.flush();
 });
 
+
+if (document.addEventListener) {
+  // Only run this test on browsers with support for event
+  // capturing. A more detailed analysis can be found at
+  // https://www.meteor.com/blog/2013/09/06/browser-events-bubbling-capturing-and-delegation
+
+  // This is related to issue at https://gist.github.com/mquandalle/8157017
+  // Tests two situations related to events that can only be captured, not bubbled:
+  // 1. Event should only fire the handler that matches the selector given
+  // 2. Event should work on every element in the selector and not just the first element
+  // This test isn't written against mouseenter because it is synthesized by jQuery,
+  // the bug also happened with the play event
+  Tinytest.add("templating - capturing events", function (test) {
+    var video1Played = 0,
+        video2Played = 0;
+
+    Template.test_capture_events.events({
+      'play .video1': function () {
+        video1Played++;
+      },
+      'play .video2': function () {
+        video2Played++;
+      }
+    });
+
+    // add to body or else events don't actually fire
+    var containerDiv = renderToDiv(Template.test_capture_events);
+    var cleanupDiv = addToBody(containerDiv);
+
+    var checkAndResetEvents = function(video1, video2) {
+      test.equal(video1Played, video1);
+      test.equal(video2Played, video2);
+
+      video1Played = 0;
+      video2Played = 0;
+    };
+
+    simulateEvent($(containerDiv).find(".video1").get(0),
+                  "play", {}, {bubbles: false});
+    checkAndResetEvents(1, 0);
+
+    simulateEvent($(containerDiv).find(".video2").get(0),
+                  "play", {}, {bubbles: false});
+    checkAndResetEvents(0, 1);
+
+    simulateEvent($(containerDiv).find(".video2").get(1),
+                  "play", {}, {bubbles: false});
+    checkAndResetEvents(0, 1);
+
+    // clean up DOM
+    cleanupDiv();
+    Deps.flush();
+  });
+}
+
 Tinytest.add("templating - safestring", function(test) {
 
   Template.test_safestring_a.foo = function() {
-    return "1<2";
+    return "<br>";
   };
   Template.test_safestring_a.bar = function() {
-    return new Handlebars.SafeString("3<4");
+    return new Spacebars.SafeString("<hr>");
   };
 
-  var obj = {fooprop: "1<2",
-             barprop: new Handlebars.SafeString("3<4")};
+  var obj = {fooprop: "<br>",
+             barprop: new Spacebars.SafeString("<hr>")};
+  var html = canonicalizeHtml(
+    renderToDiv(Template.test_safestring_a.extend({data: obj})).innerHTML);
 
-  test.equal(Template.test_safestring_a(obj).replace(/\s+/g, ' '),
-             "1&lt;2 1<2 3<4 3<4 1<2 3<4 "+
-             "1&lt;2 1<2 3<4 3<4 1<2 3<4");
+  test.equal(html,
+             "&lt;br&gt;<br><hr><hr>"+
+             "&lt;br&gt;<br><hr><hr>");
 
 });
 
 Tinytest.add("templating - helpers and dots", function(test) {
-  Handlebars.registerHelper("platypus", function() {
+  UI.registerHelper("platypus", function() {
     return "eggs";
   });
-  Handlebars.registerHelper("watermelon", function() {
+  UI.registerHelper("watermelon", function() {
     return "seeds";
   });
 
-  Handlebars.registerHelper("daisygetter", function() {
+  UI.registerHelper("daisygetter", function() {
     return this.daisy;
   });
 
   // XXX for debugging
-  Handlebars.registerHelper("debugger", function() {
+  UI.registerHelper("debugger", function() {
     debugger;
   });
 
@@ -171,7 +234,7 @@ Tinytest.add("templating - helpers and dots", function(test) {
     };
   };
 
-  Handlebars.registerHelper("fancyhelper", getFancyObject);
+  UI.registerHelper("fancyhelper", getFancyObject);
 
   Template.test_helpers_a.platypus = 'bill';
   Template.test_helpers_a.warthog = function() {
@@ -179,8 +242,10 @@ Tinytest.add("templating - helpers and dots", function(test) {
   };
 
   var listFour = function(a, b, c, d, options) {
+    test.isTrue(options instanceof Spacebars.kw);
     var keywordArgs = _.map(_.keys(options.hash), function(k) {
-      return k+':'+options.hash[k];
+      var val = options.hash[k];
+      return k+':'+val;
     });
     return [a, b, c, d].concat(keywordArgs).join(' ');
   };
@@ -198,7 +263,10 @@ Tinytest.add("templating - helpers and dots", function(test) {
     methodListFour: listFour
   };
 
-  test.equal(Template.test_helpers_a(dataObj).match(/\S+/g), [
+  var html;
+  html = canonicalizeHtml(
+    renderToDiv(Template.test_helpers_a.extend({data: dataObj})).innerHTML);
+  test.equal(html.match(/\S+/g), [
     'platypus=bill', // helpers on Template object take first priority
     'watermelon=seeds', // global helpers take second priority
     'daisy=petal', // unshadowed object property
@@ -206,14 +274,18 @@ Tinytest.add("templating - helpers and dots", function(test) {
     'warthog=snout' // function Template property
   ]);
 
-  test.equal(Template.test_helpers_b(dataObj).match(/\S+/g), [
+  html = canonicalizeHtml(
+    renderToDiv(Template.test_helpers_b.extend({data: dataObj})).innerHTML);
+  test.equal(html.match(/\S+/g), [
     // unknown properties silently fail
     'unknown=',
     // falsy property comes through
     'zero=0'
   ]);
 
-  test.equal(Template.test_helpers_c(dataObj).match(/\S+/g), [
+  html = canonicalizeHtml(
+    renderToDiv(Template.test_helpers_c.extend({data: dataObj})).innerHTML);
+  test.equal(html.match(/\S+/g), [
     // property gets are supposed to silently fail
     'platypus.X=',
     'watermelon.X=',
@@ -225,7 +297,9 @@ Tinytest.add("templating - helpers and dots", function(test) {
     'getUndefined.X.Y='
   ]);
 
-  test.equal(Template.test_helpers_d(dataObj).match(/\S+/g), [
+  html = canonicalizeHtml(
+    renderToDiv(Template.test_helpers_d.extend({data: dataObj})).innerHTML);
+  test.equal(html.match(/\S+/g), [
     // helpers should get current data context in `this`
     'daisygetter=petal',
     // object methods should get object in `this`
@@ -237,7 +311,9 @@ Tinytest.add("templating - helpers and dots", function(test) {
     '../fancy.currentFruit=guava'
   ]);
 
-  test.equal(Template.test_helpers_e(dataObj).match(/\S+/g), [
+  html = canonicalizeHtml(
+    renderToDiv(Template.test_helpers_e.extend({data: dataObj})).innerHTML);
+  test.equal(html.match(/\S+/g), [
     'fancy.foo=bar',
     'fancy.apple.banana=smoothie',
     'fancy.currentFruit=guava',
@@ -246,7 +322,9 @@ Tinytest.add("templating - helpers and dots", function(test) {
     'fancy.currentCountry.unicorns=0'
   ]);
 
-  test.equal(Template.test_helpers_f(dataObj).match(/\S+/g), [
+  html = canonicalizeHtml(
+    renderToDiv(Template.test_helpers_f.extend({data: dataObj})).innerHTML);
+  test.equal(html.match(/\S+/g), [
     'fancyhelper.foo=bar',
     'fancyhelper.apple.banana=smoothie',
     'fancyhelper.currentFruit=guava',
@@ -257,7 +335,9 @@ Tinytest.add("templating - helpers and dots", function(test) {
 
   // test significance of 'this', which prevents helper from
   // shadowing property
-  test.equal(Template.test_helpers_g(dataObj).match(/\S+/g), [
+  html = canonicalizeHtml(
+    renderToDiv(Template.test_helpers_g.extend({data: dataObj})).innerHTML);
+  test.equal(html.match(/\S+/g), [
     'platypus=eggs',
     'this.platypus=weird'
   ]);
@@ -266,8 +346,10 @@ Tinytest.add("templating - helpers and dots", function(test) {
 
   Template.test_helpers_h.helperListFour = listFour;
 
+  html = canonicalizeHtml(
+    renderToDiv(Template.test_helpers_h.extend({data: dataObj})).innerHTML);
   var trials =
-        Template.test_helpers_h(dataObj).match(/\(.*?\)/g);
+        html.match(/\(.*?\)/g);
   test.equal(trials[0],
              '(methodListFour 6 7 8 9=6 7 8 9)');
   test.equal(trials[1],
@@ -280,46 +362,6 @@ Tinytest.add("templating - helpers and dots", function(test) {
              '(helperListFour platypus thisTest fancyhelper.currentFruit fancyhelper.currentCountry.unicorns a=platypus b=thisTest c=fancyhelper.currentFruit d=fancyhelper.currentCountry.unicorns=eggs leaf guava 0 a:eggs b:leaf c:guava d:0)');
   test.equal(trials.length, 5);
 
-  // test interpretation of block helper invocation
-
-  Template.test_helpers_i.uppercase = function(fn) {
-    return fn().toUpperCase();
-  };
-  Template.test_helpers_i.tr = function(options) {
-    var str = options.fn();
-    _.each(options.hash, function(v,k) {
-      str = str.replace(new RegExp(k, 'g'), v);
-    });
-    return str;
-  };
-  Template.test_helpers_i.arg_and_dict = function(arg, options) {
-    if (typeof options.hash !== "object")
-      throw new Error();
-    return _.keys(options.hash).length;
-  };
-  Template.test_helpers_i.get_arg = function(arg) {
-    return arg;
-  };
-  Template.test_helpers_i.two_args = function(arg1, arg2) {
-    return [typeof arg1 === "string",
-            typeof arg2 === "string"].join();
-  };
-  Template.test_helpers_i.helperListFour = listFour;
-
-  trials =
-        Template.test_helpers_i(dataObj).match(/\(.*?\)/g);
-  test.equal(trials[0], "(uppercase apple=APPLE)");
-  test.equal(trials[1], "(altered banana=bododo)");
-  // presence of arg should prevent keyword arguments from
-  // being passed to block helper, whether or not the arg
-  // is a function.
-  test.equal(trials[2], "(nokeys=0)");
-  test.equal(trials[3], "(nokeys=0)");
-  test.equal(trials[4],
-             '(biggie=eggs leaf guava 0 a:eggs b:leaf c:guava d:0)');
-  // can't pass > 1 positional arg to block helper
-  test.equal(trials[5], "(twoArgBlock=true,false)");
-  test.equal(trials.length, 6);
 });
 
 
@@ -330,30 +372,23 @@ Tinytest.add("templating - rendered template", function(test) {
     return this.x + 1;
   };
 
-  Template.test_render_a.preserve(['br']);
+  var div = renderToDiv(Template.test_render_a.extend({data: {x: 123}}));
+  test.equal($(div).text().match(/\S+/)[0], "124");
 
-  var div = OnscreenDiv(
-    Meteor.render(function () {
-      return Template.test_render_a({ x: 123 });
-    }));
-
-  test.equal(div.text().match(/\S+/)[0], "124");
-
-  var br1 = div.node().getElementsByTagName('br')[0];
-  var hr1 = div.node().getElementsByTagName('hr')[0];
+  var br1 = div.getElementsByTagName('br')[0];
+  var hr1 = div.getElementsByTagName('hr')[0];
   test.isTrue(br1);
   test.isTrue(hr1);
 
   R.set('bar');
   Deps.flush();
-  var br2 = div.node().getElementsByTagName('br')[0];
-  var hr2 = div.node().getElementsByTagName('hr')[0];
+  var br2 = div.getElementsByTagName('br')[0];
+  var hr2 = div.getElementsByTagName('hr')[0];
   test.isTrue(br2);
   test.isTrue(br1 === br2);
   test.isTrue(hr2);
-  test.isFalse(hr1 === hr2);
+  test.isTrue(hr1 === hr2);
 
-  div.kill();
   Deps.flush();
 
   /////
@@ -364,214 +399,24 @@ Tinytest.add("templating - rendered template", function(test) {
     R.get();
     return (+this) + 1;
   };
-  Template.test_render_b.preserve(['br']);
 
-  div = OnscreenDiv(
-    Meteor.render(function () {
-      return Template.test_render_b({ x: 123 });
-    }));
+  div = renderToDiv(Template.test_render_b.extend({data: {x: 123}}));
+  test.equal($(div).text().match(/\S+/)[0], "201");
 
-  test.equal(div.text().match(/\S+/)[0], "201");
-
-  var br1 = div.node().getElementsByTagName('br')[0];
-  var hr1 = div.node().getElementsByTagName('hr')[0];
+  var br1 = div.getElementsByTagName('br')[0];
+  var hr1 = div.getElementsByTagName('hr')[0];
   test.isTrue(br1);
   test.isTrue(hr1);
 
   R.set('bar');
   Deps.flush();
-  var br2 = div.node().getElementsByTagName('br')[0];
-  var hr2 = div.node().getElementsByTagName('hr')[0];
+  var br2 = div.getElementsByTagName('br')[0];
+  var hr2 = div.getElementsByTagName('hr')[0];
   test.isTrue(br2);
   test.isTrue(br1 === br2);
   test.isTrue(hr2);
-  test.isFalse(hr1 === hr2);
+  test.isTrue(hr1 === hr2);
 
-  div.kill();
-  Deps.flush();
-
-  /////
-
-  var stuff = new LocalCollection();
-  stuff.insert({foo:'bar'});
-
-  Template.test_render_c.preserve(['br']);
-
-  div = OnscreenDiv(
-    Meteor.renderList(
-      stuff.find(), function (data) {
-        return Template.test_render_c(data, 'blah');
-      }));
-
-  var br1 = div.node().getElementsByTagName('br')[0];
-  var hr1 = div.node().getElementsByTagName('hr')[0];
-  test.isTrue(br1);
-  test.isTrue(hr1);
-
-  stuff.update({foo:'bar'}, {$set: {foo: 'baz'}});
-  Deps.flush();
-  var br2 = div.node().getElementsByTagName('br')[0];
-  var hr2 = div.node().getElementsByTagName('hr')[0];
-  test.isTrue(br2);
-  test.isTrue(br1 === br2);
-  test.isTrue(hr2);
-  test.isFalse(hr1 === hr2);
-
-  div.kill();
-  Deps.flush();
-
-  /////
-
-  var stuff = new LocalCollection();
-  stuff.insert({foo:'bar'});
-
-  Template.test_render_c.preserve(['br']);
-
-  div = OnscreenDiv(Meteor.renderList(stuff.find(),
-                                      Template.test_render_c));
-
-  var br1 = div.node().getElementsByTagName('br')[0];
-  var hr1 = div.node().getElementsByTagName('hr')[0];
-  test.isTrue(br1);
-  test.isTrue(hr1);
-
-  stuff.update({foo:'bar'}, {$set: {foo: 'baz'}});
-  Deps.flush();
-  var br2 = div.node().getElementsByTagName('br')[0];
-  var hr2 = div.node().getElementsByTagName('hr')[0];
-  test.isTrue(br2);
-  test.isTrue(br1 === br2);
-  test.isTrue(hr2);
-  test.isFalse(hr1 === hr2);
-
-  div.kill();
-  Deps.flush();
-
-});
-
-Tinytest.add("templating - branch labels", function(test) {
-  var R = ReactiveVar('foo');
-  Template.test_branches_a['var'] = function () {
-    return R.get();
-  };
-
-  var elems = [];
-
-  // use constant landmarks to test that each
-  // block helper invocation gets a different label
-  Template.test_branches_a.myConstant = function (options) {
-    var data = this;
-    var firstRender = true;
-    return Spark.createLandmark({ constant: true,
-                                  rendered: function () {
-                                    if (! firstRender)
-                                      return;
-                                    firstRender = false;
-                                    var hr = this.find('hr');
-                                    hr.myIndex = elems.length;
-                                    elems.push(this.find('hr'));
-                                  }},
-                                function () {
-                                  return options.fn(data);
-                                });
-  };
-
-  var div = OnscreenDiv(Meteor.render(Template.test_branches_a));
-  Deps.flush();
-  test.equal(DomUtils.find(div.node(), 'span').innerHTML, 'foo');
-  test.equal(elems.length, 3);
-
-  R.set('bar');
-  Deps.flush();
-  var elems2 = DomUtils.findAll(div.node(), 'hr');
-  elems2.sort(function(a, b) { return a.myIndex - b.myIndex; });
-  test.equal(elems[0], elems2[0]);
-  test.equal(elems[1], elems2[1]);
-  test.equal(elems[2], elems2[2]);
-  test.equal(DomUtils.find(div.node(), 'span').innerHTML, 'bar');
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("templating - matching in list", function (test) {
-  var c = new LocalCollection();
-  c.insert({letter:'a'});
-  c.insert({letter:'b'});
-  c.insert({letter:'c'});
-
-  _.extend(Template.test_listmatching_a0, {
-    'var': function () { return R.get(); },
-    c: function () { return c.find(); }
-  });
-
-  var buf = [];
-  _.extend(Template.test_listmatching_a1, {
-    created: function () { buf.push('+'); },
-    rendered: function () {
-      var letter = canonicalizeHtml(
-        DomUtils.rangeToHtml(this.firstNode,
-                             this.lastNode).match(/\S+/)[0]);
-      buf.push('*'+letter);
-    },
-    destroyed: function () { buf.push('-'); }
-  });
-
-  var R = ReactiveVar('foo');
-  var div = OnscreenDiv(Spark.render(Template.test_listmatching_a0));
-  Deps.flush();
-
-  test.equal(DomUtils.find(div.node(), 'span').innerHTML, 'foo');
-  test.equal(div.html().match(/<p>(.*?)<\/p>/)[1].match(/\S+/g), ['a','b','c']);
-  test.equal(buf.join(''), '+++*a*b*c');
-
-  buf.length = 0;
-  R.set('bar');
-  Deps.flush();
-  test.equal(DomUtils.find(div.node(), 'span').innerHTML, 'bar');
-  test.equal(div.html().match(/<p>(.*?)<\/p>/)[1].match(/\S+/g), ['a','b','c']);
-  test.equal(buf.join(''), '*a*b*c');
-
-  div.kill();
-  Deps.flush();
-
-});
-
-Tinytest.add("templating - isolate helper", function (test) {
-  var Rs = _.map(_.range(4), function () { return ReactiveVar(1); });
-  var touch = function (n) { Rs[n-1].get(); };
-  var bump = function (n) { Rs[n-1].set(Rs[n-1].get() + 1); };
-  var counts = _.map(_.range(4), function () { return 0; });
-  var tally = function (n) { return ++counts[n-1]; };
-
-  _.extend(Template.test_isolate_a, {
-    helper: function (n) {
-      touch(n);
-      return tally(n);
-    }
-  });
-
-  var div = OnscreenDiv(Meteor.render(Template.test_isolate_a));
-
-  var getTallies = function () {
-    return _.map(div.html().match(/\S+/g), Number);
-  };
-  var expect = function(str) {
-    test.equal(getTallies().join(','), str);
-  };
-
-  Deps.flush();
-  expect("1,1,1,1");
-  bump(1);  Deps.flush();  expect("2,2,2,2");
-  bump(2);  Deps.flush();  expect("2,3,3,3");
-  bump(3);  Deps.flush();  expect("2,3,4,4");
-  bump(4);  Deps.flush();  expect("2,3,4,5");
-  Deps.flush(); expect("2,3,4,5");
-  bump(3);  Deps.flush();  expect("2,3,5,6");
-  bump(2);  Deps.flush();  expect("2,4,6,7");
-  bump(1);  Deps.flush();  expect("3,5,7,8");
-
-  div.kill();
   Deps.flush();
 
 });
@@ -613,61 +458,14 @@ Tinytest.add("templating - template arg", function (test) {
     test.throws(function () { return self.findAll("*"); });
   };
 
-  var div = OnscreenDiv(Spark.render(function () {
-    return Template.test_template_arg_a({food: "pie"});
-  }));
+  var div = renderToDiv(Template.test_template_arg_a.extend({data: {food: "pie"}}));
+  var cleanupDiv = addToBody(div);
+  Deps.flush(); // cause `rendered` to be called
+  test.equal($(div).text(), "Greetings 1-bold Line");
+  clickElement(div.querySelector('i'));
+  test.equal($(div).text(), "Hello 3-element World (the secret is strawberry pie)");
 
-  test.equal(div.text(), "Foo Bar Baz");
-  Deps.flush();
-  test.equal(div.text(), "Greetings 1-bold Line");
-  clickElement(DomUtils.find(div.node(), 'i'));
-  test.equal(div.text(), "Hello 3-element World (the secret is strawberry pie)");
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("templating - preserve", function (test) {
-  var R = ReactiveVar('foo');
-
-  var tmpl = Template.test_template_preserve_a;
-  tmpl.preserve(['.b']);
-  tmpl.preserve(['.c']);
-  tmpl.preserve({'.d': true});
-  tmpl.preserve({'span': function (n) {
-    return _.contains(['e','f'], n.className) && n.className;
-  }});
-  tmpl.preserve(['span.a']);
-  tmpl['var'] = function () { return R.get(); };
-
-  var div = OnscreenDiv(Meteor.render(tmpl));
-  Deps.flush();
-  test.equal(DomUtils.find(div.node(), 'u').firstChild.nodeValue.match(
-      /\S+/)[0], 'foo');
-  var spans1 = {};
-  _.each(DomUtils.findAll(div.node(), 'span'), function (sp) {
-    spans1[sp.className] = sp;
-  });
-
-  R.set('bar');
-  Deps.flush();
-  test.equal(DomUtils.find(div.node(), 'u').firstChild.nodeValue.match(
-      /\S+/)[0], 'bar');
-  var spans2 = {};
-  _.each(DomUtils.findAll(div.node(), 'span'), function (sp) {
-    spans2[sp.className] = sp;
-  });
-
-  test.isTrue(spans1.a === spans2.a);
-  test.isTrue(spans1.b === spans2.b);
-  test.isTrue(spans1.c === spans2.c);
-  test.isTrue(spans1.d === spans2.d);
-  test.isTrue(spans1.e === spans2.e);
-  test.isTrue(spans1.f === spans2.f);
-  test.isFalse(spans1.y === spans2.y);
-  test.isFalse(spans1.z === spans2.z);
-
-  div.kill();
+  cleanupDiv();
   Deps.flush();
 });
 
@@ -679,9 +477,8 @@ Tinytest.add("templating - helpers", function (test) {
   // helpers(...) takes precendence of assigned helper
   tmpl.helpers({foo: 'a', baz: function() { return 'c'; }});
 
-  var div = OnscreenDiv(Meteor.render(tmpl));
-  test.equal(div.text().match(/\S+/)[0], 'abc');
-  div.kill();
+  var div = renderToDiv(tmpl);
+  test.equal($(div).text().match(/\S+/)[0], 'abc');
   Deps.flush();
 
   tmpl = Template.test_template_helpers_b;
@@ -694,26 +491,20 @@ Tinytest.add("templating - helpers", function (test) {
     'var': 'D'
   });
 
-  div = OnscreenDiv(Meteor.render(tmpl));
-  var txt = div.text().match(/\S+/)[0];
-  test.isTrue(txt.match(/^ABC?4D$/));
-  // We don't get 'C' (the ability to name a helper {{toString}})
-  // in IE < 9 because of the famed DontEnum bug.  This could be
-  // fixed but it would require making all the code that handles
-  // the dictionary of helpers be DontEnum-aware.  In practice,
-  // the Object prototype method names (toString, hasOwnProperty,
-  // isPropertyOf, ...) make poor helper names and are unlikely
-  // to be used in apps.
+  div = renderToDiv(tmpl);
+  var txt = $(div).text();
+  txt = txt.replace('[object Object]', 'X'); // IE 8
+  txt = txt.match(/\S+/)[0];
+  test.isTrue(txt.match(/^AB[CX]4D$/));
+  // We don't make helpers with names like toString work in IE 8.
   test.expect_fail();
   test.equal(txt, 'ABC4D');
-  div.kill();
   Deps.flush();
 
   // test that helpers don't "leak"
   tmpl = Template.test_template_helpers_c;
-  div = OnscreenDiv(Meteor.render(tmpl));
-  test.equal(div.text(), 'x');
-  div.kill();
+  div = renderToDiv(tmpl);
+  test.equal($(div).text(), 'x');
   Deps.flush();
 });
 
@@ -727,10 +518,11 @@ Tinytest.add("templating - events", function (test) {
     'click b': function () { buf.push('b'); }
   };
 
-  var div = OnscreenDiv(Meteor.render(tmpl));
-  clickElement(DomUtils.find(div.node(), 'b'));
+  var div = renderToDiv(tmpl);
+  var cleanupDiv = addToBody(div);
+  clickElement($(div).find('b')[0]);
   test.equal(buf, ['b']);
-  div.kill();
+  cleanupDiv();
   Deps.flush();
 
   ///
@@ -745,11 +537,12 @@ Tinytest.add("templating - events", function (test) {
     'click i': function () { buf.push('i'); }
   });
 
-  var div = OnscreenDiv(Meteor.render(tmpl));
-  clickElement(DomUtils.find(div.node(), 'u'));
-  clickElement(DomUtils.find(div.node(), 'i'));
+  div = renderToDiv(tmpl);
+  cleanupDiv = addToBody(div);
+  clickElement($(div).find('u')[0]);
+  clickElement($(div).find('i')[0]);
   test.equal(buf, ['u', 'i']);
-  div.kill();
+  cleanupDiv();
   Deps.flush();
 
   //Test for identical callbacks for issue #650
@@ -762,267 +555,20 @@ Tinytest.add("templating - events", function (test) {
     'click u': function () { buf.push('b'); }
   });
 
-  div = OnscreenDiv(Meteor.render(tmpl));
-  clickElement(DomUtils.find(div.node(), 'u'));
+  div = renderToDiv(tmpl);
+  cleanupDiv = addToBody(div);
+  clickElement($(div).find('u')[0]);
   test.equal(buf.length, 2);
   test.isTrue(_.contains(buf, 'a'));
   test.isTrue(_.contains(buf, 'b'));
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("templating - #each rendered callback", function (test) {
-  // test that any list modification triggers a rendered callback on the
-  // enclosing template
-
-  var entries = new LocalCollection();
-  entries.insert({x:'a'});
-  entries.insert({x:'b'});
-  entries.insert({x:'c'});
-
-  var buf = [];
-
-  var tmpl = Template.test_template_eachrender_a;
-  tmpl.helpers({entries: function() {
-    return entries.find({}, {sort: ['x']}); }});
-  tmpl.rendered = function () {
-    buf.push(canonicalizeHtml(
-      DomUtils.rangeToHtml(this.firstNode, this.lastNode)).replace(/\s/g, ''));
-  };
-  var div = OnscreenDiv(Meteor.render(tmpl));
-  Deps.flush();
-  test.equal(buf, ['<div>a</div><div>b</div><div>c</div>']);
-  buf.length = 0;
-
-  // added
-  entries.insert({x:'d'});
-  test.equal(buf, []);
-  Deps.flush();
-  test.equal(buf, ['<div>a</div><div>b</div><div>c</div><div>d</div>']);
-  buf.length = 0;
-
-  // removed
-  entries.remove({x:'a'});
-  test.equal(buf, []);
-  Deps.flush();
-  test.equal(buf, ['<div>b</div><div>c</div><div>d</div>']);
-  buf.length = 0;
-
-  // moved/changed
-  entries.update({x:'b'}, {$set: {x: 'z'}});
-  test.equal(buf, []);
-  Deps.flush();
-  test.equal(buf, ['<div>c</div><div>d</div><div>z</div>',
-                   '<div>c</div><div>d</div><div>z</div>']);
-  buf.length = 0;
-
-  div.kill();
-  Deps.flush();
-
-  // test pure "moved"
-
-  tmpl = Template.test_template_eachrender_b;
-  var cbks = [];
-  var xs = ['a','b','c'];
-  tmpl.helpers({entries: function() {
-    return { observeChanges: function (callbacks) {
-      cbks.push(callbacks);
-      _.each(xs, function(x) {
-        callbacks.addedBefore(x, {x:x}, null);
-      });
-      return {
-        stop: function () {
-          cbks = _.without(cbks, callbacks);
-        }
-      };
-    }};
-  }});
-  tmpl.rendered = function () {
-    buf.push(canonicalizeHtml(
-      DomUtils.rangeToHtml(this.firstNode, this.lastNode)).replace(/\s/g, ''));
-  };
-  buf = [];
-  var div = OnscreenDiv(Meteor.render(tmpl));
-  test.equal(buf, []);
-  Deps.flush();
-  test.equal(buf, ['<div>a</div><div>b</div><div>c</div>']);
-  buf.length = 0;
-
-  _.each(cbks, function (callbacks) {
-    callbacks.movedBefore('a', null);
-  });
-  test.equal(buf, []);
-  Deps.flush();
-  test.equal(div.html().replace(/\s/g, ''),
-             '<div>b</div><div>c</div><div>a</div>');
-  test.equal(buf, ['<div>b</div><div>c</div><div>a</div>']);
-  buf.length = 0;
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("templating - landmarks in helpers", function (test) {
-  var buf = [];
-
-  var R = ReactiveVar('foo');
-
-  var tmpl = Template.test_template_landmarks_a;
-  tmpl.LM = function () {
-    return new Handlebars.SafeString(
-      Spark.createLandmark({created: function () { buf.push('c'); },
-                            rendered: function () { buf.push('r'); },
-                            destroyed: function () { buf.push('d'); }},
-                           function () { return 'x'; }));
-  };
-  tmpl.v = function () {
-    return R.get();
-  };
-
-  var div = OnscreenDiv(Meteor.render(tmpl));
-  test.equal(div.text().match(/\S+/)[0], 'xxxxfoo');
-  Deps.flush();
-  buf.sort();
-  test.equal(buf.join(''), 'ccccrrrr');
-  buf.length = 0;
-
-  R.set('bar');
-  Deps.flush();
-  test.equal(div.text().match(/\S+/)[0], 'xxxxbar');
-  test.equal(buf.join(''), 'rrrr');
-  buf.length = 0;
-
-  div.kill();
-  Deps.flush();
-  test.equal(buf.join(''), 'dddd');
-});
-
-Tinytest.add("templating - bare each has no matching", function (test) {
-  var buf = [];
-
-  var R = ReactiveVar('foo');
-
-  var tmpl = Template.test_template_bare_each_a;
-  tmpl.abc = [{}, {}, {}];
-  tmpl.LM = function () {
-    return new Handlebars.SafeString(
-      Spark.createLandmark({created: function () { buf.push('c'); },
-                            rendered: function () { buf.push('r'); },
-                            destroyed: function () { buf.push('d'); }},
-                           function () { return 'x'; }));
-  };
-  tmpl.v = function () {
-    return R.get();
-  };
-
-  var div = OnscreenDiv(Meteor.render(tmpl));
-  Deps.flush();
-  buf.sort();
-  test.equal(buf.join(''), 'cccrrr');
-  buf.length = 0;
-
-  R.set('bar');
-  Deps.flush();
-  buf.sort();
-  test.equal(buf.join(''), 'cccdddrrr');
-  buf.length = 0;
-
-  div.kill();
-  Deps.flush();
-  test.equal(buf.join(''), 'ddd');
-});
-
-Tinytest.add("templating - templates are labeled", function (test) {
-  var buf = [];
-
-  var R = ReactiveVar('foo');
-
-  var tmpls = _.map([0,1,2,3], function (n) {
-    return Template['test_template_labels_a'+n];
-  });
-  tmpls[0].stuff = function () {
-    return tmpls[1]() + tmpls[2]() + tmpls[3]() + R.get();
-  };
-  _.each([tmpls[1], tmpls[2], tmpls[3]], function (tmpl) {
-    tmpl.preserve(['hr']);
-    tmpl.created = function () { buf.push('c'); };
-    tmpl.rendered = function () { buf.push('r'); };
-    tmpl.destroyed = function () { buf.push('d'); };
-  });
-
-  var div = OnscreenDiv(Meteor.render(tmpls[0]));
-  Deps.flush();
-  test.equal(div.html(), "<hr><hr><hr>foo");
-  buf.sort();
-  test.equal(buf.join(''), 'cccrrr');
-  buf.length = 0;
-
-  R.set('bar');
-  Deps.flush();
-  test.equal(div.html(), "<hr><hr><hr>bar");
-  buf.sort();
-  test.equal(buf.join(''), 'rrr');
-  buf.length = 0;
-
-  div.kill();
-  Deps.flush();
-  test.equal(buf.join(''), 'ddd');
-});
-
-Tinytest.add("templating - unlabeled cursor", function (test) {
-  var R = ReactiveVar("foo");
-
-  var div = OnscreenDiv(Meteor.render(function () {
-    R.get(); // create dependency
-    return Template.test_unlabeled_cursor_a0(
-      {observeChanges: function (callbacks) {
-        callbacks.addedBefore('0', {}, null);
-        callbacks.addedBefore('1', {}, null);
-        callbacks.addedBefore('2', {}, null);
-        return { stop: function () {} };
-      }}
-    );
-  }));
-
-  R.set("bar");
-  // This will fail with "can't create second landmark in branch"
-  // unless _id-less objects returned from a cursor are given
-  // unique branch labels in an {{#each}}.
-  Deps.flush();
-
-  div.kill();
-  Deps.flush();
-});
-
-Tinytest.add("templating - constant text patching", function (test) {
-  // Issue #323.
-
-  var tmpl = Template.test_constant_text_a0;
-
-  var R = ReactiveVar("foo");
-
-  tmpl.preserve(['p']);
-  tmpl.v = function () {
-    return R.get();
-  };
-
-  var div = OnscreenDiv(Meteor.render(tmpl));
-  Deps.flush();
-
-  R.set("bar");
-  // This flush will fail if we can't patch the constant region,
-  // which starts with a text node, after preserving the preceding
-  // paragraph.
-  Deps.flush();
-
-  div.kill();
+  cleanupDiv();
   Deps.flush();
 });
 
 
 Tinytest.add('templating - helper typecast Issue #617', function (test) {
 
-  Handlebars.registerHelper('testTypeCasting', function (/*arguments*/) {
+  UI.registerHelper('testTypeCasting', function (/*arguments*/) {
     // Return a string representing the arguments passed to this
     // function, including types. eg:
     // (1, true) -> "[number,1][boolean,true]"
@@ -1034,8 +580,8 @@ Tinytest.add('templating - helper typecast Issue #617', function (test) {
     return x;
   });
 
-  var frag = Meteor.render(Template.test_type_casting);
-  var result = canonicalizeHtml(DomUtils.fragmentToHtml(frag));
+  var div = renderToDiv(Template.test_type_casting);
+  var result = canonicalizeHtml(div.innerHTML);
   test.equal(
     result,
     // This corresponds to entries in templating_tests.html.
@@ -1043,59 +589,20 @@ Tinytest.add('templating - helper typecast Issue #617', function (test) {
     "[string,true][string,false][boolean,true][boolean,false]" +
       // numbers
       "[number,0][number,1][number,-1][number,10][number,-10]" +
-      // errors
-      "[undefined,undefined][undefined,undefined]" +
       // handlebars 'options' argument. appended to args of all helpers.
       "[object]");
 });
 
-Tinytest.add("templating - tricky branch labels", function (test) {
-  // regression test for issue #724
-
-  var loading = ReactiveVar(true);
-  var v = ReactiveVar(1);
-
-  var x = [];
-
-  Template.test_template_trickylabels_a0.loading = function () {
-    return loading.get();
-  };
-
-  Template.test_template_trickylabels_a1.v = function () {
-    return v.get();
-  };
-
-  _.extend(Template.test_template_trickylabels_a2, {
-    created: function () { x.push('c'); },
-    rendered: function () { x.push('r'); },
-    destroyed: function () { x.push('d'); }
-  });
-
-  var div = OnscreenDiv(Meteor.render(Template.test_template_trickylabels_a0));
-  Deps.flush();
-  loading.set(false);
-  Deps.flush();
-  x.length = 0;
-
-  v.set(2);
-  Deps.flush();
-  test.equal(x.join(''), 'r'); // no 'c' or 'd'
-  test.equal(div.html().replace(/\s+/g, ''), '<div>foo</div>2<div>bar</div>');
-
-  div.kill();
-  Deps.flush();
-});
-
 Tinytest.add('templating - each falsy Issue #801', function (test) {
-  //Minor test for issue #801
-  Template.test_template_issue801.values = function() { return [1,2,null,undefined]; };
-  var frag = Meteor.render(Template.test_template_issue801);
-  test.equal(canonicalizeHtml(DomUtils.fragmentToHtml(frag)), "12null");
+  //Minor test for issue #801 (#each over array containing nulls)
+  Template.test_template_issue801.values = function() { return [0,1,2,null,undefined,false]; };
+  var div = renderToDiv(Template.test_template_issue801);
+  test.equal(canonicalizeHtml(div.innerHTML), "012");
 });
 
-Tinytest.add('templating - with falsy Issue #770', function (test) {
-  Template.test_template_issue770.value1 = function () { return "abc"; };
-  Template.test_template_issue770.value2 = function () { return false; };
-  var frag = Meteor.render(Template.test_template_issue770);
-  test.equal(canonicalizeHtml(DomUtils.fragmentToHtml(frag)), "abcxxxabc");
+Tinytest.add('templating - duplicate template error', function (test) {
+  Template.__define__("test_duplicate_template", function () {});
+  test.throws(function () {
+    Template.__define__("test_duplicate_template", function () {});
+  });
 });
diff --git a/packages/test-helpers/async_multi.js b/packages/test-helpers/async_multi.js
index fbbb34db35..1f5d001e25 100644
--- a/packages/test-helpers/async_multi.js
+++ b/packages/test-helpers/async_multi.js
@@ -116,11 +116,14 @@ testAsyncMulti = function (name, funcs) {
   Tinytest.addAsync(name, function (test, onComplete) {
     var remaining = _.clone(funcs);
     var context = {};
+    var i = 0;
 
     var runNext = function () {
       var func = remaining.shift();
-      if (!func)
+      if (!func) {
+        delete test.extraDetails.asyncBlock;
         onComplete();
+      }
       else {
         var em = new ExpectationManager(test, function () {
           Meteor.clearTimeout(timer);
@@ -135,6 +138,7 @@ testAsyncMulti = function (name, funcs) {
           return;
         }, timeout);
 
+        test.extraDetails.asyncBlock = i++;
         try {
           func.apply(context, [test, _.bind(em.expect, em)]);
         } catch (exception) {
diff --git a/packages/test-helpers/canonicalize_html.js b/packages/test-helpers/canonicalize_html.js
index 633c97cce8..ba1868d0a3 100644
--- a/packages/test-helpers/canonicalize_html.js
+++ b/packages/test-helpers/canonicalize_html.js
@@ -1,42 +1,71 @@
 canonicalizeHtml = function(html) {
   var h = html;
-  // kill IE-specific comments inserted by Spark
+  // kill IE-specific comments inserted by DomRange
   h = h.replace(/<!--IE-->/g, '');
   // ignore exact text of comments
   h = h.replace(/<!--.*?-->/g, '<!---->');
   // make all tags lowercase
   h = h.replace(/<\/?(\w+)/g, function(m) {
     return m.toLowerCase(); });
-  // kill \n and \r characters
-  h = h.replace(/[\n\r]/g, '');
+  // replace whitespace sequences with spaces
+  h = h.replace(/\s+/g, ' ');
+  // Trim leading and trailing whitespace
+  h = h.replace(/^\s+|\s+$/g, '');
+  // remove whitespace before and after tags
+  h = h.replace(/\s*(<\/?\w.*?>)\s*/g, function (m, tag) {
+    return tag; });
   // make tag attributes uniform
   h = h.replace(/<(\w+)\s+(.*?)\s*>/g, function(m, tagName, attrs) {
     // Drop expando property used by Sizzle (part of jQuery) which leaks into
     // attributes in IE8. Note that its value always contains spaces.
     attrs = attrs.replace(/sizcache[0-9]+="[^"]*"/g, ' ');
+    // Similarly for expando properties used by jQuery to track data.
+    attrs = attrs.replace(/jQuery[0-9]+="[0-9]+"/g, ' ');
+    // Similarly for expando properties used to DomBackend to keep
+    // track of callbacks to fire when an element is removed
+    attrs = attrs.replace(/\$meteor_ui_removal_callbacks="[^"]*"/g, ' ');
+
     attrs = attrs.replace(/\s*=\s*/g, '=');
     attrs = attrs.replace(/^\s+/g, '');
     attrs = attrs.replace(/\s+$/g, '');
     attrs = attrs.replace(/\s+/g, ' ');
-    var attrList = attrs.split(' ');
+    // quote unquoted attribute values, as in `type=checkbox`.  This
+    // will do the wrong thing if there's an `=` in an attribute value.
+    attrs = attrs.replace(/(\w)=([^" >/]+)/g, '$1="$2"');
+    // for the purpose of splitting attributes in a string like
+    // 'a="b" c="d"', assume they are separated by a single space
+    // and values are double-quoted, but allow for spaces inside
+    // the quotes.  Split on space following quote.
+    var attrList = attrs.replace(/" /g, '"\u0000').split('\u0000');
     // put attributes in alphabetical order
     attrList.sort();
+
     var tagContents = [tagName];
+
     for(var i=0; i<attrList.length; i++) {
+      // If there were no attrs, attrList could be `[""]`,
+      // so skip falsy values.
+      if (! attrList[i])
+        continue;
       var a = attrList[i].split('=');
+
+      // In IE8, attributes whose value is "" appear
+      // without the '=' sign altogether.
       if (a.length < 2)
-        a.push(a[0]); // things like checked=checked, in theory
+        a.push("");
+
       var key = a[0];
       // Drop another expando property used by Sizzle.
       if (key === 'sizset')
         continue;
       var value = a[1];
       value = value.replace(/["'`]/g, '"');
+      // this check is probably made unreachable by a regex above
+      // that quotes unquoted attribute values
       if (value.charAt(0) !== '"')
         value = '"'+value+'"';
       tagContents.push(key+'='+value);
     }
-
     return '<'+tagContents.join(' ')+'>';
   });
   return h;
diff --git a/packages/test-helpers/domutils.js b/packages/test-helpers/domutils.js
new file mode 100644
index 0000000000..e5a29025e2
--- /dev/null
+++ b/packages/test-helpers/domutils.js
@@ -0,0 +1,70 @@
+var testDiv = document.createElement("div");
+testDiv.innerHTML = "   <link/><table></table><select><!----></select>";
+// Need to wrap in a div rather than directly creating SELECT to avoid
+// *another* IE bug.
+var testSelectDiv = document.createElement("div");
+testSelectDiv.innerHTML = "<select><option selected>Foo</option></select>";
+testSelectDiv.firstChild.setAttribute("name", "myname");
+
+// Tests that, if true, indicate browser quirks present.
+var quirks = {
+  // IE loses initial whitespace when setting innerHTML.
+  leadingWhitespaceKilled: (testDiv.firstChild.nodeType !== 3),
+
+  // IE may insert an empty tbody tag in a table.
+  tbodyInsertion: testDiv.getElementsByTagName("tbody").length > 0,
+
+  // IE loses some tags in some environments (requiring extra wrapper).
+  tagsLost: testDiv.getElementsByTagName("link").length === 0,
+
+  // IE <= 9 loses HTML comments in <select> and <option> tags.
+  commentsLost: (! testDiv.getElementsByTagName("select")[0].firstChild),
+
+  selectValueMustBeFromAttribute: (testSelectDiv.firstChild.value !== "Foo"),
+
+  // In IE7, setAttribute('name', foo) doesn't show up in rendered HTML.
+  // (In FF3, outerHTML is undefined, but it doesn't have this quirk.)
+  mustSetNameInCreateElement: (
+    testSelectDiv.firstChild.outerHTML &&
+      testSelectDiv.firstChild.outerHTML.indexOf("myname") === -1)
+};
+
+DomUtils = {};
+
+DomUtils.setElementValue = function (node, value) {
+  // Try to assign the value.
+  node.value = value;
+  if (node.value === value || node.nodeName !== 'SELECT')
+    return;
+
+  // IE (all versions) appears to only let you assign SELECT values which
+  // match valid OPTION values... and moreover, the OPTION value must be
+  // explicitly given as an attribute, not just as the text. So we hunt for
+  // the OPTION and select it.
+  var options = $(node).find('option');
+  for (var i = 0; i < options.length; ++i) {
+    if (DomUtils.getElementValue(options[i]) === value) {
+      options[i].selected = true;
+      return;
+    }
+  }
+};
+
+// Gets the value of an element, portably across browsers. There's a special
+// case for SELECT elements in IE.
+DomUtils.getElementValue = function (node) {
+  if (!quirks.selectValueMustBeFromAttribute)
+    return node.value;
+
+  if (node.nodeName === 'OPTION') {
+    // Inspired by jQuery.valHooks.option.get.
+    var val = node.attributes.value;
+    return !val || val.specified ? node.value : node.text;
+  } else if (node.nodeName === 'SELECT') {
+    if (node.selectedIndex < 0)
+      return null;
+    return DomUtils.getElementValue(node.options[node.selectedIndex]);
+  } else {
+    return node.value;
+  }
+};
diff --git a/packages/test-helpers/event_simulation.js b/packages/test-helpers/event_simulation.js
index a2865d62cd..72b1133ae6 100644
--- a/packages/test-helpers/event_simulation.js
+++ b/packages/test-helpers/event_simulation.js
@@ -1,9 +1,14 @@
-simulateEvent = function (node, event, args) {
+// possible options:
+// bubbles: A boolean indicating whether the event should bubble up through
+//  the event chain or not. (default is true)
+simulateEvent = function (node, event, args, options) {
   node = (node instanceof $ ? node[0] : node);
 
+  var bubbles = (options && "bubbles" in options) ? options.bubbles : true;
+
   if (document.createEvent) {
     var e = document.createEvent("Event");
-    e.initEvent(event, true, true);
+    e.initEvent(event, bubbles, true);
     _.extend(e, args);
     node.dispatchEvent(e);
   } else {
diff --git a/packages/test-helpers/onscreendiv.js b/packages/test-helpers/onscreendiv.js
deleted file mode 100644
index dc0296761b..0000000000
--- a/packages/test-helpers/onscreendiv.js
+++ /dev/null
@@ -1,73 +0,0 @@
-// OnscreenDiv is an object that appends a DIV to the document
-// body and keeps track of it, providing methods that query it,
-// mutate, and destroy it.
-//
-// By default the DIV has style 'display: none'.
-//
-// In general, methods of OnscreenDiv operate on the contents
-// of the DIV excluding the DIV itself.
-
-// Constructor, with optional 'new':
-// var d = [new] OnscreenDiv([frag])
-OnscreenDiv = function(optFrag) {
-  if (! (this instanceof OnscreenDiv))
-    return new OnscreenDiv(optFrag);
-
-  this.div = DomUtils.htmlToFragment(
-    '<div class="OnscreenDiv" style="display: none"></div>').firstChild;
-  document.body.appendChild(this.div);
-
-  if (optFrag)
-    this.div.appendChild(optFrag);
-};
-
-// get the innerHTML of the DIV
-OnscreenDiv.prototype.rawHtml = function() {
-  return this.div.innerHTML;
-};
-
-// get the innerHTML with some sanitization that tries
-// to produce predictable results across browsers.
-OnscreenDiv.prototype.html = function() {
-  return canonicalizeHtml(this.rawHtml());
-};
-
-// get the text of the DIV
-OnscreenDiv.prototype.text = function() {
-  return this.div.innerText || this.div.textContent;
-};
-
-// get the DIV itself
-OnscreenDiv.prototype.node = function() {
-  return this.div;
-};
-
-// remove the DIV from the document and trigger
-// "fast GC" -- i.e., after the next Deps.flush()
-// the DIV will be fully cleaned up by LiveUI.
-OnscreenDiv.prototype.kill = function() {
-  var self = this;
-  if (self.div.parentNode)
-    self.div.parentNode.removeChild(self.div);
-
-  Deps.afterFlush(function () {
-    Spark.finalize(self.div);
-  });
-};
-
-// remove the DIV from the document
-OnscreenDiv.prototype.remove = function() {
-  this.div.parentNode.removeChild(this.div);
-};
-
-// Show the div (which is otherwise display:none),
-// for tests that require it or for debugging of tests.
-// If invisibly=true, make the div 0-height to obscure
-// the contents.
-OnscreenDiv.prototype.show = function(invisibly) {
-  this.div.style.display = "block";
-  if (invisibly) {
-    this.div.style.height = 0;
-    this.div.style.overflow = 'hidden';
-  }
-};
diff --git a/packages/test-helpers/package.js b/packages/test-helpers/package.js
index da007032f6..0b305b54bb 100644
--- a/packages/test-helpers/package.js
+++ b/packages/test-helpers/package.js
@@ -7,9 +7,8 @@ Package.describe({
 });
 
 Package.on_use(function (api) {
-  api.use(['underscore', 'deps', 'ejson', 'tinytest', 'random',
-          'domutils']);
-  api.use(['spark', 'jquery'], 'client');
+  api.use(['underscore', 'deps', 'ejson', 'tinytest', 'random']);
+  api.use(['jquery'], 'client');
 
   // XXX for connection.js. Not sure this really belongs in
   // test-helpers. It probably would be better off in livedata. But it's
@@ -21,22 +20,21 @@ Package.on_use(function (api) {
 
 
   api.export([
-    'pollUntil', 'WrappedFrag', 'try_all_permutations',
-    'SeededRandom', 'ReactiveVar', 'OnscreenDiv', 'clickElement', 'blurElement',
+    'pollUntil', 'try_all_permutations',
+    'SeededRandom', 'ReactiveVar', 'clickElement', 'blurElement',
     'focusElement', 'simulateEvent', 'getStyleProperty', 'canonicalizeHtml',
     'withCallbackLogger', 'testAsyncMulti', 'simplePoll',
-    'makeTestConnection'], {testOnly: true});
+    'makeTestConnection', 'DomUtils'], {testOnly: true});
 
   api.add_files('try_all_permutations.js');
   api.add_files('async_multi.js');
   api.add_files('event_simulation.js');
   api.add_files('seeded_random.js');
   api.add_files('canonicalize_html.js');
-  api.add_files('onscreendiv.js');
-  api.add_files('wrappedfrag.js');
   api.add_files('current_style.js');
   api.add_files('reactivevar.js');
   api.add_files('callback_logger.js');
+  api.add_files('domutils.js', 'client');
   api.add_files('connection.js', 'server');
 });
 
diff --git a/packages/test-helpers/wrappedfrag.js b/packages/test-helpers/wrappedfrag.js
deleted file mode 100644
index 1023890cea..0000000000
--- a/packages/test-helpers/wrappedfrag.js
+++ /dev/null
@@ -1,44 +0,0 @@
-// A WrappedFrag provides utility methods pertaining to a given
-// DocumentFragment that are helpful in tests.  For example,
-// WrappedFrag(frag).html() constructs a sort of cross-browser
-// innerHTML for the fragment.
-
-// Constructor, with optional 'new':
-// var f = [new] WrappedFrag([frag])
-WrappedFrag = function(frag) {
-  if (! (this instanceof WrappedFrag))
-    return new WrappedFrag(frag);
-
-  this.frag = frag;
-};
-
-WrappedFrag.prototype.rawHtml = function() {
-  return DomUtils.fragmentToHtml(this.frag);
-};
-
-WrappedFrag.prototype.html = function() {
-  return canonicalizeHtml(this.rawHtml());
-};
-
-WrappedFrag.prototype.hold = function() {
-  // increments frag's GC protection reference count
-  this.frag["_protect"] = (this.frag["_protect"] || 0) + 1;
-  return this;
-};
-
-WrappedFrag.prototype.release = function() {
-  var frag = this.frag;
-  // decrement frag's GC protection reference count
-  // Clean up on flush, if hits 0.  Wait to decrement
-  // so no one else cleans it up first.
-  Deps.afterFlush(function () {
-    if (! --frag["_protect"]) {
-      Spark.finalize(frag);
-    }
-  });
-  return this;
-};
-
-WrappedFrag.prototype.node = function() {
-  return this.frag;
-};
diff --git a/packages/test-in-browser/driver.css b/packages/test-in-browser/driver.css
index 7b9bf2fb95..f9506bd2a7 100644
--- a/packages/test-in-browser/driver.css
+++ b/packages/test-in-browser/driver.css
@@ -141,7 +141,7 @@ body {
   text-decoration: none;
 }
 .string_equal_expected ins {
-  background: #fe0;
+  background: #ed0;
 }
 .string_equal_actual ins {
   color: #d00;
diff --git a/packages/test-in-browser/driver.html b/packages/test-in-browser/driver.html
index 2f9a35f4b3..4b27177fa5 100644
--- a/packages/test-in-browser/driver.html
+++ b/packages/test-in-browser/driver.html
@@ -87,28 +87,26 @@
 <template name="testTable">
   <div class="row-fluid"><div class="span12">
   <div class="test_table">
-    {{#each data}}
-      {{> test_group this}}
+    {{#each testdata}}
+      {{> test_group thisWithDep}}
     {{/each}}
   </div>
   </div></div>
 </template>
 
 <template name="test_group">
-  {{groupDep}}
   <div class="group">
     <div class="groupname"><a>{{name}}</a></div>
     {{#each tests}}
-      {{> test}}
+      {{> test thisWithDep}}
     {{/each}}
     {{#each groups}}
-      {{> test_group}}
+      {{> test_group thisWithDep}}
     {{/each}}
   </div>
 </template>
 
 <template name="test">
-  {{testDep}}
   <div class="test {{test_class}}">
     <div class="testrow">
       <div class="teststatus">
diff --git a/packages/test-in-browser/driver.js b/packages/test-in-browser/driver.js
index cc891a7643..635ea4bea2 100644
--- a/packages/test-in-browser/driver.js
+++ b/packages/test-in-browser/driver.js
@@ -220,99 +220,82 @@ var _testStatus = function(t) {
 
 //// Template - navBars
 
-Template.navBars.running = function() {
-  countDep.depend();
-  return running;
-};
+Template.navBars.helpers({
+  running: function() {
+    countDep.depend();
+    return running;
+  },
+  passed: function() {
+    countDep.depend();
+    return failedCount === 0;
+  },
+  total_test_time: function() {
+    countDep.depend();
 
-Template.navBars.passed = function() {
-  countDep.depend();
-  return failedCount === 0;
-};
+    // walk whole tree to get all tests
+    var walk = function (groups) {
+      var total = 0;
 
-Template.navBars.total_test_time = function() {
-  countDep.depend();
+      _.each(groups || [], function (group) {
+        _.each(group.tests || [], function (t) {
+          total += _testTime(t);
+        });
 
-  // walk whole tree to get all tests
-  var walk = function (groups) {
-    var total = 0;
-
-    _.each(groups || [], function (group) {
-      _.each(group.tests || [], function (t) {
-        total += _testTime(t);
+        total += walk(group.groups);
       });
 
-      total += walk(group.groups);
-    });
+      return total;
+    };
 
-    return total;
-  };
-
-  return walk(resultTree);
-};
+    return walk(resultTree);
+  }
+});
 
 
 //// Template - progressBar
 
-Template.progressBar.running = function () {
-  countDep.depend();
-  return running;
-};
-
-Template.progressBar.percentPass = function () {
-  countDep.depend();
-  if (totalCount === 0)
-    return 0;
-  return 100*passedCount/totalCount;
-};
-
-Template.progressBar.totalCount = function () {
-  countDep.depend();
-  return totalCount;
-};
-
-Template.progressBar.passedCount = function () {
-  countDep.depend();
-  return passedCount;
-};
-
-Template.progressBar.percentFail = function () {
-  countDep.depend();
-  if (totalCount === 0)
-    return 0;
-  return 100*failedCount/totalCount;
-};
-
-Template.progressBar.anyFail = function () {
-  countDep.depend();
-  return failedCount > 0;
-};
-
-Template.progressBar.barOuterClass = function () {
-  return Template.progressBar.running() ? 'progress-striped' : '';
-};
-
-Template.progressBar.barInnerClass = function () {
-  return (Template.progressBar.anyFail() ?
-          'bar-warning' : 'bar-success');
-};
-
+Template.progressBar.helpers({
+  running: function () {
+    countDep.depend();
+    return running;
+  },
+  percentPass: function () {
+    countDep.depend();
+    if (totalCount === 0)
+      return 0;
+    return 100*passedCount/totalCount;
+  },
+  totalCount: function () {
+    countDep.depend();
+    return totalCount;
+  },
+  passedCount: function () {
+    countDep.depend();
+    return passedCount;
+  },
+  percentFail: function () {
+    countDep.depend();
+    if (totalCount === 0)
+      return 0;
+    return 100*failedCount/totalCount;
+  },
+  anyFail: function () {
+    countDep.depend();
+    return failedCount > 0;
+  },
+  barOuterClass: function () {
+    countDep.depend();
+    return running ? 'progress-striped' : '';
+  },
+  barInnerClass: function () {
+    countDep.depend();
+    return (failedCount > 0 ?
+            'bar-warning' : 'bar-success');
+  }
+});
 
 //// Template - groupNav
 
-Template.groupNav.groupPaths = function () {
-  var groupPath = Session.get("groupPath");
-  var ret = [];
-  for (var i = 1; i <= groupPath.length; i++) {
-    ret.push({path: groupPath.slice(0,i), name: groupPath[i-1]});
-  }
-  return ret;
-};
-
-Template.groupNav.rerunScheduled = function () {
-  return Session.get("rerunScheduled");
-};
-
 var changeToPath = function (path) {
   Session.set("groupPath", path);
   Session.set("rerunScheduled", true);
@@ -321,11 +304,25 @@ var changeToPath = function (path) {
   Reload._reload();
 };
 
+Template.groupNav.helpers({
+  groupPaths: function () {
+    var groupPath = Session.get("groupPath");
+    var ret = [];
+    for (var i = 1; i <= groupPath.length; i++) {
+      ret.push({path: groupPath.slice(0,i), name: groupPath[i-1]});
+    }
+    return ret;
+  },
+  rerunScheduled: function () {
+    return Session.get("rerunScheduled");
+  }
+});
+
 Template.groupNav.events({
-  "click .group": function () {
+  'click .group': function () {
     changeToPath(this.path);
   },
-  "click .rerun": function () {
+  'click .rerun': function () {
     Session.set("rerunScheduled", true);
     Reload._reload();
   }
@@ -334,117 +331,122 @@ Template.groupNav.events({
 
 //// Template - failedTests
 
-Template.failedTests.failedTests = function() {
-  countDep.depend();
-  return failedTests;
-};
-
-
+Template.failedTests.helpers({
+  failedTests: function() {
+    countDep.depend();
+    return failedTests;
+  }
+});
 
 //// Template - testTable
 
-Template.testTable.data = function() {
-  topLevelGroupsDep.depend();
-  return resultTree;
-};
-
+Template.testTable.helpers({
+  testdata: function () {
+    topLevelGroupsDep.depend();
+    return resultTree;
+  },
+  thisWithDep: function () {
+    this.dep.depend();
+    return this;
+  }
+});
 
 //// Template - test_group
 
-Template.test_group.groupDep = function () {
-  // this template just establishes a dependency. It doesn't actually
-  // render anything.
-  this.dep.depend();
-  return "";
-};
+Template.test_group.helpers({
+  thisWithDep: function () {
+    this.dep.depend();
+    return this;
+  }
+});
 
 Template.test_group.events({
-  "click .groupname": function () {
+  'click .groupname': function (evt) {
     changeToPath(this.path);
+    // prevent enclosing groups from also triggering on
+    // same groupname.  It would be cleaner to think of
+    // this as each group only listening to its *own*
+    // groupname, but currently it listens to all of them.
+    evt.stopImmediatePropagation();
   }
 });
 
 
 //// Template - test
 
-Template.test.testDep = function () {
-  // this template just establishes a dependency. It doesn't actually
-  // render anything.
-  this.dep.depend();
-  return "";
-};
+Template.test.helpers({
+  test_status_display: function() {
+    var status = _testStatus(this);
+    if (status == "failed") {
+      return "FAIL";
+    } else if (status == "succeeded") {
+      return "PASS";
+    } else {
+      return "waiting...";
+    }
+  },
 
-Template.test.test_status_display = function() {
-  var status = _testStatus(this);
-  if (status == "failed") {
-    return "FAIL";
-  } else if (status == "succeeded") {
-    return "PASS";
-  } else {
-    return "waiting...";
+  test_time_display: function() {
+    var time = _testTime(this);
+    return (typeof time === "number") ? time + " ms" : "";
+  },
+
+  test_class: function() {
+    var events = this.events || [];
+    var classes = [_testStatus(this)];
+
+    if (this.expanded) {
+      classes.push("expanded");
+    } else {
+      classes.push("collapsed");
+    }
+
+    return classes.join(' ');
+  },
+
+  eventsArray: function() {
+    var events = _.filter(this.events, function(e) {
+      return e.type != "finish";
+    });
+
+    var partitionBy = function(seq, func) {
+      var result = [];
+      var lastValue = {};
+      _.each(seq, function(x) {
+        var newValue = func(x);
+        if (newValue === lastValue) {
+          result[result.length-1].push(x);
+        } else {
+          lastValue = newValue;
+          result.push([x]);
+        }
+      });
+      return result;
+    };
+
+    var dupLists = partitionBy(
+      _.map(events, function(e) {
+        // XXX XXX We need something better than stringify!
+        // stringify([undefined]) === "[null]"
+        e = _.clone(e);
+        delete e.sequence;
+        return {obj: e, str: JSON.stringify(e)};
+      }), function(x) { return x.str; });
+
+    return _.map(dupLists, function(L) {
+      var obj = L[0].obj;
+      return (L.length > 1) ? _.extend({times: L.length}, obj) : obj;
+    });
   }
-};
-
-Template.test.test_time_display = function() {
-  var time = _testTime(this);
-  return (typeof time === "number") ? time + " ms" : "";
-};
-
-Template.test.test_class = function() {
-  var events = this.events || [];
-  var classes = [_testStatus(this)];
-
-  if (this.expanded) {
-    classes.push("expanded");
-  } else {
-    classes.push("collapsed");
-  }
-
-  return classes.join(' ');
-};
+});
 
 Template.test.events({
-  'click .testname': function() {
+  'click .testname': function () {
     this.expanded = ! this.expanded;
     this.dep.changed();
   }
 });
 
-Template.test.eventsArray = function() {
-  var events = _.filter(this.events, function(e) {
-    return e.type != "finish";
-  });
-
-  var partitionBy = function(seq, func) {
-    var result = [];
-    var lastValue = {};
-    _.each(seq, function(x) {
-      var newValue = func(x);
-      if (newValue === lastValue) {
-        result[result.length-1].push(x);
-      } else {
-        lastValue = newValue;
-        result.push([x]);
-      }
-    });
-    return result;
-  };
-
-  var dupLists = partitionBy(
-    _.map(events, function(e) {
-      // XXX XXX We need something better than stringify!
-      // stringify([undefined]) === "[null]"
-      e = _.clone(e);
-      delete e.sequence;
-      return {obj: e, str: JSON.stringify(e)};
-    }), function(x) { return x.str; });
-
-  return _.map(dupLists, function(L) {
-    var obj = L[0].obj;
-    return (L.length > 1) ? _.extend({times: L.length}, obj) : obj;
-  });
-};
-
 
 //// Template - event
 
@@ -481,6 +483,7 @@ Template.event.helpers({
       details = _.clone(details);
       delete details.type;
       delete details.stack;
+
       var prepare = function(details) {
         if (type === 'string_equal') {
           var diff = doDiff(details.actual,
@@ -494,20 +497,20 @@ Template.event.helpers({
           if (type === 'string_equal' &&
               (key === 'actual' || key === 'expected')) {
             var html = '<pre class="string_equal string_equal_'+key+'">';
-          _.each(diff, function (piece) {
-            var which = piece[0];
-            var text = piece[1];
-            if (which === 0 ||
-                which === (key === 'actual' ? -1 : 1)) {
-              var htmlBit = Handlebars._escape(text).replace(
-                /\n/g, '<br>');
-              if (which !== 0)
-                htmlBit = '<ins>' + htmlBit + '</ins>';
-              html += htmlBit;
-            }
-          });
-          html += '</pre>';
-          val = new Handlebars.SafeString(html);
+            _.each(diff, function (piece) {
+              var which = piece[0];
+              var text = piece[1];
+              if (which === 0 ||
+                  which === (key === 'actual' ? -1 : 1)) {
+                var htmlBit = UI._escape(text).replace(
+                    /\n/g, '<br>');
+                if (which !== 0)
+                  htmlBit = '<ins>' + htmlBit + '</ins>';
+                html += htmlBit;
+              }
+            });
+            html += '</pre>';
+            val = new Spacebars.SafeString(html);
           }
 
           // You can end up with a an undefined value, e.g. using
@@ -530,9 +533,9 @@ Template.event.helpers({
         details: prepare(details)
       };
     }
+  },
+
+  is_debuggable: function() {
+    return !!this.cookie;
   }
 });
-
-Template.event.is_debuggable = function() {
-  return !!this.cookie;
-};
diff --git a/packages/test-in-browser/package.js b/packages/test-in-browser/package.js
index 72240629de..4e92e55318 100644
--- a/packages/test-in-browser/package.js
+++ b/packages/test-in-browser/package.js
@@ -5,7 +5,6 @@ Package.describe({
 });
 
 Package.on_use(function (api) {
-
   // XXX this should go away, and there should be a clean interface
   // that tinytest and the driver both implement?
   api.use('tinytest');
@@ -15,7 +14,10 @@ Package.on_use(function (api) {
   api.use('session');
   api.use('reload');
 
-  api.use(['spark', 'livedata', 'templating', 'deps'], 'client');
+  api.use(['ui', 'templating', 'spacebars',
+           'livedata', 'deps'], 'client');
+
+  api.add_files('diff_match_patch_uncompressed.js', 'client');
 
   api.add_files('diff_match_patch_uncompressed.js', 'client');
 
diff --git a/packages/tinytest/tinytest.js b/packages/tinytest/tinytest.js
index 3e937fbec6..21498996a6 100644
--- a/packages/tinytest/tinytest.js
+++ b/packages/tinytest/tinytest.js
@@ -11,6 +11,7 @@ TestCaseResults = function (test_case, onEvent, onException, stop_at_offset) {
   self.stop_at_offset = stop_at_offset;
   self.onException = onException;
   self.id = Random.id();
+  self.extraDetails = {};
 };
 
 _.extend(TestCaseResults.prototype, {
@@ -41,6 +42,8 @@ _.extend(TestCaseResults.prototype, {
       doc = { type: "fail", message: doc };
     }
 
+    doc = _.extend({}, doc, self.extraDetails);
+
     if (self.stop_at_offset === 0) {
       if (Meteor.isClient) {
         // Only supported on the browser for now..
@@ -168,16 +171,23 @@ _.extend(TestCaseResults.prototype, {
                  actual: actual, regexp: regexp.toString()});
   },
 
-  // XXX nodejs assert.throws can take an expected error, as a class,
-  // regular expression, or predicate function.  However, with its
-  // implementation if a constructor (class) is passed in and `actual`
-  // fails the instanceof test, the constructor is then treated as
-  // a predicate and called with `actual` (!)
-  //
   // expected can be:
   //  undefined: accept any exception.
-  //  regexp: accept an exception with message passing the regexp.
+  //  string: pass if the string is a substring of the exception message.
+  //  regexp: pass if the exception message passes the regexp.
   //  function: call the function as a predicate with the exception.
+  //
+  // Note: Node's assert.throws also accepts a constructor to test
+  // whether the error is of the expected class.  But since
+  // JavaScript can't distinguish between constructors and plain
+  // functions and Node's assert.throws also accepts a predicate
+  // function, if the error fails the instanceof test with the
+  // constructor then the constructor is then treated as a predicate
+  // and called (!)
+  //
+  // The upshot is, if you want to test whether an error is of a
+  // particular class, use a predicate function.
+  //
   throws: function (f, expected) {
     var actual, predicate;
 
@@ -185,6 +195,11 @@ _.extend(TestCaseResults.prototype, {
       predicate = function (actual) {
         return true;
       };
+    else if (_.isString(expected))
+      predicate = function (actual) {
+        return _.isString(actual.message) &&
+               actual.message.indexOf(expected) !== -1;
+      };
     else if (expected instanceof RegExp)
       predicate = function (actual) {
         return expected.test(actual.message)
@@ -192,7 +207,7 @@ _.extend(TestCaseResults.prototype, {
     else if (typeof expected === 'function')
       predicate = expected;
     else
-      throw new Error('expected should be a predicate function or regexp');
+      throw new Error('expected should be a string, regexp, or predicate function');
 
     try {
       f();
@@ -201,9 +216,14 @@ _.extend(TestCaseResults.prototype, {
     }
 
     if (actual && predicate(actual))
-      this.ok({message: actual.message});
+      this.ok();
     else
-      this.fail({type: "throws"});
+      this.fail({
+        type: "throws",
+        message: actual ?
+          "wrong error thrown: " + actual.message :
+          "did not throw an error as expected"
+      });
   },
 
   isTrue: function (v, msg) {
diff --git a/packages/twitter/twitter_client.js b/packages/twitter/twitter_client.js
index c8ca6fd44e..8ff7fa6138 100644
--- a/packages/twitter/twitter_client.js
+++ b/packages/twitter/twitter_client.js
@@ -14,26 +14,22 @@ Twitter.requestCredential = function (options, credentialRequestCompleteCallback
 
   var config = ServiceConfiguration.configurations.findOne({service: 'twitter'});
   if (!config) {
-    credentialRequestCompleteCallback && credentialRequestCompleteCallback(new ServiceConfiguration.ConfigError("Service not configured"));
+    credentialRequestCompleteCallback && credentialRequestCompleteCallback(
+      new ServiceConfiguration.ConfigError());
     return;
   }
 
-  var credentialToken = Random.id();
+  var credentialToken = Random.secret();
   // We need to keep credentialToken across the next two 'steps' so we're adding
   // a credentialToken parameter to the url and the callback url that we'll be returned
   // to by oauth provider
 
-  // url back to app, enters "step 2" as described in
-  // packages/accounts-oauth1-helper/oauth1_server.js
-  var callbackUrl = Meteor.absoluteUrl('_oauth/twitter?close&state=' + credentialToken);
-
   // url to app, enters "step 1" as described in
   // packages/accounts-oauth1-helper/oauth1_server.js
-  var loginUrl = '/_oauth/twitter/?requestTokenAndRedirect='
-        + encodeURIComponent(callbackUrl)
+  var loginUrl = '/_oauth/twitter/?requestTokenAndRedirect=true'
         + '&state=' + credentialToken;
 
-  Oauth.showPopup(
+  OAuth.showPopup(
     loginUrl,
     _.bind(credentialRequestCompleteCallback, null, credentialToken)
   );
diff --git a/packages/twitter/twitter_configure.html b/packages/twitter/twitter_configure.html
index 67195547db..32820e4505 100644
--- a/packages/twitter/twitter_configure.html
+++ b/packages/twitter/twitter_configure.html
@@ -9,5 +9,15 @@
     <li>
       Set Callback URL to: <span class="url">{{siteUrl}}_oauth/twitter?close</span>
     </li>
+    <li>
+      Select "Create your Twitter application".
+    </li>
+    <li>
+      On the Settings tab, enable "Allow this application to be used to Sign in with Twitter" and click
+      "Update settings".
+    </li>
+    <li>
+      Switch to the API Keys tab.
+    </li>
   </ol>
 </template>
diff --git a/packages/twitter/twitter_configure.js b/packages/twitter/twitter_configure.js
index e41329cbde..c40ca0808d 100644
--- a/packages/twitter/twitter_configure.js
+++ b/packages/twitter/twitter_configure.js
@@ -5,7 +5,7 @@ Template.configureLoginServiceDialogForTwitter.siteUrl = function () {
 
 Template.configureLoginServiceDialogForTwitter.fields = function () {
   return [
-    {property: 'consumerKey', label: 'Consumer key'},
-    {property: 'secret', label: 'Consumer secret'}
+    {property: 'consumerKey', label: 'API key'},
+    {property: 'secret', label: 'API secret'}
   ];
-};
\ No newline at end of file
+};
diff --git a/packages/twitter/twitter_server.js b/packages/twitter/twitter_server.js
index ce05ea0119..f7b6c0dcb0 100644
--- a/packages/twitter/twitter_server.js
+++ b/packages/twitter/twitter_server.js
@@ -11,14 +11,14 @@ var urls = {
 // https://dev.twitter.com/docs/api/1.1/get/account/verify_credentials
 Twitter.whitelistedFields = ['profile_image_url', 'profile_image_url_https', 'lang'];
 
-Oauth.registerService('twitter', 1, urls, function(oauthBinding) {
+OAuth.registerService('twitter', 1, urls, function(oauthBinding) {
   var identity = oauthBinding.get('https://api.twitter.com/1.1/account/verify_credentials.json').data;
 
   var serviceData = {
     id: identity.id_str,
     screenName: identity.screen_name,
-    accessToken: oauthBinding.accessToken,
-    accessTokenSecret: oauthBinding.accessTokenSecret
+    accessToken: OAuth.sealSecret(oauthBinding.accessToken),
+    accessTokenSecret: OAuth.sealSecret(oauthBinding.accessTokenSecret)
   };
 
   // include helpful fields from twitter
@@ -37,5 +37,5 @@ Oauth.registerService('twitter', 1, urls, function(oauthBinding) {
 
 
 Twitter.retrieveCredential = function(credentialToken) {
-  return Oauth.retrieveCredential(credentialToken);
+  return OAuth.retrieveCredential(credentialToken);
 };
diff --git a/packages/ui/.gitignore b/packages/ui/.gitignore
new file mode 100644
index 0000000000..677a6fc263
--- /dev/null
+++ b/packages/ui/.gitignore
@@ -0,0 +1 @@
+.build*
diff --git a/packages/ui/README-old.md b/packages/ui/README-old.md
new file mode 100644
index 0000000000..8e44afe656
--- /dev/null
+++ b/packages/ui/README-old.md
@@ -0,0 +1,87 @@
+# Meteor UI
+
+XXX This README just talks about DomRange, and the information is out of date or may change before release.
+
+## DomRange
+
+- - -
+**What users need to know:** DomRange is the type of object found at `component.dom` (sometimes `this.dom`).  It provides useful methods like `dom.$(selector)` and `dom.elements()`.  A DomRange represents the DOM extent of a rendered component, sort of like virtual wrapper element.
+- - -
+
+A DomRange can be conceptualized as an invisible element in the DOM tree which sits under some parent element and contains some of the element's children as members.  There's one DomRange for every template, component, or block helper in a Meteor application.  The members of a DomRange may be either nodes or other DomRanges, forming a miniature tree.  Since all the nodes in a DomRange tree are siblings in the DOM, this miniature tree occurs entirely at one DOM tree level.
+
+For example, take the following template code:
+
+```
+<template name="posts">
+  {{#each posts}}
+    {{#if recent}}
+      <div class="post-wrapper">
+        {{> post}}
+      </div>
+    {{/if}}
+  {{/each}}
+</template>
+```
+
+Surrounding the `post-wrapper` div elements is a DomRange tree at least three levels deep, containing DomRanges for the `template`, `each`, and `if`s.  Additionally, there is a DomRange inside each div that encloses the `post` template, but because this DomRange occurs at a different level of the DOM, it doesn't interact with the others.
+
+Compared to a real DOM element, a DomRange holds few pointers to other nodes and makes few assumptions about its members.  Member elements may be removed or re-ordered without notifying the DomRange (leading to, at worst, fewer ordering guarantees from future operations).  Essentially, a DomRange holds an unordered set of member pointers which are weak, bidirectional, and optionally labeled with names.  There are no pointers across levels of the DOM.
+
+Meteor UI uses DomRange for all manipulation of DOM structures, and user hooks allow these operations to be customized at a fine level for the sake of animated transitions.  Constructs like `#each` call DomRange's high-level member operations like add, move, and remove, which in turn call low-level DOM operations that can be customized to suit the context (for example, a container element all of whose children should be animated in and out).
+
+DomRanges also provide a range of other core Meteor UI functionality such as:
+
+* Detection of removed nodes
+* Event binding
+* Containment and selector testing
+
+A helper library such as jQuery provides DOM compatibility shimming and API expansion (adding features to selectors and event objects, for example).  A common interface connects DomRange to "DOM backends" like jQuery or Zepto.  Each backend requires an adaptor library which adapts names and semantics to fit DomRange's requirements.
+
+DomRange attaches a `.$ui` property to DOM elements that makes it easy to get from an element to its immediately enclosing range.  Going in the other direction is as easy as `range.elements()`.
+
+Given that components, not ranges, are likely to be of the most interest to the application, DomRange is designed to hang off a *host object* in a property called `.dom`.  Thus, following pointers from a DomRange to other ranges, or following `.$ui` from an element, goes to the host object if there is one, not the DomRange itself.  In this way, DomRange interoperates with components while knowing only that they have a `.dom` property.
+
+### Host Objects
+
+When a DomRange is created, an object called the "host" or "component" can be supplied, and this object is used in arguments and return values of DomRange methods instead of the DomRange itself.  This lets you treat a DomRange as having components as members.  For example, `myComponent.dom.get("foo")` will be a component, not a DomRange, and `myElement.$ui` will also be a component even though DomRange itself uses this pointer to find the DomRange that owns an element.
+
+The only thing DomRange knows about components is that they are host objects for DomRanges.
+
+### Methods
+
+In the following method signatures, a "component" is a DomRange host object.  A "member" is a component or DOM node.
+
+`new DomRange([component])`
+
+Creates an empty DomRange in an offscreen document fragment.  If `component` is provided, it is used as the host of the new DomRange, and `component.dom` is set to the new DomRange.  Otherwise, the new DomRange serves as its own host and receives a `dom` property pointing to itself.
+
+.......
+
+### Representation
+
+DomRange is not a tight abstraction over the DOM, it's more of a tool or machine, so it's helpful to understand how it operates before using it.  Meteor application developers do *not* need to know this level of detail unless they are doing a fair amount of custom DOM manipulation.
+
+DomRange uses two empty text nodes as `start` and `end` markers.  (In IE 8, they must be comment nodes.)  Empty text nodes are allowed in a wide variety of DOM positions and do not affect how the DOM is displayed by the browser.  In addition, text nodes are largely ignored by libraries like jQuery and inspectors like Chrome Dev Tools.  We expect that even if a DomRange's member elements (and member elements of its descendants) are arbitrarily moved or removed without the DomRange's knowledge, the start/end markers will still be present, though their locations may carry little meaning.  (It's also possible the markers will be removed completely, for example if innerHTML is set on the parent element.)
+
+Because a DomRange points to all its members, the start/end markers are not needed to traverse the contents of a DomRange or define which nodes it contains.  However, accurate markers are needed for DomRange methods that add or move members relative to other members, and the markers will always be accurate in the absence of foreign DOM manipulation (like elements being added, moved, or removed by jQuery).  An operation called **refresh** repositions a DomRange's start/end markers based on the positions of its members.  A DomRange is refreshed automatically at certain times when its nodes are required to be consecutive or accurate markers are important.  In some cases where nodes are reordered outside of DomRange, a manual call to refresh may be necessary as well.
+
+#### Details of Refresh
+
+Refreshing a DomRange generally causes it to "follow" its elements.  For example, if DomRange A contains B, which contains C, which contains a div, the initial, clean DOM will have three start markers, then the div, then three end markers.  If the div is moved to a different position (under the same parent node), refreshing A will cause all three start markers and all three end markers to snap into place around the relocated div.
+
+An automatic refresh happens:
+
+* When a range is removed
+* When a range is moved (by its owner range)
+* When a range is inserted into the document for the first time
+* When a range's start marker is needed to determine the position of an added or moved sibling member
+
+An automatic refresh does *not* happen when adding or moving a member to the end of a range, even though the end marker is used.  We don't want to refresh an entire list just to add a member to the end.  This means that if you have a DomRange with labeled members (e.g. an "each") and you perform foreign DOM manipulation that may make the end marker inaccurate (e.g. by moving elements to the end of the parent element), you should manually refresh the DomRange after doing the manipulation.
+
+The refresh algorithm is as follows:
+
+* Recursively refresh all member ranges
+* Find the first and last node that is either a member node (but not a text node with only whitespace) or a marker of a member range
+* Move the start and end markers to just before the first such node and just after the last such node
+* Nodes found between members that don't belong to any DomRange may be "adopted" and made members.  This allows foreign-inserted nodes to be moved or removed along with their surroundings.
diff --git a/packages/ui/attrs.js b/packages/ui/attrs.js
new file mode 100644
index 0000000000..7961c60337
--- /dev/null
+++ b/packages/ui/attrs.js
@@ -0,0 +1,327 @@
+
+// An AttributeHandler object is responsible for updating a particular attribute
+// of a particular element.  AttributeHandler subclasses implement
+// browser-specific logic for dealing with particular attributes across
+// different browsers.
+//
+// To define a new type of AttributeHandler, use
+// `var FooHandler = AttributeHandler.extend({ update: function ... })`
+// where the `update` function takes arguments `(element, oldValue, value)`.
+// The `element` argument is always the same between calls to `update` on
+// the same instance.  `oldValue` and `value` are each either `null` or
+// a Unicode string of the type that might be passed to the value argument
+// of `setAttribute` (i.e. not an HTML string with character references).
+// When an AttributeHandler is installed, an initial call to `update` is
+// always made with `oldValue = null`.  The `update` method can access
+// `this.name` if the AttributeHandler class is a generic one that applies
+// to multiple attribute names.
+//
+// AttributeHandlers can store custom properties on `this`, as long as they
+// don't use the names `element`, `name`, `value`, and `oldValue`.
+//
+// AttributeHandlers can't influence how attributes appear in rendered HTML,
+// only how they are updated after materialization as DOM.
+
+AttributeHandler = function (name, value) {
+  this.name = name;
+  this.value = value;
+};
+
+AttributeHandler.prototype.update = function (element, oldValue, value) {
+  if (value === null) {
+    if (oldValue !== null)
+      element.removeAttribute(this.name);
+  } else {
+    element.setAttribute(this.name, value);
+  }
+};
+
+AttributeHandler.extend = function (options) {
+  var curType = this;
+  var subType = function AttributeHandlerSubtype(/*arguments*/) {
+    AttributeHandler.apply(this, arguments);
+  };
+  subType.prototype = new curType;
+  subType.extend = curType.extend;
+  if (options)
+    _.extend(subType.prototype, options);
+  return subType;
+};
+
+// Extended below to support both regular and SVG elements
+var BaseClassHandler = AttributeHandler.extend({
+  update: function (element, oldValue, value) {
+    if (!this.getCurrentValue || !this.setValue)
+      throw new Error("Missing methods in subclass of 'BaseClassHandler'");
+
+    var oldClasses = oldValue ? _.compact(oldValue.split(' ')) : [];
+    var newClasses = value ? _.compact(value.split(' ')) : [];
+
+    // the current classes on the element, which we will mutate.
+    var classes = _.compact(this.getCurrentValue(element).split(' '));
+
+    // optimize this later (to be asymptotically faster) if necessary
+    for (var i = 0; i < oldClasses.length; i++) {
+      var c = oldClasses[i];
+      if (! _.contains(newClasses, c))
+        classes = _.without(classes, c);
+    }
+    for (var i = 0; i < newClasses.length; i++) {
+      var c = newClasses[i];
+      if ((! _.contains(oldClasses, c)) &&
+          (! _.contains(classes, c)))
+        classes.push(c);
+    }
+
+    this.setValue(element, classes.join(' '));
+  }
+});
+
+var ClassHandler = BaseClassHandler.extend({
+  // @param rawValue {String}
+  getCurrentValue: function (element) {
+    return element.className;
+  },
+  setValue: function (element, className) {
+    element.className = className;
+  }
+});
+
+var SVGClassHandler = BaseClassHandler.extend({
+  getCurrentValue: function (element) {
+    return element.className.baseVal;
+  },
+  setValue: function (element, className) {
+    element.setAttribute('class', className);
+  }
+});
+
+var BooleanHandler = AttributeHandler.extend({
+  update: function (element, oldValue, value) {
+    var focused = this.focused(element);
+
+    if (!focused) {
+      var name = this.name;
+      if (value == null) {
+        if (oldValue != null)
+          element[name] = false;
+      } else {
+        element[name] = true;
+      }
+    }
+  },
+  // is the element part of a control which is focused?
+  focused: function (element) {
+    if (element.tagName === 'INPUT') {
+      return element === document.activeElement;
+
+    } else if (element.tagName === 'OPTION') {
+      // find the containing SELECT element, on which focus
+      // is actually set
+      var selectEl = element;
+      while (selectEl && selectEl.tagName !== 'SELECT')
+        selectEl = selectEl.parentNode;
+
+      if (selectEl)
+        return selectEl === document.activeElement;
+      else
+        return false;
+    } else {
+      throw new Error("Expected INPUT or OPTION element");
+    }
+  }
+});
+
+var ValueHandler = AttributeHandler.extend({
+  update: function (element, oldValue, value) {
+    var focused = (element === document.activeElement);
+
+    if (!focused)
+      element.value = value;
+  }
+});
+
+// attributes of the type 'xlink:something' should be set using
+// the correct namespace in order to work
+var XlinkHandler = AttributeHandler.extend({
+  update: function(element, oldValue, value) {
+    var NS = 'http://www.w3.org/1999/xlink';
+    if (value === null) {
+      if (oldValue !== null)
+        element.removeAttributeNS(NS, this.name);
+    } else {
+      element.setAttributeNS(NS, this.name, this.value);
+    }
+  }
+});
+
+// cross-browser version of `instanceof SVGElement`
+var isSVGElement = function (elem) {
+  return 'ownerSVGElement' in elem;
+};
+
+var isUrlAttribute = function (tagName, attrName) {
+  // Compiled from http://www.w3.org/TR/REC-html40/index/attributes.html
+  // and
+  // http://www.w3.org/html/wg/drafts/html/master/index.html#attributes-1
+  var urlAttrs = {
+    FORM: ['action'],
+    BODY: ['background'],
+    BLOCKQUOTE: ['cite'],
+    Q: ['cite'],
+    DEL: ['cite'],
+    INS: ['cite'],
+    OBJECT: ['classid', 'codebase', 'data', 'usemap'],
+    APPLET: ['codebase'],
+    A: ['href'],
+    AREA: ['href'],
+    LINK: ['href'],
+    BASE: ['href'],
+    IMG: ['longdesc', 'src', 'usemap'],
+    FRAME: ['longdesc', 'src'],
+    IFRAME: ['longdesc', 'src'],
+    HEAD: ['profile'],
+    SCRIPT: ['src'],
+    INPUT: ['src', 'usemap', 'formaction'],
+    BUTTON: ['formaction'],
+    BASE: ['href'],
+    MENUITEM: ['icon'],
+    HTML: ['manifest'],
+    VIDEO: ['poster']
+  };
+
+  if (attrName === 'itemid') {
+    return true;
+  }
+
+  var urlAttrNames = urlAttrs[tagName] || [];
+  return _.contains(urlAttrNames, attrName);
+};
+
+// To get the protocol for a URL, we let the browser normalize it for
+// us, by setting it as the href for an anchor tag and then reading out
+// the 'protocol' property.
+if (Meteor.isClient) {
+  var anchorForNormalization = document.createElement('A');
+}
+
+var normalizeUrl = function (url) {
+  if (Meteor.isClient) {
+    anchorForNormalization.href = url;
+    return anchorForNormalization.href;
+  } else {
+    throw new Error('normalizeUrl not implemented on the server');
+  }
+};
+
+// UrlHandler is an attribute handler for all HTML attributes that take
+// URL values. It disallows javascript: URLs, unless
+// UI._allowJavascriptUrls() has been called. To detect javascript:
+// urls, we set the attribute and then reads the attribute out of the
+// DOM, in order to avoid writing our own URL normalization code. (We
+// don't want to be fooled by ' javascript:alert(1)' or
+// 'jAvAsCrIpT:alert(1)'.) In future, when the URL interface is more
+// widely supported, we can use that, which will be
+// cleaner.  https://developer.mozilla.org/en-US/docs/Web/API/URL
+var origUpdate = AttributeHandler.prototype.update;
+var UrlHandler = AttributeHandler.extend({
+  update: function (element, oldValue, value) {
+    var self = this;
+    var args = arguments;
+
+    if (UI._javascriptUrlsAllowed()) {
+      origUpdate.apply(self, args);
+    } else {
+      var isJavascriptProtocol =
+            (normalizeUrl(value).indexOf('javascript:') === 0);
+      if (isJavascriptProtocol) {
+        Meteor._debug("javascript: URLs are not allowed. " +
+                      "Use UI._allowJavascriptUrls() to enable them.");
+        origUpdate.apply(self, [element, oldValue, null]);
+      } else {
+        origUpdate.apply(self, args);
+      }
+    }
+  }
+});
+
+// XXX make it possible for users to register attribute handlers!
+makeAttributeHandler = function (elem, name, value) {
+  // generally, use setAttribute but certain attributes need to be set
+  // by directly setting a JavaScript property on the DOM element.
+  if (name === 'class') {
+    if (isSVGElement(elem)) {
+      return new SVGClassHandler(name, value);
+    } else {
+      return new ClassHandler(name, value);
+    }
+  } else if ((elem.tagName === 'OPTION' && name === 'selected') ||
+             (elem.tagName === 'INPUT' && name === 'checked')) {
+    return new BooleanHandler(name, value);
+  } else if ((elem.tagName === 'TEXTAREA' || elem.tagName === 'INPUT')
+             && name === 'value') {
+    // internally, TEXTAREAs tracks their value in the 'value'
+    // attribute just like INPUTs.
+    return new ValueHandler(name, value);
+  } else if (name.substring(0,6) === 'xlink:') {
+    return new XlinkHandler(name.substring(6), value);
+  } else if (isUrlAttribute(elem.tagName, name)) {
+    return new UrlHandler(name, value);
+  } else {
+    return new AttributeHandler(name, value);
+  }
+
+  // XXX will need one for 'style' on IE, though modern browsers
+  // seem to handle setAttribute ok.
+};
+
+
+ElementAttributesUpdater = function (elem) {
+  this.elem = elem;
+  this.handlers = {};
+};
+
+// Update attributes on `elem` to the dictionary `attrs`, whose
+// values are strings.
+ElementAttributesUpdater.prototype.update = function(newAttrs) {
+  var elem = this.elem;
+  var handlers = this.handlers;
+
+  for (var k in handlers) {
+    if (! newAttrs.hasOwnProperty(k)) {
+      // remove attributes (and handlers) for attribute names
+      // that don't exist as keys of `newAttrs` and so won't
+      // be visited when traversing it.  (Attributes that
+      // exist in the `newAttrs` object but are `null`
+      // are handled later.)
+      var handler = handlers[k];
+      var oldValue = handler.value;
+      handler.value = null;
+      handler.update(elem, oldValue, null);
+      delete handlers[k];
+    }
+  }
+
+  for (var k in newAttrs) {
+    var handler = null;
+    var oldValue;
+    var value = newAttrs[k];
+    if (! handlers.hasOwnProperty(k)) {
+      if (value !== null) {
+        // make new handler
+        handler = makeAttributeHandler(elem, k, value);
+        handlers[k] = handler;
+        oldValue = null;
+      }
+    } else {
+      handler = handlers[k];
+      oldValue = handler.value;
+    }
+    if (oldValue !== value) {
+      handler.value = value;
+      handler.update(elem, oldValue, value);
+      if (value === null)
+        delete handlers[k];
+    }
+  }
+};
diff --git a/packages/ui/base.js b/packages/ui/base.js
new file mode 100644
index 0000000000..4f4d3f0bea
--- /dev/null
+++ b/packages/ui/base.js
@@ -0,0 +1,354 @@
+UI = {};
+
+// A very basic operation like Underscore's `_.extend` that
+// copies `src`'s own, enumerable properties onto `tgt` and
+// returns `tgt`.
+_extend = function (tgt, src) {
+  for (var k in src)
+    if (src.hasOwnProperty(k))
+      tgt[k] = src[k];
+  return tgt;
+};
+
+// Defines a single non-enumerable, read-only property
+// on `tgt`.
+// It won't be non-enumerable in IE 8, so its
+// non-enumerability can't be relied on for logic
+// purposes, it just makes things prettier in
+// the dev console.
+var _defineNonEnum = function (tgt, name, value) {
+  try {
+    Object.defineProperty(tgt, name, {value: value});
+  } catch (e) {
+    // IE < 9
+    tgt[name] = value;
+  }
+  return tgt;
+};
+
+// Named function (like `function Component() {}` below) make
+// inspection in debuggers more descriptive. In IE, this sets the
+// value of the `Component` var in the function scope in which it's
+// executed. We already have a top-level `Component` var so we create
+// a new function scope to not write it over in IE.
+(function () {
+
+  // Components and Component kinds are the same thing, just
+  // objects; there are no constructor functions, no `new`,
+  // and no `instanceof`.  A Component object is like a class,
+  // until it is inited, at which point it becomes more like
+  // an instance.
+  //
+  // `y = x.extend({ ...new props })` creates a new Component
+  // `y` with `x` as its prototype, plus additional properties
+  // on `y` itself.  `extend` is used both to subclass and to
+  // create instances (and the hope is we can gloss over the
+  // difference in the docs).
+  UI.Component = (function (constr) {
+
+    // Make sure the "class name" that Chrome infers for
+    // UI.Component is "Component", and that
+    // `new UI.Component._constr` (which is what `extend`
+    // does) also produces objects whose inferred class
+    // name is "Component".  Chrome's name inference rules
+    // are a little mysterious, but a function name in
+    // the source code (as in `function Component() {}`)
+    // seems to be reliable and high precedence.
+    var C = new constr;
+    _defineNonEnum(C, '_constr', constr);
+    _defineNonEnum(C, '_super', null);
+    return C;
+  })(function Component() {});
+})();
+
+_extend(UI, {
+  nextGuid: 2, // Component is 1!
+
+  isComponent: function (obj) {
+    return obj && UI.isKindOf(obj, UI.Component);
+  },
+  // `UI.isKindOf(a, b)` where `a` and `b` are Components
+  // (or kinds) asks if `a` is or descends from
+  // (transitively extends) `b`.
+  isKindOf: function (a, b) {
+    while (a) {
+      if (a === b)
+        return true;
+      a = a._super;
+    }
+    return false;
+  },
+  // use these to produce error messages for developers
+  // (though throwing a more specific error message is
+  // even better)
+  _requireNotDestroyed: function (c) {
+    if (c.isDestroyed)
+      throw new Error("Component has been destroyed; can't perform this operation");
+  },
+  _requireInited: function (c) {
+    if (! c.isInited)
+      throw new Error("Component must be inited to perform this operation");
+  },
+  _requireDom: function (c) {
+    if (! c.dom)
+      throw new Error("Component must be built into DOM to perform this operation");
+  }
+});
+
+Component = UI.Component;
+
+_extend(UI.Component, {
+  kind: "Component",
+  guid: "1",
+  dom: null,
+  // Has this Component ever been inited?
+  isInited: false,
+  // Has this Component been destroyed?  Only inited Components
+  // can be destroyed.
+  isDestroyed: false,
+  // Component that created this component (typically also
+  // the DOM containment parent).
+  // No child pointers (except in `dom`).
+  parent: null,
+
+  // create a new subkind or instance whose proto pointer
+  // points to this, with additional props set.
+  extend: function (props) {
+    // this function should never cause `props` to be
+    // mutated in case people want to reuse `props` objects
+    // in a mixin-like way.
+
+    if (this.isInited)
+      // Disallow extending inited Components so that
+      // inited Components don't inherit instance-specific
+      // properties from other inited Components, just
+      // default values.
+      throw new Error("Can't extend an inited Component");
+
+    var constr;
+    var constrMade = false;
+    if (props && props.kind) {
+      // If `kind` is different from super, set a constructor.
+      // We used to set the function name here so that components
+      // printed better in the console, but we took it out because
+      // of CSP (and in hopes that Chrome finally adds proper
+      // displayName support).
+      constr = function () {};
+      constrMade = true;
+    } else {
+      constr = this._constr;
+    }
+
+    // We don't know where we're getting `constr` from --
+    // it might be from some supertype -- just that it has
+    // the right function name.  So set the `prototype`
+    // property each time we use it as a constructor.
+    constr.prototype = this;
+
+    var c = new constr;
+    if (constrMade)
+      c._constr = constr;
+
+    if (props)
+      _extend(c, props);
+
+    // for efficient Component instantiations, we assign
+    // as few things as possible here.
+    _defineNonEnum(c, '_super', this);
+    c.guid = String(UI.nextGuid++);
+
+    return c;
+  }
+});
+
+//callChainedCallback = function (comp, propName, orig) {
+  // Call `comp.foo`, `comp._super.foo`,
+  // `comp._super._super.foo`, and so on, but in reverse
+  // order, and only if `foo` is an "own property" in each
+  // case.  Furthermore, the passed value of `this` should
+  // remain `comp` for all calls (which is achieved by
+  // filling in `orig` when recursing).
+//  if (comp._super)
+//    callChainedCallback(comp._super, propName, orig || comp);
+//
+//  if (comp.hasOwnProperty(propName))
+//    comp[propName].call(orig || comp);
+//};
+
+
+// Returns 0 if the nodes are the same or either one contains the other;
+// otherwise, -1 if a comes before b, or else 1 if b comes before a in
+// document order.
+// Requires: `a` and `b` are element nodes in the same document tree.
+var compareElementIndex = function (a, b) {
+  // See http://ejohn.org/blog/comparing-document-position/
+  if (a === b)
+    return 0;
+  if (a.compareDocumentPosition) {
+    var n = a.compareDocumentPosition(b);
+    return ((n & 0x18) ? 0 : ((n & 0x4) ? -1 : 1));
+  } else {
+    // Only old IE is known to not have compareDocumentPosition (though Safari
+    // originally lacked it).  Thankfully, IE gives us a way of comparing elements
+    // via the "sourceIndex" property.
+    if (a.contains(b) || b.contains(a))
+      return 0;
+    return (a.sourceIndex < b.sourceIndex ? -1 : 1);
+  }
+};
+
+findComponentWithProp = function (id, comp) {
+  while (comp) {
+    if (typeof comp[id] !== 'undefined')
+      return comp;
+    comp = comp.parent;
+  }
+  return null;
+};
+
+findComponentWithHelper = function (id, comp) {
+  while (comp) {
+    if (comp.__helperHost) {
+      if (typeof comp[id] !== 'undefined')
+        return comp;
+      else
+        return null;
+    }
+    comp = comp.parent;
+  }
+  return null;
+};
+
+getComponentData = function (comp) {
+  comp = findComponentWithProp('data', comp);
+  return (comp ?
+          (typeof comp.data === 'function' ?
+           comp.data() : comp.data) :
+          null);
+};
+
+updateTemplateInstance = function (comp) {
+  // Populate `comp.templateInstance.{firstNode,lastNode,data}`
+  // on demand.
+  var tmpl = comp.templateInstance;
+  tmpl.data = getComponentData(comp);
+
+  if (comp.dom && !comp.isDestroyed) {
+    tmpl.firstNode = comp.dom.startNode().nextSibling;
+    tmpl.lastNode = comp.dom.endNode().previousSibling;
+    // Catch the case where the DomRange is empty and we'd
+    // otherwise pass the out-of-order nodes (end, start)
+    // as (firstNode, lastNode).
+    if (tmpl.lastNode && tmpl.lastNode.nextSibling === tmpl.firstNode)
+      tmpl.lastNode = tmpl.firstNode;
+  } else {
+    // on 'created' or 'destroyed' callbacks we don't have a DomRange
+    tmpl.firstNode = null;
+    tmpl.lastNode = null;
+  }
+};
+
+_extend(UI.Component, {
+  // We implement the old APIs here, including how data is passed
+  // to helpers in `this`.
+  helpers: function (dict) {
+    _extend(this, dict);
+  },
+  events: function (dict) {
+    var events;
+    if (this.hasOwnProperty('_events'))
+      events = this._events;
+    else
+      events = (this._events = []);
+
+    _.each(dict, function (handler, spec) {
+      var clauses = spec.split(/,\s+/);
+      // iterate over clauses of spec, e.g. ['click .foo', 'click .bar']
+      _.each(clauses, function (clause) {
+        var parts = clause.split(/\s+/);
+        if (parts.length === 0)
+          return;
+
+        var newEvents = parts.shift();
+        var selector = parts.join(' ');
+        events.push({events: newEvents,
+                     selector: selector,
+                     handler: handler});
+      });
+    });
+  }
+});
+
+// XXX we don't really want this to be a user-visible callback,
+// it's just a particular signal we need from DomRange.
+UI.Component.notifyParented = function () {
+  var self = this;
+  for (var comp = self; comp; comp = comp._super) {
+    var events = (comp.hasOwnProperty('_events') && comp._events) || null;
+    if ((! events) && comp.hasOwnProperty('events') &&
+        typeof comp.events === 'object') {
+      // Provide limited back-compat support for `.events = {...}`
+      // syntax.  Pass `comp.events` to the original `.events(...)`
+      // function.  This code must run only once per component, in
+      // order to not bind the handlers more than once, which is
+      // ensured by the fact that we only do this when `comp._events`
+      // is falsy, and we cause it to be set now.
+      UI.Component.events.call(comp, comp.events);
+      events = comp._events;
+    }
+    _.each(events, function (esh) { // {events, selector, handler}
+      // wrap the handler here, per instance of the template that
+      // declares the event map, so we can pass the instance to
+      // the event handler.
+      var wrappedHandler = function (event) {
+        var comp = UI.DomRange.getContainingComponent(event.currentTarget);
+        var data = comp && getComponentData(comp);
+        var args = _.toArray(arguments);
+        updateTemplateInstance(self);
+        return Deps.nonreactive(function () {
+          // put self.templateInstance as the second argument
+          args.splice(1, 0, self.templateInstance);
+          // Don't want to be in a deps context, even if we were somehow
+          // triggered synchronously in an existing deps context
+          // (the `blur` event can do this).
+          // XXX we should probably do what Spark did and block all
+          // event handling during our DOM manip.  Many apps had weird
+          // unanticipated bugs until we did that.
+          return esh.handler.apply(data === null ? {} : data, args);
+        });
+      };
+
+      self.dom.on(esh.events, esh.selector, wrappedHandler);
+    });
+  }
+
+  if (self.rendered) {
+    // Defer rendered callback until flush time.
+    Deps.afterFlush(function () {
+      if (! self.isDestroyed) {
+        updateTemplateInstance(self);
+        self.rendered.call(self.templateInstance);
+      }
+    });
+  }
+};
+
+// past compat
+UI.Component.preserve = function () {
+  Meteor._debug("The 'preserve' method on templates is now unnecessary and deprecated.");
+};
+
+// Gets the data context of the enclosing component that rendered a
+// given element
+UI.getElementData = function (el) {
+  var comp = UI.DomRange.getContainingComponent(el);
+  return comp && getComponentData(comp);
+};
+
+var jsUrlsAllowed = false;
+UI._allowJavascriptUrls = function () {
+  jsUrlsAllowed = true;
+};
+UI._javascriptUrlsAllowed = function () {
+  return jsUrlsAllowed;
+};
diff --git a/packages/ui/base_tests.js b/packages/ui/base_tests.js
new file mode 100644
index 0000000000..9965fc5944
--- /dev/null
+++ b/packages/ui/base_tests.js
@@ -0,0 +1,214 @@
+
+/*
+THESE TESTS ARE OUT OF DATE.
+
+TODO: WRITE TESTS AGAINST THE LATEST base.js
+
+Tinytest.add("ui - Component basics", function (test) {
+  var Foo = UI.Component.extend();
+  var Bar = Foo.extend({x: 1, y: 2});
+  var Baz = Bar.extend({y: 3, z: 4});
+
+  test.equal(typeof Foo.x, 'undefined');
+  test.equal(typeof Foo.y, 'undefined');
+  test.equal(typeof Foo.z, 'undefined');
+  test.equal(Bar.x, 1);
+  test.equal(Bar.y, 2);
+  test.equal(typeof Bar.z, 'undefined');
+  test.equal(Baz.x, 1);
+  test.equal(Baz.y, 3);
+  test.equal(Baz.z, 4);
+
+  // _super
+
+  test.equal(Foo._super, UI.Component);
+  test.equal(Bar._super, Foo);
+  test.equal(Baz._super, Bar);
+
+  // isa
+
+  test.isTrue(UI.isComponent(UI.Component));
+  test.isTrue(UI.isComponent(Foo));
+  test.isTrue(UI.isComponent(Bar));
+  test.isTrue(UI.isComponent(Baz));
+  test.isTrue(UI.Component.isa(UI.Component));
+  test.isFalse(UI.Component.isa(Foo));
+  test.isFalse(UI.Component.isa(Bar));
+  test.isFalse(UI.Component.isa(Baz));
+  test.isTrue(Foo.isa(UI.Component));
+  test.isTrue(Foo.isa(Foo));
+  test.isFalse(Foo.isa(Bar));
+  test.isFalse(Foo.isa(Baz));
+  test.isTrue(Bar.isa(UI.Component));
+  test.isTrue(Bar.isa(Foo));
+  test.isTrue(Bar.isa(Bar));
+  test.isFalse(Bar.isa(Baz));
+  test.isTrue(Baz.isa(UI.Component));
+  test.isTrue(Baz.isa(Foo));
+  test.isTrue(Baz.isa(Bar));
+  test.isTrue(Baz.isa(Baz));
+
+  test.isFalse(UI.isComponent({}));
+  test.isFalse(UI.isComponent(null));
+  test.isFalse(UI.isComponent());
+  test.isFalse(UI.isComponent(function () {}));
+  test.isFalse(Foo.isa({}));
+  test.isFalse(Foo.isa(null));
+  test.isFalse(Foo.isa());
+  test.isFalse(Foo.isa(function () {}));
+
+  // guid
+
+  var a = UI.Component.guid,
+      b = Foo.guid,
+      c = Bar.guid,
+      d = Baz.guid;
+
+  test.isTrue(a > 0);
+  test.isTrue(b > 0);
+  test.isTrue(c > 0);
+  test.isTrue(d > 0);
+  test.isTrue(a !== b);
+  test.isTrue(a !== c);
+  test.isTrue(a !== d);
+  test.isTrue(b !== c);
+  test.isTrue(b !== d);
+  test.isTrue(c !== d);
+});
+
+Tinytest.add("ui - Component init/destroy", function (test) {
+  var buf = [];
+
+  var x = UI.Component.extend({
+    init: function () {
+      test.isTrue(this.isInited);
+      test.isFalse(this.isAssembled);
+      test.isFalse(this.isDestroyed);
+      buf.push('init');
+    },
+    destroyed: function () {
+      test.isTrue(this.isInited);
+      test.isFalse(this.isAssembled);
+      test.isTrue(this.isDestroyed);
+      buf.push('destroyed');
+    }
+  });
+  test.isFalse(this.isInited);
+  test.isFalse(this.isAssembled);
+  test.isFalse(this.isDestroyed);
+  test.equal(buf, []);
+  x.makeRoot();
+  test.equal(buf, ['init']);
+  x.destroy();
+  test.equal(buf, ['init', 'destroyed']);
+
+  buf.length = 0;
+  x = UI.Component.extend({
+    init: function () { buf.push('init'); },
+    destroyed: function () { buf.push('destroyed'); }
+  });
+  test.throws(function () {
+    x.destroy();
+  });
+  x.makeRoot();
+  test.throws(function () {
+    x.makeRoot();
+  });
+  test.throws(function () {
+    var y = x.extend();
+  });
+  test.equal(buf, ['init']);
+  x.destroy();
+  x.destroy();
+  test.equal(buf, ['init', 'destroyed']);
+  test.throws(function () {
+    x.makeRoot();
+  });
+  test.throws(function () {
+    var y = x.extend();
+  });
+
+  buf.length = 0;
+  x = UI.Component.extend({
+    init: function () { buf.push('init'); },
+    destroyed: function () { buf.push('destroyed'); }
+  });
+  var y = x.extend({
+    init: function () { buf.push('init2'); },
+    destroyed: function () { buf.push('destroyed2'); }
+  });
+  test.equal(buf, []);
+  y.makeRoot();
+  test.equal(buf, ['init', 'init2']);
+  y.destroy();
+  test.equal(buf, ['init', 'init2', 'destroyed', 'destroyed2']);
+
+  buf.length = 0;
+  var z = x.extend();
+  z.makeRoot();
+  z.destroy();
+  test.equal(buf, ['init', 'destroyed']);
+});
+
+Tinytest.add("ui - Component add/remove", function (test) {
+  var x = UI.Component.extend();
+  var y = UI.Component.extend();
+
+  test.throws(function () {
+    x.add(y);
+  });
+
+  test.isFalse(x.isInited);
+  x.makeRoot();
+  test.isTrue(x.isInited);
+  test.isFalse(y.isInited);
+  test.isFalse(x.hasChild(y));
+  test.equal(_.keys(x.children), []);
+  test.equal(_.keys(y.children), []);
+
+  x.add(y);
+  test.isTrue(y.isInited);
+  test.equal(y.parent, x);
+  test.isTrue(x.hasChild(y));
+  test.isFalse(y.hasChild(x));
+  test.equal(_.keys(x.children), [String(y.guid)]);
+  test.equal(_.keys(y.children), []);
+  test.equal(x.children[y.guid], y);
+
+  var z = UI.Component.extend();
+  x.add(z);
+  test.isTrue(z.isInited);
+  test.equal(z.parent, x);
+  test.isTrue(x.hasChild(z));
+  test.isFalse(z.hasChild(x));
+  test.equal(_.keys(x.children).sort(),
+             [String(y.guid), String(z.guid)].sort());
+  test.equal(_.keys(z.children), []);
+  test.equal(x.children[z.guid], z);
+
+  x.remove(y);
+  z.remove();
+  test.isFalse(x.hasChild(y));
+  test.isFalse(x.hasChild(z));
+  test.equal(_.keys(x.children), []);
+  // children are destroyed
+  test.isTrue(y.isDestroyed);
+  test.isTrue(z.isDestroyed);
+  // parent pointers remain
+  test.equal(y.parent, x);
+  test.equal(z.parent, x);
+  test.throws(function () {
+    y.remove();
+  });
+  test.throws(function () {
+    z.remove();
+  });
+  test.throws(function () {
+    x.remove(y);
+  });
+  test.throws(function () {
+    x.remove(z);
+  });
+});
+
+*/
\ No newline at end of file
diff --git a/packages/ui/builtins.js b/packages/ui/builtins.js
new file mode 100644
index 0000000000..2ba0da6f48
--- /dev/null
+++ b/packages/ui/builtins.js
@@ -0,0 +1,126 @@
+
+UI.If = function (argFunc, contentBlock, elseContentBlock) {
+  checkBlockHelperArguments('If', argFunc, contentBlock, elseContentBlock);
+
+  var f = function () {
+    var emboxedCondition = emboxCondition(argFunc);
+    f.stop = function () {
+      emboxedCondition.stop();
+    };
+    if (emboxedCondition())
+      return contentBlock;
+    else
+      return elseContentBlock || null;
+  };
+
+  return f;
+};
+
+
+UI.Unless = function (argFunc, contentBlock, elseContentBlock) {
+  checkBlockHelperArguments('Unless', argFunc, contentBlock, elseContentBlock);
+
+  var f = function () {
+    var emboxedCondition = emboxCondition(argFunc);
+    f.stop = function () {
+      emboxedCondition.stop();
+    };
+    if (! emboxedCondition())
+      return contentBlock;
+    else
+      return elseContentBlock || null;
+  };
+
+  return f;
+};
+
+// Returns true if `a` and `b` are `===`, unless they are of a mutable type.
+// (Because then, they may be equal references to an object that was mutated,
+// and we'll never know.  We save only a reference to the old object; we don't
+// do any deep-copying or diffing.)
+UI.safeEquals = function (a, b) {
+  if (a !== b)
+    return false;
+  else
+    return ((!a) || (typeof a === 'number') || (typeof a === 'boolean') ||
+            (typeof a === 'string'));
+};
+
+// Unlike Spacebars.With, there's no else case and no conditional logic.
+//
+// We don't do any reactive emboxing of `argFunc` here; it should be done
+// by the caller if efficiency and/or number of calls to the data source
+// is important.
+UI.With = function (argFunc, contentBlock) {
+  checkBlockHelperArguments('With', argFunc, contentBlock);
+
+  var block = contentBlock;
+  if ('data' in block) {
+    // XXX TODO: get religion about where `data` property goes
+    block = UI.block(function () {
+      return contentBlock;
+    });
+  }
+
+  block.data = function () {
+    throw new Error("Can't get data for component kind");
+  };
+
+  block.init = function () {
+    this.data = UI.emboxValue(argFunc, UI.safeEquals);
+  };
+
+  block.materialized = function () {
+    var self = this;
+    if (Deps.active) {
+      Deps.onInvalidate(function () {
+        self.data.stop();
+      });
+    }
+  };
+  block.materialized.isWith = true;
+
+  return block;
+};
+
+UI.Each = function (argFunc, contentBlock, elseContentBlock) {
+  checkBlockHelperArguments('Each', argFunc, contentBlock, elseContentBlock);
+
+  return UI.EachImpl.extend({
+    __sequence: argFunc,
+    __content: contentBlock,
+    __elseContent: elseContentBlock
+  });
+};
+
+var checkBlockHelperArguments = function (which, argFunc, contentBlock, elseContentBlock) {
+  if (typeof argFunc !== 'function')
+    throw new Error('First argument to ' + which + ' must be a function');
+  if (! UI.isComponent(contentBlock))
+    throw new Error('Second argument to ' + which + ' must be a template or UI.block');
+  if (elseContentBlock && ! UI.isComponent(elseContentBlock))
+    throw new Error('Third argument to ' + which + ' must be a template or UI.block if present');
+};
+
+// Returns a function that computes `!! conditionFunc()` except:
+//
+// - Empty array is considered falsy
+// - The result is UI.emboxValue'd (doesn't trigger invalidation
+//   as long as the condition stays truthy or stays falsy)
+var emboxCondition = function (conditionFunc) {
+  return UI.namedEmboxValue('if/unless', function () {
+    // `condition` is emboxed; it is always a function,
+    // and it only triggers invalidation if its return
+    // value actually changes.  We still need to isolate
+    // the calculation of whether it is truthy or falsy
+    // in order to not re-render if it changes from one
+    // truthy or falsy value to another.
+    var cond = conditionFunc();
+
+    // empty arrays are treated as falsey values
+    if (cond instanceof Array && cond.length === 0)
+      return false;
+    else
+      return !! cond;
+  });
+};
diff --git a/packages/ui/dombackend.js b/packages/ui/dombackend.js
new file mode 100644
index 0000000000..637ccf6ab0
--- /dev/null
+++ b/packages/ui/dombackend.js
@@ -0,0 +1,139 @@
+if (Meteor.isClient) {
+
+  // XXX in the future, make the jQuery adapter a separate
+  // package and make the choice of back-end library
+  // configurable.  Adapters all expose the same DomBackend interface.
+
+  if (! Package.jquery)
+    throw new Error("Meteor UI jQuery adapter: jQuery not found.");
+
+  var $jq = Package.jquery.jQuery;
+
+  var DomBackend = {};
+  UI.DomBackend = DomBackend;
+
+  ///// Removal detection and interoperability.
+
+  // For an explanation of this technique, see:
+  // http://bugs.jquery.com/ticket/12213#comment:23 .
+  //
+  // In short, an element is considered "removed" when jQuery
+  // cleans up its *private* userdata on the element,
+  // which we can detect using a custom event with a teardown
+  // hook.
+
+  var JQUERY_REMOVAL_WATCHER_EVENT_NAME = 'meteor_ui_removal_watcher';
+  var REMOVAL_CALLBACKS_PROPERTY_NAME = '$meteor_ui_removal_callbacks';
+  var NOOP = function () {};
+
+  // Causes `elem` (a DOM element) to be detached from its parent, if any.
+  // Whether or not `elem` was detached, causes any callbacks registered
+  // with `onRemoveElement` on `elem` and its descendants to fire.
+  // Not for use on non-element nodes.
+  //
+  // This method is modeled after the behavior of jQuery's `$(elem).remove()`,
+  // which causes teardown on the subtree being removed.
+  DomBackend.removeElement = function (elem) {
+    $jq(elem).remove();
+  };
+
+  // Registers a callback function to be called when the given element or
+  // one of its ancestors is removed from the DOM via the backend library.
+  // The callback function is called at most once, and it receives the element
+  // in question as an argument.
+  DomBackend.onRemoveElement = function (elem, func) {
+    if (! elem[REMOVAL_CALLBACKS_PROPERTY_NAME]) {
+      elem[REMOVAL_CALLBACKS_PROPERTY_NAME] = [];
+
+      // Set up the event, only the first time.
+      $jq(elem).on(JQUERY_REMOVAL_WATCHER_EVENT_NAME, NOOP);
+    }
+
+    elem[REMOVAL_CALLBACKS_PROPERTY_NAME].push(func);
+  };
+
+  $jq.event.special[JQUERY_REMOVAL_WATCHER_EVENT_NAME] = {
+    teardown: function() {
+      var elem = this;
+      var callbacks = elem[REMOVAL_CALLBACKS_PROPERTY_NAME];
+      if (callbacks) {
+        for (var i = 0; i < callbacks.length; i++)
+          callbacks[i](elem);
+        elem[REMOVAL_CALLBACKS_PROPERTY_NAME] = null;
+      }
+    }
+  };
+
+  DomBackend.parseHTML = function (html) {
+    // Return an array of nodes.
+    //
+    // jQuery does fancy stuff like creating an appropriate
+    // container element and setting innerHTML on it, as well
+    // as working around various IE quirks.
+    return $jq.parseHTML(html) || [];
+  };
+
+  // Must use jQuery semantics for `context`, not
+  // querySelectorAll's.  In other words, all the parts
+  // of `selector` must be found under `context`.
+  DomBackend.findBySelector = function (selector, context) {
+    return $jq(selector, context);
+  };
+
+  DomBackend.newFragment = function (nodeArray) {
+    var frag = document.createDocumentFragment();
+    for (var i = 0; i < nodeArray.length; i++)
+      frag.appendChild(nodeArray[i]);
+    return frag;
+  };
+
+  // `selector` is non-null.  `type` is one type (but
+  // may be in backend-specific form, e.g. have namespaces).
+  // Order fired must be order bound.
+  DomBackend.delegateEvents = function (elem, type, selector, handler) {
+    $jq(elem).on(type, selector, handler);
+  };
+
+  DomBackend.undelegateEvents = function (elem, type, handler) {
+    $jq(elem).off(type, handler);
+  };
+
+  DomBackend.bindEventCapturer = function (elem, type, selector, handler) {
+    var $elem = $jq(elem);
+
+    var wrapper = function (event) {
+      event = $jq.event.fix(event);
+      event.currentTarget = event.target;
+
+      // Note: It might improve jQuery interop if we called into jQuery
+      // here somehow.  Since we don't use jQuery to dispatch the event,
+      // we don't fire any of jQuery's event hooks or anything.  However,
+      // since jQuery can't bind capturing handlers, it's not clear
+      // where we would hook in.  Internal jQuery functions like `dispatch`
+      // are too high-level.
+      var $target = $jq(event.currentTarget);
+      if ($target.is($elem.find(selector)))
+        handler.call(elem, event);
+    };
+
+    handler._meteorui_wrapper = wrapper;
+
+    type = this.parseEventType(type);
+    // add *capturing* event listener
+    elem.addEventListener(type, wrapper, true);
+  };
+
+  DomBackend.unbindEventCapturer = function (elem, type, handler) {
+    type = this.parseEventType(type);
+    elem.removeEventListener(type, handler._meteorui_wrapper, true);
+  };
+
+  DomBackend.parseEventType = function (type) {
+    // strip off namespaces
+    var dotLoc = type.indexOf('.');
+    if (dotLoc >= 0)
+      return type.slice(0, dotLoc);
+    return type;
+  };
+
+}
\ No newline at end of file
diff --git a/packages/ui/dombackend_tests.js b/packages/ui/dombackend_tests.js
new file mode 100644
index 0000000000..1b3583b192
--- /dev/null
+++ b/packages/ui/dombackend_tests.js
@@ -0,0 +1,123 @@
+
+var runDivSpanBTest = function (func) {
+  // Common code
+
+  var div = document.createElement("DIV");
+  var span = document.createElement("SPAN");
+  var b = document.createElement("B");
+  div.appendChild(span);
+  span.appendChild(b);
+
+  var buf = [];
+
+  var func1 = function (elem) { buf.push(elem.nodeName + "1"); };
+  var func2 = function (elem) { buf.push(elem.nodeName + "2"); };
+  var func3 = function (elem) { buf.push(elem.nodeName + "3"); };
+  var func4 = function (elem) { buf.push(elem.nodeName + "4"); };
+
+  func(div, span, b, buf, func1, func2, func3, func4);
+};
+
+var DomBackend =  UI.DomBackend;
+
+// Essentially test that the `node` argument has been removed from the
+// DOM. The caveat is that in IE8, calling `removeChild` leaves the
+// removed child with a document fragment parent, which itself has no
+// parent.
+var isDetachedSingleNode = function (test, node) {
+  if (!node.parentNode) {
+    test.ok();
+  } else {
+    test.equal(node.parentNode.nodeName, '#document-fragment');
+    test.equal(node.parentNode.childNodes.length, 1);
+    test.equal(node.parentNode.parentNode, null);
+  }
+};
+
+Tinytest.add("ui - DomBackend - element removal", function (test) {
+  // Test that calling removeElement on a detached element calls onRemoveElement
+  // on it and its descendents. For jQuery, `removeElement` runs `$(elem).remove()`,
+  // so it tests detecting a jQuery removal, as well as the stronger condition
+  // that clean-up still happens on the DOM tree in the detached case.
+  runDivSpanBTest(function (div, span, b, buf, func1, func2, func3, func4) {
+    DomBackend.onRemoveElement(div, func1);
+    DomBackend.onRemoveElement(span, func2);
+    DomBackend.onRemoveElement(b, func3);
+    // test second callback on same element
+    DomBackend.onRemoveElement(div, func4);
+
+    DomBackend.removeElement(div); // "remove" the (parentless) DIV
+
+    buf.sort();
+    test.equal(buf, ["B3", "DIV1", "DIV4", "SPAN2"]);
+
+    buf.length = 0;
+    DomBackend.removeElement(div);
+    test.equal(buf.length, 0);
+  });
+
+  // Test that `removeElement` actually removes the element
+  // (and fires appropriate callbacks).
+  runDivSpanBTest(function (div, span, b, buf, func1, func2, func3, func4) {
+    DomBackend.onRemoveElement(div, func1);
+    DomBackend.onRemoveElement(span, func2);
+    DomBackend.onRemoveElement(b, func3);
+    DomBackend.onRemoveElement(div, func4);
+
+    DomBackend.removeElement(span); // remove the SPAN
+
+    test.equal(div.childNodes.length, 0);
+    isDetachedSingleNode(test, span);
+
+    buf.sort();
+    test.equal(buf, ["B3", "SPAN2"]);
+
+    buf.length = 0;
+    DomBackend.removeElement(div); // remove the DIV
+    test.equal(buf, ["DIV1", "DIV4"]);
+  });
+
+});
+
+Tinytest.add("ui - DomBackend - element removal (jQuery)", function (test) {
+
+  // Test with `$(elem).remove()`.
+  runDivSpanBTest(function (div, span, b, buf, func1, func2, func3, func4) {
+    DomBackend.onRemoveElement(div, func1);
+    DomBackend.onRemoveElement(span, func2);
+    DomBackend.onRemoveElement(b, func3);
+    DomBackend.onRemoveElement(div, func4);
+
+    $(span).remove(); // remove the SPAN
+
+    test.equal(div.childNodes.length, 0);
+    isDetachedSingleNode(test, span);
+
+    buf.sort();
+    test.equal(buf, ["B3", "SPAN2"]);
+
+    buf.length = 0;
+    $(div).remove(); // "remove" the DIV
+    test.equal(buf, ["DIV1", "DIV4"]);
+  });
+
+  // Test that `$(elem).detach()` is NOT considered a removal.
+  runDivSpanBTest(function (div, span, b, buf, func1, func2, func3, func4) {
+    DomBackend.onRemoveElement(div, func1);
+    DomBackend.onRemoveElement(span, func2);
+    DomBackend.onRemoveElement(b, func3);
+    DomBackend.onRemoveElement(div, func4);
+
+    $(span).detach(); // detach the SPAN
+
+    test.equal(div.childNodes.length, 0);
+    isDetachedSingleNode(test, span);
+
+    test.equal(buf, []);
+
+    buf.length = 0;
+    $(div).detach(); // "detach" the DIV
+    test.equal(buf, []);
+  });
+
+});
diff --git a/packages/ui/domrange.js b/packages/ui/domrange.js
new file mode 100644
index 0000000000..cc0460cd41
--- /dev/null
+++ b/packages/ui/domrange.js
@@ -0,0 +1,1035 @@
+// TODO
+// - Lazy removal detection
+// - UI hooks (expose, test)
+// - Quick remove/add (mark "leaving" members; needs UI hooks)
+// - Event removal on removal
+
+var DomBackend = UI.DomBackend;
+
+var removeNode = function (n) {
+//  if (n.nodeType === 1 &&
+//      n.parentNode.$uihooks && n.parentNode.$uihooks.removeElement)
+//    n.parentNode.$uihooks.removeElement(n);
+//  else
+    n.parentNode.removeChild(n);
+};
+
+var insertNode = function (n, parent, next) {
+//  if (n.nodeType === 1 &&
+//      parent.$uihooks && parent.$uihooks.insertElement)
+//    parent.$uihooks.insertElement(n, parent, next);
+//  else
+    // `|| null` because IE throws an error if 'next' is undefined
+  parent.insertBefore(n, next || null);
+};
+
+var moveNode = function (n, parent, next) {
+//  if (n.nodeType === 1 &&
+//      parent.$uihooks && parent.$uihooks.moveElement)
+//    parent.$uihooks.moveElement(n, parent, next);
+//  else
+    // `|| null` because IE throws an error if 'next' is undefined
+    parent.insertBefore(n, next || null);
+};
+
+// A very basic operation like Underscore's `_.extend` that
+// copies `src`'s own, enumerable properties onto `tgt` and
+// returns `tgt`.
+var _extend = function (tgt, src) {
+  for (var k in src)
+    if (src.hasOwnProperty(k))
+      tgt[k] = src[k];
+  return tgt;
+};
+
+var _contains = function (list, item) {
+  if (! list)
+    return false;
+  for (var i = 0, N = list.length; i < N; i++)
+    if (list[i] === item)
+      return true;
+  return false;
+};
+
+var isArray = function (x) {
+  return !!((typeof x.length === 'number') &&
+            (x.sort || x.splice));
+};
+
+// Text nodes consisting of only whitespace
+// are "insignificant" nodes.
+var isSignificantNode = function (n) {
+  return ! (n.nodeType === 3 &&
+            (! n.nodeValue ||
+             /^\s+$/.test(n.nodeValue)));
+};
+
+var checkId = function (id) {
+  if (typeof id !== 'string')
+    throw new Error("id must be a string");
+  if (! id)
+    throw new Error("id may not be empty");
+};
+
+var textExpandosSupported = (function () {
+  var tn = document.createTextNode('');
+  try {
+    tn.blahblah = true;
+    return true;
+  } catch (e) {
+    // IE 8
+    return false;
+  }
+})();
+
+var createMarkerNode = (
+  textExpandosSupported ?
+    function () { return document.createTextNode(""); } :
+  function () { return document.createComment("IE"); });
+
+var rangeParented = function (range) {
+  if (! range.isParented) {
+    range.isParented = true;
+
+    if (! range.owner) {
+      // top-level (unowned) ranges in an element,
+      // keep a pointer to the range on the parent
+      // element.  This is really just for IE 9+
+      // TextNode GC issues, but we can't do reliable
+      // feature detection (i.e. bug detection).
+      var parentNode = range.parentNode();
+      var rangeDict = (
+        parentNode.$_uiranges ||
+          (parentNode.$_uiranges = {}));
+      rangeDict[range._rangeId] = range;
+      range._rangeDict = rangeDict;
+
+      // get jQuery to tell us when this node is removed
+      DomBackend.onRemoveElement(parentNode, function () {
+        rangeRemoved(range);
+      });
+    }
+
+    if (range.component && range.component.notifyParented)
+      range.component.notifyParented();
+
+    // recurse on member ranges
+    var members = range.members;
+    for (var k in members) {
+      var mem = members[k];
+      if (mem instanceof DomRange)
+        rangeParented(mem);
+    }
+  }
+};
+
+var rangeRemoved = function (range) {
+  if (! range.isRemoved) {
+    range.isRemoved = true;
+
+    if (range._rangeDict)
+      delete range._rangeDict[range._rangeId];
+
+    // XXX clean up events in $_uievents
+
+    // notify component of removal
+    if (range.removed)
+      range.removed();
+
+    membersRemoved(range);
+  }
+};
+
+var nodeRemoved = function (node, viaBackend) {
+  if (node.nodeType === 1) { // ELEMENT
+    var comps = DomRange.getComponents(node);
+    for (var i = 0, N = comps.length; i < N; i++)
+      rangeRemoved(comps[i]);
+
+    if (! viaBackend)
+      DomBackend.removeElement(node);
+  }
+};
+
+var membersRemoved = function (range) {
+  var members = range.members;
+  for (var k in members) {
+    var mem = members[k];
+    if (mem instanceof DomRange)
+      rangeRemoved(mem);
+    else
+      nodeRemoved(mem);
+  }
+};
+
+var nextGuid = 1;
+
+var DomRange = function () {
+  var start = createMarkerNode();
+  var end = createMarkerNode();
+  var fragment = DomBackend.newFragment([start, end]);
+  fragment.$_uiIsOffscreen = true;
+
+  this.start = start;
+  this.end = end;
+  start.$ui = this;
+  end.$ui = this;
+
+  this.members = {};
+  this.nextMemberId = 1;
+  this.owner = null;
+  this._rangeId = nextGuid++;
+  this._rangeDict = null;
+
+  this.isParented = false;
+  this.isRemoved = false;
+};
+
+_extend(DomRange.prototype, {
+  getNodes: function () {
+    if (! this.parentNode())
+      return [];
+
+    this.refresh();
+
+    var afterNode = this.end.nextSibling;
+    var nodes = [];
+    for (var n = this.start;
+         n && n !== afterNode;
+         n = n.nextSibling)
+      nodes.push(n);
+    return nodes;
+  },
+  removeAll: function () {
+    if (! this.parentNode())
+      return;
+
+    this.refresh();
+
+    // leave start and end
+    var afterNode = this.end;
+    var nodes = [];
+    for (var n = this.start.nextSibling;
+         n && n !== afterNode;
+         n = n.nextSibling) {
+      // don't remove yet since then we'd lose nextSibling
+      nodes.push(n);
+    }
+    for (var i = 0, N = nodes.length; i < N; i++)
+      removeNode(nodes[i]);
+
+    membersRemoved(this);
+
+    this.members = {};
+  },
+  // (_nextNode is internal)
+  add: function (id, newMemberOrArray, beforeId, _nextNode) {
+    if (id != null && typeof id !== 'string') {
+      if (typeof id !== 'object')
+        // a non-object first argument is probably meant
+        // as an id, NOT a new member, so complain about it
+        // as such.
+        throw new Error("id must be a string");
+      beforeId = newMemberOrArray;
+      newMemberOrArray = id;
+      id = null;
+    }
+
+    if (! newMemberOrArray || typeof newMemberOrArray !== 'object')
+      throw new Error("Expected component, node, or array");
+
+    if (isArray(newMemberOrArray)) {
+      if (newMemberOrArray.length === 1) {
+        newMemberOrArray = newMemberOrArray[0];
+      } else {
+        if (id != null)
+          throw new Error("Can only add one node or one component if id is given");
+        var array = newMemberOrArray;
+        // calculate `nextNode` once in case it involves a refresh
+        _nextNode = this.getInsertionPoint(beforeId);
+        for (var i = 0; i < array.length; i++)
+          this.add(null, array[i], beforeId, _nextNode);
+        return;
+      }
+    }
+
+    var parentNode = this.parentNode();
+    // Consider ourselves removed (and don't mind) if
+    // start marker has no parent.
+    if (! parentNode)
+      return;
+    // because this may call `refresh`, it must be done
+    // early, before we add the new member.
+    var nextNode = (_nextNode ||
+                    this.getInsertionPoint(beforeId));
+
+    var newMember = newMemberOrArray;
+    if (id == null) {
+      id = this.nextMemberId++;
+    } else {
+      checkId(id);
+      id = ' ' + id;
+    }
+
+    var members = this.members;
+    if (members.hasOwnProperty(id)) {
+      var oldMember = members[id];
+      if (oldMember instanceof DomRange) {
+        // range, does it still exist?
+        var oldRange = oldMember;
+        if (oldRange.start.parentNode !== parentNode) {
+          delete members[id];
+          oldRange.owner = null;
+          rangeRemoved(oldRange);
+        } else {
+          throw new Error("Member already exists: " + id.slice(1));
+        }
+      } else {
+        // node, does it still exist?
+        var oldNode = oldMember;
+        if (oldNode.parentNode !== parentNode) {
+          nodeRemoved(oldNode);
+          delete members[id];
+        } else {
+          throw new Error("Member already exists: " + id.slice(1));
+        }
+      }
+    }
+
+    if (newMember instanceof DomRange) {
+      // Range
+      var range = newMember;
+      range.owner = this;
+      var nodes = range.getNodes();
+
+      members[id] = newMember;
+      for (var i = 0; i < nodes.length; i++)
+        insertNode(nodes[i], parentNode, nextNode);
+
+      if (this.isParented)
+        rangeParented(range);
+    } else {
+      // Node
+      if (typeof newMember.nodeType !== 'number')
+        throw new Error("Expected Component or Node");
+      var node = newMember;
+      // can't attach `$ui` to a TextNode in IE 8, so
+      // don't bother on any browser.
+      if (node.nodeType !== 3)
+        node.$ui = this;
+
+      members[id] = newMember;
+      insertNode(node, parentNode, nextNode);
+    }
+  },
+  remove: function (id) {
+    if (id == null) {
+      // remove self
+      this.removeAll();
+      removeNode(this.start);
+      removeNode(this.end);
+      this.owner = null;
+      rangeRemoved(this);
+      return;
+    }
+
+    checkId(id);
+    id = ' ' + id;
+    var members = this.members;
+    var member = (members.hasOwnProperty(id) &&
+                  members[id]);
+    delete members[id];
+
+    // Don't mind double-remove.
+    if (! member)
+      return;
+
+    var parentNode = this.parentNode();
+    // Consider ourselves removed (and don't mind) if
+    // start marker has no parent.
+    if (! parentNode)
+      return;
+
+    if (member instanceof DomRange) {
+      // Range
+      var range = member;
+      range.owner = null;
+      // Don't mind if range (specifically its start
+      // marker) has been removed already.
+      if (range.start.parentNode === parentNode)
+        member.remove();
+    } else {
+      // Node
+      var node = member;
+      // Don't mind if node has been removed already.
+      if (node.parentNode === parentNode)
+        removeNode(node);
+    }
+  },
+  moveBefore: function (id, beforeId) {
+    var nextNode = this.getInsertionPoint(beforeId);
+    checkId(id);
+    id = ' ' + id;
+    var members = this.members;
+    var member =
+          (members.hasOwnProperty(id) &&
+           members[id]);
+    // Don't mind if member doesn't exist.
+    if (! member)
+      return;
+
+    var parentNode = this.parentNode();
+    // Consider ourselves removed (and don't mind) if
+    // start marker has no parent.
+    if (! parentNode)
+      return;
+
+    if (member instanceof DomRange) {
+      // Range
+      var range = member;
+      // Don't mind if range (specifically its start marker)
+      // has been removed already.
+      if (range.start.parentNode === parentNode) {
+        range.refresh();
+        var nodes = range.getNodes();
+        for (var i = 0; i < nodes.length; i++)
+          moveNode(nodes[i], parentNode, nextNode);
+      }
+    } else {
+      // Node
+      var node = member;
+      moveNode(node, parentNode, nextNode);
+    }
+  },
+  get: function (id) {
+    checkId(id);
+    id = ' ' + id;
+    var members = this.members;
+    if (members.hasOwnProperty(id))
+      return members[id];
+    return null;
+  },
+  parentNode: function () {
+    return this.start.parentNode;
+  },
+  startNode: function () {
+    return this.start;
+  },
+  endNode: function () {
+    return this.end;
+  },
+  eachMember: function (nodeFunc, rangeFunc) {
+    var members = this.members;
+    var parentNode = this.parentNode();
+    for (var k in members) {
+      // mem is a component (hosting a Range) or a Node
+      var mem = members[k];
+      if (mem instanceof DomRange) {
+        // Range
+        var range = mem;
+        if (range.start.parentNode === parentNode) {
+          rangeFunc && rangeFunc(range); // still there
+        } else {
+          range.owner = null;
+          delete members[k]; // gone
+          rangeRemoved(range);
+        }
+      } else {
+        // Node
+        var node = mem;
+        if (node.parentNode === parentNode) {
+          nodeFunc && nodeFunc(node); // still there
+        } else {
+          delete members[k]; // gone
+          nodeRemoved(node);
+        }
+      }
+    }
+  },
+
+  ///////////// INTERNALS below this point, pretty much
+
+  // The purpose of "refreshing" a DomRange is to
+  // take into account any element removals or moves
+  // that may have occurred, and to "fix" the start
+  // and end markers before the entire range is moved
+  // or removed so that they bracket the appropriate
+  // content.
+  //
+  // For example, if a DomRange contains a single element
+  // node, and this node is moved using jQuery, refreshing
+  // the DomRange will look to the element as ground truth
+  // and move the start/end markers around the element.
+  // A refreshed DomRange's nodes may surround nodes from
+  // sibling DomRanges (including their marker nodes)
+  // until the sibling DomRange is refreshed.
+  //
+  // Specifically, `refresh` moves the `start`
+  // and `end` nodes to immediate before the first,
+  // and after the last, "significant" node the
+  // DomRange contains, where a significant node
+  // is any node except a whitespace-only text-node.
+  // All member ranges are refreshed first.  Adjacent
+  // insignificant member nodes are included between
+  // `start` and `end` as well, but it's possible that
+  // other insignificant nodes remain as siblings
+  // elsewhere.  Nodes with no DomRange owner that are
+  // found between this DomRange's nodes are adopted.
+  //
+  // Performing add/move/remove operations on an "each"
+  // shouldn't require refreshing the entire each, just
+  // the member in question.  (However, adding to the
+  // end may require refreshing the whole "each";
+  // see `getInsertionPoint`.  Adding multiple members
+  // at once using `add(array)` is faster.
+  refresh: function () {
+
+    var parentNode = this.parentNode();
+    if (! parentNode)
+      return;
+
+    // Using `eachMember`, do several things:
+    // - Refresh all member ranges
+    // - Count our members
+    // - If there's only one, get that one
+    // - Make a list of member TextNodes, which we
+    //   can't detect with a `$ui` property because
+    //   IE 8 doesn't allow user-defined properties
+    //   on TextNodes.
+    var someNode = null;
+    var someRange = null;
+    var numMembers = 0;
+    var textNodes = null;
+    this.eachMember(function (node) {
+      someNode = node;
+      numMembers++;
+      if (node.nodeType === 3) {
+        textNodes = (textNodes || []);
+        textNodes.push(node);
+      }
+    }, function (range) {
+      range.refresh();
+      someRange = range;
+      numMembers++;
+    });
+
+    var firstNode = null;
+    var lastNode = null;
+
+    if (numMembers === 0) {
+      // don't scan for members
+    } else if (numMembers === 1) {
+      if (someNode) {
+        firstNode = someNode;
+        lastNode = someNode;
+      } else if (someRange) {
+        firstNode = someRange.start;
+        lastNode = someRange.end;
+      }
+    } else {
+      // This loop is O(childNodes.length), even if our members
+      // are already consecutive.  This means refreshing just one
+      // item in a list is technically order of the total number
+      // of siblings, including in other list items.
+      //
+      // The root cause is we intentionally don't track the
+      // DOM order of our members, so finding the first
+      // and last in sibling order either involves a scan
+      // or a bunch of calls to compareDocumentPosition.
+      //
+      // Fortunately, the common cases of zero and one members
+      // are optimized.  Also, the scan is super-fast because
+      // no work is done for unknown nodes.  It could be possible
+      // to optimize this code further if it becomes a problem.
+      for (var node = parentNode.firstChild;
+           node; node = node.nextSibling) {
+
+        var nodeOwner;
+        if (node.$ui &&
+            (nodeOwner = node.$ui) &&
+            ((nodeOwner === this &&
+              node !== this.start &&
+              node !== this.end &&
+              isSignificantNode(node)) ||
+             (nodeOwner !== this &&
+              nodeOwner.owner === this &&
+              nodeOwner.start === node))) {
+          // found a member range or node
+          // (excluding "insignificant" empty text nodes,
+          // which won't be moved by, say, jQuery)
+          if (firstNode) {
+            // if we've already found a member in our
+            // scan, see if there are some easy ownerless
+            // nodes to "adopt" by scanning backwards.
+            for (var n = firstNode.previousSibling;
+                 n && ! n.$ui;
+                 n = n.previousSibling) {
+              this.members[this.nextMemberId++] = n;
+              // can't attach `$ui` to a TextNode in IE 8, so
+              // don't bother on any browser.
+              if (n.nodeType !== 3)
+                n.$ui = this;
+            }
+          }
+          if (node.$ui === this) {
+            // Node
+            firstNode = (firstNode || node);
+            lastNode = node;
+          } else {
+            // Range
+            // skip it and include its nodes in
+            // firstNode/lastNode.
+            firstNode = (firstNode || node);
+            node = node.$ui.end;
+            lastNode = node;
+          }
+        }
+      }
+    }
+    if (firstNode) {
+      // some member or significant node was found.
+      // expand to include our insigificant member
+      // nodes as well.
+      for (var n;
+           (n = firstNode.previousSibling) &&
+           (n.$ui && n.$ui === this ||
+            _contains(textNodes, n));)
+        firstNode = n;
+      for (var n;
+           (n = lastNode.nextSibling) &&
+           (n.$ui && n.$ui === this ||
+            _contains(textNodes, n));)
+        lastNode = n;
+      // adjust our start/end pointers
+      if (firstNode !== this.start)
+        insertNode(this.start,
+                   parentNode, firstNode);
+      if (lastNode !== this.end)
+        insertNode(this.end, parentNode,
+                 lastNode.nextSibling);
+    }
+  },
+  getInsertionPoint: function (beforeId) {
+    var members = this.members;
+    var parentNode = this.parentNode();
+
+    if (! beforeId) {
+      // Refreshing here is necessary if we want to
+      // allow elements to move around arbitrarily.
+      // If jQuery is used to reorder elements, it could
+      // easily make our `end` pointer meaningless,
+      // even though all our members continue to make
+      // good reference points as long as they are refreshed.
+      //
+      // However, a refresh is expensive!  Let's
+      // make the developer manually refresh if
+      // elements are being re-ordered externally.
+      return this.end;
+    }
+
+    checkId(beforeId);
+    beforeId = ' ' + beforeId;
+    var mem = members[beforeId];
+
+    if (mem instanceof DomRange) {
+      // Range
+      var range = mem;
+      if (range.start.parentNode === parentNode) {
+        // still there
+        range.refresh();
+        return range.start;
+      } else {
+        range.owner = null;
+        rangeRemoved(range);
+      }
+    } else {
+      // Node
+      var node = mem;
+      if (node.parentNode === parentNode)
+        return node; // still there
+      else
+        nodeRemoved(node);
+    }
+
+    // not there anymore
+    delete members[beforeId];
+    // no good position
+    return this.end;
+  }
+});
+
+DomRange.prototype.elements = function (intoArray) {
+  intoArray = (intoArray || []);
+  this.eachMember(function (node) {
+    if (node.nodeType === 1)
+      intoArray.push(node);
+  }, function (range) {
+    range.elements(intoArray);
+  });
+  return intoArray;
+};
+
+// XXX alias the below as `UI.refresh` and `UI.insert`
+
+// In a real-life case where you need a refresh,
+// you probably don't have easy
+// access to the appropriate DomRange or component,
+// just the enclosing element:
+//
+// ```
+// {{#Sortable}}
+//   <div>
+//     {{#each}}
+//       ...
+// ```
+//
+// In this case, Sortable wants to call `refresh`
+// on the div, not the each, so it would use this function.
+DomRange.refresh = function (element) {
+  var comps = DomRange.getComponents(element);
+
+  for (var i = 0, N = comps.length; i < N; i++)
+    comps[i].refresh();
+};
+
+DomRange.getComponents = function (element) {
+  var topLevelComps = [];
+  for (var n = element.firstChild;
+       n; n = n.nextSibling) {
+    if (n.$ui && n === n.$ui.start &&
+        ! n.$ui.owner)
+      topLevelComps.push(n.$ui);
+  }
+  return topLevelComps;
+};
+
+// `parentNode` must be an ELEMENT, not a fragment
+DomRange.insert = function (range, parentNode, nextNode) {
+  var nodes = range.getNodes();
+  for (var i = 0; i < nodes.length; i++)
+    insertNode(nodes[i], parentNode, nextNode);
+  rangeParented(range);
+};
+
+DomRange.getContainingComponent = function (element) {
+  while (element && ! element.$ui)
+    element = element.parentNode;
+
+  var range = (element && element.$ui);
+
+  while (range) {
+    if (range.component)
+      return range.component;
+    range = range.owner;
+  }
+  return null;
+};
+
+///// FIND BY SELECTOR
+
+DomRange.prototype.contains = function (compOrNode) {
+  if (! compOrNode)
+    throw new Error("Expected Component or Node");
+
+  var parentNode = this.parentNode();
+  if (! parentNode)
+    return false;
+
+  var range;
+  if (compOrNode instanceof DomRange) {
+    // Component
+    range = compOrNode;
+    var pn = range.parentNode();
+    if (! pn)
+      return false;
+    // If parentNode is different, it must be a node
+    // we contain.
+    if (pn !== parentNode)
+      return this.contains(pn);
+    if (range === this)
+      return false; // don't contain self
+    // Ok, `range` is a same-parent range to see if we
+    // contain.
+  } else {
+    // Node
+    var node = compOrNode;
+    if (! elementContains(parentNode, node))
+      return false;
+
+    while (node.parentNode !== parentNode)
+      node = node.parentNode;
+
+    range = node.$ui;
+  }
+
+  // Now see if `range` is truthy and either `this`
+  // or an immediate subrange
+
+  while (range && range !== this)
+    range = range.owner;
+
+  return range === this;
+};
+
+DomRange.prototype.$ = function (selector) {
+  var self = this;
+
+  var parentNode = this.parentNode();
+  if (! parentNode)
+    throw new Error("Can't select in removed DomRange");
+
+  // Strategy: Find all selector matches under parentNode,
+  // then filter out the ones that aren't in this DomRange
+  // using upwards pointers ($ui, owner, parentNode).  This is
+  // asymptotically slow in the presence of O(N) sibling
+  // content that is under parentNode but not in our range,
+  // so if performance is an issue, the selector should be
+  // run on a child element.
+
+  // Since jQuery can't run selectors on a DocumentFragment,
+  // we don't expect findBySelector to work.
+  if (parentNode.nodeType === 11 /* DocumentFragment */ ||
+      parentNode.$_uiIsOffscreen)
+    throw new Error("Can't use $ on an offscreen component");
+
+  var results = DomBackend.findBySelector(selector, parentNode);
+
+  // We don't assume `results` has jQuery API; a plain array
+  // should do just as well.  However, if we do have a jQuery
+  // array, we want to end up with one also, so we use
+  // `.filter`.
+
+
+  // Function that selects only elements that are actually
+  // in this DomRange, rather than simply descending from
+  // `parentNode`.
+  var filterFunc = function (elem) {
+    // handle jQuery's arguments to filter, where the node
+    // is in `this` and the index is the first argument.
+    if (typeof elem === 'number')
+      elem = this;
+
+    return self.contains(elem);
+  };
+
+  if (! results.filter) {
+    // not a jQuery array, and not a browser with
+    // Array.prototype.filter (e.g. IE <9)
+    var newResults = [];
+    for (var i = 0; i < results.length; i++) {
+      var x = results[i];
+      if (filterFunc(x))
+        newResults.push(x);
+    }
+    results = newResults;
+  } else {
+    // `results.filter` is either jQuery's or ECMAScript's `filter`
+    results = results.filter(filterFunc);
+  }
+
+  return results;
+};
+
+
+///// EVENTS
+
+// List of events to always delegate, never capture.
+// Since jQuery fakes bubbling for certain events in
+// certain browsers (like `submit`), we don't want to
+// get in its way.
+//
+// We could list all known bubbling
+// events here to avoid creating speculative capturers
+// for them, but it would only be an optimization.
+var eventsToDelegate = {
+  blur: 1, change: 1, click: 1, focus: 1, focusin: 1,
+  focusout: 1, reset: 1, submit: 1
+};
+
+var EVENT_MODE_TBD = 0;
+var EVENT_MODE_BUBBLING = 1;
+var EVENT_MODE_CAPTURING = 2;
+
+var HandlerRec = function (elem, type, selector, handler, $ui) {
+  this.elem = elem;
+  this.type = type;
+  this.selector = selector;
+  this.handler = handler;
+  this.$ui = $ui;
+
+  this.mode = EVENT_MODE_TBD;
+
+  // It's important that delegatedHandler be a different
+  // instance for each handlerRecord, because its identity
+  // is used to remove it.
+  //
+  // It's also important that the closure have access to
+  // `this` when it is not called with it set.
+  this.delegatedHandler = (function (h) {
+    return function (evt) {
+      if ((! h.selector) && evt.currentTarget !== evt.target)
+        // no selector means only fire on target
+        return;
+      if (! h.$ui.contains(evt.currentTarget))
+        return;
+      return h.handler.apply(h.$ui, arguments);
+    };
+  })(this);
+
+  // WHY CAPTURE AND DELEGATE: jQuery can't delegate
+  // non-bubbling events, because
+  // event capture doesn't work in IE 8.  However, there
+  // are all sorts of new-fangled non-bubbling events
+  // like "play" and "touchenter".  We delegate these
+  // events using capture in all browsers except IE 8.
+  // IE 8 doesn't support these events anyway.
+
+  var tryCapturing = elem.addEventListener &&
+        (! eventsToDelegate.hasOwnProperty(
+          DomBackend.parseEventType(type)));
+
+  if (tryCapturing) {
+    this.capturingHandler = (function (h) {
+      return function (evt) {
+        if (h.mode === EVENT_MODE_TBD) {
+          // must be first time we're called.
+          if (evt.bubbles) {
+            // this type of event bubbles, so don't
+            // get called again.
+            h.mode = EVENT_MODE_BUBBLING;
+            DomBackend.unbindEventCapturer(
+              h.elem, h.type, h.capturingHandler);
+            return;
+          } else {
+            // this type of event doesn't bubble,
+            // so unbind the delegation, preventing
+            // it from ever firing.
+            h.mode = EVENT_MODE_CAPTURING;
+            DomBackend.undelegateEvents(
+              h.elem, h.type, h.delegatedHandler);
+          }
+        }
+
+        h.delegatedHandler(evt);
+      };
+    })(this);
+
+  } else {
+    this.mode = EVENT_MODE_BUBBLING;
+  }
+};
+
+HandlerRec.prototype.bind = function () {
+  // `this.mode` may be EVENT_MODE_TBD, in which case we bind both. in
+  // this case, 'capturingHandler' is in charge of detecting the
+  // correct mode and turning off one or the other handlers.
+  if (this.mode !== EVENT_MODE_BUBBLING) {
+    DomBackend.bindEventCapturer(
+      this.elem, this.type, this.selector || '*',
+      this.capturingHandler);
+  }
+
+  if (this.mode !== EVENT_MODE_CAPTURING)
+    DomBackend.delegateEvents(
+      this.elem, this.type,
+      this.selector || '*', this.delegatedHandler);
+};
+
+HandlerRec.prototype.unbind = function () {
+  if (this.mode !== EVENT_MODE_BUBBLING)
+    DomBackend.unbindEventCapturer(this.elem, this.type,
+                                   this.capturingHandler);
+
+  if (this.mode !== EVENT_MODE_CAPTURING)
+    DomBackend.undelegateEvents(this.elem, this.type,
+                                this.delegatedHandler);
+};
+
+
+// XXX could write the form of arguments for this function
+// in several different ways, including simply as an event map.
+DomRange.prototype.on = function (events, selector, handler) {
+  var parentNode = this.parentNode();
+  if (! parentNode)
+    // if we're not in the DOM, silently fail.
+    return;
+  // haven't been added yet; error
+  if (parentNode.$_uiIsOffscreen)
+    throw new Error("Can't bind events before DomRange is inserted");
+
+  var eventTypes = [];
+  events.replace(/[^ /]+/g, function (e) {
+    eventTypes.push(e);
+  });
+
+  if (! handler && (typeof selector === 'function')) {
+    // omitted `selector`
+    handler = selector;
+    selector = null;
+  } else if (! selector) {
+    // take `""` to `null`
+    selector = null;
+  }
+
+  for (var i = 0, N = eventTypes.length; i < N; i++) {
+    var type = eventTypes[i];
+
+    var eventDict = parentNode.$_uievents;
+    if (! eventDict)
+      eventDict = (parentNode.$_uievents = {});
+
+    var info = eventDict[type];
+    if (! info) {
+      info = eventDict[type] = {};
+      info.handlers = [];
+    }
+    var handlerList = info.handlers;
+    var handlerRec = new HandlerRec(
+      parentNode, type, selector, handler, this);
+    handlerRec.bind();
+    handlerList.push(handlerRec);
+    // move handlers of enclosing ranges to end
+    for (var r = this.owner; r; r = r.owner) {
+      // r is an enclosing DomRange
+      for (var j = 0, Nj = handlerList.length;
+           j < Nj; j++) {
+        var h = handlerList[j];
+        if (h.$ui === r) {
+          h.unbind();
+          h.bind();
+          handlerList.splice(j, 1); // remove handlerList[j]
+          handlerList.push(h);
+          j--; // account for removed handler
+          Nj--; // don't visit appended handlers
+        }
+      }
+    }
+  }
+};
+
+  // Returns true if element a contains node b and is not node b.
+  var elementContains = function (a, b) {
+    if (a.nodeType !== 1) // ELEMENT
+      return false;
+    if (a === b)
+      return false;
+
+    if (a.compareDocumentPosition) {
+      return a.compareDocumentPosition(b) & 0x10;
+    } else {
+          // Should be only old IE and maybe other old browsers here.
+          // Modern Safari has both functions but seems to get contains() wrong.
+          // IE can't handle b being a text node.  We work around this
+          // by doing a direct parent test now.
+      b = b.parentNode;
+      if (! (b && b.nodeType === 1)) // ELEMENT
+        return false;
+      if (a === b)
+        return true;
+
+      return a.contains(b);
+    }
+  };
+
+
+UI.DomRange = DomRange;
diff --git a/packages/ui/domrange_tests.js b/packages/ui/domrange_tests.js
new file mode 100644
index 0000000000..fb042f2dea
--- /dev/null
+++ b/packages/ui/domrange_tests.js
@@ -0,0 +1,958 @@
+
+var DomRange = UI.DomRange;
+var parseHTML = UI.DomBackend.parseHTML;
+
+// fake component; DomRange host
+var Comp = function (which) {
+  this.which = which;
+  this.dom = new DomRange;
+  this.dom.component = this;
+};
+
+var isStartMarker = function (n) {
+  return (n.$ui && n === n.$ui.start);
+};
+
+var isEndMarker = function (n) {
+  return (n.$ui && n === n.$ui.end);
+};
+
+var inDocument = function (range, func) {
+  var onscreen = document.createElement("DIV");
+  onscreen.style.display = 'none';
+  document.body.appendChild(onscreen);
+  DomRange.insert(range, onscreen);
+  try {
+    func(range);
+  } finally {
+    document.body.removeChild(onscreen);
+  }
+};
+
+var htmlRange = function (html) {
+  var r = new DomRange;
+  _.each(parseHTML(html), function (node) {
+    r.add(node);
+  });
+  return r;
+};
+
+Tinytest.add("ui - DomRange - basic", function (test) {
+  var r = new DomRange;
+  r.which = 'R';
+
+  // `r.start` and `r.end` -- accessed via
+  // `r.startNode() and `r.endNode()` -- are adjacent empty
+  // text nodes used as markers.  They are initially created
+  // in a DocumentFragment or other offscreen container.
+  // At all times, the members of a DomRange have the same
+  // parent element (`r.parentNode()`), though this element
+  // may change (typically just once when the DomRange is
+  // first put into the DOM).
+  var rStart = r.startNode();
+  var rEnd = r.endNode();
+
+  test.isTrue(isStartMarker(rStart));
+  test.isTrue(isEndMarker(rEnd));
+  test.equal(rStart.nextSibling, rEnd);
+  test.isTrue(rStart.parentNode);
+  test.equal(r.parentNode(), rStart.parentNode);
+
+  test.equal(typeof r.members, 'object');
+  test.equal(_.keys(r.members).length, 0);
+
+  test.equal(rStart.$ui, r);
+  test.equal(rEnd.$ui, r);
+
+  // add a node
+  var div = document.createElement("DIV");
+  r.add(div);
+
+  test.equal(_.keys(r.members).length, 1);
+  test.equal(div.previousSibling, rStart);
+  test.equal(div.nextSibling, rEnd);
+  test.equal(div.$ui, r);
+
+  // add a subrange
+  var s = new DomRange;
+  s.which = 'S';
+  var span = document.createElement("SPAN");
+  s.add(span);
+  r.add(s);
+  test.equal(_.keys(r.members).length, 2);
+  test.isFalse(r.owner);
+  test.equal(s.owner, r);
+
+  // DOM should go: rStart, DIV, sStart, SPAN, sEnd, rEnd.
+  test.equal(span.previousSibling, s.startNode());
+  test.equal(span.nextSibling, s.endNode());
+  test.equal(span.nextSibling.nextSibling, rEnd);
+  test.equal(span.previousSibling.previousSibling,
+             div);
+  test.equal(span.$ui, s);
+
+  // eachMember
+  var buf = [];
+  r.eachMember(function (node) {
+    buf.push(node.nodeName);
+  }, function (range) {
+    buf.push('range ' + range.which);
+  });
+  buf.sort();
+  test.equal(buf, ['DIV', 'range S']);
+
+  // removal
+  s.remove();
+  test.isFalse(s.owner);
+  // sStart, SPAN, sEnd are gone from the DOM.
+  test.equal(rStart.nextSibling, div);
+  test.equal(rEnd.previousSibling, div);
+  // `r` still has two members
+  test.equal(_.keys(r.members).length, 2);
+  // until we refresh
+  r.refresh();
+  test.equal(_.keys(r.members).length, 1);
+  // remove all
+  r.removeAll();
+  test.equal(rStart.nextSibling, rEnd);
+  test.equal(_.keys(r.members).length, 0);
+});
+
+Tinytest.add("ui - DomRange - shuffling", function (test) {
+  var r = new DomRange;
+
+  var B = document.createElement("B");
+  var I = document.createElement("I");
+  var U = document.createElement("U");
+
+  r.add('B', B);
+  r.add('I', I);
+  r.add('U', U);
+
+  var spellDom = function () {
+    var frag = r.parentNode();
+    var str = '';
+    _.each(frag.childNodes, function (n) {
+      if (n.nodeType === 3 || isStartMarker(n) ||
+          isEndMarker(n)) {
+        if (isStartMarker(n))
+          str += '(';
+        else if (isEndMarker(n))
+          str += ')';
+        else
+          str += '-';
+      } else {
+        if (n.$ui.component && n.$ui.component.which)
+          str += n.$ui.component.which;
+        else
+          str += (n.nodeName || '?');
+      }
+    });
+    return str;
+  };
+
+  test.equal(spellDom(), '(BIU)');
+  r.moveBefore('B');
+  test.equal(spellDom(), '(IUB)');
+  r.moveBefore('I', 'U');
+  test.equal(spellDom(), '(IUB)');
+  r.moveBefore('I', 'B');
+  test.equal(spellDom(), '(UIB)');
+  r.moveBefore('B', 'U');
+  test.equal(spellDom(), '(BUI)');
+  r.moveBefore('U', null);
+  test.equal(spellDom(), '(BIU)');
+
+  test.equal(B.$ui, r);
+
+  // add some member rangers, with host objects
+  var X = new Comp('X');
+  var Y = new Comp('Y');
+  var Z = new Comp('Z');
+  r.add('X', X.dom, 'I');
+  X.dom.add(document.createElement("SPAN"));
+  Y.dom.add(document.createElement("SPAN"));
+  Z.dom.add(document.createElement("SPAN"));
+  r.add('Y', Y.dom, 'U');
+  r.add('Z', Z.dom);
+
+  test.equal(spellDom(), '(B(X)I(Y)U(Z))');
+
+  r.add([document.createElement('A'),
+         document.createElement('A')], 'X');
+
+  test.equal(spellDom(), '(BAA(X)I(Y)U(Z))');
+
+  r.moveBefore('I', 'X');
+  r.moveBefore('X', 'B');
+  r.moveBefore('Z', 'U');
+  r.moveBefore('U', 'Y');
+  test.equal(spellDom(), '((X)BAAIU(Y)(Z))');
+
+
+  r.moveBefore('Z', 'X');
+  r.moveBefore('Y', 'X');
+  test.equal(spellDom(), '((Z)(Y)(X)BAAIU)');
+
+  test.isTrue(r.get('X') === X.dom);
+  test.isTrue(r.get('Y') === Y.dom);
+  test.isTrue(r.get('Z') === Z.dom);
+  test.isTrue(r.get('B') === B);
+  test.isTrue(r.get('I') === I);
+  test.isTrue(r.get('U') === U);
+
+  test.isFalse(r.owner);
+  test.isTrue(X.dom.owner === r);
+  test.isTrue(Y.dom.owner === r);
+  test.isTrue(Z.dom.owner === r);
+
+  r.remove('Y');
+  test.equal(spellDom(), '((Z)(X)BAAIU)');
+  test.equal(r.get('Y'), null);
+
+  r.remove('X');
+  test.equal(spellDom(), '((Z)BAAIU)');
+
+  r.removeAll();
+  test.equal(spellDom(), '()');
+});
+
+Tinytest.add("ui - DomRange - nested", function (test) {
+  var r = new DomRange;
+
+  var spellDom = function () {
+    var frag = r.parentNode();
+    var str = '';
+    _.each(frag.childNodes, function (n) {
+      var ui = n.$ui;
+      if (isStartMarker(n))
+        str += (ui.component ? ui.component.which : '(');
+      else if (isEndMarker(n))
+        str += (ui.component ? ui.component.which.toLowerCase() : ')');
+      else
+        str += '?';
+    });
+    return str;
+  };
+
+  // nest empty ranges; should work even though
+  // there are no element nodes
+  var A,B,C,D,E,F;
+
+  test.equal(spellDom(), '()');
+  r.add((A = new Comp('A')).dom);
+  test.equal(spellDom(), '(Aa)');
+  r.add('B', (B = new Comp('B')).dom);
+  r.add('C', (C = new Comp('C')).dom, 'B');
+  test.equal(spellDom(), '(AaCcBb)');
+
+  r.get('B').add('D', (D = new Comp('D')).dom);
+  D.dom.add('E', (E = new Comp('E')).dom);
+  test.equal(spellDom(), '(AaCcBDEedb)');
+  B.dom.add('F', (F = new Comp('F')).dom);
+  test.equal(spellDom(), '(AaCcBDEedFfb)');
+
+  r.moveBefore('B', 'C');
+  test.equal(spellDom(), '(AaBDEedFfbCc)');
+  B.dom.moveBefore('D', null);
+  test.equal(spellDom(), '(AaBFfDEedbCc)');
+  r.moveBefore('C', 'B');
+  test.equal(spellDom(), '(AaCcBFfDEedb)');
+  D.dom.remove('E');
+  test.equal(spellDom(), '(AaCcBFfDdb)');
+  r.remove('B');
+  test.equal(spellDom(), '(AaCc)');
+
+  test.isFalse(r.owner);
+  test.equal(A.dom.owner, r);
+  test.equal(C.dom.owner, r);
+});
+
+Tinytest.add("ui - DomRange - external moves", function (test) {
+  // In this one, uppercase letters are div elements,
+  // lowercase letters are marker text nodes, as follows:
+  //
+  // a-X-b - c-d-Y-Z-e-f - g-h-i-W-j-k-l V
+  //
+  // In other words, one DomRange containing an element (X),
+  // then two nested DomRanges containing two elements (Y,Z),
+  // etc.
+
+  var wsp = function () {
+    return document.createTextNode(' ');
+  };
+
+  var X = document.createElement("DIV");
+  X.id = 'X';
+  var Y = document.createElement("DIV");
+  Y.id = 'Y';
+  var Z = document.createElement("DIV");
+  Z.id = 'Z';
+  var W = document.createElement("DIV");
+  W.id = 'W';
+  var V = document.createElement("DIV");
+  V.id = 'V';
+
+  var ab = new Comp('ab');
+  ab.dom.add(wsp());
+  ab.dom.add('X', X);
+  ab.dom.add(wsp());
+  var cf = new Comp('cf');
+  var de = new Comp('de');
+  de.dom.add(wsp());
+  de.dom.add('Y', Y);
+  de.dom.add(wsp());
+  de.dom.add('Z', Z);
+  de.dom.add(wsp());
+  cf.dom.add(wsp());
+  cf.dom.add('de', de.dom);
+  cf.dom.add(wsp());
+  var gl = new Comp('gl');
+  var hk = new Comp('hk');
+  var ij = new Comp('ij');
+  ij.dom.add(wsp());
+  ij.dom.add('W', W);
+  ij.dom.add(wsp());
+  // i-W-j
+  test.equal(ij.dom.getNodes().length, 5);
+  gl.dom.add(wsp());
+  gl.dom.add('hk', hk.dom);
+  gl.dom.add(wsp());
+  // g-hk-l
+  test.equal(gl.dom.getNodes().length, 6);
+  hk.dom.add(wsp());
+  hk.dom.add('ij', ij.dom);
+  hk.dom.add(wsp());
+  // h-i-W-j-k
+  test.equal(hk.dom.getNodes().length, 9);
+  // g-h-i-W-j-k-l
+  test.equal(gl.dom.getNodes().length, 13);
+
+  var r = new DomRange;
+  r.add('ab', ab.dom);
+  r.add(wsp());
+  r.add('cf', cf.dom);
+  r.add(wsp());
+  r.add('gl', gl.dom);
+  r.add('V', V);
+
+  var spellDom = function () {
+    var frag = r.parentNode();
+    var str = '';
+    _.each(frag.childNodes, function (n) {
+      var ui = n.$ui;
+      if (isStartMarker(n))
+        str += (ui.component ? ui.component.which.charAt(0) : '(');
+      else if (isEndMarker(n))
+        str += (ui.component ? ui.component.which.charAt(1) : ')');
+      else if (n.nodeType === 3)
+        str += '-';
+      else
+        str += (n.id || '?');
+    });
+    return str;
+  };
+  var strip = function (str) {
+    return str.replace(/[^-\w()]+/g, '');
+  };
+
+  test.equal(spellDom(),
+             strip('(a-X-b - c-d-Y-Z-e-f - g-h-i-W-j-k-l V)'));
+
+  test.isTrue(ab.dom.owner === r);
+  test.isTrue(cf.dom.owner === r);
+  test.isTrue(de.dom.owner === cf.dom);
+  test.isTrue(gl.dom.owner === r);
+  test.isTrue(hk.dom.owner === gl.dom);
+  test.isTrue(ij.dom.owner === hk.dom);
+
+  // all right, now let's mess around with these elements!
+
+  $([Y,Z]).insertBefore(X);
+
+  // jQuery lifted Y,Z right out and stuck them before X
+  test.equal(spellDom(),
+             strip('(a-YZX-b - c-d---e-f - g-h-i-W-j-k-l V)'));
+
+  r.moveBefore('cf', 'ab');
+
+  // the move causes a refresh of `ab` and `cf` and their
+  // descendent members, re-establishing proper organization
+  // (ignoring whitespace textnodes)
+  test.equal(spellDom(),
+             strip('(- cdYZef aX-b ------- g-h-i-W-j-k-l V)'));
+
+  $(W).insertBefore(X);
+
+  test.equal(spellDom(),
+             strip('(- cdYZef aWX-b ------- g-h-i--j-k-l V)'));
+
+  $(Z).insertBefore(W);
+
+  test.equal(spellDom(),
+             strip('(- cdYef aZWX-b ------- g-h-i--j-k-l V)'));
+
+  r.moveBefore('ab', 'cf');
+
+  // WOW!  `ab` and `cf` have been fixed.  Here's what
+  // happened:
+  // - Because `cf` is serving as an insertion point, it
+  //   is refreshed first, and it recursively refreshes
+  //   `de`.  This causes `e` and then `f` to move to the
+  //   right of `Z`.  There's still `a` floating in the middle.
+  // - Then `ab` is refreshed.  This moves `a` to right before
+  //   `X`.
+  // - Finally, `aX-b` is moved before `c`.
+  test.equal(spellDom(),
+             strip('(- aX-b cdYZef W ------- g-h-i--j-k-l V)'));
+
+  r.moveBefore('ab', 'gl');
+
+  // Because `gl` is being used as a reference point,
+  // it is refreshed to contain `W`.
+  // Because the `-` that was initial came from `ab`,
+  // it is recaptured.
+  test.equal(spellDom(),
+             strip('(cdYZef a-X-b ghiWjkl ------------- V)'));
+
+  $(Z).insertBefore(X);
+
+  test.equal(spellDom(),
+             strip('(cdYef a-ZX-b ghiWjkl ------------- V)'));
+
+  r.moveBefore('gl', 'cf');
+
+  // Note that the `a` is still misplaced here.
+  test.equal(spellDom(),
+             strip('(ghiWjkl cdY a-ZefX-b ------------- V)'));
+
+  r.moveBefore('cf', 'V');
+
+  test.equal(spellDom(),
+             strip('(ghiWjkl X-b ------------- cdY a-Zef V)'));
+
+
+  $(X).insertBefore(Y);
+
+  // holy crap, now `aXb` is a mess.  Really `a` and `b`
+  // are in the completely wrong place.
+  test.equal(spellDom(),
+             strip('(ghiWjkl -b ------------- cdXY a-Zef V)'));
+
+  r.moveBefore('gl', 'ab');
+
+  // Now `c` and `d` are wrong.  It looks like `cdYZef`
+  // also includes `W` and `X`.
+  test.equal(spellDom(),
+             strip('(-------------- cd ghiWjkl aXbY-Zef V)'));
+
+  // However, remove `cf` will do a refresh first.
+  r.remove('cf');
+
+  test.equal(spellDom(),
+             strip('(-------------- ghiWjkl aXb V)'));
+
+  $(X).insertBefore(W);
+  r.parentNode().appendChild(W);
+
+  test.equal(spellDom(),
+             strip('(-------------- ghiXjkl ab V) W'));
+
+  r.moveBefore('ab', 'gl');
+
+
+  test.equal(spellDom(),
+             strip('(-------------- V) aXb ghiWjkl'));
+
+  r.remove('V');
+
+  test.equal(spellDom(),
+             strip('(--------------) aXb ghiWjkl'));
+
+
+  // Manual refresh is required for move-to-end
+  // (or add-at-end) if elements may have moved externally,
+  // because the `end` pointer could be totally wrong.
+  // Otherwise, the order of `ab` and `gl` would swap,
+  // meaning the DomRange operations would do something
+  // different from the jQuery operations.
+  //
+  // See `range.getInsertionPoint`.
+
+  // Same as `r.refresh()` but tests
+  // the convenience function `DomRange.refresh(element)`:
+  DomRange.refresh(r.parentNode());
+
+  r.moveBefore('gl', null);
+
+  test.equal(spellDom(),
+             strip('-------------- (aXb ghiWjkl)'));
+});
+
+Tinytest.add("ui - DomRange - basic events", function (test) {
+  // test.equal doesn't work on arrays of DOM nodes, so
+  // we need this.  It's `===` that descends recursively
+  // into any arrays.
+  var arrayEqual = function (a, b) {
+    test.equal(_.isArray(a), _.isArray(b));
+    if (_.isArray(a)) {
+      test.equal(a.length, b.length);
+      for (var i = 0; i < a.length; i++) {
+        arrayEqual(a[i], b[i]);
+      }
+    } else {
+      test.isTrue(a[i] === b[i]);
+    }
+  };
+
+  var q = new DomRange;
+  test.throws(function () {
+    // can't bind events before DomRange is added to
+    // the DOM
+    q.on('click', function (evt) {});
+  });
+
+  inDocument(
+    htmlRange("<span>Foo</span>"),
+    function (r) {
+      var buf = [];
+
+      r.on('click', 'span', function (evt) {
+        buf.push([evt.type, evt.target, evt.currentTarget]);
+      });
+
+      arrayEqual(buf, []);
+      var span = r.elements()[0];
+      clickElement(span);
+      arrayEqual(buf, [['click', span, span]]);
+    });
+
+  inDocument(
+    htmlRange("<div><span>Foo</span></div>"),
+    function (r) {
+      var buf = [];
+
+      // test click with no selector; should only
+      // fire on the event target.
+      r.on('click', function (evt) {
+        buf.push([evt.type, evt.target, evt.currentTarget]);
+      });
+
+      arrayEqual(buf, []);
+      var span = r.$('span')[0];
+      clickElement(span);
+      arrayEqual(buf, [['click', span, span]]);
+    });
+
+  inDocument(
+    htmlRange('<div id="yeah"><span>Foo</span></div>' +
+              '<div id="no">Bar</div>'),
+    function (r) {
+      var buf = [];
+
+      // test click on particular div, which is
+      // not the target or the bound element
+      r.on('click', '#yeah', function (evt) {
+        buf.push([evt.type, evt.target, evt.currentTarget]);
+      });
+
+      arrayEqual(buf, []);
+      clickElement(r.$('#no')[0]);
+      arrayEqual(buf, []);
+      var yeah = r.$('#yeah')[0];
+      clickElement(yeah);
+      arrayEqual(buf, [['click', yeah, yeah]]);
+    });
+
+  inDocument(
+    new DomRange,
+    function (r) {
+      var s;
+      r.add(s = htmlRange('<div id="one"></div>'));
+      r.add(htmlRange('<div id="two"></div>'));
+      var one = r.$('#one')[0];
+      var two = r.$('#two')[0];
+
+      var buf = [];
+
+      // test that click must be in range to fire
+      // event handler
+      s.on('click', 'div', function (evt) {
+        buf.push([evt.type, evt.target, evt.currentTarget]);
+      });
+
+      arrayEqual(buf, []);
+      clickElement(two);
+      arrayEqual(buf, []);
+      clickElement(one);
+      arrayEqual(buf, [['click', one, one]]);
+    });
+
+});
+
+Tinytest.add("ui - DomRange - contains", function (test) {
+  inDocument(new DomRange, function (r) {
+    var s = htmlRange('<div id="one"><span>Foo</span></div>');
+    var t = new DomRange;
+    t.add(s);
+    r.add(t);
+    r.add(htmlRange('<div id="two"></div>'));
+    var one = r.$('#one')[0];
+    var two = r.$('#two')[0];
+    var span = r.$('span')[0];
+
+    test.isFalse(r.contains(r));
+    test.isTrue(r.contains(s));
+    test.isTrue(r.contains(t));
+    test.isTrue(r.contains(one));
+    test.isTrue(s.contains(one));
+    test.isTrue(t.contains(one));
+    test.isTrue(r.contains(two));
+    test.isFalse(s.contains(two));
+    test.isFalse(t.contains(two));
+    test.isTrue(r.contains(span));
+    test.isTrue(s.contains(span));
+    test.isTrue(t.contains(span));
+    test.isFalse(r.contains(r.parentNode()));
+    test.isFalse(r.contains(document.createElement("DIV")));
+  });
+});
+
+Tinytest.add("ui - DomRange - constructor", function (test) {
+  var r = new DomRange;
+
+  test.isTrue(r.parentNode());
+
+  test.isTrue(r.start.$ui === r);
+  test.isTrue(r.end.$ui === r);
+
+  var div = document.createElement('div');
+  r.add(div);
+  test.isTrue(div.$ui === r);
+});
+
+Tinytest.add("ui - DomRange - get", function (test) {
+  var r = new DomRange;
+  var a = document.createElement('div');
+  var b = document.createElement('div');
+  var c = document.createElement('div');
+  var d = document.createElement('div');
+
+  r.add(a);
+  r.add(null, b);
+  r.add('c', c);
+  test.throws(function () {
+    r.add(0, d);
+  });
+  test.throws(function () {
+    r.add(1, d);
+  });
+  test.throws(function () {
+    r.add('', d);
+  });
+
+  test.isTrue(r.get('toString') === null);
+  test.isTrue(r.get('__proto__') === null);
+  test.isTrue(r.get('_proto__') === null);
+  test.isTrue(r.get('blahblah') === null);
+  r.add('toString', d);
+
+  test.throws(function () {
+    r.get('');
+  });
+  test.throws(function () {
+    r.get(null);
+  });
+  test.throws(function () {
+    r.get(1);
+  });
+
+  test.equal(r.elements().length, 4);
+
+  test.isTrue(r.get('c') === c);
+  test.isTrue(r.get('toString') === d);
+});
+
+// This test targets IE 9 and 10, which allow properties
+// to be attached to TextNodes but may lose them over time.
+// Specifically, the JavaScript view of a TextNode seems to
+// be only weakly retained by the TextNode itself, so if you
+// hang an object graph off a TextNode, you need some other
+// pointer to the TextNode or an object in the graph to
+// retain it.
+Tinytest.addAsync("ui - DomRange - IE TextNode GC", function (test, onComplete) {
+  var r = new DomRange;
+  var B = document.createElement('B');
+  B.id = 'ie_textnode_gc_test';
+  document.body.appendChild(B);
+  DomRange.insert(r, B);
+  r = null;
+  B = null;
+
+  // trigger GC...
+  if (typeof CollectGarbage === 'function')
+    CollectGarbage();
+
+  // come back later...
+  window.setTimeout(function () {
+    var B = document.getElementById("ie_textnode_gc_test");
+    test.isTrue(B.firstChild.$ui);
+    test.isTrue(B.lastChild.$ui);
+    window.BBB = B;
+    document.body.removeChild(B);
+    onComplete();
+  }, 500);
+});
+
+Tinytest.add("ui - DomRange - more TBODY", function (test) {
+  inDocument(htmlRange("<table></table>"), function (r) {
+    var table = r.elements()[0];
+    var tableContent = new DomRange;
+    var buf = [];
+    DomRange.insert(tableContent, table);
+    var trRange = htmlRange("<tr><td>Hello</td></tr>");
+    tableContent.add(trRange);
+    test.isTrue(tableContent.contains(trRange));
+  });
+
+  inDocument(htmlRange("<table></table>"), function (r) {
+    var table = r.elements()[0];
+    var tableContent = new DomRange;
+    var buf = [];
+    DomRange.insert(tableContent, table);
+    var trRange = htmlRange("<tr><td>Hello</td></tr>");
+    var tr = trRange.elements()[0];
+    tableContent.add('tr', tr);
+    test.equal(_.keys(tableContent.members).length, 1);
+    test.isTrue(tableContent.contains(tr));
+    tableContent.remove('tr');
+    // bizarrely, in IE 8, the `tr` still has some
+    // DocumentFragment as its parent even though `removeChild`
+    // has been called on it directly.
+    test.isFalse(tr.parentNode && tr.parentNode.nodeType === 1);
+  });
+});
+
+Tinytest.add("ui - DomRange - events in tables", function (test) {
+  inDocument(htmlRange("<table></table>"), function (r) {
+    var table = r.elements()[0];
+    var tableContent = new DomRange;
+    var buf = [];
+    DomRange.insert(tableContent, table);
+    tableContent.on('click', 'tr', function (evt) {
+      buf.push('click ' + evt.currentTarget.nodeName);
+    });
+    var trRange = htmlRange("<tr><td>Hello</td></tr>");
+    tableContent.add(trRange);
+    var tr = trRange.elements()[0];
+    test.equal(buf, []);
+    clickElement(tr);
+    test.equal(buf, ['click TR']);
+    // XXX test something that would break if the event data
+    // is on the TABLE rather than the TBODY (the new
+    // parentNode of `tableContent`).
+  });
+});
+
+Tinytest.add("ui - DomRange - nested event order", function (test) {
+  inDocument(new DomRange, function (r) {
+    var a = new DomRange;
+    var b = new DomRange;
+    var c = new DomRange;
+    var d = new DomRange;
+    r.add(a);
+    a.add(b);
+    b.add(c);
+    c.add(d);
+    var div = document.createElement("DIV");
+    d.add(div);
+
+    var buf = [];
+    var appender = function (str) {
+      return function (evt) {
+        buf.push(str);
+      };
+    };
+
+    b.on('click', 'div', appender("B"));
+    a.on('click', 'div', appender("A"));
+    d.on('click', appender("D"));
+    c.on('click', 'div', appender("C"));
+    test.equal(buf, []);
+    clickElement(div);
+    test.equal(buf, ['D', 'C', 'B', 'A']);
+    buf.length = 0;
+
+    b.on('click', appender("B2"));
+    d.on('click', 'div', appender("D2"));
+    clickElement(div);
+    test.equal(buf, ['D', 'D2', 'C', 'B', 'B2', 'A']);
+  });
+});
+
+Tinytest.add("ui - DomRange - isParented", function (test) {
+  inDocument(new DomRange, function (r) {
+    test.equal(r.isParented, true);
+    var a = new DomRange;
+    var b = new DomRange;
+    var c = new DomRange;
+    var d = new DomRange;
+    var e = new DomRange;
+    var abcde = function (ap, bp, cp, dp, ep) {
+      test.equal(!! a.isParented, !! ap);
+      test.equal(!! b.isParented, !! bp);
+      test.equal(!! c.isParented, !! cp);
+      test.equal(!! d.isParented, !! dp);
+      test.equal(!! e.isParented, !! ep);
+    };
+    var div = document.createElement("DIV");
+    c.add(div);
+    abcde(0, 0, 0, 0, 0);
+    d.add(e);
+    abcde(0, 0, 0, 0, 0);
+    DomRange.insert(d, div);
+    abcde(0, 0, 0, 1, 1);
+    a.add(b);
+    abcde(0, 0, 0, 1, 1);
+    r.add(a);
+    abcde(1, 1, 0, 1, 1);
+    b.add(c);
+    abcde(1, 1, 1, 1, 1);
+
+    var container = r.parentNode();
+    test.equal(_.keys(container.$_uiranges).length, 1);
+    test.equal(_.keys(div.$_uiranges).length, 1);
+    d.remove();
+    test.equal(_.keys(div.$_uiranges).length, 0);
+    r.remove();
+    test.equal(_.keys(container.$_uiranges).length, 0);
+  });
+});
+
+Tinytest.add("ui - DomRange - structural removal", function (test) {
+  inDocument(new DomRange, function (r) {
+    var a = new DomRange;
+    test.isFalse(a.isRemoved);
+    r.add('a', a);
+    test.isFalse(a.isRemoved);
+    r.remove('a');
+    test.isTrue(a.isRemoved);
+
+
+    var b = new DomRange;
+    test.isFalse(b.isRemoved);
+    r.add(b);
+    test.isFalse(b.isRemoved);
+    r.removeAll();
+    test.isTrue(b.isRemoved);
+
+
+    var c = new DomRange;
+    var d = new DomRange;
+    var e = new DomRange;
+    c.add(d);
+    d.add(e);
+    r.add('c', c);
+    test.isFalse(c.isRemoved);
+    test.isFalse(d.isRemoved);
+    test.isFalse(e.isRemoved);
+    r.remove('c');
+    test.isTrue(c.isRemoved);
+    test.isTrue(d.isRemoved);
+    test.isTrue(e.isRemoved);
+
+
+    for (var scenario = 0; scenario < 2; scenario++) {
+      var f = new DomRange;
+      var g = document.createElement("DIV");
+      var h = new DomRange;
+      var i = document.createElement("DIV");
+      var j = document.createElement("DIV");
+      var k = new DomRange;
+      r.add('f', f);
+      f.add(g);
+      DomRange.insert(h, g);
+      h.add(i);
+      DomRange.insert(k, j);
+      i.appendChild(j);
+      test.isFalse(f.isRemoved);
+      test.isFalse(h.isRemoved);
+      test.isFalse(k.isRemoved);
+      if (scenario === 0)
+        r.removeAll();
+      else if (scenario === 1)
+        r.remove('f');
+      test.isTrue(f.isRemoved);
+      test.isTrue(h.isRemoved);
+      test.isTrue(k.isRemoved);
+
+      r.removeAll();
+    }
+  });
+});
+
+Tinytest.add("ui - DomRange - noticed removal", function (test) {
+  // TODO
+  //
+  // e.g. noticed via `eachMember` or `add`
+});
+
+Tinytest.add("ui - DomRange - jQuery removal", function (test) {
+  inDocument(htmlRange("<div></div>"), function (r) {
+    for (var scenario = 0; scenario < 3; scenario++) {
+      var f = document.createElement("DIV");
+      var g = document.createElement("DIV");
+      var h = new DomRange;
+      var i = document.createElement("DIV");
+      var j = document.createElement("DIV");
+      var k = new DomRange;
+      r.add(f);
+      f.appendChild(g);
+      DomRange.insert(h, g);
+      h.add(i);
+      DomRange.insert(k, j);
+      i.appendChild(j);
+      test.isFalse(h.isRemoved);
+      test.isFalse(k.isRemoved);
+
+      $(g).removeData();
+      test.isFalse(h.isRemoved);
+      test.isFalse(k.isRemoved);
+
+      if (scenario === 0)
+        $(g).remove();
+      else if (scenario === 1)
+        $(f).empty();
+      else if (scenario === 2)
+        $(f).html("<br>");
+      else if (scenario === 3)
+        $(g).detach();
+
+      if (scenario !== 3) {
+        test.isTrue(h.isRemoved);
+        test.isTrue(k.isRemoved);
+      } else {
+        // `detach` doesn't remove
+        test.isFalse(h.isRemoved);
+        test.isFalse(k.isRemoved);
+      }
+
+      r.removeAll();
+    }
+  });
+});
+
+// TO TEST STILL:
+// - external remove element
+// - double-add, double-remove
+// - external entire remove
+// - element adoption during move/remove/refresh
+// - first arg of add must be string, errors on `0` for example.
+//   same with remove and move `id` arguments.
+// - can't add multiple members with id, but can add array of 1.
+//   can add 0 with no id.
+// - add a node or range with the same id as an old member
+//   works if that member is gone.
+// - events (and other stuff) get moved when wrapping in TBODY
+// - event unbinding
+// - "noticed" removal due to `eachMembers`, `add`, etc.
diff --git a/packages/ui/each.js b/packages/ui/each.js
new file mode 100644
index 0000000000..6a93a73a42
--- /dev/null
+++ b/packages/ui/each.js
@@ -0,0 +1,119 @@
+UI.EachImpl = Component.extend({
+  typeName: 'Each',
+  render: function (modeHint) {
+    var self = this;
+    var content = self.__content;
+    var elseContent = self.__elseContent;
+
+    if (modeHint === 'STATIC') {
+      // This is a hack.  The caller gives us a hint if the
+      // value we return will be static (in HTML or text)
+      // or dynamic (materialized DOM).  The dynamic path
+      // returns `null` and then we populate the DOM from
+      // the `materialized` callback.
+      //
+      // It would be much cleaner to always return the same
+      // value here, and to have that value be some special
+      // object that encapsulates the logic for populating
+      // the #each using a mode-agnostic interface that
+      // works for HTML, text, and DOM.  Alternatively, we
+      // could formalize the current pattern, e.g. defining
+      // a method like component.populate(domRange) and one
+      // like renderStatic() or even renderHTML / renderText.
+      var parts = _.map(
+        ObserveSequence.fetch(self.__sequence()),
+        function (item) {
+          return content.extend({data: function () {
+            return item;
+          }});
+        });
+
+      if (parts.length) {
+        return parts;
+      } else {
+        return elseContent;
+      }
+      return parts;
+    } else {
+      return null;
+    }
+  },
+  materialized: function () {
+    var self = this;
+
+    var range = self.dom;
+
+    var content = self.__content;
+    var elseContent = self.__elseContent;
+
+    // if there is an else clause, keep track of the number of
+    // rendered items.  use this to display the else clause when count
+    // becomes zero, and remove it when count becomes positive.
+    var itemCount = 0;
+    var addToCount = function(delta) {
+      if (!elseContent) // if no else, no need to keep track of count
+        return;
+
+      if (itemCount + delta < 0)
+        throw new Error("count should never become negative");
+
+      if (itemCount === 0) {
+        // remove else clause
+        range.removeAll();
+      }
+      itemCount += delta;
+      if (itemCount === 0) {
+        UI.materialize(elseContent, range, null, self);
+      }
+    };
+
+    this.observeHandle = ObserveSequence.observe(function () {
+      return self.__sequence();
+    }, {
+      addedAt: function (id, item, i, beforeId) {
+        addToCount(1);
+        id = LocalCollection._idStringify(id);
+
+        var data = item;
+        var dep = new Deps.Dependency;
+
+        // function to become `comp.data`
+        var dataFunc = function () {
+          dep.depend();
+          return data;
+        };
+        // Storing `$set` on `comp.data` lets us
+        // access it from `changed`.
+        dataFunc.$set = function (v) {
+          data = v;
+          dep.changed();
+        };
+
+        if (beforeId)
+          beforeId = LocalCollection._idStringify(beforeId);
+
+        var renderedItem = UI.render(content.extend({data: dataFunc}), self);
+        range.add(id, renderedItem.dom, beforeId);
+      },
+      removedAt: function (id, item) {
+        addToCount(-1);
+        range.remove(LocalCollection._idStringify(id));
+      },
+      movedTo: function (id, item, i, j, beforeId) {
+        range.moveBefore(
+          LocalCollection._idStringify(id),
+          beforeId && LocalCollection._idStringify(beforeId));
+      },
+      changedAt: function (id, newItem, atIndex) {
+        range.get(LocalCollection._idStringify(id)).component.data.$set(newItem);
+      }
+    });
+
+    // on initial render, display the else clause if no items
+    addToCount(0);
+  },
+  destroyed: function () {
+    if (this.__component__.observeHandle)
+      this.__component__.observeHandle.stop();
+  }
+});
diff --git a/packages/ui/exceptions.js b/packages/ui/exceptions.js
new file mode 100644
index 0000000000..f60d053c62
--- /dev/null
+++ b/packages/ui/exceptions.js
@@ -0,0 +1,34 @@
+
+var debugFunc;
+
+// Meteor UI calls into user code in many places, and it's nice to catch exceptions
+// propagated from user code immediately so that the whole system doesn't just
+// break.  Catching exceptions is easy; reporting them is hard.  This helper
+// reports exceptions.
+//
+// Usage:
+//
+// ```
+// try {
+//   // ... someStuff ...
+// } catch (e) {
+//   reportUIException(e);
+// }
+// ```
+//
+// An optional second argument overrides the default message.
+
+reportUIException = function (e, msg) {
+  if (! debugFunc)
+    // adapted from Deps
+    debugFunc = function () {
+      return (typeof Meteor !== "undefined" ? Meteor._debug :
+              ((typeof console !== "undefined") && console.log ? console.log :
+               function () {}));
+    };
+
+  // In Chrome, `e.stack` is a multiline string that starts with the message
+  // and contains a stack trace.  Furthermore, `console.log` makes it clickable.
+  // `console.log` supplies the space between the two arguments.
+  debugFunc()(msg || 'Exception in Meteor UI:', e.stack || e.message);
+};
diff --git a/packages/ui/fields.js b/packages/ui/fields.js
new file mode 100644
index 0000000000..e598d37668
--- /dev/null
+++ b/packages/ui/fields.js
@@ -0,0 +1,136 @@
+
+var global = (function () { return this; })();
+
+// Searches for the given property in `comp` or a parent,
+// and returns it as is (without call it if it's a function).
+var lookupComponentProp = function (comp, prop) {
+  comp = findComponentWithProp(prop, comp);
+  var result = (comp ? comp.data : null);
+  if (typeof result === 'function')
+    result = _.bind(result, comp);
+  return result;
+};
+
+// Component that's a no-op when used as a block helper like
+// `{{#foo}}...{{/foo}}`. Prints a warning that it is deprecated.
+var noOpComponent = function (name) {
+  return Component.extend({
+    kind: 'NoOp',
+    render: function () {
+      Meteor._debug("{{#" + name + "}} is now unnecessary and deprecated.");
+      return this.__content;
+    }
+  });
+};
+
+// This map is searched first when you do something like `{{#foo}}` in
+// a template.
+var builtInComponents = {
+  // for past compat:
+  'constant': noOpComponent("constant"),
+  'isolate': noOpComponent("isolate")
+};
+
+_extend(UI.Component, {
+  // Options:
+  //
+  // - template {Boolean} If true, look at the list of templates after
+  //   helpers and before data context.
+  lookup: function (id, opts) {
+    var self = this;
+    var template = opts && opts.template;
+    var result;
+    var comp;
+
+    if (!id)
+      throw new Error("must pass id to lookup");
+
+    if (/^\./.test(id)) {
+      // starts with a dot. must be a series of dots which maps to an
+      // ancestor of the appropriate height.
+      if (!/^(\.)+$/.test(id)) {
+        throw new Error("id starting with dot must be a series of dots");
+      }
+
+      var compWithData = findComponentWithProp('data', self);
+      for (var i = 1; i < id.length; i++) {
+        compWithData = compWithData ? findComponentWithProp('data', compWithData.parent) : null;
+      }
+
+      return (compWithData ? compWithData.data : null);
+
+    } else if ((comp = findComponentWithHelper(id, self))) {
+      // found a property or method of a component
+      // (`self` or one of its ancestors)
+      var result = comp[id];
+
+    } else if (_.has(builtInComponents, id)) {
+      return builtInComponents[id];
+
+    // Code to search the global namespace for capitalized names
+    // like component classes, `Template`, `StringUtils.foo`,
+    // etc.
+    //
+    // } else if (/^[A-Z]/.test(id) && (id in global)) {
+    //   // Only look for a global identifier if `id` is
+    //   // capitalized.  This avoids having `{{name}}` mean
+    //   // `window.name`.
+    //   result = global[id];
+    //   return function (/*arguments*/) {
+    //     var data = getComponentData(self);
+    //     if (typeof result === 'function')
+    //       return result.apply(data, arguments);
+    //     return result;
+    //   };
+    } else if (template && _.has(Template, id)) {
+      return Template[id];
+
+    } else if ((result = UI._globalHelper(id))) {
+
+    } else {
+      // Resolve id `foo` as `data.foo` (with a "soft dot").
+      return function (/*arguments*/) {
+        var data = getComponentData(self);
+        if (template && !(data && _.has(data, id)))
+          throw new Error("Can't find template, helper or data context key: " + id);
+        if (! data)
+          return data;
+        var result = data[id];
+        if (typeof result === 'function')
+          return result.apply(data, arguments);
+        return result;
+      };
+    }
+
+    if (typeof result === 'function' && ! result._isEmboxedConstant) {
+      // Wrap the function `result`, binding `this` to `getComponentData(self)`.
+      // This creates a dependency when the result function is called.
+      // Don't do this if the function is really just an emboxed constant.
+      return function (/*arguments*/) {
+        var data = getComponentData(self);
+        return result.apply(data === null ? {} : data, arguments);
+      };
+    } else {
+      return result;
+    };
+  },
+  lookupTemplate: function (id) {
+    return this.lookup(id, {template: true});
+  },
+  get: function (id) {
+    // support `this.get()` to get the data context.
+    if (id === undefined)
+      id = ".";
+
+    var result = this.lookup(id);
+    return (typeof result === 'function' ? result() : result);
+  },
+  set: function (id, value) {
+    var comp = findComponentWithProp(id, this);
+    if (! comp || ! comp[id])
+      throw new Error("Can't find field: " + id);
+    if (typeof comp[id] !== 'function')
+      throw new Error("Not a settable field: " + id);
+    comp[id](value);
+  }
+});
diff --git a/packages/ui/handlebars_backcompat.js b/packages/ui/handlebars_backcompat.js
new file mode 100644
index 0000000000..b089dfd7c3
--- /dev/null
+++ b/packages/ui/handlebars_backcompat.js
@@ -0,0 +1,42 @@
+// XXX this file no longer makes sense in isolation.  take it apart as
+// part file reorg on the 'ui' package
+var globalHelpers = {};
+
+UI.registerHelper = function (name, func) {
+  globalHelpers[name] = func;
+};
+
+UI._globalHelper = function (name) {
+  return globalHelpers[name];
+};
+
+Handlebars = {};
+Handlebars.registerHelper = UI.registerHelper;
+
+// Utility to HTML-escape a string.
+UI._escape = Handlebars._escape = (function() {
+  var escape_map = {
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "`": "&#x60;", /* IE allows backtick-delimited attributes?? */
+    "&": "&amp;"
+  };
+  var escape_one = function(c) {
+    return escape_map[c];
+  };
+
+  return function (x) {
+    return x.replace(/[&<>"'`]/g, escape_one);
+  };
+})();
+
+// Return these from {{...}} helpers to achieve the same as returning
+// strings from {{{...}}} helpers
+Handlebars.SafeString = function(string) {
+  this.string = string;
+};
+Handlebars.SafeString.prototype.toString = function() {
+  return this.string.toString();
+};
diff --git a/packages/ui/package.js b/packages/ui/package.js
new file mode 100644
index 0000000000..291de0fe6a
--- /dev/null
+++ b/packages/ui/package.js
@@ -0,0 +1,53 @@
+Package.describe({
+  name: "ui",
+  test: "ui-test",
+  summary: "Meteor UI Components framework",
+  version: '1.0.0',
+  internal: true
+});
+
+Package.on_use(function (api) {
+  api.export(['UI', 'Handlebars']);
+  api.use('jquery'); // should be a weak dep, by having multiple "DOM backends"
+  api.use('deps');
+  api.use('random');
+  api.use('ejson');
+  api.use('underscore'); // slight
+  api.use('ordered-dict');
+  api.use('minimongo');  // for idStringify
+  api.use('observe-sequence');
+
+  api.use('htmljs');
+  api.imply('htmljs');
+
+  api.add_files(['exceptions.js', 'base.js']);
+
+  api.add_files(['dombackend.js',
+                 'domrange.js'], 'client');
+
+  api.add_files(['attrs.js',
+                 'render.js',
+                 'builtins.js',
+                 'each.js',
+                 'fields.js'
+                ]);
+
+  api.add_files(['handlebars_backcompat.js']);
+});
+
+Package.on_test(function (api) {
+  api.use('tinytest');
+  api.use('jquery'); // strong dependency, for testing jQuery backend
+  api.use('ui');
+  api.use(['test-helpers', 'underscore'], 'client');
+  api.use('spacebars-compiler'); // for `HTML.toJS`
+
+  api.use('html-tools');
+
+  api.add_files([
+    'base_tests.js',
+    'domrange_tests.js',
+    'render_tests.js',
+    'dombackend_tests.js'
+  ], 'client');
+});
diff --git a/packages/ui/render.js b/packages/ui/render.js
new file mode 100644
index 0000000000..5c38868eaa
--- /dev/null
+++ b/packages/ui/render.js
@@ -0,0 +1,431 @@
+
+UI.Component.instantiate = function (parent) {
+  var kind = this;
+
+  // check arguments
+  if (UI.isComponent(kind)) {
+    if (kind.isInited)
+      throw new Error("A component kind is required, not an instance");
+  } else {
+    throw new Error("Expected Component kind");
+  }
+
+  var inst = kind.extend(); // XXX args go here
+  inst.isInited = true;
+
+  // XXX messy to define this here
+  inst.templateInstance = {
+    findAll: function (selector) {
+      // XXX check that `.dom` exists here?
+      return inst.dom.$(selector);
+    },
+    find: function (selector) {
+      var result = this.findAll(selector);
+      return result[0] || null;
+    },
+    firstNode: null,
+    lastNode: null,
+    data: null,
+    __component__: inst
+  };
+  inst.templateInstance.$ = inst.templateInstance.findAll;
+
+  inst.parent = (parent || null);
+
+  if (inst.init)
+    inst.init();
+
+  if (inst.created) {
+    updateTemplateInstance(inst);
+    inst.created.call(inst.templateInstance);
+  }
+
+  return inst;
+};
+
+UI.Component.render = function () {
+  return null;
+};
+
+var Box = function (func, equals) {
+  var self = this;
+
+  self.func = func;
+  self.equals = equals;
+
+  self.curResult = null;
+
+  self.dep = new Deps.Dependency;
+
+  self.resultComputation = Deps.nonreactive(function () {
+    return Deps.autorun(function (c) {
+      var func = self.func;
+
+      var newResult = func();
+
+      if (! c.firstRun) {
+        var equals = self.equals;
+        var oldResult = self.curResult;
+
+        if (equals ? equals(newResult, oldResult) :
+            newResult === oldResult) {
+          // same as last time
+          return;
+        }
+      }
+
+      self.curResult = newResult;
+      self.dep.changed();
+    });
+  });
+};
+
+Box.prototype.stop = function () {
+  this.resultComputation.stop();
+};
+
+Box.prototype.get = function () {
+  if (Deps.active && ! this.resultComputation.stopped)
+    this.dep.depend();
+
+  return this.curResult;
+};
+
+// Takes a reactive function (call it `inner`) and returns a reactive function
+// `outer` which is equivalent except in its reactive behavior.  Specifically,
+// `outer` has the following two special properties:
+//
+// 1. Isolation:  An invocation of `outer()` only invalidates its context
+//    when the value of `inner()` changes.  For example, `inner` may be a
+//    function that gets one or more Session variables and calculates a
+//    true/false value.  `outer` blocks invalidation signals caused by the
+//    Session variables changing and sends a signal out only when the value
+//    changes between true and false (in this example).  The value can be
+//    of any type, and it is compared with `===` unless an `equals` function
+//    is provided.
+//
+// 2. Value Sharing:  The `outer` function returned by `emboxValue` can be
+//    shared between different contexts, for example by assigning it to an
+//    object as a method that can be accessed at any time, such as by
+//    different templates or different parts of a template.  No matter
+//    how many times `outer` is called, `inner` is only called once until
+//    it changes.  The most recent value is stored internally.
+//
+// Conceptually, an emboxed value is much like a Session variable which is
+// kept up to date by an autorun.  Session variables provide storage
+// (value sharing) and they don't notify their listeners unless a value
+// actually changes (isolation).  The biggest difference is that such an
+// autorun would never be stopped, and the Session variable would never be
+// deleted even if it wasn't used any more.  An emboxed value, on the other
+// hand, automatically stops computing when it's not being used, and starts
+// again when called from a reactive context.  This means that when it stops
+// being used, it can be completely garbage-collected.
+//
+// If a non-function value is supplied to `emboxValue` instead of a reactive
+// function, then `outer` is still a function but it simply returns the value.
+//
+UI.emboxValue = function (funcOrValue, equals) {
+  if (typeof funcOrValue === 'function') {
+
+    var func = funcOrValue;
+    var box = new Box(func, equals);
+
+    var f = function () {
+      return box.get();
+    };
+
+    f.stop = function () {
+      box.stop();
+    };
+
+    return f;
+
+  } else {
+    var value = funcOrValue;
+    var result = function () {
+      return value;
+    };
+    result._isEmboxedConstant = true;
+    return result;
+  }
+};
+
+
+UI.namedEmboxValue = function (name, funcOrValue, equals) {
+  if (! Deps.active) {
+    var f = UI.emboxValue(funcOrValue, equals);
+    f.stop();
+    return f;
+  }
+
+  var c = Deps.currentComputation;
+  if (! c[name])
+    c[name] = UI.emboxValue(funcOrValue, equals);
+
+  return c[name];
+};
+
+////////////////////////////////////////
+
+UI.insert = function (renderedTemplate, parentElement, nextNode) {
+  if (! renderedTemplate.dom)
+    throw new Error("Expected template rendered with UI.render");
+
+  UI.DomRange.insert(renderedTemplate.dom, parentElement, nextNode);
+};
+
+// Insert a DOM node or DomRange into a DOM element or DomRange.
+//
+// One of three things happens depending on what needs to be inserted into what:
+// - `range.add` (anything into DomRange)
+// - `UI.DomRange.insert` (DomRange into element)
+// - `elem.insertBefore` (node into element)
+//
+// The optional `before` argument is an existing node or id to insert before in
+// the parent element or DomRange.
+var insert = function (nodeOrRange, parent, before) {
+  if (! parent)
+    throw new Error("Materialization parent required");
+
+  if (parent instanceof UI.DomRange) {
+    parent.add(nodeOrRange, before);
+  } else if (nodeOrRange instanceof UI.DomRange) {
+    // parent is an element; inserting a range
+    UI.DomRange.insert(nodeOrRange, parent, before);
+  } else {
+    // parent is an element; inserting an element
+    parent.insertBefore(nodeOrRange, before || null); // `null` for IE
+  }
+};
+
+UI.render = function (kind, parentComponent) {
+  if (kind.isInited)
+    throw new Error("Can't render component instance, only component kind");
+
+  var inst, content, range;
+
+  Deps.nonreactive(function () {
+
+    inst = kind.instantiate(parentComponent);
+
+    content = (inst.render && inst.render());
+
+    range = new UI.DomRange;
+    inst.dom = range;
+    range.component = inst;
+
+  });
+
+  materialize(content, range, null, inst);
+
+  range.removed = function () {
+    inst.isDestroyed = true;
+    if (inst.destroyed) {
+      Deps.nonreactive(function () {
+        updateTemplateInstance(inst);
+        inst.destroyed.call(inst.templateInstance);
+      });
+    }
+  };
+
+  return inst;
+};
+
+UI.renderWithData = function (kind, data, parentComponent) {
+  if (! UI.isComponent(kind))
+    throw new Error("Component required here");
+  if (kind.isInited)
+    throw new Error("Can't render component instance, only component kind");
+  if (typeof data === 'function')
+    throw new Error("Data argument can't be a function");
+
+  return UI.render(kind.extend({data: function () { return data; }}),
+                   parentComponent);
+};
+
+var contentEquals = function (a, b) {
+  if (a instanceof HTML.Raw) {
+    return (b instanceof HTML.Raw) && (a.value === b.value);
+  } else if (a == null) {
+    return (b == null);
+  } else {
+    return (a === b) &&
+      ((typeof a === 'number') || (typeof a === 'boolean') ||
+       (typeof a === 'string'));
+  }
+};
+
+UI.InTemplateScope = function (tmplInstance, content) {
+  if (! (this instanceof UI.InTemplateScope))
+    // called without `new`
+    return new UI.InTemplateScope(tmplInstance, content);
+
+  var parentPtr = tmplInstance.parent;
+  if (parentPtr.__isTemplateWith)
+    parentPtr = parentPtr.parent;
+
+  this.parentPtr = parentPtr;
+  this.content = content;
+};
+
+UI.InTemplateScope.prototype.toHTML = function (parentComponent) {
+  return HTML.toHTML(this.content, this.parentPtr);
+};
+
+UI.InTemplateScope.prototype.toText = function (textMode, parentComponent) {
+  return HTML.toText(this.content, textMode, this.parentPtr);
+};
+
+// Convert the pseudoDOM `node` into reactive DOM nodes and insert them
+// into the element or DomRange `parent`, before the node or id `before`.
+var materialize = function (node, parent, before, parentComponent) {
+  // XXX should do more error-checking for the case where user is supplying the tags.
+  // For example, check that CharRef has `html` and `str` properties and no content.
+  // Check that Comment has a single string child and no attributes.  Etc.
+
+  if (node == null) {
+    // null or undefined.
+    // do nothinge.
+  } else if ((typeof node === 'string') || (typeof node === 'boolean') || (typeof node === 'number')) {
+    node = String(node);
+    insert(document.createTextNode(node), parent, before);
+  } else if (node instanceof Array) {
+    for (var i = 0; i < node.length; i++)
+      materialize(node[i], parent, before, parentComponent);
+  } else if (typeof node === 'function') {
+
+    var range = new UI.DomRange;
+    var lastContent = null;
+    var rangeUpdater = Deps.autorun(function (c) {
+      var content = node();
+      // normalize content a little, for easier comparison
+      if (HTML.isNully(content))
+        content = null;
+      else if ((content instanceof Array) && content.length === 1)
+        content = content[0];
+
+      // update if content is different from last time
+      if (! contentEquals(content, lastContent)) {
+        lastContent = content;
+
+        if (! c.firstRun)
+          range.removeAll();
+
+        materialize(content, range, null, parentComponent);
+      }
+    });
+    range.removed = function () {
+      rangeUpdater.stop();
+      if (node.stop)
+        node.stop();
+    };
+    // XXXX HACK
+    if (Deps.active && node.stop) {
+      Deps.onInvalidate(function () {
+        node.stop();
+      });
+    }
+    insert(range, parent, before);
+  } else if (node instanceof HTML.Tag) {
+    var tagName = node.tagName;
+    var elem;
+    if (HTML.isKnownSVGElement(tagName) && document.createElementNS) {
+      elem = document.createElementNS('http://www.w3.org/2000/svg', tagName);
+    } else {
+      elem = document.createElement(node.tagName);
+    }
+
+    var rawAttrs = node.attrs;
+    var children = node.children;
+    if (node.tagName === 'textarea') {
+      rawAttrs = (rawAttrs || {});
+      rawAttrs.value = children;
+      children = [];
+    };
+
+    if (rawAttrs) {
+      var attrComp = Deps.autorun(function (c) {
+        var attrUpdater = c.updater;
+        if (! attrUpdater) {
+          attrUpdater = c.updater = new ElementAttributesUpdater(elem);
+        }
+
+        try {
+          var attrs = HTML.evaluateAttributes(rawAttrs, parentComponent);
+          var stringAttrs = {};
+          if (attrs) {
+            for (var k in attrs) {
+              stringAttrs[k] = HTML.toText(attrs[k], HTML.TEXTMODE.STRING,
+                                           parentComponent);
+            }
+            attrUpdater.update(stringAttrs);
+          }
+        } catch (e) {
+          reportUIException(e);
+        }
+      });
+      UI.DomBackend.onRemoveElement(elem, function () {
+        attrComp.stop();
+      });
+    }
+    materialize(children, elem, null, parentComponent);
+
+    insert(elem, parent, before);
+  } else if (typeof node.instantiate === 'function') {
+    // component
+    var instance = UI.render(node, parentComponent);
+
+    // Call internal callback, which may take advantage of the current
+    // Deps computation.
+    if (instance.materialized)
+      instance.materialized();
+
+    insert(instance.dom, parent, before);
+  } else if (node instanceof HTML.CharRef) {
+    insert(document.createTextNode(node.str), parent, before);
+  } else if (node instanceof HTML.Comment) {
+    insert(document.createComment(node.sanitizedValue), parent, before);
+  } else if (node instanceof HTML.Raw) {
+    // Get an array of DOM nodes by using the browser's HTML parser
+    // (like innerHTML).
+    var htmlNodes = UI.DomBackend.parseHTML(node.value);
+    for (var i = 0; i < htmlNodes.length; i++)
+      insert(htmlNodes[i], parent, before);
+  } else if (Package['html-tools'] && (node instanceof Package['html-tools'].HTMLTools.Special)) {
+    throw new Error("Can't materialize Special tag, it's just an intermediate rep");
+  } else if (node instanceof UI.InTemplateScope) {
+    materialize(node.content, parent, before, node.parentPtr);
+  } else {
+    // can't get here
+    throw new Error("Unexpected node in htmljs: " + node);
+  }
+};
+
+
+
+// XXX figure out the right names, and namespace, for these.
+// for example, maybe some of them go in the HTML package.
+UI.materialize = materialize;
+
+UI.body = UI.Component.extend({
+  kind: 'body',
+  contentParts: [],
+  render: function () {
+    return this.contentParts;
+  },
+  // XXX revisit how body works.
+  INSTANTIATED: false,
+  __helperHost: true
+});
+
+UI.block = function (renderFunc) {
+  return UI.Component.extend({ render: renderFunc });
+};
+
+UI.toHTML = function (content, parentComponent) {
+  return HTML.toHTML(content, parentComponent);
+};
+
+UI.toRawText = function (content, parentComponent) {
+  return HTML.toText(content, HTML.TEXTMODE.STRING, parentComponent);
+};
diff --git a/packages/ui/render_tests.js b/packages/ui/render_tests.js
new file mode 100644
index 0000000000..87688c866b
--- /dev/null
+++ b/packages/ui/render_tests.js
@@ -0,0 +1,538 @@
+var materialize = UI.materialize;
+var toHTML = HTML.toHTML;
+var toCode = HTML.toJS;
+
+var P = HTML.P;
+var CharRef = HTML.CharRef;
+var DIV = HTML.DIV;
+var Comment = HTML.Comment;
+var BR = HTML.BR;
+var A = HTML.A;
+var UL = HTML.UL;
+var LI = HTML.LI;
+var SPAN = HTML.SPAN;
+var HR = HTML.HR;
+var TEXTAREA = HTML.TEXTAREA;
+var INPUT = HTML.INPUT;
+
+Tinytest.add("ui - render - basic", function (test) {
+  var run = function (input, expectedInnerHTML, expectedHTML, expectedCode) {
+    var div = document.createElement("DIV");
+    materialize(input, div);
+    test.equal(canonicalizeHtml(div.innerHTML), expectedInnerHTML);
+    test.equal(toHTML(input), expectedHTML);
+    if (typeof expectedCode !== 'undefined')
+      test.equal(toCode(input), expectedCode);
+  };
+
+  run(P('Hello'),
+      '<p>Hello</p>',
+      '<p>Hello</p>',
+      'HTML.P("Hello")');
+
+  run(null, '', '', 'null');
+  run([], '', '', '[]');
+  run([null, null], '', '', '[null, null]');
+
+  // Test crazy character references
+
+  // `&zopf;` is "Mathematical double-struck small z" a.k.a. "open-face z"
+  run(P(CharRef({html: '&zopf;', str: '\ud835\udd6b'})),
+      '<p>\ud835\udd6b</p>',
+      '<p>&zopf;</p>',
+      'HTML.P(HTML.CharRef({html: "&zopf;", str: "\\ud835\\udd6b"}))');
+
+  run(P({id: CharRef({html: '&zopf;', str: '\ud835\udd6b'})}, 'Hello'),
+      '<p id="\ud835\udd6b">Hello</p>',
+      '<p id="&zopf;">Hello</p>',
+      'HTML.P({id: HTML.CharRef({html: "&zopf;", str: "\\ud835\\udd6b"})}, "Hello")');
+
+  run(P({id: [CharRef({html: '&zopf;', str: '\ud835\udd6b'}), '!']}, 'Hello'),
+      '<p id="\ud835\udd6b!">Hello</p>',
+      '<p id="&zopf;!">Hello</p>',
+      'HTML.P({id: [HTML.CharRef({html: "&zopf;", str: "\\ud835\\udd6b"}), "!"]}, "Hello")');
+
+  // Test comments
+
+  run(DIV(Comment('Test')),
+      '<div><!----></div>', // our innerHTML-canonicalization function kills comment contents
+      '<div><!--Test--></div>',
+      'HTML.DIV(HTML.Comment("Test"))');
+
+  // Test arrays
+
+  run([P('Hello'), P('World')],
+      '<p>Hello</p><p>World</p>',
+      '<p>Hello</p><p>World</p>',
+      '[HTML.P("Hello"), HTML.P("World")]');
+
+  // Test slightly more complicated structure
+
+  run(DIV({'class': 'foo'}, UL(LI(P(A({href: '#one'}, 'One'))),
+                               LI(P('Two', BR(), 'Three')))),
+      '<div class="foo"><ul><li><p><a href="#one">One</a></p></li><li><p>Two<br>Three</p></li></ul></div>',
+      '<div class="foo"><ul><li><p><a href="#one">One</a></p></li><li><p>Two<br>Three</p></li></ul></div>',
+      'HTML.DIV({"class": "foo"}, HTML.UL(HTML.LI(HTML.P(HTML.A({href: "#one"}, "One"))), HTML.LI(HTML.P("Two", HTML.BR(), "Three"))))');
+
+
+  // Test nully attributes
+  run(BR({x: null,
+          y: [[], []],
+          a: [['']]}),
+      '<br a="">',
+      '<br a="">',
+      'HTML.BR({a: [[""]]})');
+
+  run(BR({
+    x: function () { return function () { return []; }; },
+    a: function () { return function () { return ''; }; }}),
+      '<br a="">',
+      '<br a="">');
+});
+
+// test that we correctly update the 'value' property on input fields
+// rather than the 'value' attribute. the 'value' attribute only sets
+// the initial value.
+Tinytest.add("ui - render - input - value", function (test) {
+  var R = ReactiveVar("hello");
+  var div = document.createElement("DIV");
+  materialize(INPUT({value: function () { return R.get(); }}), div);
+  var inputEl = div.querySelector('input');
+  test.equal(inputEl.value, "hello");
+  inputEl.value = "goodbye";
+  R.set("hola");
+  Deps.flush();
+  test.equal(inputEl.value, "hola");
+});
+
+// test that we correctly update the 'checked' property rather than
+// the 'checked' attribute on input fields of type 'checkbox'. the
+// 'checked' attribute only sets the initial value.
+Tinytest.add("ui - render - input - checked", function (test) {
+  var R = ReactiveVar(null);
+  var div = document.createElement("DIV");
+  materialize(INPUT({type: "checkbox", checked: function () { return R.get(); }}), div);
+  var inputEl = div.querySelector('input');
+  test.equal(inputEl.checked, false);
+  inputEl.checked = true;
+
+  R.set("checked");
+  Deps.flush();
+  R.set(null);
+  Deps.flush();
+  test.equal(inputEl.checked, false);
+});
+
+Tinytest.add("ui - render - textarea", function (test) {
+  var run = function (optNode, text, html, code) {
+    if (typeof optNode === 'string') {
+      // called with args (text, html, code)
+      code = html;
+      html = text;
+      text = optNode;
+      optNode = null;
+    }
+    var div = document.createElement("DIV");
+    var node = TEXTAREA(optNode || text);
+    materialize(node, div);
+
+    var value = div.querySelector('textarea').value;
+    value = value.replace(/\r\n/g, "\n"); // IE8 substitutes \n with \r\n
+    test.equal(value, text);
+
+    test.equal(toHTML(node), html);
+    if (typeof code === 'string')
+      test.equal(toCode(node), code);
+  };
+
+  run('Hello',
+      '<textarea>Hello</textarea>',
+      'HTML.TEXTAREA("Hello")');
+
+  run('\nHello',
+      '<textarea>\n\nHello</textarea>',
+      'HTML.TEXTAREA("\\nHello")');
+
+  run('</textarea>',
+      '<textarea>&lt;/textarea></textarea>',
+      'HTML.TEXTAREA("</textarea>")');
+
+  run(CharRef({html: '&amp;', str: '&'}),
+      '&',
+      '<textarea>&amp;</textarea>',
+      'HTML.TEXTAREA(HTML.CharRef({html: "&amp;", str: "&"}))');
+
+  run(['a', function () { return 'b'; }, 'c'],
+      'abc',
+      '<textarea>abc</textarea>');
+
+});
+
+Tinytest.add("ui - render - closures", function (test) {
+
+  // Reactively change a text node
+  (function () {
+    var R = ReactiveVar('Hello');
+    var test1 = P(function () { return R.get(); });
+
+    test.equal(toHTML(test1), '<p>Hello</p>');
+
+    var div = document.createElement("DIV");
+    materialize(test1, div);
+    test.equal(canonicalizeHtml(div.innerHTML), "<p>Hello</p>");
+
+    R.set('World');
+    Deps.flush();
+    test.equal(canonicalizeHtml(div.innerHTML), "<p>World</p>");
+  })();
+
+  // Reactively change an array of text nodes
+  (function () {
+    var R = ReactiveVar(['Hello', ' World']);
+    var test1 = P(function () { return R.get(); });
+
+    test.equal(toHTML(test1), '<p>Hello World</p>');
+
+    var div = document.createElement("DIV");
+    materialize(test1, div);
+    test.equal(canonicalizeHtml(div.innerHTML), "<p>Hello World</p>");
+
+    R.set(['Goodbye', ' World']);
+    Deps.flush();
+    test.equal(canonicalizeHtml(div.innerHTML), "<p>Goodbye World</p>");
+  })();
+
+});
+
+Tinytest.add("ui - render - closure GC", function (test) {
+  // test that removing parent element removes listeners and stops autoruns.
+  (function () {
+    var R = ReactiveVar('Hello');
+    var test1 = P(function () { return R.get(); });
+
+    var div = document.createElement("DIV");
+    materialize(test1, div);
+    test.equal(canonicalizeHtml(div.innerHTML), "<p>Hello</p>");
+
+    R.set('World');
+    Deps.flush();
+    test.equal(canonicalizeHtml(div.innerHTML), "<p>World</p>");
+
+    test.equal(R.numListeners(), 1);
+
+    $(div).remove();
+
+    test.equal(R.numListeners(), 0);
+
+    R.set('Steve');
+    Deps.flush();
+    // should not have changed:
+    test.equal(canonicalizeHtml(div.innerHTML), "<p>World</p>");
+  })();
+
+});
+
+Tinytest.add("ui - render - reactive attributes", function (test) {
+  (function () {
+    var R = ReactiveVar({'class': ['david gre', CharRef({html: '&euml;', str: '\u00eb'}), 'nspan'],
+                         id: 'foo'});
+
+    var spanCode = SPAN({$dynamic: [function () { return R.get(); }]});
+
+    test.equal(toHTML(spanCode), '<span class="david gre&euml;nspan" id="foo"></span>');
+
+    test.equal(R.numListeners(), 0);
+
+    var div = document.createElement("DIV");
+    materialize(spanCode, div);
+    test.equal(canonicalizeHtml(div.innerHTML), '<span class="david gre\u00ebnspan" id="foo"></span>');
+
+    test.equal(R.numListeners(), 1);
+
+    var span = div.firstChild;
+    test.equal(span.nodeName, 'SPAN');
+    span.className += ' blah';
+
+    R.set({'class': 'david smith', id: 'bar'});
+    Deps.flush();
+    test.equal(canonicalizeHtml(div.innerHTML), '<span class="david blah smith" id="bar"></span>');
+    test.equal(R.numListeners(), 1);
+
+    R.set({});
+    Deps.flush();
+    test.equal(canonicalizeHtml(div.innerHTML), '<span class="blah"></span>');
+    test.equal(R.numListeners(), 1);
+
+    $(div).remove();
+
+    test.equal(R.numListeners(), 0);
+  })();
+
+  // Test `null`, `undefined`, and `[]` attributes
+  (function () {
+    var R = ReactiveVar({id: 'foo',
+                         aaa: null,
+                         bbb: undefined,
+                         ccc: [],
+                         ddd: [null],
+                         eee: [undefined],
+                         fff: [[]],
+                         ggg: ['x', ['y', ['z']]]});
+
+    var spanCode = SPAN({$dynamic: [function () { return R.get(); }]});
+
+    test.equal(toHTML(spanCode), '<span id="foo" ggg="xyz"></span>');
+    test.equal(toCode(SPAN(R.get())),
+               'HTML.SPAN({id: "foo", ggg: ["x", ["y", ["z"]]]})');
+
+    var div = document.createElement("DIV");
+    materialize(spanCode, div);
+    var span = div.firstChild;
+    test.equal(span.nodeName, 'SPAN');
+
+    test.equal(canonicalizeHtml(div.innerHTML), '<span ggg="xyz" id="foo"></span>');
+    R.set({id: 'foo', ggg: [[], [], []]});
+    Deps.flush();
+    test.equal(canonicalizeHtml(div.innerHTML), '<span id="foo"></span>');
+
+    R.set({id: 'foo', ggg: null});
+    Deps.flush();
+    test.equal(canonicalizeHtml(div.innerHTML), '<span id="foo"></span>');
+
+    R.set({id: 'foo', ggg: ''});
+    Deps.flush();
+    test.equal(canonicalizeHtml(div.innerHTML), '<span ggg="" id="foo"></span>');
+
+    $(span).remove();
+
+    test.equal(R.numListeners(), 0);
+  })();
+});
+
+Tinytest.add("ui - render - components", function (test) {
+  (function () {
+    var counter = 1;
+    var buf = [];
+
+    var myComponent = UI.Component.extend({
+      init: function () {
+        // `this` is the component instance
+        var number = counter++;
+        this.number = number;
+
+        if (this.parent)
+          buf.push('parent of ' + this.number + ' is ' + this.parent.number);
+
+        this.data = function () {
+          return this.number;
+        };
+      },
+      created: function () {
+        // `this` is the template instance
+        buf.push('created ' + this.data);
+      },
+      render: function () {
+        // `this` is the component instance
+        return [String(this.number),
+
+                (this.number < 3 ? myComponent : HR())];
+      },
+      rendered: function () {
+        // `this` is the template instance
+        var nodeDescr = function (node) {
+          if (node.nodeType === 8) // comment
+            return '';
+          if (node.nodeType === 3) // text
+            return node.nodeValue;
+
+          return node.nodeName;
+        };
+
+        var start = this.firstNode;
+        var end = this.lastNode;
+        // skip marker nodes
+        while (start !== end && ! nodeDescr(start))
+          start = start.nextSibling;
+        while (end !== start && ! nodeDescr(end))
+          end = end.previousSibling;
+
+
+        // `this` is the template instance
+        buf.push('dom-' + this.data + ' is ' + nodeDescr(start) +'..' +
+                 nodeDescr(end));
+      },
+      destroyed: function () {
+        // `this` is the template instance
+        buf.push('destroyed ' + this.data);
+      }
+    });
+
+    var div = document.createElement("DIV");
+
+    materialize(myComponent, div);
+    buf.push('---flush---');
+    Deps.flush();
+    test.equal(buf, ['created 1',
+                     'parent of 2 is 1',
+                     'created 2',
+                     'parent of 3 is 2',
+                     'created 3',
+                     '---flush---',
+                     // (proper order for these has not be thought out:)
+                     'dom-1 is 1..HR',
+                     'dom-2 is 2..HR',
+                     'dom-3 is 3..HR']);
+
+    test.equal(canonicalizeHtml(div.innerHTML), '123<hr>');
+
+    buf.length = 0;
+    $(div).remove();
+    buf.sort();
+    test.equal(buf, ['destroyed 1', 'destroyed 2', 'destroyed 3']);
+
+    // Now use toHTML.  Should still get most of the callbacks (not `rendered`).
+
+    buf.length = 0;
+    counter = 1;
+
+    var html = toHTML(myComponent);
+
+    test.equal(buf, ['created 1',
+                     'parent of 2 is 1',
+                     'created 2',
+                     'parent of 3 is 2',
+                     'created 3']);
+
+    test.equal(html, '123<hr>');
+  })();
+});
+
+Tinytest.add("ui - render - reactive attributes 2", function (test) {
+  var R1 = ReactiveVar(['foo']);
+  var R2 = ReactiveVar(['bar']);
+
+  var spanCode = SPAN({
+    blah: function () { return R1.get(); },
+    $dynamic: [function () { return { blah: [function () { return R2.get(); }] }; }]
+  });
+
+  var div = document.createElement("DIV");
+  materialize(spanCode, div);
+  var check = function (expected) {
+    test.equal(toHTML(spanCode), expected);
+    test.equal(canonicalizeHtml(div.innerHTML), expected);
+  };
+  check('<span blah="bar"></span>');
+
+  test.equal(R1.numListeners(), 1);
+  test.equal(R2.numListeners(), 1);
+
+  R2.set([[]]);
+  Deps.flush();
+  // We combine `['foo']` with what evaluates to `[[[]]]`, which is nully.
+  test.equal(spanCode.evaluateAttributes().blah, ["foo"]);
+  check('<span blah="foo"></span>');
+
+  R2.set([['']]);
+  Deps.flush();
+  // We combine `['foo']` with what evaluates to `[[['']]]`, which is non-nully.
+  test.equal(spanCode.evaluateAttributes().blah, [[['']]]);
+  check('<span blah=""></span>');
+
+  R2.set(null);
+  Deps.flush();
+  // We combine `['foo']` with `[null]`, which is nully.
+  test.equal(spanCode.evaluateAttributes().blah, ['foo']);
+  check('<span blah="foo"></span>');
+
+  R1.set([[], []]);
+  Deps.flush();
+  // We combine two nully values.
+  check('<span></span>');
+
+  R1.set([[], ['foo']]);
+  Deps.flush();
+  check('<span blah="foo"></span>');
+
+  // clean up
+
+  $(div).remove();
+
+  test.equal(R1.numListeners(), 0);
+  test.equal(R2.numListeners(), 0);
+});
+
+Tinytest.add("ui - render - SVG", function (test) {
+  if (! document.createElementNS) {
+    // IE 8
+    return;
+  }
+
+  var fillColor = ReactiveVar('red');
+  var classes = ReactiveVar('one two');
+
+  var content = DIV({'class': 'container'}, HTML.SVG(
+    {width: 100, height: 100},
+    HTML.CIRCLE({cx: 50, cy: 50, r: 40,
+                 stroke: 'black', 'stroke-width': 3,
+                 'class': function () { return classes.get(); },
+                 fill: function () { return fillColor.get(); }})));
+
+  var div = document.createElement("DIV");
+  materialize(content, div);
+
+  var circle = div.querySelector('.container > svg > circle');
+  test.equal(circle.getAttribute('fill'), 'red');
+  test.equal(circle.className.baseVal, 'one two');
+
+  fillColor.set('green');
+  classes.set('two three');
+  Deps.flush();
+  test.equal(circle.getAttribute('fill'), 'green');
+  test.equal(circle.className.baseVal, 'two three');
+
+  test.equal(circle.nodeName, 'circle');
+  test.equal(circle.namespaceURI, "http://www.w3.org/2000/svg");
+  test.equal(circle.parentNode.namespaceURI, "http://www.w3.org/2000/svg");
+});
+
+Tinytest.add("ui - UI.render", function (test) {
+  var div = document.createElement("DIV");
+  document.body.appendChild(div);
+
+  var R = ReactiveVar('aaa');
+  var tmpl = UI.Component.extend({
+    render: function () {
+      var self = this;
+      return SPAN(function () {
+        return (self.get('greeting') || 'Hello') + ' ' + R.get();
+      });
+    }
+  });
+
+  UI.insert(UI.render(tmpl), div);
+  UI.insert(UI.renderWithData(tmpl, {greeting: 'Bye'}), div);
+  test.equal(canonicalizeHtml(div.innerHTML),
+             "<span>Hello aaa</span><span>Bye aaa</span>");
+  R.set('bbb');
+  Deps.flush();
+  test.equal(canonicalizeHtml(div.innerHTML),
+             "<span>Hello bbb</span><span>Bye bbb</span>");
+
+  document.body.removeChild(div);
+});
+
+Tinytest.add("ui - UI.getDataContext", function (test) {
+  var div = document.createElement("DIV");
+
+  var tmpl = UI.Component.extend({
+    render: function () {
+      return SPAN();
+    }
+  });
+
+  UI.insert(UI.renderWithData(tmpl, {foo: "bar"}), div);
+  var span = $(div).children('SPAN')[0];
+  test.isTrue(span);
+  test.equal(UI.getElementData(span), {foo: "bar"});
+});
diff --git a/packages/universal-events/event_tests.js b/packages/universal-events/event_tests.js
deleted file mode 100644
index 5ae1288e18..0000000000
--- a/packages/universal-events/event_tests.js
+++ /dev/null
@@ -1,83 +0,0 @@
-
-Tinytest.add("universal-events - basic", function(test) {
-
-  var runTest = function (testMissingHandlers) {
-    var msgs = [];
-    var listeners = [];
-
-    var createListener = function () {
-      var out = [];
-      msgs.push(out);
-      var ret = new UniversalEventListener(function(event) {
-        var node = event.currentTarget;
-        if (DomUtils.elementContains(document.body, node)) {
-          out.push(event.currentTarget.nodeName.toLowerCase());
-        }
-      }, testMissingHandlers);
-      listeners.push(ret);
-      return ret;
-    };
-
-    var L1 = createListener();
-
-    var check = function (event, expected) {
-      _.each(msgs, function (m) {
-        m.length = 0;
-      });
-      simulateEvent(DomUtils.find(d.node(), "b"), event);
-      for (var i = 0; i < listeners.length; i++)
-        test.equal(msgs[i], testMissingHandlers ? [] : expected[i]);
-    };
-
-    var d = OnscreenDiv(Meteor.render("<div><span><b>Hello</b></span></div>"));
-    L1.addType('mousedown');
-    if (!testMissingHandlers)
-      L1.installHandler(d.node(), 'mousedown');
-    var x = ['b', 'span', 'div', 'div'];
-    check('mousedown', [x]);
-
-    check('mouseup', [[]]);
-
-    L1.removeType('mousedown');
-    check('mousedown', [[]]);
-    L1.removeType('mousedown');
-    check('mousedown', [[]]);
-
-    L1.addType('mousedown');
-    check('mousedown', [x]);
-    L1.addType('mousedown');
-    check('mousedown', [x]);
-    L1.removeType('mousedown');
-    check('mousedown', [[]]);
-
-    var L2 = createListener();
-    if (!testMissingHandlers)
-      L2.installHandler(d.node(), 'mousedown');
-
-    L1.addType('mousedown');
-    check('mousedown', [x, []]);
-    L2.addType('mousedown');
-    check('mousedown', [x, x]);
-    L2.addType('mousedown');
-    check('mousedown', [x, x]);
-    L1.removeType('mousedown');
-    check('mousedown', [[], x]);
-    L1.removeType('mousedown');
-    check('mousedown', [[], x]);
-    L2.removeType('mousedown');
-    check('mousedown', [[], []]);
-    L1.addType('mousedown');
-    check('mousedown', [x, []]);
-    L1.removeType('mousedown');
-    check('mousedown', [[], []]);
-    L2.addType('mousedown');
-    check('mousedown', [[], x]);
-    L2.removeType('mousedown');
-    check('mousedown', [[], []]);
-
-    d.kill();
-  };
-
-  runTest(false);
-  runTest(true);
-});
diff --git a/packages/universal-events/events-ie.js b/packages/universal-events/events-ie.js
deleted file mode 100644
index d785c9e697..0000000000
--- a/packages/universal-events/events-ie.js
+++ /dev/null
@@ -1,162 +0,0 @@
-// Universal Events implementation for IE versions 6-8, which lack
-// addEventListener and event capturing.
-//
-// The strategy is very different.  We walk the subtree in question
-// and just attach the handler to all elements.  If the handler is
-// foo and the eventType is 'click', we assign node.onclick = foo
-// everywhere.  Since there is only one function object and we are
-// just assigning a property, hopefully this is somewhat lightweight.
-//
-// We use the node.onfoo method of binding events, also called "DOM0"
-// or the "traditional event registration", rather than the IE-native
-// node.attachEvent(...), mainly because we have the benefit of
-// referring to `this` from the handler in order to populate
-// event.currentTarget.  It seems that otherwise we'd have to create
-// a closure per node to remember what node we are handling.
-//
-// We polyfill the usual event properties from their various locations.
-// We also make 'change' and 'submit' bubble, and we fire 'change'
-// events on checkboxes and radio buttons immediately rather than
-// only when the user blurs them, another old IE quirk.
-
-UniversalEventListener._impl = UniversalEventListener._impl ||  {};
-
-// Singleton
-UniversalEventListener._impl.ie = function (deliver) {
-  var self = this;
-  this.deliver = deliver;
-  this.curriedHandler = function () {
-    self.handler.call(this, self);
-  };
-
-  // The 'submit' event on IE doesn't bubble.  We want to simulate
-  // bubbling submit to match other browsers, and to do that we use
-  // IE's own event machinery.  We can't dispatch events with arbitrary
-  // names in IE, so we appropriate the obscure "datasetcomplete" event
-  // for this purpose.
-  document.attachEvent('ondatasetcomplete', function () {
-    var evt = window.event;
-    var target = evt && evt.srcElement;
-    if (evt.synthetic && target &&
-        target.nodeName === 'FORM' &&
-        evt.returnValue !== false)
-      // No event handler called preventDefault on the simulated
-      // submit event.  That means the form should be submitted.
-      target.submit();
-  });
-};
-
-_.extend(UniversalEventListener._impl.ie.prototype, {
-  addType: function (type) {
-    // not necessary for IE
-  },
-
-  removeType: function (type) {
-    // not necessary for IE
-  },
-
-  installHandler: function (node, type) {
-    // use old-school event binding, so that we can
-    // access the currentTarget as `this` in the handler.
-    // note: handler is never removed from node
-    var prop = 'on' + type;
-
-    if (node.nodeType === 1) { // ELEMENT
-      this._install(node, prop);
-
-      // hopefully fast traversal, since the browser is doing it
-      var descendents = node.getElementsByTagName('*');
-
-      for(var i=0, N = descendents.length; i<N; i++)
-        this._install(descendents[i], prop);
-    }
-  },
-
-  _install: function (node, prop) {
-    var props = [prop];
-
-    // install handlers for faking focus/blur if necessary
-    if (prop === 'onfocus')
-      props.push('onfocusin');
-    else if (prop === 'onblur')
-      props.push('onfocusout');
-    // install handlers for faking bubbling change/submit
-    else if (prop === 'onchange') {
-      // if we're looking at a checkbox or radio button,
-      // sign up for propertychange and NOT change
-      if (node.nodeName === 'INPUT' &&
-          (node.type === 'checkbox' || node.type === 'radio'))
-        props = ['onpropertychange'];
-      props.push('oncellchange');
-    } else if (prop === 'onsubmit')
-      props.push('ondatasetcomplete');
-
-    for(var i = 0; i < props.length; i++)
-      node[props[i]] = this.curriedHandler;
-  },
-
-  // This is the handler we assign to DOM nodes, so it shouldn't close over
-  // anything that would create a circular reference leading to a memory leak.
-  //
-  // This handler is called via this.curriedHandler. When it is called:
-  //  - 'this' is the node currently handling the event (set by IE)
-  //  - 'self' is what would normally be 'this'
-  handler: function (self) {
-    var sendEvent = function (ontype, target) {
-      var e = document.createEventObject();
-      e.synthetic = true;
-      target.fireEvent(ontype, e);
-      return e.returnValue;
-    };
-
-
-    var event = window.event;
-    var type = event.type;
-    var target = event.srcElement || document;
-    event.target = target;
-    if (this.nodeType !== 1)
-      return; // sanity check that we have a real target (always an element)
-    event.currentTarget = this;
-    var curNode = this;
-
-    // simulate focus/blur so that they are synchronous;
-    // simulate change/submit so that they bubble.
-    // The IE-specific 'cellchange' and 'datasetcomplete' events actually
-    // have nothing to do with change and submit, we are just using them
-    // as dummy events because we need event types that IE considers real
-    // (and apps are unlikely to use them).
-    if (curNode === target && ! event.synthetic) {
-      if (type === 'focusin')
-        sendEvent('onfocus', curNode);
-      else if (type === 'focusout')
-        sendEvent('onblur', curNode);
-      else if (type === 'change')
-        sendEvent('oncellchange', curNode);
-      else if (type === 'propertychange') {
-        if (event.propertyName === 'checked')
-          sendEvent('oncellchange', curNode);
-      } else if (type === 'submit') {
-        sendEvent('ondatasetcomplete', curNode);
-      }
-    }
-    // ignore non-simulated events of types we simulate
-    if ((type === 'focus' || event.type === 'blur'
-         || event.type === 'change' ||
-         event.type === 'submit') && ! event.synthetic) {
-      if (event.type === 'submit')
-        event.returnValue = false; // block all native submits, we will submit
-      return;
-    }
-
-    // morph the event
-    if (type === 'cellchange' && event.synthetic) {
-      type = event.type = 'change';
-    }
-    if (type === 'datasetcomplete' && event.synthetic) {
-      type = event.type = 'submit';
-    }
-
-    self.deliver(event);
-  }
-
-});
diff --git a/packages/universal-events/events-w3c.js b/packages/universal-events/events-w3c.js
deleted file mode 100644
index 466e6c85ae..0000000000
--- a/packages/universal-events/events-w3c.js
+++ /dev/null
@@ -1,220 +0,0 @@
-// Universal Events implementation that depends on the W3C event
-// model, i.e. addEventListener and capturing.  It's intended for all
-// browsers except IE <= 8.
-//
-// We take advantage of the fact that event handlers installed during
-// the capture phase are live during the bubbling phase.  By installing
-// a capturing listener on the document, we bind the handler to the
-// event target and its ancestors "just in time".
-
-var SIMULATE_NEITHER = 0;
-var SIMULATE_FOCUS_BLUR = 1;
-var SIMULATE_FOCUSIN_FOCUSOUT = 2;
-
-UniversalEventListener._impl = UniversalEventListener._impl ||  {};
-
-// Singleton
-UniversalEventListener._impl.w3c = function (deliver) {
-  this.deliver = deliver;
-  this.typeCounts = {}; // map from event type name to count
-
-  this.boundHandler = _.bind(this.handler, this);
-  this.boundCapturer = _.bind(this.capturer, this);
-
-  // Focusin/focusout are the bubbling versions of focus/blur, and
-  // are part of the W3C spec, but are absent from Firefox as of
-  // today (v11), so we supply them.
-  //
-  // In addition, while most browsers fire these events sync in
-  // response to a programmatic action (like .focus()), not all do.
-  // IE 9+ fires focusin/focusout sync but focus/blur async.  Opera
-  // fires them all async.  We don't do anything about this right
-  // now, but simulating focus/blur on IE would make them sync.
-  //
-  // We have the capabiilty here to simulate focusin/focusout from
-  // focus/blur, vice versa, or neither.
-  //
-  // We do a browser check that fails in old Firefox (3.6) but will
-  // succeed if Firefox ever implements focusin/focusout.  Old
-  // Firefox fails all tests of the form ('onfoo' in node), while
-  // new Firefox and all other known browsers will pass if 'foo' is
-  // a known event.
-  this.focusBlurMode = ('onfocusin' in document.createElement("DIV")) ?
-    SIMULATE_NEITHER : SIMULATE_FOCUSIN_FOCUSOUT;
-
-  // mouseenter/mouseleave is non-bubbling mouseover/mouseout.  It's
-  // standard but only IE and Opera seem to support it,
-  // so we simulate it (which works in IE but not in Opera for some reason).
-  this.simulateMouseEnterLeave = (! window.opera);
-};
-
-_.extend(UniversalEventListener._impl.w3c.prototype, {
-  addType: function (eventType) {
-    this._listen(this._expandEventType(eventType));
-  },
-
-  removeType: function (type) {
-    this._unlisten(this._expandEventType(type));
-  },
-
-  installHandler: function (node, type) {
-    // Unnecessary in w3c implementation
-  },
-
-  _expandEventType: function (type) {
-    var ret = [type];
-
-    // install handlers for the events used to fake events of this
-    // type, in addition to handlers for the real type
-
-    if (this.focusBlurMode === SIMULATE_FOCUS_BLUR) {
-      if (type === 'focus')
-        ret.push('focusin');
-      else if (type === 'blur')
-        ret.push('focusout');
-    } else if (this.focusBlurMode === SIMULATE_FOCUSIN_FOCUSOUT) {
-      if (type === 'focusin')
-        ret.push('focus');
-      else if (type === 'focusout')
-        ret.push('blur');
-    }
-    if (this.simulateMouseEnterLeave) {
-      if (type === 'mouseenter')
-        ret.push('mouseover');
-      else if (type === 'mouseleave')
-        ret.push('mouseout');
-    }
-
-    if (type === 'tap') {
-      ret.push('touchmove');
-      ret.push('touchend');
-    }
-
-    return ret;
-  },
-
-  _listen: function (types) {
-    var self = this;
-    _.each(types, function (type) {
-      if ((self.typeCounts[type] = (self.typeCounts[type] || 0) + 1) === 1)
-        document.addEventListener(type, self.boundCapturer, true);
-    });
-  },
-
-  _unlisten: function (types) {
-    var self = this;
-    _.each(types, function (type) {
-      if (!(--self.typeCounts[type])) {
-        document.removeEventListener(type, self.boundCapturer, true);
-      }
-    });
-  },
-
-  capturer: function (event) {
-    if (event.target.nodeType === 3) // fix text-node target
-      event.target = event.target.parentNode;
-
-    var type = event.type;
-    var bubbles = event.bubbles;
-    var target = event.target;
-
-    target.addEventListener(type, this.boundHandler, false);
-
-    // According to the DOM event spec, if the DOM is mutated during
-    // event handling, the original bubbling order still applies.
-    // So we can determine the chain of nodes that could possibly
-    // be bubbled to right now.
-    var ancestors;
-    if (bubbles) {
-      ancestors = [];
-      for(var n = target.parentNode; n; n = n.parentNode) {
-        n.addEventListener(type, this.boundHandler, false);
-        ancestors.push(n);
-      };
-    }
-
-    // Unbind the handlers later.
-    setTimeout(function() {
-      target.removeEventListener(type, this.boundHandler, false);
-      if (bubbles) {
-        _.each(ancestors, function(n) {
-          n.removeEventListener(type, this.boundHandler, false);
-        });
-      };
-    }, 0);
-  },
-
-  handler: function (event) {
-    var sendUIEvent = function (type, target, bubbles, cancelable, detail) {
-      var evt = document.createEvent("UIEvents");
-      evt.initUIEvent(type, bubbles, cancelable, window, detail);
-      evt.synthetic = true;
-      target.dispatchEvent(evt);
-    };
-
-    // fire synthetic focusin/focusout on blur/focus or vice versa
-    if (event.currentTarget === event.target) {
-      if (this.focusBlurMode === SIMULATE_FOCUS_BLUR) {
-        if (event.type === 'focusin')
-          sendUIEvent('focus', event.target, false);
-        else if (event.type === 'focusout')
-          sendUIEvent('blur', event.target, false);
-      } else if (this.focusBlurMode === SIMULATE_FOCUSIN_FOCUSOUT) {
-        if (event.type === 'focus')
-          sendUIEvent('focusin', event.target, true);
-        else if (event.type === 'blur')
-          sendUIEvent('focusout', event.target, true);
-      }
-    }
-    // only respond to synthetic events of the types we are faking
-    if (this.focusBlurMode === SIMULATE_FOCUS_BLUR) {
-      if (event.type === 'focus' || event.type === 'blur') {
-        if (! event.synthetic)
-          return;
-      }
-    } else if (this.focusBlurMode === SIMULATE_FOCUSIN_FOCUSOUT) {
-      if (event.type === 'focusin' || event.type === 'focusout') {
-        if (! event.synthetic)
-          return;
-      }
-    }
-    if (this.simulateMouseEnterLeave) {
-      if (event.type === 'mouseenter' || event.type === 'mouseleave') {
-        if (! event.synthetic)
-          return;
-      }
-    }
-
-    this.deliver(event);
-
-    // event ordering: fire mouseleave after mouseout
-    if (this.simulateMouseEnterLeave &&
-        // We respond to mouseover/mouseout here even on
-        // bubble, i.e. when event.currentTarget !== event.target,
-        // to ensure we see every enter and leave.
-        // We ignore the case where the mouse enters from
-        // a child or leaves to a child (by checking if
-        // relatedTarget is present and a descendent).
-        (! event.relatedTarget ||
-         (event.currentTarget !== event.relatedTarget &&
-          ! DomUtils.elementContains(
-            event.currentTarget, event.relatedTarget)))) {
-      if (event.type === 'mouseover') {
-        sendUIEvent('mouseenter', event.currentTarget, false);
-      }
-      else if (event.type === 'mouseout') {
-        sendUIEvent('mouseleave', event.currentTarget, false);
-      }
-    }
-
-    if (event.type === 'touchmove') {
-      event.currentTarget._notTapping = true;
-    }
-    if (event.type === 'touchend') {
-      if (!event.currentTarget._notTapping) {
-        sendUIEvent('tap', event.currentTarget, true);
-      }
-      delete event.currentTarget._notTapping;
-    }
-  }
-});
diff --git a/packages/universal-events/listener.js b/packages/universal-events/listener.js
deleted file mode 100644
index b6863d9d72..0000000000
--- a/packages/universal-events/listener.js
+++ /dev/null
@@ -1,251 +0,0 @@
-// Meteor Universal Events -- Normalized cross-browser event handling library
-//
-// This module lets you set up a function f that will be called
-// whenever an event fires on any element in the DOM. Specifically,
-// when an event fires on node N, f will be called with N. Then, if
-// the event is a bubbling event, f will be called again with N's
-// parent, then called again with N's grandparent, etc, until the root
-// of the document is reached. This provides a good base on top of
-// which custom event handling systems can be implemented.
-//
-// f also receives the event object for the event that fired. The
-// event object is normalized and extended to smooth over
-// cross-browser differences in event handling. See the details in
-// setHandler.
-//
-// Usage:
-//   var listener = new UniversalEventListener(function (event) { ... });
-//   listener.addType("click");
-//
-// If you want to support IE <= 8, you must also call installHandler
-// on each subtree of DOM nodes on which you wish to receive events,
-// eg, before inserting them into the document.
-//
-// Universal Events works reliably for events that fire on any DOM
-// element. It may not work consistently across browsers for events
-// that are intended to fire on non-element nodes (eg, text nodes).
-// We're not sure if it's possible to handle those events consistently
-// across browsers, but in any event, it's not a common use case.
-//
-// Implementation notes:
-//
-// Internally, there are two separate implementations, one for modern
-// browsers (in events-w3c.js), and one for old browsers with no
-// event capturing support (in events-ie.js.) The correct
-// implementation will be chosen for you automatically at runtime.
-
-var listeners = [];
-
-var returnFalse = function() { return false; };
-var returnTrue = function() { return true; };
-
-// inspired by jquery fix()
-var normalizeEvent = function (event) {
-  var originalStopPropagation = event.stopPropagation;
-  var originalPreventDefault = event.preventDefault;
-  event.isPropagationStopped = returnFalse;
-  event.isImmediatePropagationStopped = returnFalse;
-  event.isDefaultPrevented = returnFalse;
-  event.stopPropagation = function() {
-    event.isPropagationStopped = returnTrue;
-    if (originalStopPropagation)
-      originalStopPropagation.call(event);
-    else
-      event.cancelBubble = true; // IE
-  };
-  event.preventDefault = function() {
-    event.isDefaultPrevented = returnTrue;
-    if (originalPreventDefault)
-      originalPreventDefault.call(event);
-    else
-      event.returnValue = false; // IE
-  };
-  event.stopImmediatePropagation = function() {
-    event.stopPropagation();
-    event.isImmediatePropagationStopped = returnTrue;
-  };
-
-  var type = event.type;
-
-  // adapted from jquery
-  if (event.metaKey === undefined)
-    event.metaKey = event.ctrlKey;
-  if (/^key/.test(type)) {
-    // KEY EVENTS
-    // Add which.  Technically char codes and key codes are
-    // different things; the former is ASCII/unicode/etc and the
-    // latter is arbitrary.  But browsers that lack charCode
-    // seem to put character info in keyCode.
-    // (foo == null) tests for null or undefined
-    if (event.which == null)
-      event.which = (event.charCode != null ? event.charCode : event.keyCode);
-  } else if (/^(?:mouse|contextmenu)|click/.test(type)) {
-    // MOUSE EVENTS
-    // Add relatedTarget, if necessary
-    if (! event.relatedTarget && event.fromElement)
-      event.relatedTarget = (event.fromElement === event.target ?
-                             event.toElement : event.fromElement);
-    // Add which for click: 1 === left; 2 === middle; 3 === right
-    if (! event.which && event.button !== undefined ) {
-      var button = event.button;
-      event.which = (button & 1 ? 1 :
-                     (button & 2 ? 3 :
-                       (button & 4 ? 2 : 0 )));
-    }
-  }
-
-  return event;
-};
-
-var deliver = function (event) {
-  event = normalizeEvent(event);
-  _.each(listeners, function (listener) {
-    if (listener.types[event.type]) {
-      // if in debug mode, filter out events where the user forgot
-      // to call installHandler, even if we're not on IE
-      if (!(listener._checkIECompliance &&
-            ! event.currentTarget['_uevents_test_eventtype_' + event.type]))
-        listener.handler.call(null, event);
-    }
-  });
-};
-
-// When IE8 is dead, we can remove this springboard logic.
-var impl;
-var getImpl = function () {
-  if (! impl)
-    impl = (document.addEventListener ?
-            new UniversalEventListener._impl.w3c(deliver) :
-            new UniversalEventListener._impl.ie(deliver));
-  return impl;
-};
-
-var typeCounts = {};
-
-
-////////// PUBLIC API
-
-// Create a new universal event listener with a given handler.
-// Until some event types are turned on with `addType`, the handler
-// will not receive any events.
-//
-// Whenever an event of the appropriate type fires anywhere in the
-// document, `handler` will be called with one argument, the
-// event. If the event is a bubbling event (most events are
-// bubbling, eg, 'click'), then `handler` will be called not only
-// for the element that was the origin of the event (eg, the button
-// that was clicked), but for each parent element as the event
-// bubbles up to the top of the tree.
-//
-// The event object that's passed to `handler` will be normalized
-// across browsers so that it contains the following fields and
-// methods:
-//
-// - type (e.g. "click")
-// - target
-// - currentTarget
-// - stopPropagation()
-// - preventDefault()
-// - isPropagationStopped()
-// - isDefaultPrevented()
-//
-// NOTE: If you want compatibility with IE <= 8, you will need to
-// call `installHandler` to prepare each subtree of the DOM to receive
-// the events you are interested in.
-//
-// Debugging only:
-//
-// The _checkIECompliance flag enables extra checking that the user
-// is correctly registering new DOM nodes with installHandler, even
-// in browsers that don't require it. In other words, when the flag
-// is set, modern browsers will require the same API calls as IE <=
-// 8. This is only used for tests and is private for now.
-UniversalEventListener = function (handler, _checkIECompliance) {
-  this.handler = handler;
-  this.types = {}; // map from event type name to 'true'
-  this.impl = getImpl();
-  this._checkIECompliance = _checkIECompliance;
-  listeners.push(this);
-};
-
-_.extend(UniversalEventListener.prototype, {
-  // Adds `type` to the set of event types that this listener will
-  // listen to and deliver to the handler.  Has no effect if `type`
-  // is already in the set.
-  addType: function (type) {
-    if (!this.types[type]) {
-      this.types[type] = true;
-      typeCounts[type] = (typeCounts[type] || 0) + 1;
-      if (typeCounts[type] === 1)
-        this.impl.addType(type);
-    }
-  },
-
-  // Removes `type` from the set of event types that this listener
-  // will listen to and deliver to the handler.  Has no effect if `type`
-  // is not in the set.
-  removeType: function (type) {
-    if (this.types[type]) {
-      delete this.types[type];
-      typeCounts[type]--;
-      if (! typeCounts[type])
-        this.impl.removeType(type);
-    }
-  },
-
-  // It is only necessary to call this method if you want to support
-  // IE <= 8. On those browsers, you must call this method on each
-  // set of nodes before adding them to the DOM (or at least, before
-  // expecting to receive events on them), and you must specify the
-  // types of events you'll be receiving.
-  //
-  // `node` and all of its descendents will be set up to handle
-  // events of type `type` (eg, 'click'). Only current descendents
-  // of `node` are affected; if new nodes are added to the subtree
-  // later, installHandler must be called again to ensure events are
-  // received on those nodes. To set up to handle multiple event
-  // types, make multiple calls.
-  //
-  // It is safe to call installHandler any number of times on the same
-  // arguments (it is idempotent).
-  //
-  // If you forget to call this function for a given node, it's
-  // unspecified whether you'll receive events on IE <= 8 (you may,
-  // you may not.) If you don't care about supporting IE <= 8 you
-  // can ignore this function.
-  installHandler: function (node, type) {
-    // Only work on element nodes, not e.g. text nodes or fragments
-    if (node.nodeType !== 1)
-      return;
-    this.impl.installHandler(node, type);
-
-    // When in checkIECompliance mode, mark all the nodes in the current subtree.
-    // We will later block events on nodes that weren't marked.  This
-    // tests that Spark is generating calls to registerEventType
-    // with proper subtree information, even in browsers that don't need
-    // it.
-    if (this._checkIECompliance) {
-      // set flag to mark the node for this type, recording the
-      // fact that installHandler was called for this node and type.
-      // the property value can be any non-primitive value (to prevent
-      // showing up as an HTML attribute in IE) so we use `node` itself.
-      node['_uevents_test_eventtype_'+type] = node;
-      if (node.firstChild) {
-        _.each(node.getElementsByTagName('*'), function(x) {
-          x['_uevents_test_eventtype_'+type] = x;
-        });
-      }
-    }
-  },
-
-  // Tear down this UniversalEventListener so that no more events
-  // are delivered.
-  destroy: function () {
-    var self = this;
-
-    listeners = _.without(listeners, self);
-    _.each(_.keys(self.types), function (type) {
-      self.removeType(type);
-    });
-  }
-});
diff --git a/packages/universal-events/package.js b/packages/universal-events/package.js
deleted file mode 100644
index 9e430f812d..0000000000
--- a/packages/universal-events/package.js
+++ /dev/null
@@ -1,26 +0,0 @@
-Package.describe({
-  name: "universal-events",
-  test: "universal-events-test",
-  summary: "Listen to events globally, and normalize them",
-  version: '1.0.0',
-  internal: true
-});
-
-Package.on_use(function (api) {
-  api.use(['underscore', 'domutils'], 'client');
-  api.export('UniversalEventListener', 'client');
-  api.add_files(['listener.js',
-                 'events-w3c.js',
-                 'events-ie.js'], 'client');
-});
-
-Package.on_test(function (api) {
-  api.use('tinytest');
-  api.use(['universal-events', 'test-helpers', 'underscore'], 'client');
-  api.use('domutils');
-  api.use('spark');
-
-  api.add_files([
-    'event_tests.js'
-  ], 'client');
-});
diff --git a/packages/webapp/boilerplate.html b/packages/webapp/boilerplate.html
new file mode 100644
index 0000000000..a4fb29f8fb
--- /dev/null
+++ b/packages/webapp/boilerplate.html
@@ -0,0 +1,22 @@
+<html {{htmlAttributes}}>
+<head>
+{{#each css}}  <link rel="stylesheet" href="{{bundledJsCssPrefix}}{{url}}">{{/each}}
+
+{{#if inlineScriptsAllowed}}
+<script type='text/javascript'>__meteor_runtime_config__ = {{meteorRuntimeConfig}};</script>
+{{else}}
+<script type='text/javascript' src='{{rootUrlPathPrefix}}/meteor_runtime_config.js'></script>
+{{/if}}
+{{#each js}}  <script type="text/javascript" src="{{bundledJsCssPrefix}}{{url}}"></script>
+{{/each}}
+{{#if inlineScriptsAllowed}}
+<script type='text/javascript'>{{{reloadSafetyBelt}}}</script>
+{{else}}
+<script type='text/javascript' src='{{rootUrlPathPrefix}}/meteor_reload_safetybelt.js'></script>
+{{/if}}
+{{{head}}}
+</head>
+<body>
+{{{body}}}
+</body>
+</html>
diff --git a/packages/webapp/package.js b/packages/webapp/package.js
index a5d18af9ae..309475d7ad 100644
--- a/packages/webapp/package.js
+++ b/packages/webapp/package.js
@@ -9,7 +9,9 @@ Npm.depends({connect: "2.9.0",
              useragent: "2.0.7"});
 
 Package.on_use(function (api) {
-  api.use(['logging', 'underscore', 'routepolicy'], 'server');
+  api.use(['logging', 'underscore', 'routepolicy', 'spacebars-compiler',
+           'spacebars', 'htmljs', 'ui'],
+          'server');
   api.use(['underscore'], 'client');
   api.use(['application-configuration', 'follower-livedata'], {
     unordered: true
@@ -22,5 +24,10 @@ Package.on_use(function (api) {
   api.export(['WebApp', 'main', 'WebAppInternals'], 'server');
   api.export(['WebApp'], 'client');
   api.add_files('webapp_server.js', 'server');
+  // This is a spacebars template, but we process it manually with the spacebars
+  // compiler rather than letting the 'templating' package (which isn't fully
+  // supported on the server yet) handle it. That also means that it doesn't
+  // contain the outer "<template>" tag.
+  api.add_files('boilerplate.html', 'server', {isAsset: true});
   api.add_files('webapp_client.js', 'client');
 });
diff --git a/packages/webapp/webapp_server.js b/packages/webapp/webapp_server.js
index ad3fe4e1cb..ab22ce2414 100644
--- a/packages/webapp/webapp_server.js
+++ b/packages/webapp/webapp_server.js
@@ -25,10 +25,10 @@ var bundledJsCssPrefix;
 // CSS.  This prevents you from displaying the page in that case, and instead
 // reloads it, presumably all on the new version now.
 var RELOAD_SAFETYBELT = "\n" +
-      "if (typeof Package === 'undefined' || \n" +
-      "    ! Package.webapp || \n" +
-      "    ! Package.webapp.WebApp || \n" +
-      "    ! Package.webapp.WebApp._isCssLoaded()) \n" +
+      "if (typeof Package === 'undefined' ||\n" +
+      "    ! Package.webapp ||\n" +
+      "    ! Package.webapp.WebApp ||\n" +
+      "    ! Package.webapp.WebApp._isCssLoaded())\n" +
       "  document.location.reload(); \n";
 
 // Keepalives so that when the outer server dies unceremoniously and
@@ -131,14 +131,17 @@ WebApp.categorizeRequest = function (req) {
 // be added to the '<html>' tag. Each function is passed a 'request' object (see
 // #BrowserIdentification) and should return a string,
 var htmlAttributeHooks = [];
-var htmlAttributes = function (template, request) {
-  var attributes = '';
+var getHtmlAttributes = function (request) {
+  var combinedAttributes  = {};
   _.each(htmlAttributeHooks || [], function (hook) {
-    var attribute = hook(request);
-    if (attribute !== null && attribute !== undefined && attribute !== '')
-      attributes += ' ' + attribute;
+    var attributes = hook(request);
+    if (attributes === null)
+      return;
+    if (typeof attributes !== 'object')
+      throw Error("HTML attribute hook must return null or object");
+    _.extend(combinedAttributes, attributes);
   });
-  return template.replace('##HTML_ATTRIBUTES##', attributes);
+  return combinedAttributes;
 };
 WebApp.addHtmlAttributeHook = function (hook) {
   htmlAttributeHooks.push(hook);
@@ -432,13 +435,17 @@ var runWebAppServer = function () {
   });
 
   // Will be updated by main before we listen.
-  var boilerplateHtml = null;
+  var boilerplateTemplate = null;
+  var boilerplateBaseData = null;
+  var boilerplateByAttributes = {};
   app.use(function (req, res, next) {
     if (! appUrl(req.url))
       return next();
 
-    if (!boilerplateHtml)
-      throw new Error("boilerplateHtml should be set before listening!");
+    if (!boilerplateTemplate)
+      throw new Error("boilerplateTemplate should be set before listening!");
+    if (!boilerplateBaseData)
+      throw new Error("boilerplateBaseData should be set before listening!");
 
 
     var headers = {
@@ -459,9 +466,32 @@ var runWebAppServer = function () {
       res.end();
       return undefined;
     }
+
+    var htmlAttributes = getHtmlAttributes(request);
+
+    // The only thing that changes from request to request (for now) are the
+    // HTML attributes (used by, eg, appcache), so we can memoize based on that.
+    var attributeKey = JSON.stringify(htmlAttributes);
+    if (!_.has(boilerplateByAttributes, attributeKey)) {
+      try {
+        var boilerplateData = _.extend({htmlAttributes: htmlAttributes},
+                                       boilerplateBaseData);
+        var boilerplateInstance = boilerplateTemplate.extend({
+          data: boilerplateData
+        });
+        var boilerplateHtmlJs = boilerplateInstance.render();
+        boilerplateByAttributes[attributeKey] = "<!DOCTYPE html>\n" +
+              HTML.toHTML(boilerplateHtmlJs, boilerplateInstance);
+      } catch (e) {
+        Log.error("Error running template: " + e);
+        res.writeHead(500, headers);
+        res.end();
+        return undefined;
+      }
+    }
+
     res.writeHead(200, headers);
-    var requestSpecificHtml = htmlAttributes(boilerplateHtml, request);
-    res.write(requestSpecificHtml);
+    res.write(boilerplateByAttributes[attributeKey]);
     res.end();
     return undefined;
   });
@@ -559,37 +589,48 @@ var runWebAppServer = function () {
     // '--keepalive' is a use of the option.
     var expectKeepalives = _.contains(argv, '--keepalive');
 
-    var boilerplateHtmlPath = path.join(clientDir, clientJson.page);
-    boilerplateHtml = fs.readFileSync(boilerplateHtmlPath, 'utf8');
+    boilerplateBaseData = {
+      css: [],
+      js: [],
+      head: '',
+      body: '',
+      inlineScriptsAllowed: WebAppInternals.inlineScriptsAllowed(),
+      meteorRuntimeConfig: JSON.stringify(__meteor_runtime_config__),
+      reloadSafetyBelt: RELOAD_SAFETYBELT,
+      rootUrlPathPrefix: __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || '',
+      bundledJsCssPrefix: bundledJsCssPrefix ||
+        __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || ''
+    };
 
-    // Include __meteor_runtime_config__ in the app html, as an inline script if
-    // it's not forbidden by CSP.
-    if (WebAppInternals.inlineScriptsAllowed()) {
-      boilerplateHtml = boilerplateHtml.replace(
-          /##RUNTIME_CONFIG##/,
-        "<script type='text/javascript'>__meteor_runtime_config__ = " +
-          JSON.stringify(__meteor_runtime_config__) + ";</script>");
-      boilerplateHtml = boilerplateHtml.replace(
-          /##RELOAD_SAFETYBELT##/,
-        "<script type='text/javascript'>"+RELOAD_SAFETYBELT+"</script>");
-    } else {
-      boilerplateHtml = boilerplateHtml.replace(
-        /##RUNTIME_CONFIG##/,
-        "<script type='text/javascript' src='##ROOT_URL_PATH_PREFIX##/meteor_runtime_config.js'></script>"
-      );
-      boilerplateHtml = boilerplateHtml.replace(
-          /##RELOAD_SAFETYBELT##/,
-        "<script type='text/javascript' src='##ROOT_URL_PATH_PREFIX##/meteor_reload_safetybelt.js'></script>");
+    _.each(WebApp.clientProgram.manifest, function (item) {
+      if (item.type === 'css' && item.where === 'client') {
+        boilerplateBaseData.css.push({url: item.url});
+      }
+      if (item.type === 'js' && item.where === 'client') {
+        boilerplateBaseData.js.push({url: item.url});
+      }
+      if (item.type === 'head') {
+        boilerplateBaseData.head = fs.readFileSync(
+          path.join(clientDir, item.path), 'utf8');
+      }
+      if (item.type === 'body') {
+        boilerplateBaseData.body = fs.readFileSync(
+          path.join(clientDir, item.path), 'utf8');
+      }
+    });
 
-    }
-    boilerplateHtml = boilerplateHtml.replace(
-        /##ROOT_URL_PATH_PREFIX##/g,
-      __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || "");
+    var boilerplateTemplateSource = Assets.getText("boilerplate.html");
+    var boilerplateRenderCode = Spacebars.compile(
+      boilerplateTemplateSource, { isBody: true });
 
-    boilerplateHtml = boilerplateHtml.replace(
-        /##BUNDLED_JS_CSS_PREFIX##/g,
-      bundledJsCssPrefix ||
-        __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || "");
+    // Note that we are actually depending on eval's local environment capture
+    // so that UI and HTML are visible to the eval'd code.
+    var boilerplateRender = eval(boilerplateRenderCode);
+
+    boilerplateTemplate = UI.Component.extend({
+      kind: "MainPage",
+      render: boilerplateRender
+    });
 
     // only start listening after all the startup code has run.
     var localPort = parseInt(process.env.PORT) || 0;
diff --git a/packages/weibo/weibo_client.js b/packages/weibo/weibo_client.js
index 32b95f292c..e7a56742cf 100644
--- a/packages/weibo/weibo_client.js
+++ b/packages/weibo/weibo_client.js
@@ -14,11 +14,12 @@ Weibo.requestCredential = function (options, credentialRequestCompleteCallback)
 
   var config = ServiceConfiguration.configurations.findOne({service: 'weibo'});
   if (!config) {
-    credentialRequestCompleteCallback && credentialRequestCompleteCallback(new ServiceConfiguration.ConfigError("Service not configured"));
+    credentialRequestCompleteCallback && credentialRequestCompleteCallback(
+      new ServiceConfiguration.ConfigError());
     return;
   }
 
-  var credentialToken = Random.id();
+  var credentialToken = Random.secret();
   // XXX need to support configuring access_type and scope
   var loginUrl =
         'https://api.weibo.com/oauth2/authorize' +
@@ -27,7 +28,7 @@ Weibo.requestCredential = function (options, credentialRequestCompleteCallback)
         '&redirect_uri=' + Meteor.absoluteUrl('_oauth/weibo?close', {replaceLocalhost: true}) +
         '&state=' + credentialToken;
 
-  Oauth.showPopup(
+  OAuth.showPopup(
     loginUrl,
     _.bind(credentialRequestCompleteCallback, null, credentialToken)
   );
diff --git a/packages/weibo/weibo_server.js b/packages/weibo/weibo_server.js
index 1d2f525638..8da78bb22b 100644
--- a/packages/weibo/weibo_server.js
+++ b/packages/weibo/weibo_server.js
@@ -1,6 +1,6 @@
 Weibo = {};
 
-Oauth.registerService('weibo', 2, null, function(query) {
+OAuth.registerService('weibo', 2, null, function(query) {
 
   var response = getTokenResponse(query);
   var uid = parseInt(response.uid, 10);
@@ -33,7 +33,7 @@ Oauth.registerService('weibo', 2, null, function(query) {
 var getTokenResponse = function (query) {
   var config = ServiceConfiguration.configurations.findOne({service: 'weibo'});
   if (!config)
-    throw new ServiceConfiguration.ConfigError("Service not configured");
+    throw new ServiceConfiguration.ConfigError();
 
   var response;
   try {
@@ -41,7 +41,7 @@ var getTokenResponse = function (query) {
       "https://api.weibo.com/oauth2/access_token", {params: {
         code: query.code,
         client_id: config.clientId,
-        client_secret: config.secret,
+        client_secret: OAuth.openSecret(config.secret),
         redirect_uri: Meteor.absoluteUrl("_oauth/weibo?close", {replaceLocalhost: true}),
         grant_type: 'authorization_code'
       }});
@@ -73,5 +73,5 @@ var getIdentity = function (accessToken, userId) {
 };
 
 Weibo.retrieveCredential = function(credentialToken) {
-  return Oauth.retrieveCredential(credentialToken);
+  return OAuth.retrieveCredential(credentialToken);
 };
diff --git a/scripts/admin/banner.txt b/scripts/admin/banner.txt
index 571b063d08..92f42a493e 100644
--- a/scripts/admin/banner.txt
+++ b/scripts/admin/banner.txt
@@ -1,5 +1,4 @@
-=> Meteor 0.7.2: Support limit queries in the oplog tailing driver. Add
-   hooks to customize the login process.
+=> Meteor 0.8.0.1: Fix security problem in Twitter OAuth flow.
 
    This release is being downloaded in the background. Update your
-   project to Meteor 0.7.2 by running 'meteor update'.
+   project to Meteor 0.8.0.1 by running 'meteor update'.
diff --git a/scripts/admin/bless-release.js b/scripts/admin/bless-release.js
index 9a9b2d3247..ade802b47c 100644
--- a/scripts/admin/bless-release.js
+++ b/scripts/admin/bless-release.js
@@ -248,11 +248,28 @@ var main = function () {
   _.each(notices, function (record) {
     if (!record.release)
       die("An element of notices.json lacks a release.");
-    _.each(record.notices, function (line) {
-      if (line.length + record.release.length + 2 > 80) {
-        die("notices.json: notice line too long: " + line);
+
+    var checkNotices = function (lines) {
+      if (!(lines instanceof Array)) {
+        die("notices.json: notice not array");
       }
-    });
+
+      _.each(lines, function (line) {
+        if (line.length + record.release.length + 2 > 80) {
+          die("notices.json: notice line too long: " + line);
+        }
+      });
+    };
+
+    if (record.notices) {
+      checkNotices(record.notices);
+    }
+
+    if (record.packageNotices) {
+      _.each(record.packageNotices, function (lines, pkg) {
+        checkNotices(lines);
+      });
+    }
   });
 
   var bannerFilename = path.resolve(__dirname, 'banner.txt');
diff --git a/scripts/admin/build-release.sh b/scripts/admin/build-release.sh
index 3f0ce4c95b..d70df75c57 100755
--- a/scripts/admin/build-release.sh
+++ b/scripts/admin/build-release.sh
@@ -46,7 +46,7 @@ cat > "$OUTDIR/release.json-$PLATFORM" <<ENDOFMANIFEST
   "packages": {
 $MANIFEST_PACKAGE_CHUNK
   },
-  "upgraders": ["app-packages"]
+  "upgraders": ["app-packages", "no-preserve-inputs"]
 }
 ENDOFMANIFEST
 
diff --git a/scripts/admin/notices.json b/scripts/admin/notices.json
index f63180f934..3d232543db 100644
--- a/scripts/admin/notices.json
+++ b/scripts/admin/notices.json
@@ -94,6 +94,29 @@
   {
     "release": "0.7.2"
   },
+  {
+    "release": "0.7.2.1"
+  },
+  {
+    "release": "0.8.0",
+    "notices": [
+      "Meteor has a new live templating engine: Blaze!",
+      "See https://github.com/meteor/meteor/wiki/Using-Blaze for what's new."
+    ],
+    "packageNotices": {
+      "accounts-ui": ["Include login buttons with {{> loginButtons}}, not {{loginButtons}}."],
+      "spark": ["The spark package has been removed."],
+      "domutils": ["The domutils package has been removed."],
+      "universal-events": ["The universal-events package has been removed.",
+                           "Use jQuery event delegation instead."],
+      "liverange": ["The liverange package has been removed."],
+      "madewith": ["The madewith package has been removed.",
+                   "http://madewith.meteor.com/ no longer supports app badges."]
+    }
+  },
+  {
+    "release": "0.8.0.1"
+  },
   {
     "release": "NEXT"
   }
diff --git a/scripts/admin/spark-standalone.sh b/scripts/admin/spark-standalone.sh
deleted file mode 100755
index 4e68880961..0000000000
--- a/scripts/admin/spark-standalone.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/bash
-
-## Creates a self-contained spark.js and writes it stdout.
-
-set -e
-
-PACKAGES_DIR=`dirname $0`/../../packages
-
-echo 'Meteor = {};'
-cat $PACKAGES_DIR/underscore/underscore.js
-cat $PACKAGES_DIR/logging/logging.js
-cat $PACKAGES_DIR/random/random.js
-cat $PACKAGES_DIR/deps/deps.js
-cat $PACKAGES_DIR/deps/deps-utils.js
-cat $PACKAGES_DIR/liverange/liverange.js
-cat $PACKAGES_DIR/universal-events/listener.js
-cat $PACKAGES_DIR/universal-events/events-ie.js
-cat $PACKAGES_DIR/universal-events/events-w3c.js
-cat $PACKAGES_DIR/domutils/domutils.js
-cat $PACKAGES_DIR/ordered-dict/ordered_dict.js
-cat $PACKAGES_DIR/spark/spark.js
-cat $PACKAGES_DIR/spark/patch.js
diff --git a/scripts/generate-dev-bundle.sh b/scripts/generate-dev-bundle.sh
index 942a092caf..d9b5c7690e 100755
--- a/scripts/generate-dev-bundle.sh
+++ b/scripts/generate-dev-bundle.sh
@@ -76,7 +76,7 @@ cd node
 # When upgrading node versions, also update the values of MIN_NODE_VERSION at
 # the top of tools/meteor.js and tools/server/boot.js, and the text in
 # docs/client/concepts.html and the README in tools/bundler.js.
-git checkout v0.10.25
+git checkout v0.10.26
 
 ./configure --prefix="$DIR"
 make -j4
@@ -107,6 +107,7 @@ npm install kexec@0.2.0
 npm install source-map@0.1.32
 npm install source-map-support@0.2.5
 npm install bcrypt@0.7.7
+npm install node-aes-gcm@0.1.3
 npm install heapdump@0.2.5
 
 # Fork of 1.0.2 with https://github.com/nodejitsu/node-http-proxy/pull/592
@@ -141,7 +142,7 @@ cd ../..
 # particular version of openssl on the host system.
 
 cd "$DIR/build"
-OPENSSL="openssl-1.0.1f"
+OPENSSL="openssl-1.0.1g"
 OPENSSL_URL="http://www.openssl.org/source/$OPENSSL.tar.gz"
 wget $OPENSSL_URL || curl -O $OPENSSL_URL
 tar xzf $OPENSSL.tar.gz
diff --git a/scripts/generate-mongo-ssl-binaries.sh b/scripts/generate-mongo-ssl-binaries.sh
deleted file mode 100755
index d4561aa5a9..0000000000
--- a/scripts/generate-mongo-ssl-binaries.sh
+++ /dev/null
@@ -1,118 +0,0 @@
-#!/bin/bash
-# Run this script on linux box to generate mongodb binaries (most of them, not
-# only mongod and mongo) with ssl support and statically linked openssl.
-# Optional argument: build directory
-
-set -e
-set -u
-
-UNAME=$(uname)
-ARCH=$(uname -m)
-
-if [ "$UNAME" == "Linux" ] ; then
-    if [ "$ARCH" != "i686" -a "$ARCH" != "x86_64" ] ; then
-        echo "Unsupported architecture: $ARCH"
-        echo "Meteor only supports i686 and x86_64 for now."
-        exit 1
-    fi
-
-    MONGO_OS="linux"
-
-    stripBinary() {
-        strip --remove-section=.comment --remove-section=.note $1
-    }
-else
-    echo "This script is meant to be run on linux boxes."
-    exit 1
-fi
-
-PLATFORM="${UNAME}_${ARCH}"
-
-# save off meteor checkout dir as final target
-cd `dirname $0`/..
-TARGET_DIR=`pwd`
-
-# If optional argument, build directory, is passed, build there.
-# Otherwise build in a temporary directory.
-if [ $# -eq 0 ]; then
-    DIR=`mktemp -d -t generate-dev-bundle-XXXXXXXX`
-else
-    DIR="$1/`mktemp generate-mongo-ssl-XXXXXXXX`"
-    mkdir -p $DIR
-fi
-#trap 'rm -rf "$DIR" >/dev/null 2>&1' 0
-
-echo BUILDING IN "$DIR"
-
-cd "$DIR"
-chmod 755 .
-umask 022
-mkdir build
-cd build
-
-# Checkout and build mongodb.
-# We want to build a binary that includes SSL support but does not depend on a
-# particular version of openssl on the host system.
-
-cd "$DIR/build"
-OPENSSL="openssl-1.0.1e"
-OPENSSL_URL="http://www.openssl.org/source/$OPENSSL.tar.gz"
-wget $OPENSSL_URL || curl -O $OPENSSL_URL
-tar xzf $OPENSSL.tar.gz
-
-cd $OPENSSL
-./config --prefix="$DIR/build/openssl-out" no-shared
-make install
-
-# To see the mongo changelog, go to http://www.mongodb.org/downloads,
-# click 'changelog' under the current version, then 'release notes' in
-# the upper right.
-cd "$DIR/build"
-MONGO_VERSION="2.4.4"
-
-git clone git://github.com/meteor/mongo.git
-cd mongo
-git checkout ssl-r$MONGO_VERSION
-
-# Compile
-
-MONGO_FLAGS="--ssl --release "
-MONGO_FLAGS+="--cpppath $DIR/build/openssl-out/include --libpath $DIR/build/openssl-out/lib "
-
-MONGO_FLAGS+="-j2 --no-glibc-check --prefix=$DIR "
-if [ "$ARCH" == "x86_64" ]; then
-    MONGO_FLAGS+="--64"
-fi
-scons $MONGO_FLAGS all || true # It fails on 'all' target but produces the binaries we need
-
-OUT_DIR=mongodb-linux-$ARCH-$MONGOVERSION
-mkdir -p $OUTDIR/bin
-mv bsondump\
-   mongo\
-   mongobridge\
-   mongod\
-   mongodump\
-   mongoexport\
-   mongofiles\
-   mongoimport\
-   mongooplog\
-   mongoperf\
-   mongorestore\
-   mongos\
-   mongostat\
-   mongotop $OUTDIR/bin
-
-# stripBinary $OUTDIR/bin/* # uncomment this if you want to strip all output binaries
-
-echo BUNDLING
-
-tar -czf $OUTDIR.tar.gz $OUTDIR
-mv $OUTDIR.tar.gz $DIR
-
-cd "$DIR"
-
-cd "$DIR"
-rm -rf build
-
-echo DONE
-
diff --git a/tools/bundler.js b/tools/bundler.js
index 7a15861266..57c9350021 100644
--- a/tools/bundler.js
+++ b/tools/bundler.js
@@ -59,11 +59,6 @@
 //
 //  - format: "browser-program-pre1" for this version
 //
-//  - page: path to the template for the HTML to serve when a browser
-//    loads a page that is part of the application. In the file,
-//    some strings of the format ##FOO## will be replaced with
-//    appropriate values at runtime by the webapp package.
-//
 //  - manifest: array of resources to serve with HTTP, each an object:
 //    - path: path of file relative to program.json
 //    - where: "client"
@@ -74,15 +69,11 @@
 //    - size: size of file in bytes
 //    - hash: sha1 hash of the file contents
 //    - sourceMap: optional path to source map file (relative to program.json)
-//    Additionally there will be an entry with where equal to
-//    "internal", path equal to page (above), and hash equal to the
-//    sha1 of page (before replacements). Currently this is used to
-//    trigger HTML5 appcache reloads at the right time (if the
-//    'appcache' package is being used).
 //
-// Convention:
-//
-// page is 'app.html'.
+//    Additionally there may be a manifest entry with where equal to
+//    "internal", type "head" or "body", and a path and hash. These contain
+//    chunks of HTML which should be inserted in the boilerplate HTML page's
+//    <head> or <body> respectively.
 //
 //
 // == Format of a program when arch is "os.*" ==
@@ -174,7 +165,7 @@ var release = require('./release.js');
 var Fiber = require('fibers');
 var Future = require(path.join('fibers', 'future'));
 var sourcemap = require('source-map');
-var runLog = require('./run-log.js').runLog;
+var runLog = require('./run-log.js');
 var packageCache = require('./package-cache.js');
 var PackageSource = require('./package-source.js');
 var compiler = require('./compiler.js');
@@ -874,42 +865,6 @@ _.extend(ClientTarget.prototype, {
     self.css[0].setUrlToHash(".css", "?meteor_css_resource=true");
   },
 
-  // XXX Instead of packaging the boilerplate in the client program, the
-  // template should be part of WebApp, and we should make sure that all
-  // information that it needs is in the manifest (ie, make sure to include head
-  // and body).  Then it will just need to do one level of templating instead
-  // of two.  Alternatively, use spacebars with uniload.load here.
-  generateHtmlBoilerplate: function () {
-    var self = this;
-
-    var html = [];
-    html.push('<!DOCTYPE html>\n' +
-              '<html##HTML_ATTRIBUTES##>\n' +
-              '<head>\n');
-    _.each(self.css, function (css) {
-      html.push('  <link rel="stylesheet" href="##BUNDLED_JS_CSS_PREFIX##');
-      html.push(_.escape(css.url));
-      html.push('">\n');
-    });
-    html.push('\n\n##RUNTIME_CONFIG##\n\n');
-    _.each(self.js, function (js) {
-      html.push('  <script type="text/javascript" src="##BUNDLED_JS_CSS_PREFIX##');
-      html.push(_.escape(js.url));
-      html.push('"></script>\n');
-    });
-    html.push('\n\n##RELOAD_SAFETYBELT##');
-    html.push('\n\n');
-    html.push(self.head.join('\n'));  // unescaped!
-    html.push('\n' +
-              '</head>\n' +
-              '<body>\n');
-    html.push(self.body.join('\n'));  // unescaped!
-    html.push('\n' +
-              '</body>\n' +
-              '</html>\n');
-    return new Buffer(html.join(''), 'utf8');
-  },
-
   // Output the finished target to disk
   //
   // Returns the path (relative to 'builder') of the control file for
@@ -918,7 +873,6 @@ _.extend(ClientTarget.prototype, {
     var self = this;
 
     builder.reserve("program.json");
-    builder.reserve("app.html");
 
     // Helper to iterate over all resources that we serve over HTTP.
     var eachResource = function (f) {
@@ -986,20 +940,24 @@ _.extend(ClientTarget.prototype, {
       manifest.push(manifestItem);
     });
 
-    // HTML boilerplate (the HTML served to make the client load the
-    // JS and CSS files and start the app)
-    var htmlBoilerplate = self.generateHtmlBoilerplate();
-    builder.write('app.html', { data: htmlBoilerplate });
-    manifest.push({
-      path: 'app.html',
-      where: 'internal',
-      hash: Builder.sha1(htmlBoilerplate)
+    _.each(['head', 'body'], function (type) {
+      var data = self[type].join('\n');
+      if (data) {
+        var dataBuffer = new Buffer(data, 'utf8');
+        var dataFile = builder.writeToGeneratedFilename(
+          type + '.html', { data: dataBuffer });
+        manifest.push({
+          path: dataFile,
+          where: 'internal',
+          type: type,
+          hash: Builder.sha1(dataBuffer)
+        });
+      }
     });
 
     // Control file
     builder.writeJson('program.json', {
       format: "browser-program-pre1",
-      page: 'app.html',
       manifest: manifest
     });
     return "program.json";
@@ -1580,7 +1538,7 @@ var writeSiteArchive = function (targets, outputPath, options) {
 
       builder.write('README', { data: new Buffer(
 "This is a Meteor application bundle. It has only one dependency:\n" +
-"Node.js 0.10.25 or newer, plus the 'fibers' module. To run the application:\n" +
+"Node.js 0.10.26 or newer, plus the 'fibers' module. To run the application:\n" +
 "\n" +
 "  $ rm -r programs/server/node_modules/fibers\n" +
 "  $ npm install fibers@1.0.1\n" +
diff --git a/tools/commands.js b/tools/commands.js
index 3e4f4fa3c2..53564ba3b5 100644
--- a/tools/commands.js
+++ b/tools/commands.js
@@ -12,7 +12,7 @@ var auth = require('./auth.js');
 var config = require('./config.js');
 var release = require('./release.js');
 var Future = require('fibers/future');
-var runLog = require('./run-log.js').runLog;
+var runLog = require('./run-log.js');
 var packageClient = require('./package-client.js');
 var utils = require('./utils.js');
 var httpHelpers = require('./http-helpers.js');
@@ -205,8 +205,8 @@ main.registerCommand({
   name: 'run',
   requiresApp: true,
   options: {
-    port: { type: Number, short: "p", default: 3000 },
-    'app-port': { type: Number },
+    port: { type: String, short: "p", default: '3000' },
+    'app-port': { type: String },
     production: { type: Boolean },
     'raw-logs': { type: Boolean },
     settings: { type: String },
@@ -218,6 +218,32 @@ main.registerCommand({
     once: { type: Boolean }
   }
 }, function (options) {
+  // XXX factor this out into a {type: host/port}?
+  var portMatch = options.port.match(/^(?:(.+):)?([0-9]+)$/);
+  if (!portMatch) {
+    process.stderr.write(
+"run: --port (-p) must be a number or be of the form 'host:port' where\n" +
+"port is a number. Try 'meteor help run' for help.\n");
+    return 1;
+  }
+  var proxyHost = portMatch[1] || null;
+  var proxyPort = parseInt(portMatch[2]);
+
+  var appHost, appPort;
+  if (options['app-port']) {
+    var appPortMatch = options['app-port'].match(/^(?:(.+):)?([0-9]+)?$/);
+    if (!appPortMatch) {
+      process.stderr.write(
+"run: --app-port must be a number or be of the form 'host:port' where\n" +
+"port is a number. Try 'meteor help run' for help.\n");
+      return 1;
+    }
+    appHost = appPortMatch[1] || null;
+    // It's legit to specify `--app-port host:` and still let the port be
+    // randomized.
+    appPort = appPortMatch[2] ? parseInt(appPortMatch[2]) : null;
+  }
+
   if (release.forced) {
     var appRelease = project.getMeteorReleaseVersion(options.appDir);
     if (release.current.name !== appRelease) {
@@ -234,8 +260,10 @@ main.registerCommand({
 
   var runAll = require('./run-all.js');
   return runAll.run(options.appDir, {
-    port: options.port,
-    appPort: options['app-port'],
+    proxyPort: proxyPort,
+    proxyHost: proxyHost,
+    appPort: appPort,
+    appHost: appHost,
     settingsFile: options.settings,
     program: options.program || undefined,
     buildOptions: {
@@ -1364,7 +1392,7 @@ main.registerCommand({
       // sure the user doesn't 'meteor update' in the app, requiring
       // a switch to a different release
       appDirForVersionCheck: options.appDir,
-      port: options.port,
+      proxyPort: options.port,
       disableOplog: options['disable-oplog'],
       settingsFile: options.settings,
       banner: "Tests",
@@ -1797,6 +1825,26 @@ main.registerCommand({
   return 0;
 });
 
+///////////////////////////////////////////////////////////////////////////////
+// list-sites
+///////////////////////////////////////////////////////////////////////////////
+
+main.registerCommand({
+  name: 'list-sites',
+  minArgs: 0,
+  maxArgs: 0
+}, function (options) {
+  auth.pollForRegistrationCompletion();
+  if (! auth.isLoggedIn()) {
+    process.stderr.write(
+      "You must be logged in for that. Try 'meteor login'.\n");
+    return 1;
+  }
+
+  return deploy.listSites();
+});
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // dummy
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/tools/compiler.js b/tools/compiler.js
index fc44267a07..37b6868086 100644
--- a/tools/compiler.js
+++ b/tools/compiler.js
@@ -243,7 +243,9 @@ var compileBuild = function (unipackage, inputSourceArch, packageLoader,
 
   // *** Assemble the list of source file handlers from the plugins
   var allHandlers = {};
+  var sourceExtensions = {};  // maps source extensions to isTemplate
 
+  sourceExtensions['js'] = false;
   allHandlers['js'] = function (compileStep) {
     // This is a hardcoded handler for *.js files. Since plugins
     // are written in JavaScript we have to start somewhere.
@@ -258,9 +260,10 @@ var compileBuild = function (unipackage, inputSourceArch, packageLoader,
   };
 
   _.each(activePluginPackages, function (otherPkg) {
-    _.each(otherPkg.getSourceHandlers(), function (handler, ext) {
+    _.each(otherPkg.getSourceHandlers(), function (sourceHandler, ext) {
+      // XXX comparing function text here seems wrong.
       if (ext in allHandlers &&
-          allHandlers[ext].toString() !== handler.toString()) {
+          allHandlers[ext].toString() !== sourceHandler.handler.toString()) {
         buildmessage.error(
           "conflict: two packages included in " +
             (inputSourceArch.pkg.name || "the app") + ", " +
@@ -269,7 +272,8 @@ var compileBuild = function (unipackage, inputSourceArch, packageLoader,
             "are both trying to handle ." + ext);
         // Recover by just going with the first handler we saw
       } else {
-        allHandlers[ext] = handler;
+        allHandlers[ext] = sourceHandler.handler;
+        sourceExtensions[ext] = !!sourceHandler.isTemplate;
       }
     });
   });
@@ -281,7 +285,6 @@ var compileBuild = function (unipackage, inputSourceArch, packageLoader,
   // things that the getSourcesFunc consulted (such as directory
   // listings or, in some hypothetical universe, control files) to
   // determine its source files.
-  var sourceExtensions = _.keys(allHandlers);
   var sourceItems = inputSourceArch.getSourcesFunc(sourceExtensions, watchSet);
 
   // *** Process each source file
diff --git a/tools/deploy.js b/tools/deploy.js
index b9c1f68677..89521b02cc 100644
--- a/tools/deploy.js
+++ b/tools/deploy.js
@@ -34,7 +34,7 @@ var project = require('./project.js');
 //
 // Options include:
 // - method: GET, POST, or DELETE. default GET
-// - operation: "info", "logs", "mongo", "deploy"
+// - operation: "info", "logs", "mongo", "deploy", "authorized-apps"
 // - site: site name
 // - expectPayload: an array of key names. if present, then we expect
 //   the server to return JSON content on success and to return an
@@ -68,7 +68,8 @@ var deployRpc = function (options) {
 
   try {
     var result = httpHelpers.request(_.extend(options, {
-      url: config.getDeployUrl() + '/' + options.operation + '/' + options.site,
+      url: config.getDeployUrl() + '/' + options.operation +
+        (options.site ? ('/' + options.site) : ''),
       method: options.method || 'GET',
       bodyStream: options.bodyStream,
       useAuthHeader: true,
@@ -712,6 +713,32 @@ site + ": " + "successfully transferred to your account.\n" +
   return 0;
 };
 
+var listSites = function () {
+  var result = deployRpc({
+    method: "GET",
+    operation: "authorized-apps",
+    promptIfAuthFails: true,
+    expectPayload: ["sites"]
+  });
+
+  if (result.errorMessage) {
+    process.stderr.write("Couldn't list sites: " +
+                         result.errorMessage + "\n");
+    return 1;
+  }
+
+  if (! result.payload ||
+      ! result.payload.sites ||
+      ! result.payload.sites.length) {
+    process.stdout.write("You don't have any sites yet.\n");
+  } else {
+    _.each(result.payload.sites, function (site) {
+      process.stdout.write(site + "\n");
+    });
+  }
+  return 0;
+};
+
 
 exports.bundleAndDeploy = bundleAndDeploy;
 exports.deleteApp = deleteApp;
@@ -720,3 +747,4 @@ exports.logs = logs;
 exports.listAuthorized = listAuthorized;
 exports.changeAuthorized = changeAuthorized;
 exports.claim = claim;
+exports.listSites = listSites;
diff --git a/tools/fiber-helpers.js b/tools/fiber-helpers.js
index 35716b1df6..9cc396d547 100644
--- a/tools/fiber-helpers.js
+++ b/tools/fiber-helpers.js
@@ -46,3 +46,33 @@ exports.firstTimeResolver = function (fut) {
     resolver(err, val);
   };
 };
+
+// Waits for one future given as an argument to be resolved. Throws if it threw,
+// otherwise returns whichever one returns first.  (Because of this, you
+// probably want at most one of the futures to be capable of returning, and have
+// the other be throw-only.)
+exports.waitForOne = function (/* futures */) {
+  var fiber = Fiber.current;
+  if (!fiber)
+    throw Error("Can't waitForOne without a fiber");
+  if (arguments.length === 0)
+    throw Error("Must wait for at least one future");
+
+  var combinedFuture = new Future;
+  for (var i = 0; i < arguments.length; ++i) {
+    var f = arguments[i];
+    if (f.isResolved()) {
+      // Move its value into combinedFuture.
+      f.resolve(combinedFuture.resolver());
+      break;
+    }
+    // Otherwise, this function will be invoked when the future is resolved.
+    f.resolve(function (err, result) {
+      if (!combinedFuture.isResolved()) {
+        combinedFuture.resolver()(err, result);
+      }
+    });
+  }
+
+  return combinedFuture.wait();
+};
diff --git a/tools/files.js b/tools/files.js
index c2a494af70..2736c897b1 100644
--- a/tools/files.js
+++ b/tools/files.js
@@ -451,11 +451,8 @@ files.createTarGzStream = function (dirPath, options) {
   var tar = require("tar");
   var fstream = require('fstream');
   var zlib = require("zlib");
-  var reader = fstream.Reader({
-    path: dirPath,
-    type: 'Directory'
-  });
-  return reader.pipe(tar.Pack()).pipe(zlib.createGzip());
+  return fstream.Reader({ path: dirPath, type: 'Directory' }).pipe(
+    tar.Pack({ noProprietary: true })).pipe(zlib.createGzip());
 };
 
 // Tar-gzips a directory into a tarball on disk, synchronously.
diff --git a/tools/help.txt b/tools/help.txt
index ff60fbb47f..96355eaa72 100644
--- a/tools/help.txt
+++ b/tools/help.txt
@@ -34,6 +34,7 @@ the .meteor directory in the root of the project.
 Options:
   --port, -p    Port to listen on (instead of the default 3000). Also
                 uses port N+1 and a port specified by --app-port.
+                Specify as --port=host:port to bind to a specific interface.
   --production  Simulate production mode. Minify and bundle CSS and JS files.
   --raw-logs    Run without parsing logs from stdout and stderr.
   --settings    Set optional data for Meteor.settings on the server
@@ -365,6 +366,7 @@ Usage: meteor admin grant [XXX]
 
 Not yet implemented
 
+
 >>> publish
 Publish a new version of a package, as specified in your package.js file
 to the meteor package server.
@@ -372,3 +374,12 @@ to the meteor package server.
 Usage: meteor publish [--create]
 
 Pass --create to create a new package.
+
+
+>>> list-sites
+List sites for which you are authorized.
+Usage: meteor list-sites
+
+List the sites that you have deployed with 'meteor deploy', and sites
+for which other users have authorized you with the 'meteor authorized'
+command.
diff --git a/tools/main.js b/tools/main.js
index fc0894beca..eb43bd4de0 100644
--- a/tools/main.js
+++ b/tools/main.js
@@ -335,13 +335,24 @@ Fiber(function () {
 
   // Check required Node version.
   // This code is duplicated in tools/server/boot.js.
-  var MIN_NODE_VERSION = 'v0.10.25';
+  var MIN_NODE_VERSION = 'v0.10.26';
   if (require('semver').lt(process.version, MIN_NODE_VERSION)) {
     process.stderr.write(
       'Meteor requires Node ' + MIN_NODE_VERSION + ' or later.\n');
     process.exit(1);
   }
 
+  // This is a bit of a hack, but: if we don't check this in the tool, then the
+  // first time we do a unipackage.load, it will fail due to the check in the
+  // meteor package, and that'll look a lot uglier.
+  if (process.env.ROOT_URL) {
+    var parsedUrl = require('url').parse(process.env.ROOT_URL);
+    if (!parsedUrl.host) {
+      process.stderr.write('$ROOT_URL, if specified, must be an URL.\n');
+      process.exit(1);
+    }
+  }
+
   // Parse the arguments.
   //
   // We must first identify which options are boolean and which take
@@ -845,8 +856,7 @@ commandName + ": can only take one " + helpfulOptionName + " option.\n" +
       var value = values[0];
       if (value === null) {
         // This option requires a value and they didn't give it one
-        // (it was the last word on the command line, or it was
-        // a short option immediately followed by a non-number).
+        // (it was the last word on the command line).
         process.stderr.write(
 commandName + ": the " + helpfulOptionName + " option needs a value.\n" +
 "Try 'meteor help " + commandName + "' for help.\n");
diff --git a/tools/meteor-npm.js b/tools/meteor-npm.js
index a137888836..d4a9f670f7 100644
--- a/tools/meteor-npm.js
+++ b/tools/meteor-npm.js
@@ -13,7 +13,7 @@ var files = require(path.join(__dirname, 'files.js'));
 var httpHelpers = require('./http-helpers.js');
 var buildmessage = require('./buildmessage.js');
 var utils = require('./utils.js');
-var runLog = require('./run-log.js').runLog;
+var runLog = require('./run-log.js');
 var _ = require('underscore');
 
 var meteorNpm = exports;
diff --git a/tools/package-source.js b/tools/package-source.js
index 906df1d944..1ffac4a427 100644
--- a/tools/package-source.js
+++ b/tools/package-source.js
@@ -32,47 +32,56 @@ var earliestCompatible = function (version) {
   return m[1] + ".0.0";
 };
 
-// A sort comparator to order files into load order.
-var loadOrderSort = function (a, b) {
-  // XXX HUGE HACK --
-  // push html (template) files ahead of everything else. this is
-  // important because the user wants to be able to say
-  // Template.foo.events = { ... }
-  //
-  // maybe all of the templates should go in one file? packages should
-  // probably have a way to request this treatment (load order
-  // dependency tags?) .. who knows.
-  var ishtml_a = path.extname(a) === '.html';
-  var ishtml_b = path.extname(b) === '.html';
-  if (ishtml_a !== ishtml_b) {
-    return (ishtml_a ? -1 : 1);
-  }
+// Returns a sort comparator to order files into load order.
+// templateExtensions should be a list of extensions like 'html'
+// which should be loaded before other extensions.
+var loadOrderSort = function (templateExtensions) {
+  var templateExtnames = {};
+  _.each(templateExtensions, function (extension) {
+    templateExtnames['.' + extension] = true;
+  });
 
-  // main.* loaded last
-  var ismain_a = (path.basename(a).indexOf('main.') === 0);
-  var ismain_b = (path.basename(b).indexOf('main.') === 0);
-  if (ismain_a !== ismain_b) {
-    return (ismain_a ? 1 : -1);
-  }
+  return function (a, b) {
+    // XXX MODERATELY SIZED HACK --
+    // push template files ahead of everything else. this is
+    // important because the user wants to be able to say
+    //   Template.foo.events = { ... }
+    // in a JS file and not have to worry about ordering it
+    // before the corresponding .html file.
+    //
+    // maybe all of the templates should go in one file?
+    var isTemplate_a = _.has(templateExtnames, path.extname(a));
+    var isTemplate_b = _.has(templateExtnames, path.extname(b));
+    if (isTemplate_a !== isTemplate_b) {
+      return (isTemplate_a ? -1 : 1);
+    }
 
-  // /lib/ loaded first
-  var islib_a = (a.indexOf(path.sep + 'lib' + path.sep) !== -1 ||
-                 a.indexOf('lib' + path.sep) === 0);
-  var islib_b = (b.indexOf(path.sep + 'lib' + path.sep) !== -1 ||
-                 b.indexOf('lib' + path.sep) === 0);
-  if (islib_a !== islib_b) {
-    return (islib_a ? -1 : 1);
-  }
+    // main.* loaded last
+    var ismain_a = (path.basename(a).indexOf('main.') === 0);
+    var ismain_b = (path.basename(b).indexOf('main.') === 0);
+    if (ismain_a !== ismain_b) {
+      return (ismain_a ? 1 : -1);
+    }
 
-  // deeper paths loaded first.
-  var len_a = a.split(path.sep).length;
-  var len_b = b.split(path.sep).length;
-  if (len_a !== len_b) {
-    return (len_a < len_b ? 1 : -1);
-  }
+    // /lib/ loaded first
+    var islib_a = (a.indexOf(path.sep + 'lib' + path.sep) !== -1 ||
+                   a.indexOf('lib' + path.sep) === 0);
+    var islib_b = (b.indexOf(path.sep + 'lib' + path.sep) !== -1 ||
+                   b.indexOf('lib' + path.sep) === 0);
+    if (islib_a !== islib_b) {
+      return (islib_a ? -1 : 1);
+    }
 
-  // otherwise alphabetical
-  return (a < b ? -1 : 1);
+    // deeper paths loaded first.
+    var len_a = a.split(path.sep).length;
+    var len_b = b.split(path.sep).length;
+    if (len_a !== len_b) {
+      return (len_a < len_b ? 1 : -1);
+    }
+
+    // otherwise alphabetical
+    return (a < b ? -1 : 1);
+  };
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -904,7 +913,7 @@ _.extend(PackageSource.prototype, {
       build.getSourcesFunc = function (extensions, watchSet) {
         var sourceInclude = _.map(
           extensions,
-          function (ext) {
+          function (isTemplate, ext) {
             return new RegExp('\\.' + quotemeta(ext) + '$');
           }
         );
@@ -990,7 +999,11 @@ _.extend(PackageSource.prototype, {
         }
 
         // We've found all the source files. Sort them!
-        sources.sort(loadOrderSort);
+        var templateExtensions = [];
+        _.each(extensions, function (isTemplate, ext) {
+          isTemplate && templateExtensions.push(ext);
+        });
+        sources.sort(loadOrderSort(templateExtensions));
 
         // Convert into relPath/fileOptions objects.
         sources = _.map(sources, function (relPath) {
diff --git a/tools/run-all.js b/tools/run-all.js
index 8b371318b0..202c4b5587 100644
--- a/tools/run-all.js
+++ b/tools/run-all.js
@@ -5,23 +5,24 @@ var files = require('./files.js');
 var inFiber = require('./fiber-helpers.js').inFiber;
 var release = require('./release.js');
 
-var runLog = require('./run-log.js').runLog;
+var runLog = require('./run-log.js');
 var Proxy = require('./run-proxy.js').Proxy;
 var AppRunner = require('./run-app.js').AppRunner;
 var MongoRunner = require('./run-mongo.js').MongoRunner;
 var Updater = require('./run-updater.js').Updater;
 
-// options: port, buildOptions, settingsFile, banner, program,
-// onRunEnd, onFailure, watchForChanges, quiet, rootUrl, mongoUrl,
-// oplogUrl, disableOplog, appDirForVersionCheck
+// options: proxyPort, proxyHost, appPort, appHost, buildOptions,
+// settingsFile, banner, program, onRunEnd, onFailure, watchForChanges,
+// quiet, rootUrl, mongoUrl, oplogUrl, disableOplog,
+// appDirForVersionCheck
 var Runner = function (appDir, options) {
   var self = this;
   self.appDir = appDir;
 
-  if (! _.has(options, 'port'))
-    throw new Error("no port?");
+  if (! _.has(options, 'proxyPort'))
+    throw new Error("no proxyPort?");
 
-  var listenPort = options.port;
+  var listenPort = options.proxyPort;
   var mongoPort = listenPort + 1;
   self.specifiedAppPort = options.appPort;
   self.regenerateAppPort();
@@ -29,11 +30,19 @@ var Runner = function (appDir, options) {
   self.stopped = false;
   self.quiet = options.quiet;
   self.banner = options.banner || files.prettyPath(self.appDir);
-  self.rootUrl = options.rootUrl || ('http://localhost:' + listenPort + '/');
+  if (options.rootUrl) {
+    self.rootUrl = options.rootUrl;
+  } else if (options.proxyHost) {
+    self.rootUrl = 'http://' + options.proxyHost + ':' + listenPort + '/';
+  } else {
+    self.rootUrl = 'http://localhost:' + listenPort + '/';
+  }
 
   self.proxy = new Proxy({
     listenPort: listenPort,
+    listenHost: options.proxyHost,
     proxyToPort: self.appPort,
+    proxyToHost: options.appHost,
     onFailure: options.onFailure
   });
 
@@ -46,12 +55,14 @@ var Runner = function (appDir, options) {
     self.mongoRunner = new MongoRunner({
       appDir: self.appDir,
       port: mongoPort,
-      onFailure: options.onFailure
+      onFailure: options.onFailure,
+      // For testing mongod failover, run with 3 mongod if the env var is
+      // set. Note that data is not preserved from one run to the next.
+      multiple: !!process.env.METEOR_TEST_MULTIPLE_MONGOD_REPLSET
     });
 
-    mongoUrl = "mongodb://127.0.0.1:" + mongoPort + "/meteor";
-    oplogUrl = (options.disableOplog ? null :
-                "mongodb://127.0.0.1:" + mongoPort + "/local");
+    mongoUrl = self.mongoRunner.mongoUrl();
+    oplogUrl = options.disableOplog ? null : self.mongoRunner.oplogUrl();
   }
 
   self.updater = new Updater;
@@ -59,6 +70,7 @@ var Runner = function (appDir, options) {
   self.appRunner = new AppRunner(appDir, {
     appDirForVersionCheck: options.appDirForVersionCheck,
     port: self.appPort,
+    listenHost: options.appHost,
     mongoUrl: mongoUrl,
     oplogUrl: oplogUrl,
     buildOptions: options.buildOptions,
@@ -199,7 +211,7 @@ _.extend(Runner.prototype, {
 //
 // Options:
 //
-// - port: the port to connect to to access the application (we will
+// - proxyPort: the port to connect to to access the application (we will
 //   run a proxy here that proxies to the actual app process). required
 // - buildOptions: 'buildOptions' argument to bundler.bundle()
 // - settingsFile: path to file containing deploy-time settings
@@ -243,8 +255,11 @@ exports.run = function (appDir, options) {
           result.outcome === "wrong-release" ||
           (result.outcome === "terminated" &&
            result.signal === undefined && result.code === undefined)) {
-        runner.stop();
-        fut.isResolved() || fut['return'](result);
+        // Allow run() to continue (and call runner.stop()) only once the
+        // AppRunner has processed our "return false"; otherwise we deadlock.
+        process.nextTick(function () {
+          fut.isResolved() || fut['return'](result);
+        });
         return false;  // stop restarting
       }
       runner.regenerateAppPort();
diff --git a/tools/run-app.js b/tools/run-app.js
index 03607e1743..1ebc856835 100644
--- a/tools/run-app.js
+++ b/tools/run-app.js
@@ -10,8 +10,8 @@ var bundler = require('./bundler.js');
 var release = require('./release.js');
 var buildmessage = require('./buildmessage.js');
 var inFiber = require('./fiber-helpers.js').inFiber;
-var runLog = require('./run-log.js').runLog;
-var catalog = require('./catalog.js').catalog;
+var runLog = require('./run-log.js');
+var catalog = require('./catalog.js');
 var packageCache = require('./package-cache.js');
 var PackageLoader = require('./package-loader.js');
 
@@ -55,6 +55,7 @@ var AppProcess = function (options) {
 
   self.bundlePath = options.bundlePath;
   self.port = options.port;
+  self.listenHost = options.listenHost;
   self.rootUrl = options.rootUrl;
   self.mongoUrl = options.mongoUrl;
   self.oplogUrl = options.oplogUrl;
@@ -172,12 +173,19 @@ _.extend(AppProcess.prototype, {
     env.PORT = self.port;
     env.ROOT_URL = self.rootUrl;
     env.MONGO_URL = self.mongoUrl;
-    if (self.oplogUrl)
+    if (self.oplogUrl) {
       env.MONGO_OPLOG_URL = self.oplogUrl;
-    if (self.settings)
+    }
+    if (self.settings) {
       env.METEOR_SETTINGS = self.settings;
-    else
+    } else {
       delete env.METEOR_SETTINGS;
+    }
+    if (self.listenHost) {
+      env.BIND_IP = self.listenHost;
+    } else {
+      delete env.BIND_IP;
+    }
 
     // Display errors from (eg) the NPM connect module over the network.
     env.NODE_ENV = 'development';
@@ -270,11 +278,9 @@ _.extend(AppProcess.prototype, {
 //   mongoUrl, oplogUrl, buildOptions, rootUrl, settingsFile, program,
 //   proxy
 //
-// To use, construct an instance of AppRunner, and then call start()
-// to start it running. Call stop() at any time to shut it down and
-// clean it up. You should call stop() to clean up even if you return
-// false from onRunEnd(); this stops the restarting but doesn't
-// destroy the AppRunner instance.
+// To use, construct an instance of AppRunner, and then call start() to start it
+// running. To stop it, either return false from onRunEnd, or call stop().  (But
+// don't call stop() from inside onRunEnd: that causes a deadlock.)
 //
 // The 'result' argument to onRunEnd is an object with keys:
 //
@@ -317,6 +323,7 @@ var AppRunner = function (appDir, options) {
   self.appDirForVersionCheck = options.appDirForVersionCheck || self.appDir;
   // note: run-all.js updates port directly
   self.port = options.port;
+  self.listenHost = options.listenHost;
   self.mongoUrl = options.mongoUrl;
   self.oplogUrl = options.oplogUrl;
   self.buildOptions = options.buildOptions;
@@ -333,6 +340,7 @@ var AppRunner = function (appDir, options) {
   self.startFuture = null;
   self.runFuture = null;
   self.exitFuture = null;
+  self.watchFuture = null;
 };
 
 _.extend(AppRunner.prototype, {
@@ -347,7 +355,8 @@ _.extend(AppRunner.prototype, {
     self.startFuture = new Future;
     self.fiber = new Fiber(function () {
       self._fiber();
-    }).run();
+    });
+    self.fiber.run();
     self.startFuture.wait();
     self.startFuture = null;
   },
@@ -369,6 +378,7 @@ _.extend(AppRunner.prototype, {
     self.exitFuture = new Future;
 
     self._runFutureReturn({ outcome: 'stopped' });
+    self._watchFutureReturn();
 
     self.exitFuture.wait();
     self.exitFuture = null;
@@ -437,7 +447,7 @@ _.extend(AppRunner.prototype, {
 
     // HACK: Also make sure we notice when somebody adds a package to
     // the app packages dir that may override a catalog package.
-    catalog.watchLocalPackageDirs(watchSet);
+    catalog.catalog.watchLocalPackageDirs(watchSet);
 
     // Were there errors?
     if (bundleResult.errors) {
@@ -459,6 +469,7 @@ _.extend(AppRunner.prototype, {
     var appProcess = new AppProcess({
       bundlePath: bundlePath,
       port: self.port,
+      listenHost: self.listenHost,
       rootUrl: self.rootUrl,
       mongoUrl: self.mongoUrl,
       oplogUrl: self.oplogUrl,
@@ -521,6 +532,15 @@ _.extend(AppRunner.prototype, {
     runFuture['return'](value);
   },
 
+  _watchFutureReturn: function () {
+    var self = this;
+    if (!self.watchFuture)
+      return;
+    var watchFuture = self.watchFuture;
+    self.watchFuture = null;
+    watchFuture.return();
+  },
+
   _fiber: function () {
     var self = this;
 
@@ -592,13 +612,20 @@ _.extend(AppRunner.prototype, {
       }
 
       if (self.watchForChanges) {
-        var fut = new Future;
+        self.watchFuture = new Future;
         var watcher = new watch.Watcher({
           watchSet: runResult.bundleResult.watchSet,
-          onChange: function () { fut['return'](); }
+          onChange: function () {
+            self._watchFutureReturn();
+          }
         });
         self.proxy.setMode("errorpage");
-        fut.wait();
+        // If onChange wasn't called synchronously (clearing watchFuture), wait
+        // on it.
+        self.watchFuture && self.watchFuture.wait();
+        // While we were waiting, did somebody stop() us?
+        if (self.exitFuture)
+          break;
         runLog.log("=> Modified -- restarting.");
         continue;
       }
diff --git a/tools/run-log.js b/tools/run-log.js
index a9fe482daa..32a06094da 100644
--- a/tools/run-log.js
+++ b/tools/run-log.js
@@ -172,5 +172,12 @@ _.extend(RunLog.prototype, {
   }
 });
 
-// Export a singleton instance of RunLog.
-exports.runLog = new RunLog;
+// Create a singleton instance of RunLog. Expose its public methods on the
+// object you get with require('./run-log.js').
+var runLogInstance = new RunLog;
+_.each(
+  ['log', 'logTemporary', 'logRestart', 'logAppOutput', 'setRawLogs',
+   'finish', 'clearLog', 'getLog'],
+  function (method) {
+    exports[method] = _.bind(runLogInstance[method], runLogInstance);
+  });
diff --git a/tools/run-mongo.js b/tools/run-mongo.js
index 17d7d2bd06..079ee61f64 100644
--- a/tools/run-mongo.js
+++ b/tools/run-mongo.js
@@ -5,8 +5,9 @@ var files = require('./files.js');
 var utils = require('./utils.js');
 var release = require('./release.js');
 var mongoExitCodes = require('./mongo-exit-codes.js');
-var inFiber = require('./fiber-helpers.js').inFiber;
-var runLog = require('./run-log.js').runLog;
+var fiberHelpers = require('./fiber-helpers.js');
+var inFiber = fiberHelpers.inFiber;
+var runLog = require('./run-log.js');
 
 var _ = require('underscore');
 var uniload = require('./uniload.js');
@@ -60,7 +61,7 @@ var findMongoPids = function (appDir, port) {
         // Matches mongos we start. Note that this matches
         // 'fake-mongod' (our mongod stub for automated tests) as well
         // as 'mongod'.
-        var m = line.match(/^\s*(\d+).+mongod .+--port (\d+) --dbpath (.+)(?:\/|\\)\.meteor(?:\/|\\)local(?:\/|\\)db(?: |$)/);
+        var m = line.match(/^\s*(\d+).+mongod .+--port (\d+) --dbpath (.+)(?:\/|\\)\.meteor(?:\/|\\)local(?:\/|\\)db/);
         if (m && m.length === 4) {
           var foundPid =  parseInt(m[1]);
           var foundPort = parseInt(m[2]);
@@ -148,20 +149,37 @@ var findMongoAndKillItDead = function (port) {
   });
 };
 
-// Starts a single instance of mongod, and configures it properly. Does not
-// yield.
+var StoppedDuringLaunch = function () {};
+
+// Starts a single instance of mongod, and configures it properly as a singleton
+// replica set. Yields.  Returns once the mongod is successfully listening (or
+// the process exited).
+//
+// Takes an onExit handler, which will be invoked when the process exits (which
+// may be before or after this function returns depending on whether or not it
+// ever successfully started).
+//
+// If the 'multiple' option is set, it actually sets up three mongod instances
+// (launching the second and third on the next two ports after the specified
+// port). In this case, if any of the three instances exit for any reason, all
+// are killed (and onExit is then invoked). Also, the entirety of all three
+// databases is deleted before starting up.  This is mode intended for testing
+// mongo failover, not for normal development or production use.
 var launchMongo = function (options) {
-  var onListen = options.onListen || function () {};
   var onExit = options.onExit || function () {};
 
   var noOplog = false;
   var mongod_path = path.join(
     files.getDevBundle(), 'mongodb', 'bin', 'mongod');
+  var replSetName = 'meteor';
 
   // Automated testing: If this is set, instead of starting mongod, we
   // start our stub (fake-mongod) which can then be remote-controlled
   // by the test.
   if (process.env.METEOR_TEST_FAKE_MONGOD_CONTROL_PORT) {
+    if (options.multiple)
+      throw Error("Can't specify multiple with fake mongod");
+
     mongod_path = path.join(files.getCurrentToolsDir(),
                             'tools', 'tests', 'fake-mongod', 'fake-mongod');
 
@@ -170,80 +188,98 @@ var launchMongo = function (options) {
     noOplog = true;
   }
 
-  // store data in appDir
-  var dbPath = path.join(options.appDir, '.meteor', 'local', 'db');
-  files.mkdir_p(dbPath, 0755);
   // add .gitignore if needed.
   files.addToGitignore(path.join(options.appDir, '.meteor'), 'local');
 
-  var proc = null;
-  var cancelStartup = false;
-  var callOnExit;
+  var subHandles = [];
+  var stopped = false;
+  var stopFuture = new Future;
+
+  // Like Future.wrap and _.bind in one.
+  var yieldingMethod = function (/* object, methodName, args */) {
+    var args = _.toArray(arguments);
+    var object = args.shift();
+    var methodName = args.shift();
+    var f = new Future;
+    args.push(f.resolver());
+    object[methodName].apply(object, args);
+    return fiberHelpers.waitForOne(stopFuture, f);
+  };
 
   var handle = {
     stop: function () {
-      if (! proc)
-        cancelStartup = true;
-      else {
-        proc.removeListener('exit', callOnExit);
-        proc.kill('SIGINT');
-      }
+      if (stopped)
+        return;
+      stopped = true;
+      _.each(subHandles, function (handle) {
+        handle.stop();
+      });
+
+      stopFuture.throw(new StoppedDuringLaunch);
     }
   };
 
-  Fiber(function () {
-    findMongoAndKillItDead(options.port);
+  var launchOneMongoAndWaitForReadyForInitiate = function (dbPath, port,
+                                                           portFile) {
+    files.mkdir_p(dbPath, 0755);
 
-    var portFile = path.join(dbPath, 'METEOR-PORT');
-    var portFileExists = false;
-    var createReplSet = true;
-    try {
-      createReplSet = +(fs.readFileSync(portFile)) !== options.port;
-      portFileExists = true;
-    } catch (e) {
-      if (!e || e.code !== 'ENOENT')
-        throw e;
-    }
+    var proc = null;
+    var procExitHandler;
 
-    if (noOplog)
-      createReplSet = false;
-
-    // If this is the first time we're using this DB, or we changed
-    // port since the last time, then we want to destroy any
-    // existing replSet configuration and create a new one. First we
-    // delete the "local" database if it exists. (It's a pain and slow
-    // to change the port in an existing replSet configuration. It's
-    // also a little slow to initiate a new replSet, thus the attempt
-    // to not do it unless the port changes.)
-    if (createReplSet) {
-      // Delete the port file, so we don't mistakenly believe that the DB is
-      // still configured.
-      if (portFileExists)
-        fs.unlinkSync(portFile);
+    findMongoAndKillItDead(port);
 
+    if (options.multiple) {
+      // This is only for testing, so we're OK with incurring the replset
+      // setup on each startup.
+      files.rm_recursive(dbPath);
+      files.mkdir_p(dbPath, 0755);
+    } else if (portFile) {
+      var portFileExists = false;
+      var matchingPortFileExists = false;
       try {
-        var dbFiles = fs.readdirSync(dbPath);
+        matchingPortFileExists = +(fs.readFileSync(portFile)) === port;
+        portFileExists = true;
       } catch (e) {
         if (!e || e.code !== 'ENOENT')
           throw e;
       }
-      _.each(dbFiles, function (dbFile) {
-        if (/^local\./.test(dbFile))
-          fs.unlinkSync(path.join(dbPath, dbFile));
-      });
 
-      // Load mongo-livedata so we'll be able to talk to it.
-      var mongoNpmModule = uniload.load({
-        packages: [ 'mongo-livedata' ],
-        release: release.current.name
-      })['mongo-livedata'].MongoInternals.NpmModule;
+      // If this is the first time we're using this DB, or we changed port since
+      // the last time, then we want to destroy any existing replSet
+      // configuration and create a new one. First we delete the "local"
+      // database if it exists. (It's a pain and slow to change the port in an
+      // existing replSet configuration. It's also a little slow to initiate a
+      // new replSet, thus the attempt to not do it unless the port changes.)
+      //
+      // In the "multiple" case, we just wipe out the entire database and incur
+      // the cost, because this won't affect normal users running meteor.
+      if (!matchingPortFileExists) {
+        // Delete the port file if it exists, so we don't mistakenly believe
+        // that the DB is still configured.
+        if (portFileExists)
+          fs.unlinkSync(portFile);
+
+        try {
+          var dbFiles = fs.readdirSync(dbPath);
+        } catch (e) {
+          if (!e || e.code !== 'ENOENT')
+            throw e;
+        }
+        _.each(dbFiles, function (dbFile) {
+          if (/^local\./.test(dbFile)) {
+            fs.unlinkSync(path.join(dbPath, dbFile));
+          }
+        });
+      }
     }
 
-    // Start mongod with a dummy replSet and wait for it to
-    // listen.
+    // Start mongod with a dummy replSet and wait for it to listen.
     var child_process = require('child_process');
-    var replSetName = 'meteor';
-    if (cancelStartup)
+
+    // Let's not actually start a process if we yielded (eg during
+    // findMongoAndKillItDead) and we decided to stop in the middle (eg, because
+    // we're in multiple mode and another process exited).
+    if (stopped)
       return;
     proc = child_process.spawn(mongod_path, [
       // nb: cli-test.sh and findMongoPids make strong assumptions about the
@@ -251,13 +287,72 @@ var launchMongo = function (options) {
       '--bind_ip', '127.0.0.1',
       '--smallfiles',
       '--nohttpinterface',
-      '--port', options.port,
+      '--port', port,
       '--dbpath', dbPath,
       // Use an 8MB oplog rather than 256MB. Uses less space on disk and
       // initializes faster. (Not recommended for production!)
       '--oplogSize', '8',
       '--replSet', replSetName
     ]);
+    subHandles.push({
+      stop: function () {
+        if (proc) {
+          proc.removeListener('exit', procExitHandler);
+          proc.kill('SIGINT');
+          proc = null;
+        }
+      }
+    });
+
+    procExitHandler = inFiber(function (code, signal) {
+      // Defang subHandle.stop().
+      proc = null;
+
+      // Kill any other processes too. This will also remove
+      // procExitHandler from the other processes, so onExit will only be called
+      // once.
+      handle.stop();
+
+      // Invoke the outer onExit callback.
+      onExit(code, signal, stderrOutput);
+    });
+    proc.on('exit', procExitHandler);
+
+    var listening = false;
+    var replSetReadyToBeInitiated = false;
+    var replSetReady = false;
+
+    var readyToTalkFuture = new Future;
+
+    var maybeReadyToTalk = function () {
+      if (readyToTalkFuture.isResolved())
+        return;
+      if (listening && (noOplog || replSetReadyToBeInitiated || replSetReady)) {
+        proc.stdout.removeListener('data', stdoutOnData);
+        readyToTalkFuture.return();
+      }
+    };
+
+    var stdoutOnData = inFiber(function (data) {
+      // note: don't use "else ifs" in this, because 'data' can have multiple
+      // lines
+      if (/config from self or any seed \(EMPTYCONFIG\)/.test(data)) {
+        replSetReadyToBeInitiated = true;
+        maybeReadyToTalk();
+      }
+
+      if (/ \[initandlisten\] waiting for connections on port/.test(data)) {
+        listening = true;
+        maybeReadyToTalk();
+      }
+
+      if (/ \[rsMgr\] replSet (PRIMARY|SECONDARY)/.test(data)) {
+        replSetReady = true;
+        maybeReadyToTalk();
+      }
+    });
+    proc.stdout.setEncoding('utf8');
+    proc.stdout.on('data', stdoutOnData);
 
     var stderrOutput = '';
     proc.stderr.setEncoding('utf8');
@@ -265,97 +360,164 @@ var launchMongo = function (options) {
       stderrOutput += data;
     });
 
-    callOnExit = function (code, signal) {
-      onExit(code, signal, stderrOutput);
-    };
-    proc.on('exit', callOnExit);
+    fiberHelpers.waitForOne(stopFuture, readyToTalkFuture);
+  };
 
-    proc.stdout.setEncoding('utf8');
-    var listening = false;
-    var replSetReady = false;
-    var replSetReadyToBeInitiated = false;
-    var alreadyInitiatedReplSet = false;
-    var alreadyCalledOnListen = false;
-    var maybeCallOnListen = function () {
-      if (listening && (replSetReady || noOplog) && !alreadyCalledOnListen) {
-        if (createReplSet)
-          fs.writeFileSync(portFile, options.port);
-        alreadyCalledOnListen = true;
-        onListen();
-      }
-    };
 
-    var maybeInitiateReplset = function () {
-      // We need to want to create a replset, be confident that the server is
-      // listening, be confident that the server's replset implementation is
-      // ready to be initiated, and have not already done it.
-      if (!(createReplSet && listening && replSetReadyToBeInitiated
-            && !alreadyInitiatedReplSet)) {
-        return;
-      }
+  var initiateReplSetAndWaitForReady = function () {
+    try {
+      // Load mongo-livedata so we'll be able to talk to it.
+      var mongoNpmModule = uniload.load({
+        packages: [ 'mongo-livedata' ],
+        release: release.current.name
+      })['mongo-livedata'].MongoInternals.NpmModule;
 
-      alreadyInitiatedReplSet = true;
-
-      // Connect to it and start a replset.
+      // Connect to the intended primary and start a replset.
       var db = new mongoNpmModule.Db(
-        'meteor', new mongoNpmModule.Server('127.0.0.1', options.port),
+        'meteor',
+        new mongoNpmModule.Server('127.0.0.1', options.port, {poolSize: 1}),
         {safe: true});
-      db.open(function(err, db) {
-        if (err)
-          throw err;
-        db.admin().command({
-          replSetInitiate: {
-            _id: replSetName,
-            members: [{_id : 0, host: '127.0.0.1:' + options.port}]
-          }
-        }, function (err, result) {
-          if (err)
-              throw err;
-          // why this isn't in the error is unclear.
-          if (result && result.documents && result.documents[0]
-              && result.documents[0].errmsg) {
-            throw result.document[0].errmsg;
-          }
-          db.close(true);
+      yieldingMethod(db, 'open');
+      if (stopped)
+        return;
+      var configuration = {
+        _id: replSetName,
+        members: [{_id: 0, host: '127.0.0.1:' + options.port, priority: 100}]
+      };
+      if (options.multiple) {
+        // Add two more members: one of which should start as secondary but
+        // could in theory become primary, and one of which can never be
+        // primary.
+        configuration.members.push({
+          _id: 1, host: '127.0.0.1:' + (options.port + 1), priority: 5
         });
+        configuration.members.push({
+          _id: 2, host: '127.0.0.1:' + (options.port + 2), priority: 0
+        });
+      }
+
+      var initiateResult = yieldingMethod(
+        db.admin(), 'command', {replSetInitiate: configuration});
+      if (stopped)
+        return;
+      // why this isn't in the error is unclear.
+      if (initiateResult && initiateResult.documents
+          && initiateResult.documents[0]
+          && initiateResult.documents[0].errmsg) {
+        var err = initiateResult.documents[0].errmsg;
+        if (err !== "already initialized") {
+          throw Error("rs.initiate error: " +
+                      initiateResult.documents[0].errmsg);
+        }
+      }
+      // XXX timeout eventually?
+      while (!stopped) {
+        var status = yieldingMethod(db.admin(), 'command',
+                                    {replSetGetStatus: 1});
+        if (!(status && status.documents && status.documents[0]))
+          throw status;
+        status = status.documents[0];
+        if (!status.ok) {
+          if (status.startupStatus === 6) {  // "SOON"
+            utils.sleepMs(20);
+            continue;
+          }
+          throw status.errmsg;
+        }
+        // See http://docs.mongodb.org/manual/reference/replica-states/
+        // for information about the various states.
+
+        // Are any of the members starting up or recovering?
+        if (_.any(status.members, function (member) {
+          return member.stateStr === 'STARTUP' ||
+            member.stateStr === 'STARTUP2' ||
+            member.stateStr === 'RECOVERING';
+        })) {
+          utils.sleepMs(20);
+          continue;
+        }
+
+        // Is the intended primary currently a secondary? (It passes through
+        // that phase briefly.)
+
+        if (status.members[0].stateStr === 'SECONDARY') {
+          utils.sleepMs(20);
+          continue;
+        }
+
+        // Anything else for the intended primary is probably an error.
+        if (status.members[0].stateStr !== 'PRIMARY') {
+          throw Error("Unexpected Mongo status: " + JSON.stringify(status));
+        }
+
+        // Anything but secondary for the other members is probably an error.
+        for (var i = 1; i < status.members.length; ++i) {
+          if (status.members[i].stateStr !== 'SECONDARY') {
+            throw Error("Unexpected Mongo secondary status: " +
+                        JSON.stringify(status));
+          }
+        }
+
+        break;
+      }
+
+      db.close(true /* means "the app is closing the connection" */);
+    } catch (e) {
+      // If the process has exited, we're doing another form of error
+      // handling. No need to throw random low-level errors farther.
+      if (!stopped || (e instanceof StoppedDuringLaunch))
+        throw e;
+    }
+  };
+
+  try {
+    if (options.multiple) {
+      var dbBasePath = path.join(options.appDir, '.meteor', 'local', 'dbs');
+      _.each(_.range(3), function (i) {
+        // Did we get stopped (eg, by one of the processes exiting) by now? Then
+        // don't start anything new.
+        if (stopped)
+          return;
+        var dbPath = path.join(options.appDir, '.meteor', 'local', 'dbs', ''+i);
+        launchOneMongoAndWaitForReadyForInitiate(dbPath, options.port + i);
       });
-    };
-
-    proc.stdout.on('data', function (data) {
-      // note: don't use "else ifs" in this, because 'data' can have multiple
-      // lines
-      if (/config from self or any seed \(EMPTYCONFIG\)/.test(data)) {
-        replSetReadyToBeInitiated = true;
-        maybeInitiateReplset();
+      if (!stopped) {
+        initiateReplSetAndWaitForReady();
       }
-
-      if (/ \[initandlisten\] waiting for connections on port/.test(data)) {
-        listening = true;
-        maybeInitiateReplset();
-        maybeCallOnListen();
+    } else {
+      var dbPath = path.join(options.appDir, '.meteor', 'local', 'db');
+      var portFile = !noOplog && path.join(dbPath, 'METEOR-PORT');
+      launchOneMongoAndWaitForReadyForInitiate(dbPath, options.port, portFile);
+      if (!stopped && !noOplog) {
+        initiateReplSetAndWaitForReady();
+        if (!stopped) {
+          // Write down that we configured the database properly.
+          fs.writeFileSync(portFile, options.port);
+        }
       }
+    }
+  } catch (e) {
+    if (!(e instanceof StoppedDuringLaunch))
+      throw e;
+  }
 
-      if (/ \[rsMgr\] replSet PRIMARY/.test(data)) {
-        replSetReady = true;
-        maybeCallOnListen();
-      }
-    });
-  }).run();
+  if (stopped)
+    return null;
 
   return handle;
 };
 
-
 // This runs a Mongo process and restarts it whenever it fails. If it
 // restarts too often, we give up on restarting it, diagnostics are
 // logged, and onFailure is called.
 //
-// options: appDir, port, onFailure
+// options: appDir, port, onFailure, multiple
 var MongoRunner = function (options) {
   var self = this;
   self.appDir = options.appDir;
   self.port = options.port;
   self.onFailure = options.onFailure;
+  self.multiple = options.multiple;
 
   self.handle = null;
   self.shuttingDown = false;
@@ -380,11 +542,34 @@ _.extend(MongoRunner.prototype, {
     if (self.handle)
       throw new Error("already running?");
 
-    self.startupFuture = new Future;
     self._startOrRestart();
-    return self.startupFuture.wait();
+
+    // Did we properly start up? Great!
+    if (self.handle)
+      return;
+
+    // Are we shutting down? OK.
+    if (self.shuttingDown)
+      return;
+
+    // Otherwise, wait for a successful _startOrRestart, or a failure.
+    if (!self.startupFuture) {
+      self.startupFuture = new Future;
+      self.startupFuture.wait();
+    }
   },
 
+  // Tries to launch Mongo once.  It returns when either (a) Mongo is listening
+  // or (b) mongod exited before it got to the point of listening.
+  //
+  // (To be specific: in non-multiple mode, this means that the single mongod is
+  // listening and the primary, or that the single mongod died. In multiple
+  // mode, it means that the first mongod is listening and is primary and the
+  // other mongods are listening and are secondary, or that any mongod died (and
+  // it tried to kill the others).)
+  //
+  // In case (a), self.handle will be the handle returned from launchMongo; in
+  // case (b) self.handle will be null.
   _startOrRestart: function () {
     var self = this;
 
@@ -394,22 +579,18 @@ _.extend(MongoRunner.prototype, {
     self.handle = launchMongo({
       appDir: self.appDir,
       port: self.port,
-      onExit: _.bind(self._exited, self),
-      onListen: function () {
-        if (self.startupFuture) {
-          // It's come up successfully for the first time. Make
-          // start() return.
-          self.startupFuture['return'](true);
-          self.startupFuture = null;
-        }
-      }
+      multiple: self.multiple,
+      onExit: _.bind(self._exited, self)
     });
+    if (self.handle) {
+      self._allowStartupToReturn();
+    }
   },
 
   _exited: function (code, signal, stderr) {
     var self = this;
+
     self.handle = null;
-    self.restartTimer = null;
 
     // If Mongo exited because (or rather, anytime after) we told it
     // to exit, great, nothing to do. Otherwise, we'll print an error
@@ -420,7 +601,15 @@ _.extend(MongoRunner.prototype, {
     // Print the last 20 lines of stderr.
     runLog.log(
       stderr.split('\n').slice(-20).join('\n') +
-      "Unexpected mongo exit code " + code + ". Restarting.");
+      "Unexpected mongo exit code " + code +
+        (self.multiple ? "." : ". Restarting."));
+
+    // If we're in multiple mode, we never try to restart. That's to keep the
+    // test-only multiple code simple.
+    if (self.multiple) {
+      self._fail();
+      return;
+    }
 
     // We'll restart it up to 3 times in a row. The counter is reset
     // when 5 seconds goes without a restart. (Note that by using a
@@ -430,12 +619,14 @@ _.extend(MongoRunner.prototype, {
     if (self.errorTimer)
       clearTimeout(self.errorTimer);
     self.errorTimer = setTimeout(function () {
+      self.errorTimer = null;
       self.errorCount = 0;
     }, 5000);
 
     if (self.errorCount < 3) {
       // Wait a second, then restart.
       self.restartTimer = setTimeout(inFiber(function () {
+        self.restartTimer = null;
         self._startOrRestart();
       }), 1000);
       return;
@@ -463,13 +654,7 @@ _.extend(MongoRunner.prototype, {
     }
 
     runLog.log(message);
-    self.onFailure && self.onFailure();
-
-    if (self.startupFuture) {
-      // start() is still blocking.. make it return
-      self.startupFuture['return'](false);
-      self.startupFuture = null;
-    }
+    self._fail();
   },
 
   // Idempotent
@@ -488,6 +673,43 @@ _.extend(MongoRunner.prototype, {
       self.handle.stop();
       self.handle = null;
     }
+  },
+
+  _allowStartupToReturn: function () {
+    var self = this;
+    if (self.startupFuture) {
+      var startupFuture = self.startupFuture;
+      self.startupFuture = null;
+      startupFuture.return();
+    }
+  },
+
+  _fail: function () {
+    var self = this;
+    self.stop();
+    self.onFailure && self.onFailure();
+    self._allowStartupToReturn();
+  },
+
+  _mongoHosts: function () {
+    var self = this;
+    var ports = [self.port];
+    if (self.multiple) {
+      ports.push(self.port + 1, self.port + 2);
+    }
+    return _.map(ports, function (port) {
+      return "127.0.0.1:" + port;
+    }).join(",");
+  },
+
+  mongoUrl: function () {
+    var self = this;
+    return "mongodb://" + self._mongoHosts() + "/meteor";
+  },
+
+  oplogUrl: function () {
+    var self = this;
+    return "mongodb://" + self._mongoHosts() + "/local";
   }
 });
 
diff --git a/tools/run-proxy.js b/tools/run-proxy.js
index 18ae901e95..c263c16432 100644
--- a/tools/run-proxy.js
+++ b/tools/run-proxy.js
@@ -1,14 +1,16 @@
 var _ = require('underscore');
 var Future = require('fibers/future');
-var runLog = require('./run-log.js').runLog;
+var runLog = require('./run-log.js');
 
-// options: listenPort, proxyToPort, onFailure
+// options: listenPort, proxyToPort, proxyToHost, onFailure
 var Proxy = function (options) {
   var self = this;
 
   self.listenPort = options.listenPort;
+  self.listenHost = options.listenHost;
   // note: run-all.js updates proxyToPort directly
   self.proxyToPort = options.proxyToPort;
+  self.proxyToHost = options.proxyToHost || '127.0.0.1';
   self.onFailure = options.onFailure || function () {};
 
   self.mode = "hold";
@@ -56,7 +58,7 @@ _.extend(Proxy.prototype, {
 
     var fut = new Future;
     self.server.on('error', function (err) {
-      if (err.code == 'EADDRINUSE') {
+      if (err.code === 'EADDRINUSE') {
         var port = self.listenPort;
         runLog.log(
 "Can't listen on port " + port + ". Perhaps another Meteor is running?\n" +
@@ -64,6 +66,15 @@ _.extend(Proxy.prototype, {
 "Running two copies of Meteor in the same application directory\n" +
 "will not work. If something else is using port " + port + ", you can\n" +
 "specify an alternative port with --port <port>.");
+      } else if (self.listenHost &&
+                 (err.code === 'ENOTFOUND' || err.code === 'EADDRNOTAVAIL')) {
+        // This handles the case of "entered a DNS name that's unknown"
+        // (ENOTFOUND from getaddrinfo) and "entered some random IP that we
+        // can't bind to" (EADDRNOTAVAIL from listen).
+        runLog.log(
+"Can't listen on host " + self.listenHost + " (" + err.code + " from " +
+            err.syscall + ").");
+
       } else {
         runLog.log('' + err);
       }
@@ -91,7 +102,7 @@ _.extend(Proxy.prototype, {
       }
     });
 
-    self.server.listen(self.listenPort, function () {
+    self.server.listen(self.listenPort, self.listenHost || '0.0.0.0', function () {
       if (self.server) {
         self.started = true;
       } else {
@@ -167,7 +178,7 @@ _.extend(Proxy.prototype, {
         c.res.end();
       } else {
         self.proxy.web(c.req, c.res, {
-          target: 'http://127.0.0.1:' + self.proxyToPort
+          target: 'http://' + self.proxyToHost + ':' + self.proxyToPort
         });
       }
     }
@@ -178,7 +189,7 @@ _.extend(Proxy.prototype, {
 
       var c = self.websocketQueue.shift();
       self.proxy.ws(c.req, c.socket, c.head, {
-        target: 'http://127.0.0.1:' + self.proxyToPort
+        target: 'http://' + self.proxyToHost + ':' + self.proxyToPort
       });
     }
   },
diff --git a/tools/selftest.js b/tools/selftest.js
index faaa3de127..a5e0f96a3b 100644
--- a/tools/selftest.js
+++ b/tools/selftest.js
@@ -934,6 +934,12 @@ _.extend(Run.prototype, {
     }
 
     self.fakeMongoConnection.write(JSON.stringify(command) + "\n");
+    // If we told it to exit, then we should close our end and connect again if
+    // asked to send more.
+    if (command.exit) {
+      self.fakeMongoConnection.end();
+      self.fakeMongoConnection = null;
+    }
   })
 });
 
diff --git a/tools/server/boot.js b/tools/server/boot.js
index aa4df6c439..6f401f4140 100644
--- a/tools/server/boot.js
+++ b/tools/server/boot.js
@@ -5,8 +5,8 @@ var Future = require(path.join("fibers", "future"));
 var _ = require('underscore');
 var sourcemap_support = require('source-map-support');
 
-// This code is duplicated in tools/meteor.js.
-var MIN_NODE_VERSION = 'v0.10.25';
+// This code is duplicated in tools/main.js.
+var MIN_NODE_VERSION = 'v0.10.26';
 
 if (require('semver').lt(process.version, MIN_NODE_VERSION)) {
   process.stderr.write(
diff --git a/tools/skel/.meteor/packages b/tools/skel/.meteor/packages
index 320fb7d436..e442b00306 100644
--- a/tools/skel/.meteor/packages
+++ b/tools/skel/.meteor/packages
@@ -6,5 +6,3 @@
 standard-app-packages
 autopublish
 insecure
-preserve-inputs
-templating
\ No newline at end of file
diff --git a/tools/tests/apps/ddp-heartbeat/.meteor/.gitignore b/tools/tests/apps/ddp-heartbeat/.meteor/.gitignore
new file mode 100644
index 0000000000..4083037423
--- /dev/null
+++ b/tools/tests/apps/ddp-heartbeat/.meteor/.gitignore
@@ -0,0 +1 @@
+local
diff --git a/tools/tests/apps/ddp-heartbeat/.meteor/packages b/tools/tests/apps/ddp-heartbeat/.meteor/packages
new file mode 100644
index 0000000000..60221cd338
--- /dev/null
+++ b/tools/tests/apps/ddp-heartbeat/.meteor/packages
@@ -0,0 +1,7 @@
+# Meteor packages used by this project, one per line.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+standard-app-packages
+underscore
diff --git a/tools/tests/apps/ddp-heartbeat/.meteor/release b/tools/tests/apps/ddp-heartbeat/.meteor/release
new file mode 100644
index 0000000000..621e94f0ec
--- /dev/null
+++ b/tools/tests/apps/ddp-heartbeat/.meteor/release
@@ -0,0 +1 @@
+none
diff --git a/tools/tests/apps/ddp-heartbeat/server/heartbeat_test.js b/tools/tests/apps/ddp-heartbeat/server/heartbeat_test.js
new file mode 100644
index 0000000000..f6e7bb49a7
--- /dev/null
+++ b/tools/tests/apps/ddp-heartbeat/server/heartbeat_test.js
@@ -0,0 +1,96 @@
+var Fiber = Npm.require("fibers");
+var Future = Npm.require("fibers/future");
+
+// XXX Deps isn't supported on the server... but we need a way to
+// capture client connection status transitions.
+
+var waitReactive = function (fn) {
+  var future = new Future();
+  var timeoutHandle = Meteor.setTimeout(
+    function () {
+      future.throw(new Error("timeout"));
+    },
+    60000
+  );
+  Deps.autorun(function (c) {
+    var ret = fn();
+    if (ret) {
+      c.stop();
+      Meteor.clearTimeout(timeoutHandle);
+
+      // We need to run in a fiber for `defer`.
+      Fiber(function () {
+        // Use `defer` because yields are blocked inside of autorun.
+        Meteor.defer(function () {
+          future.return(ret);
+        })
+      }).run();
+    }
+  });
+  return future.wait();
+};
+
+var waitForClientConnectionStatus = function (connection, status) {
+  waitReactive(function () {
+    return connection.status().status === status;
+  });
+};
+
+
+// Expect to connect, and then to reconnect (presumably because of a
+// timeout).
+
+var expectConnectAndReconnect = function (clientConnection) {
+  console.log("client is connecting");
+  waitForClientConnectionStatus(clientConnection, "connected");
+
+  console.log("client is connected, expecting ping timeout and reconnect");
+  waitForClientConnectionStatus(clientConnection, "connecting");
+
+  console.log("client is reconnecting");
+};
+
+
+var testClientTimeout = function () {
+  console.log("Test client timeout");
+
+  var savedServerOptions = _.clone(Meteor.server.options);
+  Meteor.server.options.heartbeatInterval = 0;
+  Meteor.server.options.respondToPings = false;
+
+  var clientConnection = DDP.connect(Meteor.absoluteUrl());
+
+  expectConnectAndReconnect(clientConnection);
+
+  clientConnection.close();
+
+  Meteor.server.options = savedServerOptions;
+
+  console.log("test successful\n");
+};
+
+
+var testServerTimeout = function () {
+  console.log("Test server timeout");
+
+  var clientConnection = DDP.connect(
+    Meteor.absoluteUrl(),
+    {
+      heartbeatInterval: 0,
+      respondToPings: false
+    }
+  );
+
+  expectConnectAndReconnect(clientConnection);
+
+  clientConnection.close();
+  console.log("test successful\n");
+};
+
+Fiber(function () {
+  Meteor._printReceivedDDP = true;
+  Meteor._printSentDDP = true;
+  testClientTimeout();
+  testServerTimeout();
+  process.exit(0);
+}).run();
diff --git a/tools/tests/apps/failover-test/.meteor/.gitignore b/tools/tests/apps/failover-test/.meteor/.gitignore
new file mode 100644
index 0000000000..4083037423
--- /dev/null
+++ b/tools/tests/apps/failover-test/.meteor/.gitignore
@@ -0,0 +1 @@
+local
diff --git a/tools/tests/apps/failover-test/.meteor/packages b/tools/tests/apps/failover-test/.meteor/packages
new file mode 100644
index 0000000000..2334f880ed
--- /dev/null
+++ b/tools/tests/apps/failover-test/.meteor/packages
@@ -0,0 +1,9 @@
+# Meteor packages used by this project, one per line.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+meteor
+mongo-livedata
+underscore
+random
diff --git a/tools/tests/apps/failover-test/.meteor/release b/tools/tests/apps/failover-test/.meteor/release
new file mode 100644
index 0000000000..621e94f0ec
--- /dev/null
+++ b/tools/tests/apps/failover-test/.meteor/release
@@ -0,0 +1 @@
+none
diff --git a/tools/tests/apps/failover-test/server/failover-test.js b/tools/tests/apps/failover-test/server/failover-test.js
new file mode 100644
index 0000000000..1b704d1e12
--- /dev/null
+++ b/tools/tests/apps/failover-test/server/failover-test.js
@@ -0,0 +1,91 @@
+// Tests that an observeChanges created before a failover continues to work
+// after the failover. Doesn't test anything in particular about writes that
+// occur immediately before the failover, but does ensure that a write after the
+// failover is observed.
+//
+// Prints various things. On success, prints SUCCESS and exits 0. On failure,
+// exits non-0.
+
+var C = new Meteor.Collection(Random.id());
+
+var steps = {};
+var nextStepTimeout = null;
+
+var setNextStepTimeout = function () {
+  nextStepTimeout = Meteor.setTimeout(function () {
+    console.log('Waited too long and no next step happened.');
+    process.exit(1);
+  }, 30*1000);
+};
+
+var originalMasterName = null;
+
+steps.initialized = function () {
+  // Great, we got the first thing. Let's get another thing.
+  C.insert({step: 'next'});
+  var db = MongoInternals.defaultRemoteCollectionDriver().mongo.db;
+  var master = db.serverConfig._state.master;
+  if (!master) {
+    console.log("No master in initialized?");
+    process.exit(1);
+  }
+  originalMasterName = master.name;
+  console.log("Master starts as", originalMasterName);
+};
+
+steps.next = function () {
+  // Great, we can continue to add things. Now trigger a failover.
+  var db = MongoInternals.defaultRemoteCollectionDriver().mongo.db;
+  db.admin().command({replSetStepDown: 60, force: true});
+  while (true) {
+    try {
+      console.log("trying to insert");
+      C.insert({step: 'steppedDown'});
+      console.log("inserted");
+      return;
+    } catch (e) {
+      console.log("failed to insert", e);
+    }
+  }
+};
+
+steps.steppedDown = function () {
+  console.log("Write succeeded after stepdown.");
+  var db = MongoInternals.defaultRemoteCollectionDriver().mongo.db;
+  var master = db.serverConfig._state.master;
+  if (!master) {
+    console.log("No master in steppedDown?");
+    process.exit(1);
+  }
+  if (master.name === originalMasterName) {
+    console.log("Master didn't change?");
+    process.exit(1);
+  }
+  console.log("Master ended as", master.name);
+  console.log("SUCCESS");
+  process.exit(0);
+};
+
+C.find().observeChanges({
+  added: function (id, fields) {
+    if (nextStepTimeout) {
+      Meteor.clearTimeout(nextStepTimeout);
+      nextStepTimeout = null;
+    }
+    if (!fields.step && _.has(steps, fields.step)) {
+      console.log('Unexpected step:', fields.step);
+      process.exit(1);
+    }
+    console.log("Step", fields.step);
+    steps[fields.step]();
+    setNextStepTimeout();
+  }
+});
+
+setNextStepTimeout();
+
+C.insert({step: 'initialized'});
+
+main = function (argv) {
+  return 'DAEMON';
+};
diff --git a/tools/tests/ddp-heartbeat.js b/tools/tests/ddp-heartbeat.js
new file mode 100644
index 0000000000..643947ae7d
--- /dev/null
+++ b/tools/tests/ddp-heartbeat.js
@@ -0,0 +1,18 @@
+var selftest = require('../selftest.js');
+var Sandbox = selftest.Sandbox;
+
+var MONGO_LISTENING =
+  { stdout: " [initandlisten] waiting for connections on port" };
+
+selftest.define("ddp-heartbeat", ["slow"], function () {
+  var s = new Sandbox({ fakeMongo: true });
+  var run;
+
+  s.createApp("ddpapp", "ddp-heartbeat");
+  s.cd("ddpapp");
+
+  var run = s.run("--once", "--raw-logs");
+  run.tellMongo(MONGO_LISTENING);
+  run.waitSecs(120);
+  run.expectExit(0);
+});
diff --git a/tools/tests/list-sites.js b/tools/tests/list-sites.js
new file mode 100644
index 0000000000..48025566fc
--- /dev/null
+++ b/tools/tests/list-sites.js
@@ -0,0 +1,23 @@
+var _ = require('underscore');
+var selftest = require('../selftest.js');
+var testUtils = require('../test-utils.js');
+var files = require('../files.js');
+var Sandbox = selftest.Sandbox;
+var httpHelpers = require('../http-helpers.js');
+
+var commandTimeoutSecs = testUtils.accountsCommandTimeoutSecs;
+
+selftest.define('list-sites - basic', ['net', 'slow'], function () {
+  var s = new Sandbox;
+  var email = testUtils.randomUserEmail();
+  var appName1 = testUtils.randomAppName();
+  var appName2 = testUtils.randomAppName();
+  testUtils.deployWithNewEmail(s, email, appName1);
+  testUtils.createAndDeployApp(s, { appName: appName2 });
+  var run = s.run('list-sites');
+  run.waitSecs(commandTimeoutSecs);
+  run.read(appName1 + '.meteor.com' + '\n' + appName2 + '.meteor.com');
+  testUtils.cleanUpApp(s, appName1);
+  testUtils.cleanUpApp(s, appName2);
+  testUtils.logout(s);
+});
diff --git a/tools/tests/mongo.js b/tools/tests/mongo.js
new file mode 100644
index 0000000000..bfbf14d99c
--- /dev/null
+++ b/tools/tests/mongo.js
@@ -0,0 +1,21 @@
+var selftest = require('../selftest.js');
+var Sandbox = selftest.Sandbox;
+var utils = require('../utils.js');
+var net = require('net');
+var Future = require('fibers/future');
+var _ = require('underscore');
+var files = require('../files.js');
+
+// Tests that observeChanges continues to work even over a mongo failover.
+selftest.define("mongo failover", ["slow"], function () {
+  var s = new Sandbox();
+  s.set('METEOR_TEST_MULTIPLE_MONGOD_REPLSET', 't');
+  s.createApp("failover-test", "failover-test");
+  s.cd("failover-test");
+
+  var run = s.run("--once", "--raw-logs");
+  run.waitSecs(120);
+  run.match("SUCCESS\n");
+  run.expectEnd();
+  run.expectExit(0);
+});
diff --git a/tools/tests/old/test-bundler-options.js b/tools/tests/old/test-bundler-options.js
index 1304dad392..d82ab956cc 100644
--- a/tools/tests/old/test-bundler-options.js
+++ b/tools/tests/old/test-bundler-options.js
@@ -15,6 +15,12 @@ var tmpDir = function () {
 };
 
 var runTest = function () {
+  var readManifest = function (tmpOutputDir) {
+    return JSON.parse(fs.readFileSync(
+      path.join(tmpOutputDir, "programs", "client", "program.json"),
+      "utf8")).manifest;
+  };
+
   console.log("nodeModules: 'skip'");
   assert.doesNotThrow(function () {
     var tmpOutputDir = tmpDir();
@@ -38,10 +44,13 @@ var runTest = function () {
            .isDirectory());
 
     // verify that contents are minified
-    var appHtml = fs.readFileSync(path.join(tmpOutputDir, "programs",
-                                            "client", "app.html"), 'utf8');
-    assert(/src=\"##BUNDLED_JS_CSS_PREFIX##\/[0-9a-f]{40,40}.js\"/.test(appHtml));
-    assert(!(/src=\"##BUNDLED_JS_CSS_PREFIX##\/packages/.test(appHtml)));
+    var manifest = readManifest(tmpOutputDir);
+    _.each(manifest, function (item) {
+      if (item.type !== 'js')
+        return;
+      // Just a hash, and no "packages/".
+      assert(/^[0-9a-f]{40,40}\.js$/.test(item.path));
+    });
   });
 
   console.log("nodeModules: 'skip', no minify");
@@ -58,14 +67,25 @@ var runTest = function () {
     // sanity check -- main.js has expected contents.
     assert.strictEqual(fs.readFileSync(path.join(tmpOutputDir, "main.js"), "utf8"),
                        bundler._mainJsContents);
+
     // verify that contents are not minified
-    var appHtml = fs.readFileSync(path.join(tmpOutputDir, "programs",
-                                            "client", "app.html"), 'utf8');
-    assert(!(/src=\"##BUNDLED_JS_CSS_PREFIX##\/[0-9a-f]{40,40}.js\"/.test(appHtml)));
-    assert(/src=\"##BUNDLED_JS_CSS_PREFIX##\/packages\/meteor/.test(appHtml));
-    assert(/src=\"##BUNDLED_JS_CSS_PREFIX##\/packages\/deps/.test(appHtml));
-    // verify that tests aren't included
-    assert(!(/src=\"##BUNDLED_JS_CSS_PREFIX##\/package-tests\/meteor/.test(appHtml)));
+    var manifest = readManifest(tmpOutputDir);
+    var foundMeteor = false;
+    var foundDeps = false;
+    _.each(manifest, function (item) {
+      if (item.type !== 'js')
+        return;
+      // No minified hash.
+      assert(!/^[0-9a-f]{40,40}\.js$/.test(item.path));
+      // No tests.
+      assert(!/:tests/.test(item.path));
+      if (item.path === 'packages/meteor.js')
+        foundMeteor = true;
+      if (item.path === 'packages/deps.js')
+        foundDeps = true;
+    });
+    assert(foundMeteor);
+    assert(foundDeps);
   });
 
   console.log("nodeModules: 'skip', no minify, testPackages: ['meteor']");
@@ -82,10 +102,12 @@ var runTest = function () {
     // sanity check -- main.js has expected contents.
     assert.strictEqual(fs.readFileSync(path.join(tmpOutputDir, "main.js"), "utf8"),
                        bundler._mainJsContents);
+
     // verify that tests for the meteor package are included
-    var appHtml = fs.readFileSync(path.join(tmpOutputDir, "programs",
-                                            "client", "app.html"));
-    assert(/src=\"##BUNDLED_JS_CSS_PREFIX##\/packages\/meteor:tests\.js/.test(appHtml));
+    var manifest = readManifest(tmpOutputDir);
+    assert(_.find(manifest, function (item) {
+      return item.type === 'js' && item.path === 'packages/meteor:tests.js';
+    }));
   });
 
   console.log("nodeModules: 'copy'");
diff --git a/tools/tests/run.js b/tools/tests/run.js
index 45883021c1..80e4544544 100644
--- a/tools/tests/run.js
+++ b/tools/tests/run.js
@@ -12,7 +12,7 @@ var MONGO_LISTENING =
 var SIMPLE_WAREHOUSE = {
   v1: { tools: 'tools1' },
   v2: { tools: 'tools1', latest: true },
-  v3: { tools: 'tools1' },
+  v3: { tools: 'tools1' }
 };
 
 selftest.define("run", function () {
@@ -49,7 +49,9 @@ selftest.define("run", function () {
   run.waitSecs(5);
   run.match("is crashing");
   s.unlink("crash.js");
+  run.waitSecs(5);
   run.match("Modified");
+  run.waitSecs(5);
   run.match("restarted");
   s.write("empty.js", "");
   run.waitSecs(5);
@@ -63,6 +65,7 @@ selftest.define("run", function () {
   // Bundle failure
   s.unlink("crash.js");
   s.write("junk.js", "]");
+  run.waitSecs(5);
   run.match("Modified");
   run.match("prevented startup");
   run.match("Unexpected token");
@@ -70,6 +73,7 @@ selftest.define("run", function () {
 
   // Back to working
   s.unlink("junk.js");
+  run.waitSecs(5);
   run.match("restarted");
 
   // Crash just once, then restart successfully
@@ -85,6 +89,7 @@ selftest.define("run", function () {
 "}\n");
   run.waitSecs(5);
   run.match("with code: 137");
+  run.waitSecs(5);
   run.match("restarted");
   run.stop();
 
@@ -98,6 +103,7 @@ selftest.define("run", function () {
   run.match("Unexpected token");
   run.match("file change");
   s.unlink("junk.js");
+  run.waitSecs(5);
   run.match("restarted");
   run.stop();
 
@@ -287,3 +293,46 @@ selftest.define("update during run", ["checkout"], function () {
   run.stop();
   run.forbidAll("updated");
 });
+
+selftest.define("run with mongo crash", ["checkout"], function () {
+  var s = new Sandbox({ fakeMongo: true });
+  var run;
+
+  s.createApp("myapp", "standard-app");
+  s.cd("myapp");
+
+  // Kill mongod three times.  See that it gives up and quits.
+  run = s.run();
+  run.tellMongo(MONGO_LISTENING);
+  run.waitSecs(2);
+  run.match('localhost:3000/\n');
+  run.tellMongo({exit: 23});
+  run.read('Unexpected mongo exit code 23. Restarting.\n');
+  run.tellMongo({exit: 46});
+  run.read('Unexpected mongo exit code 46. Restarting.\n');
+  run.tellMongo({exit: 47});
+  run.read('Unexpected mongo exit code 47. Restarting.\n');
+  run.read("Can't start Mongo server.\n");
+  run.read("MongoDB exited due to excess clock skew\n");
+  run.expectEnd();
+  run.expectExit(254);
+
+  // Now create a build failure. Make sure that killing mongod three times
+  // *also* successfully quits even if we're waiting on file change.
+  s.write('bad.js', ']');
+  run = s.run();
+  run.tellMongo(MONGO_LISTENING);
+  run.waitSecs(2);
+  run.match("prevented startup");
+  run.match("file change.\n");
+  run.tellMongo({exit: 23});
+  run.read('Unexpected mongo exit code 23. Restarting.\n');
+  run.tellMongo({exit: 46});
+  run.read('Unexpected mongo exit code 46. Restarting.\n');
+  run.tellMongo({exit: 47});
+  run.read('Unexpected mongo exit code 47. Restarting.\n');
+  run.read("Can't start Mongo server.\n");
+  run.read("MongoDB exited due to excess clock skew\n");
+  run.expectEnd();
+  run.expectExit(254);
+});
diff --git a/tools/unipackage.js b/tools/unipackage.js
index 2af35f7f4d..95c315ba6e 100644
--- a/tools/unipackage.js
+++ b/tools/unipackage.js
@@ -364,9 +364,18 @@ _.extend(Unipackage.prototype, {
       // 'extension' is a file extension without the separation dot
       // (eg 'js', 'coffee', 'coffee.md')
       //
+      // 'options' can be elided. The only known option is 'isTemplate', which
+      // is a bit of a hack meaning "in an app, these files should be loaded
+      // before non-templates".
+      //
       // 'handler' is a function that takes a single argument, a
       // CompileStep (#CompileStep)
-      registerSourceHandler: function (extension, handler) {
+      registerSourceHandler: function (extension, options, handler) {
+        if (!handler) {
+          handler = options;
+          options = {};
+        }
+
         if (_.has(self.sourceHandlers, extension)) {
           buildmessage.error("duplicate handler for '*." +
                              extension + "'; may only have one per Plugin",
@@ -375,7 +384,10 @@ _.extend(Unipackage.prototype, {
           return;
         }
 
-        self.sourceHandlers[extension] = handler;
+        self.sourceHandlers[extension] = {
+          handler: handler,
+          isTemplate: !!options.isTemplate
+        };
       }
     };
 
diff --git a/tools/updater.js b/tools/updater.js
index e449bb5f3b..f0a0dd6245 100644
--- a/tools/updater.js
+++ b/tools/updater.js
@@ -4,7 +4,7 @@ var warehouse = require('./warehouse.js');
 var httpHelpers = require('./http-helpers.js');
 var config = require('./config.js');
 var release = require('./release.js');
-var runLog = require('./run-log.js').runLog;
+var runLog = require('./run-log.js');
 
 /**
  * Downloads the current manifest file and returns it. Throws
diff --git a/tools/upgraders.js b/tools/upgraders.js
index a35cf49a4d..e3d8c2a3ae 100644
--- a/tools/upgraders.js
+++ b/tools/upgraders.js
@@ -55,9 +55,19 @@ var addAppPackagesAndStandardAppPackages = function (appDir) {
   });
 };
 
+// In Meteor 0.8.0, preserve-inputs became a no-op, because Blaze doesn't
+// require manual preserve directives any more. We print a deprecation message
+// on apps that use it, but it's part of the default app skeleton, and we don't
+// want literally every user to have to type the same "meteor remove
+// preserve-inputs" command. So we do it for them.
+var noPreserveInputs = function (appDir) {
+  project.removePackage(appDir, 'preserve-inputs');
+};
+
 
 var upgradersByName = {
-  "app-packages": addAppPackagesAndStandardAppPackages
+  "app-packages": addAppPackagesAndStandardAppPackages,
+  "no-preserve-inputs": noPreserveInputs
 };
 
 exports.runUpgrader = function (upgraderName, appDir) {