diff --git a/CHANGELOG.md b/CHANGELOG.md
index f1877ad..b1d7ca8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,42 +8,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- You can now bind attributes with `??foo="${bar}"` syntax. This is functionally
-  equivalent to the `nullish` updater and will replace that functionality later.
-- A new `unsafe` updater was added to replace `unsafeHTML` and `unsafeSVG`. You
-  use it like `unsafe(value, 'html')` and `unsafe(value, 'svg')`.
+- You can now bind attributes with `??foo="${bar}"` syntax in the default
+  template engine. This is functionally equivalent to the `nullish` updater from
+  the default template engine and will replace that functionality later (#204).
 
 ### Changed
 
 - Template errors now include approximate line numbers from the offending
-  template. They also print the registered custom element tag name (#201).
+  template in the default template engine. They also print the registered custom
+  element tag name (#201).
 - The `ifDefined` updater now deletes the attribute on `null` in addition to
-  `undefined`. This makes it behave identically to `nullish`. However, both
-  updaters are deprecated and the `??attr` binding should be used instead.
-- Interpolation of `textarea` is stricter. This used to be handled with some
-  leniency — `<textarea>\n ${value} \n</textarea>`. Now, you have to fit the
-  interpolation exactly — `<textarea></textarea>`.
+  `undefined` in the default template engine. This makes it behave identically
+  to `nullish` in the default template engine. However, both updaters are
+  deprecated — the `??attr` binding should be used instead when using the
+  default template engine (#204).
+- Interpolation of `textarea` is more strict in the default template engine.
+  This used to be handled with some leniency for newlines in templates —
+  `<textarea>\n ${value} \n</textarea>`. Now, you have to interpolate exactly —
+  `<textarea>${value}</textarea>` (#219).
+- You may now bind values of type `DocumentFragment` within the template engine.
+  In particular, this was added to enable advanced flows without needing to
+  bloat the default template engine interface (#207, #216).
 
 ### Deprecated
 
 - The `ifDefined` and `nullish` updaters are deprecated, update templates to use
-  syntax like `??foo="${bar}"`.
-- The `repeat` updater is deprecated, use `map` instead.
-- The `unsafeHTML` and `unsafeSVG` updaters are deprecated, use `unsafe`.
+  syntax like `??foo="${bar}"` (#204).
+- The `repeat` updater is deprecated, use `map` instead (#204).
+- The `unsafeHTML` and `unsafeSVG` updaters are deprecated, bind a
+  `DocumentFragment` value instead (#207, #216).
 - The `plaintext` tag is no longer handled. This is a deprecated html tag which
-  required special handling… but it’s unlikely that anyone is using that.
+  required special handling… but it’s unlikely that anyone is using that (#220).
+- The `live` updater is deprecated. Use a delegated event listener for the
+  `change` event if you need tight control over DOM state in forms (#208).
 
 ### Fixed
 
-- Transitions from different content values should all now work. For example,
-  you previously could not change from a text value to an array. Additionally,
-  state is properly cleared when going from one value type to another — e.g.,
-  when going from `unsafe` back to `null`.
-- The `map` updater throws immediately when given non-array input. Previously,
-  it only threw _just before_ it was bound as content.
-- Dummy content cursor is no longer appended to end of template. This was an
-  innocuous off-by-one error when creating instrumented html from the tagged
-  template strings.
+- Transitions from different content values should all now work for the default
+  template engine. For example, you previously could not change from a text
+  value to an array. Additionally, state is properly cleared when going from one
+  value type to another — e.g., when going from `unsafe` back to `null` (#223).
+- The `map` updater throws immediately when given non-array input for the
+  default template engine. Previously, it only threw when it was bound (#222).
+- The `map` updater throws if the return value from the provided `identify`
+  callback returns a duplicate value (#218).
+- Dummy content cursor is no longer appended to end of template for the default
+  template engine. This was an innocuous off-by-one error when creating
+  instrumented html from the tagged template strings (#221).
 
 ## [1.1.1] - 2024-11-09
 
diff --git a/doc/RECIPES.md b/doc/RECIPES.md
new file mode 100644
index 0000000..739651a
--- /dev/null
+++ b/doc/RECIPES.md
@@ -0,0 +1,103 @@
+# Recipes
+
+Part of the [philosophy](../README.md#project-philosophy) for `x-element` is to
+implement only a minimal set of functionality. Rather than build a bespoke
+feature to cover each-and-every use case — we simply document how to achieve
+some desired outcomes via “recipes” for less common situations.
+
+## How do I instantiate trusted markup?
+
+In certain, _rare_ occasions, it’s acceptable to instantiate a pre-defined
+markup string as DOM using `innerHTML`. Rather than supply some sort of special
+function (e.g., `carefulWhatYouAreDoingIsUnsafe`), we trust that authors will
+understand the hazards of `innerHTML` and will use with care. The basic pattern
+here is to instantiate your markup with a `<template>` and then pass its inner
+`.content` (a `DocumentFragment`) into the template engine.
+
+```js
+class MyElement extends XElement {
+  static get properties() {
+    return {
+      // …
+      markup: {
+        type: String,
+        input: [/* … */],
+        compute: (/* … */) => {/* sanitize / purify / careful out there! */},
+      },
+      fragment: {
+        type: DocumentFragment,
+        input: ['markup'],
+        compute: (markup) => {
+          if (markup) {
+            const template = document.createElement('template');
+            template.innerHTML = markup;
+            return template.content;
+          }
+        },
+      },
+    };
+  }
+  static template(html) {
+    return ({ fragment }) => {
+      return html`
+        <div id="container">
+          <div id="title">The following is injected…</div>
+          ${fragment}
+        </div>
+      `;
+    };
+  }
+}
+```
+
+## How do I force application state to flow the way I want in forms?
+
+A common pain point when building forms is managing the _flow of data_. Does the
+model act as the source of truth? Or, does the DOM? Well, that’s up to you! If
+you _are_ trying to control forms strictly from some application state, you will
+need to make sure that (1) your change events propagate the right information,
+(2) your state is guaranteed to flow back to your view, and (3) your DOM state
+is correct by the time a potential form submission occurs (e.g., a submit event
+can follow _directly_ behind a change event in certain situations). It’s not
+possible to predict how authors wish to manage such cases — so it’s not possible
+to encode this at a library level. Here’s one way you might go about managing
+this though!
+
+```js
+class MyElement extends XElement {
+  static get properties() {
+    return {
+      // …
+      foo: {
+        type: String, // You probably want this to be a string for proper comparisons.
+      },
+    };
+  }
+  static get listeners() {
+    return {
+      change: (host, event) => this.onChange(host, event);
+    };
+  }
+  static template(html, { connected }) {
+    return ({ foo }) => {
+      return html`
+        <form id="container">
+          <input id="foo" name="foo" .value="${foo}">
+        </form>
+      `;
+    };
+  }
+  static onChange(host, event) {
+    if (event.target.id === 'foo') {
+      // The user has updated the input value. Wait for the next animation
+      //  frame and re-bind our value. Note that even in this case, if a submit
+      //  follows directly behind a change event — the DOM would still contain
+      //  possibly-stale state.
+      requestAnimationFrame(() => {
+        const foo = host.shadowRoot.getElementById('foo');
+        foo.value = host.foo;
+      });
+    }
+  }
+}
+```
diff --git a/doc/TEMPLATES.md b/doc/TEMPLATES.md
index 67fab91..60d97f7 100644
--- a/doc/TEMPLATES.md
+++ b/doc/TEMPLATES.md
@@ -21,49 +21,19 @@ static template(html, { map }) {
 }
 ```
 
-The following binding types are supported:
-
-| Type                | Example                                    |
-| :------------------ | :----------------------------------------- |
-| attribute           | `<span id="target" foo="${bar}"></span>`   |
-| attribute (boolean) | `<span id="target" ?foo="${bar}"></span>`  |
-| attribute (defined) | `<span id="target" ??foo="${bar}"></span>` |
-| property            | `<span id="target" .foo="${bar}"></span>`  |
-| content             | `<span id="target">${foo}</span>`          |
-
-Emulates:
-
-```javascript
-const el = document.createElement('div');
-el.attachShadow({ mode: 'open' });
-el.innerHTML = '<span id="target"></span>';
-const target = el.shadowRoot.getElementById('target');
-
-// attribute value bindings set the attribute value
-target.setAttribute('foo', bar);
-
-// attribute boolean bindings set the attribute to an empty string or remove
-target.setAttribute('foo', ''); // when bar is truthy
-target.removeAttribute('foo'); // when bar is falsy
-
-// attribute defined bindings set the attribute if the value is non-nullish
-target.setAttribute('foo', bar); // when bar is non-nullish
-target.removeAttribute('foo'); // when bar is nullish
-
-// property bindings assign the value to the property of the node
-target.foo = bar;
-
-// content bindings create text nodes for basic content
-const text = document.createTextNode('');
-text.textContent = foo;
-target.append(text);
-
-// content bindings append a child for singular, nested content
-target.append(foo);
-
-// content binding maps and appends children for arrays of nested content
-target.append(...foo);
-```
+The following bindings are supported:
+
+| Binding             | Template                     | Emulates                                                      |
+| :------------------ | :--------------------------- | :------------------------------------------------------------ |
+| --                  | --                           | `const el = document.createElement('div');`                   |
+| attribute           | `<div foo="${bar}"></div>`   | `el.setAttribute('foo', bar);`                                |
+| attribute (boolean) | `<div ?foo="${bar}"></div>`  | `el.setAttribute('foo', ''); // if  “bar” is truthy`          |
+| --                  | --                           | `el.removeAttribute('foo'); // if  “bar” is falsy`            |
+| attribute (defined) | `<div ??foo="${bar}"></div>` | `el.setAttribute('foo', bar); // if  “bar” is non-nullish`    |
+| --                  | --                           | `el.removeAttribute('foo'); // if  “bar” is nullish`          |
+| property            | `<div .foo="${bar}"></div>`  | `el.foo = bar;`                                               |
+| content             | `<div>${foo}</div>`          | `el.append(document.createTextNode(foo)) // if “bar” is text` |
+| --                  | --                           | (see [content binding](#content-binding) for composition)     |
 
 **Important note on serialization during data binding:**
 
@@ -81,8 +51,6 @@ The following template languages are supported:
 The following value updaters are supported:
 
 * `map` (can be used with content bindings)
-* `unsafe` (can be used with content bindings)
-* `live` (can be used with property bindings)
 
 **A note on non-primitive data:**
 
@@ -216,23 +184,6 @@ html`<div .foo="${bar}"></div>`;
 // el.foo = bar;
 ```
 
-#### The `live` property binding
-
-You can wrap the property being bound in the `live` updater to ensure that each
-`render` call will sync the template‘s value into the DOM. This is primarily
-used to control form inputs.
-
-```js
-const bar = 'something';
-html`<input .value="${live(bar)}">`;
-// <input>
-// el.value = bar;
-```
-
-The key difference to note is that the basic property binding will not attempt
-to perform an update if `value === lastValue`. The `live` binding will instead
-check if `value === el.value` whenever a `render` is kicked off.
-
 ### Content binding
 
 The content binding does different things based on the value type passed in.
@@ -324,35 +275,6 @@ html`<div>${bar}</div>`;
 // <div><span>♥1</span>…<span>♣A</span></div>
 ```
 
-#### The `unsafe` content binding
-
-The `unsafe` content binding allows you to parse / instantiate text from a
-trusted source. This should _only_ be used to inject trusted content — never
-user content.
-
-```js
-const bar = '<script>console.prompt("can you hear me now?")</script>';
-html`<div>${unsafe(bar, 'html')}</div>`;
-// <div><script>console.prompt("can you hear me now?")</script></div>
-// console.prompt('can you hear me now?');
-
-const bar = '<circle cx="50" cy="50" r="50"></circle>';
-html`
-  <svg
-    xmlns="http://www.w3.org/2000/svg"
-    viewBox="0 0 100 100">
-    ${unsafe(bar, 'svg')}
-  </svg>
-`;
-//
-// <svg
-//   xmlns="http://www.w3.org/2000/svg"
-//   viewBox="0 0 100 100">
-//   <circle cx="50" cy="50" r="50"></circle>
-// </svg>
-//
-```
-
 ## Customizing your base class
 
 Following is a working example using [lit-html](https://lit.dev):
diff --git a/test/test-template-engine.js b/test/test-template-engine.js
index 2d89ff4..6becbfc 100644
--- a/test/test-template-engine.js
+++ b/test/test-template-engine.js
@@ -2,13 +2,30 @@ import XElement from '../x-element.js';
 import { assert, describe, it } from './x-test.js';
 
 // Long-term interface.
-const { render, html, svg, map, unsafe } = XElement.templateEngine;
-
-// Tentative interface. We may or may not keep these.
-const { live } = XElement.templateEngine;
+const { render, html, svg, map } = XElement.templateEngine;
 
 // Deprecated interface. We will eventually delete these.
-const { ifDefined, nullish, repeat, unsafeHTML, unsafeSVG } = XElement.templateEngine;
+const { ifDefined, nullish, repeat, live, unsafeHTML, unsafeSVG } = XElement.templateEngine;
+
+// Overwrite console warn for testing so we don’t get spammed with our own
+//  deprecation warnings.
+const seen = new Set();
+const warn = console.warn; // eslint-disable-line no-console
+const localMessages = [
+  'Deprecated "ifDefined" from default templating engine interface.',
+  'Deprecated "nullish" from default templating engine interface.',
+  'Deprecated "live" from default templating engine interface.',
+  'Deprecated "unsafeHTML" from default templating engine interface.',
+  'Deprecated "unsafeSVG" from default templating engine interface.',
+  'Deprecated "repeat" from default templating engine interface.',
+];
+console.warn = (...args) => { // eslint-disable-line no-console
+  if (!localMessages.includes(args[0]?.message)) {
+    warn(...args);
+  } else {
+    seen.add(args[0].message);
+  }
+};
 
 describe('html rendering', () => {
   it('renders basic string', () => {
@@ -505,6 +522,24 @@ describe('html rendering', () => {
     assert(container.textContent === '[object HTMLInputElement]');
     container.remove();
   });
+
+  it('renders DocumentFragment nodes with simple append action', () => {
+    const getTemplate = ({ fragment }) => {
+      return html`${fragment}`;
+    };
+    const container = document.createElement('div');
+    document.body.append(container);
+    const template = document.createElement('template');
+    template.innerHTML = '<input>';
+    render(container, getTemplate({ fragment: template.content.cloneNode(true) }));
+    assert(container.childElementCount === 1);
+    assert(container.children[0].localName === 'input');
+    template.innerHTML = '<textarea></textarea>';
+    render(container, getTemplate({ fragment: template.content.cloneNode(true) }));
+    assert(container.childElementCount === 1);
+    assert(container.children[0].localName === 'textarea');
+    container.remove();
+  });
 });
 
 describe('html updaters', () => {
@@ -562,19 +597,6 @@ describe('html updaters', () => {
     container.remove();
   });
 
-  it('unsafe html', () => {
-    const getTemplate = ({ content }) => {
-      return html`<div id="target">${unsafe(content, 'html')}</div>`;
-    };
-    const container = document.createElement('div');
-    document.body.append(container);
-    render(container, getTemplate({ content: '<div id="injected">oh hai</div>' }));
-    assert(!!container.querySelector('#injected'));
-    render(container, getTemplate({ content: '<div id="booster">oh hai, again</div>' }));
-    assert(!!container.querySelector('#booster'));
-    container.remove();
-  });
-
   it('unsafeHTML', () => {
     const getTemplate = ({ content }) => {
       return html`<div id="target">${unsafeHTML(content)}</div>`;
@@ -892,8 +914,7 @@ describe('html updaters', () => {
     const resolve = (type, value) => {
       switch(type) {
         case 'map': return map(value, item => item.id, item => html`<div id="${item.id}"></div>`);
-        case 'html': return unsafe(value, 'html');
-        default: return value; // E.g., an array, some text, null, undefined, etc.
+        default: return value; // E.g., an array, some text, null, undefined, fragment, etc.
       }
     };
     const getTemplate = ({ type, value }) => html`<div id="target">${resolve(type, value)}</div>`;
@@ -921,6 +942,15 @@ describe('html updaters', () => {
       assert(container.querySelector('#target').childElementCount === 0);
       assert(container.querySelector('#target').textContent === 'hi there');
     };
+    const toFragmentContent = container => {
+      const fragment = new DocumentFragment();
+      fragment.append(document.createElement('p'), document.createElement('p'));
+      render(container, getTemplate({ type: undefined, value: fragment }));
+      assert(!!container.querySelector('#target'));
+      assert(container.querySelector('#target').childElementCount === 2);
+      assert(container.querySelector('#target').children[0].localName === 'p');
+      assert(container.querySelector('#target').children[1].localName === 'p');
+    };
     const toArrayContent = container => {
       const getArrayTemplate = ({ id }) => html`<div id="${id}"></div>`;
       render(container, getTemplate({
@@ -934,12 +964,6 @@ describe('html updaters', () => {
       assert(container.querySelector('#target').childElementCount === 3);
       assert(container.querySelector('#target').textContent === '', container.querySelector('#target').textContent);
     };
-    const toUnsafeHtml = container => {
-      render(container, getTemplate({ type: 'html', value: '<div id="unsafe-html"></div>' }));
-      assert(!!container.querySelector('#target'));
-      assert(!!container.querySelector('#unsafe-html'));
-      assert(container.querySelector('#target').textContent === '');
-    };
     const toMap = container => {
       render(container, getTemplate({ type: 'map', value: [{ id: 'foo' }, { id: 'bar' }] }));
       assert(!!container.querySelector('#target'));
@@ -951,39 +975,39 @@ describe('html updaters', () => {
 
     it('can change from undefined content to null content', () => run(toUndefinedContent, toNullContent));
     it('can change from undefined content to text content', () => run(toUndefinedContent, toTextContent));
+    it('can change from undefined content to fragment content', () => run(toUndefinedContent, toFragmentContent));
     it('can change from undefined content to array content', () => run(toUndefinedContent, toArrayContent));
     it('can change from undefined content to map', () => run(toUndefinedContent, toMap));
-    it('can change from undefined content to unsafe html', () => run(toUndefinedContent, toUnsafeHtml));
 
     it('can change from null content to undefined content', () => run(toNullContent, toUndefinedContent));
     it('can change from null content to text content', () => run(toNullContent, toTextContent));
+    it('can change from null content to fragment content', () => run(toNullContent, toFragmentContent));
     it('can change from null content to array content', () => run(toNullContent, toArrayContent));
     it('can change from null content to map', () => run(toNullContent, toMap));
-    it('can change from null content to unsafe html', () => run(toNullContent, toUnsafeHtml));
 
     it('can change from text content to undefined content', () => run(toTextContent, toUndefinedContent));
     it('can change from text content to null content', () => run(toTextContent, toNullContent));
+    it('can change from text content to fragment content', () => run(toTextContent, toFragmentContent));
     it('can change from text content to array content', () => run(toTextContent, toArrayContent));
     it('can change from text content to map', () => run(toTextContent, toMap));
-    it('can change from text content to unsafe html', () => run(toTextContent, toUnsafeHtml));
+
+    it('can change from fragment content to undefined content', () => run(toFragmentContent, toUndefinedContent));
+    it('can change from fragment content to null content', () => run(toFragmentContent, toNullContent));
+    it('can change from fragment content to text content', () => run(toFragmentContent, toTextContent));
+    it('can change from fragment content to array content', () => run(toFragmentContent, toArrayContent));
+    it('can change from fragment content to map', () => run(toFragmentContent, toMap));
 
     it('can change from array content to undefined content', () => run(toArrayContent, toUndefinedContent));
     it('can change from array content to null content', () => run(toArrayContent, toNullContent));
     it('can change from array content to text content', () => run(toArrayContent, toTextContent));
+    it('can change from array content to fragment content', () => run(toArrayContent, toFragmentContent));
     it('can change from array content to map', () => run(toArrayContent, toMap));
-    it('can change from array content to unsafe html', () => run(toArrayContent, toUnsafeHtml));
 
     it('can change from map to undefined content', () => run(toMap, toUndefinedContent));
     it('can change from map to null content', () => run(toMap, toNullContent));
     it('can change from map to text content', () => run(toMap, toTextContent));
+    it('can change from map to fragment content', () => run(toMap, toFragmentContent));
     it('can change from map to array content', () => run(toMap, toArrayContent));
-    it('can change from map to unsafe html', () => run(toMap, toUnsafeHtml));
-
-    it('can change from unsafeHtml to undefined content', () => run(toUnsafeHtml, toUndefinedContent));
-    it('can change from unsafeHtml to null content', () => run(toUnsafeHtml, toNullContent));
-    it('can change from unsafeHtml to text content', () => run(toUnsafeHtml, toTextContent));
-    it('can change from unsafeHtml to array content', () => run(toUnsafeHtml, toArrayContent));
-    it('can change from unsafeHtml to map', () => run(toUnsafeHtml, toMap));
   });
 });
 
@@ -1032,31 +1056,6 @@ describe('svg rendering', () => {
 });
 
 describe('svg updaters', () => {
-  it('unsafe svg', () => {
-    const getTemplate = ({ content }) => {
-      return html`
-        <svg
-          id="target"
-          xmlns="http://www.w3.org/2000/svg"
-          viewBox="0 0 100 100"
-          style="width: 100px; height: 100px;">
-          ${unsafe(content, 'svg')}
-        </svg>
-      `;
-    };
-    const container = document.createElement('div');
-    document.body.append(container);
-    render(container, getTemplate({ content: '<circle id="injected" r="10" cx="50" cy="50"></circle>' }));
-    assert(!!container.querySelector('#injected'));
-    assert(container.querySelector('#injected').getBoundingClientRect().height = 20);
-    assert(container.querySelector('#injected').getBoundingClientRect().width = 20);
-    render(container, getTemplate({ content: '<circle id="injected" r="5" cx="50" cy="50"></circle>' }));
-    assert(!!container.querySelector('#injected'));
-    assert(container.querySelector('#injected').getBoundingClientRect().height = 10);
-    assert(container.querySelector('#injected').getBoundingClientRect().width = 10);
-    container.remove();
-  });
-
   it('unsafeSVG', () => {
     const getTemplate = ({ content }) => {
       return html`
@@ -1215,6 +1214,24 @@ describe('rendering errors', () => {
       container.remove();
     });
 
+    it('throws for empty DocumentFragment value binding', () => {
+      const expected = 'Unexpected child element count of zero for given DocumentFragment.';
+      const getTemplate = ({ fragment }) => {
+        return html`<div id="target">${fragment}</div>`;
+      };
+      const container = document.createElement('div');
+      document.body.append(container);
+      let actual;
+      try {
+        render(container, getTemplate({ fragment: new DocumentFragment() }));
+      } catch (error) {
+        actual = error.message;
+      }
+      assert(!!actual, 'No error was thrown.');
+      assert(actual === expected, actual);
+      container.remove();
+    });
+
     it('throws for re-injection of template result', () => {
       const templateResultReference = html`<div id="target"></div>`;
       const container = document.createElement('div');
@@ -1474,137 +1491,6 @@ describe('rendering errors', () => {
     });
   });
 
-
-  describe('unsafe', () => {
-    it('throws if used on an unexpected language', () => {
-      const expected = 'Unexpected unsafe language "css". Expected "html" or "svg".';
-      const getTemplate = ({ maybe }) => {
-        return html`<div id="target" maybe="${unsafe(maybe, 'css')}"></div>`;
-      };
-      const container = document.createElement('div');
-      document.body.append(container);
-      let actual;
-      try {
-        render(container, getTemplate({ maybe: 'yes' }));
-      } catch (error) {
-        actual = error.message;
-      }
-      assert(!!actual, 'No error was thrown.');
-      assert(actual === expected, actual);
-      container.remove();
-    });
-
-    it('throws if used on an "attribute"', () => {
-      const expected = 'The unsafe update must be used on content, not on an attribute.';
-      const getTemplate = ({ maybe }) => {
-        return html`<div id="target" maybe="${unsafe(maybe, 'html')}"></div>`;
-      };
-      const container = document.createElement('div');
-      document.body.append(container);
-      let actual;
-      try {
-        render(container, getTemplate({ maybe: 'yes' }));
-      } catch (error) {
-        actual = error.message;
-      }
-      assert(!!actual, 'No error was thrown.');
-      assert(actual === expected, actual);
-      container.remove();
-    });
-
-    it('throws if used on a "boolean"', () => {
-      const expected = 'The unsafe update must be used on content, not on a boolean attribute.';
-      const getTemplate = ({ maybe }) => {
-        return html`<div id="target" ?maybe="${unsafe(maybe, 'html')}"></div>`;
-      };
-      const container = document.createElement('div');
-      document.body.append(container);
-      let actual;
-      try {
-        render(container, getTemplate({ maybe: 'yes' }));
-      } catch (error) {
-        actual = error.message;
-      }
-      assert(!!actual, 'No error was thrown.');
-      assert(actual === expected, actual);
-      container.remove();
-    });
-
-    it('throws if used on a "defined"', () => {
-      const expected = 'The unsafe update must be used on content, not on a defined attribute.';
-      const getTemplate = ({ maybe }) => {
-        return html`<div id="target" ??maybe="${unsafe(maybe, 'html')}"></div>`;
-      };
-      const container = document.createElement('div');
-      document.body.append(container);
-      let actual;
-      try {
-        render(container, getTemplate({ maybe: 'yes' }));
-      } catch (error) {
-        actual = error.message;
-      }
-      assert(!!actual, 'No error was thrown.');
-      assert(actual === expected, actual);
-      container.remove();
-    });
-
-    it('throws if used with a "property"', () => {
-      const expected = 'The unsafe update must be used on content, not on a property.';
-      const getTemplate = ({ maybe }) => {
-        return html`<div id="target" .maybe="${unsafe(maybe, 'html')}"></div>`;
-      };
-      const container = document.createElement('div');
-      document.body.append(container);
-      let actual;
-      try {
-        render(container, getTemplate({ maybe: 'yes' }));
-      } catch (error) {
-        actual = error.message;
-      }
-      assert(!!actual, 'No error was thrown.');
-      assert(actual === expected, actual);
-      container.remove();
-    });
-
-    it('throws if used with "text"', () => {
-      const expected = 'The unsafe update must be used on content, not on text content.';
-      const getTemplate = ({ maybe }) => {
-        return html`<textarea id="target">${unsafe(maybe, 'html')}</textarea>`;
-      };
-      const container = document.createElement('div');
-      document.body.append(container);
-      let actual;
-      try {
-        render(container, getTemplate({ maybe: 'yes' }));
-      } catch (error) {
-        actual = error.message;
-      }
-      assert(!!actual, 'No error was thrown.');
-      assert(actual === expected, actual);
-      container.remove();
-    });
-
-    it('throws for non-string value', () => {
-      const getTemplate = ({ content }) => {
-        return html`
-          <div id="target">
-            ${unsafe(content, 'html')}
-          </div>
-        `;
-      };
-      const container = document.createElement('div');
-      document.body.append(container);
-      let error;
-      try {
-        render(container, getTemplate({ content: null }));
-      } catch (e) {
-        error = e;
-      }
-      assert(error?.message === 'Unexpected unsafe value "null".', error?.message);
-      container.remove();
-    });
-  });
-
   describe('unsafeHTML', () => {
     it('throws if used on an "attribute"', () => {
       const expected = 'The unsafeHTML update must be used on content, not on an attribute.';
@@ -1956,6 +1842,47 @@ describe('rendering errors', () => {
       container.remove();
     });
 
+    it('throws for duplicate identify responses on initial render', () => {
+      const getTemplate = ({ array }) => {
+        return html`
+          <div id="target">
+            ${map(array, () => 'foo', () => html``)}
+          </div>
+        `;
+      };
+      const container = document.createElement('div');
+      document.body.append(container);
+      let error;
+      try {
+        render(container, getTemplate({ array: [1, 2, 3] }));
+      } catch (e) {
+        error = e;
+      }
+      assert(error?.message === 'Unexpected duplicate value returned from identify callback "foo".', error?.message);
+      container.remove();
+    });
+
+    it('throws for duplicate identify responses on subsequent render', () => {
+      const getTemplate = ({ array }) => {
+        return html`
+          <div id="target">
+            ${map(array, item => item, () => html``)}
+          </div>
+        `;
+      };
+      const container = document.createElement('div');
+      document.body.append(container);
+      let error;
+      render(container, getTemplate({ array: [1, 2, 3] }));
+      try {
+        render(container, getTemplate({ array: [1, 2, 3, 4, 4] }));
+      } catch (e) {
+        error = e;
+      }
+      assert(error?.message === 'Unexpected duplicate value returned from identify callback "4".', error?.message);
+      container.remove();
+    });
+
     it('throws for non-array value', () => {
       const getTemplate = ({ array }) => {
         return html`
@@ -2252,3 +2179,9 @@ describe('interface migration errors', () => {
     });
   }
 });
+
+it('confirm that deprecation warnings are still necessary', () => {
+  for (const message of localMessages) {
+    assert(seen.has(message), `Unused deprecation warning: ${message}`);
+  }
+});
diff --git a/x-element.js b/x-element.js
index bc5ff8a..4e738fc 100644
--- a/x-element.js
+++ b/x-element.js
@@ -1054,17 +1054,14 @@ class TemplateEngine {
     html: TemplateEngine.html,
     svg: TemplateEngine.svg,
     map: TemplateEngine.map,
-    unsafe: TemplateEngine.unsafe,
-
-    // Tentative interface.
-    live: TemplateEngine.live,
 
     // Deprecated interface.
-    unsafeHTML: TemplateEngine.unsafeHTML,
-    unsafeSVG: TemplateEngine.unsafeSVG,
-    ifDefined: TemplateEngine.ifDefined,
-    nullish: TemplateEngine.nullish,
-    repeat: TemplateEngine.repeat,
+    live: TemplateEngine.#interfaceDeprecated('live', TemplateEngine.live),
+    unsafeHTML: TemplateEngine.#interfaceDeprecated('unsafeHTML', TemplateEngine.unsafeHTML),
+    unsafeSVG: TemplateEngine.#interfaceDeprecated('unsafeSVG', TemplateEngine.unsafeSVG),
+    ifDefined: TemplateEngine.#interfaceDeprecated('ifDefined', TemplateEngine.ifDefined),
+    nullish: TemplateEngine.#interfaceDeprecated('nullish', TemplateEngine.nullish),
+    repeat: TemplateEngine.#interfaceDeprecated('repeat', TemplateEngine.repeat),
 
     // Removed interface.
     asyncAppend: TemplateEngine.#interfaceRemoved('asyncAppend'),
@@ -1122,13 +1119,10 @@ class TemplateEngine {
       const result = TemplateEngine.#symbolToResult.get(resultReference);
       if (TemplateEngine.#cannotReuseResult(state.result, result)) {
         TemplateEngine.#removeWithin(container);
-        TemplateEngine.#ready(result);
-        TemplateEngine.#commit(result);
         TemplateEngine.#inject(result, container);
         state.result = result;
       } else {
-        TemplateEngine.#assign(state.result, result);
-        TemplateEngine.#commit(state.result);
+        TemplateEngine.#update(state.result, result);
       }
     } else {
       TemplateEngine.#clearObject(state);
@@ -1182,6 +1176,7 @@ class TemplateEngine {
    * ```js
    * html`<input .value="${live(obj.value)}"/>`;
    * ```
+   * @deprecated
    * @param {any} value
    * @returns {any}
    */
@@ -1193,28 +1188,6 @@ class TemplateEngine {
     return symbol;
   }
 
-  /**
-   * Updater to inject trusted “html” or “svg” into the DOM.
-   * Use with caution. The "unsafe" updater allows arbitrary input to be
-   * parsed and injected into the DOM.
-   * ```js
-   * html`<div>${unsafe(obj.trustedMarkup, 'html')}</div>`;
-   * ```
-   * @param {any} value
-   * @param {'html'|'svg'} language
-   * @returns {any}
-   */
-  static unsafe(value, language) {
-    if (language !== 'html' && language !== 'svg') {
-      throw new Error(`Unexpected unsafe language "${language}". Expected "html" or "svg".`);
-    }
-    const symbol = Object.create(null);
-    const updater = TemplateEngine.#unsafe;
-    const update = { updater, value, language };
-    TemplateEngine.#symbolToUpdate.set(symbol, update);
-    return symbol;
-  }
-
   /**
    * Updater to inject trusted HTML into the DOM.
    * Use with caution. The "unsafeHTML" updater allows arbitrary input to be
@@ -1336,31 +1309,13 @@ class TemplateEngine {
     }
   }
 
+  // Deprecated. Will remove in future release.
   static #live(node, name, value) {
     if (node[name] !== value) {
       node[name] = value;
     }
   }
 
-  static #unsafe(node, startNode, value, lastValue, language) {
-    if (value !== lastValue) {
-      if (typeof value === 'string') {
-        const template = document.createElement('template');
-        if (language === 'html') {
-          template.innerHTML = value;
-          TemplateEngine.#removeBetween(startNode, node);
-          TemplateEngine.#insertAllBefore(node.parentNode, node, template.content.childNodes);
-        } else {
-          template.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg">${value}</svg>`;
-          TemplateEngine.#removeBetween(startNode, node);
-          TemplateEngine.#insertAllBefore(node.parentNode, node, template.content.firstChild.childNodes);
-        }
-      } else {
-        throw new Error(`Unexpected unsafe value "${value}".`);
-      }
-    }
-  }
-
   // Deprecated. Will remove in future release.
   static #unsafeHTML(node, startNode, value, lastValue) {
     if (value !== lastValue) {
@@ -1389,91 +1344,13 @@ class TemplateEngine {
     }
   }
 
-  static #mapInner(node, startNode, identify, callback, inputs, name) {
-    const state = TemplateEngine.#setIfMissing(TemplateEngine.#nodeToArrayState, startNode, () => ({}));
-    if (!state.map) {
-      TemplateEngine.#clearObject(state);
-      state.map = new Map();
-      let index = 0;
-      for (const input of inputs) {
-        const reference = callback ? callback(input, index) : input;
-        const result = TemplateEngine.#symbolToResult.get(reference);
-        if (result) {
-          const id = identify ? identify(input, index) : String(index);
-          const cursors = TemplateEngine.#createCursors(node);
-          TemplateEngine.#ready(result);
-          TemplateEngine.#commit(result);
-          TemplateEngine.#inject(result, cursors.node, { before: true });
-          state.map.set(id, { id, result, ...cursors });
-        } else {
-          throw new Error(`Unexpected ${name} value "${reference}" provided by callback.`);
-        }
-        index++;
-      }
-    } else {
-      let lastItem;
-      const ids = new Set();
-      let index = 0;
-      for (const input of inputs) {
-        const reference = callback ? callback(input, index) : input;
-        const result = TemplateEngine.#symbolToResult.get(reference);
-        if (result) {
-          const id = identify ? identify(input, index) : String(index);
-          if (state.map.has(id)) {
-            const item = state.map.get(id);
-            if (TemplateEngine.#cannotReuseResult(item.result, result)) {
-              // Add new comment cursors before removing old comment cursors.
-              const cursors = TemplateEngine.#createCursors(item.startNode);
-              TemplateEngine.#removeThrough(item.startNode, item.node);
-              TemplateEngine.#ready(result);
-              TemplateEngine.#commit(result);
-              TemplateEngine.#inject(result, cursors.node, { before: true });
-              Object.assign(item, { result, ...cursors });
-            } else {
-              TemplateEngine.#assign(item.result, result);
-              TemplateEngine.#commit(item.result);
-            }
-          } else {
-            const cursors = TemplateEngine.#createCursors(node);
-            TemplateEngine.#ready(result);
-            TemplateEngine.#commit(result);
-            TemplateEngine.#inject(result, cursors.node, { before: true });
-            const item = { id, result, ...cursors };
-            state.map.set(id, item);
-          }
-          const item = state.map.get(id);
-          const referenceNode = lastItem ? lastItem.node.nextSibling : startNode.nextSibling;
-          if (referenceNode !== item.startNode) {
-            const nodesToMove = [item.startNode];
-            while (nodesToMove[nodesToMove.length - 1] !== item.node) {
-              nodesToMove.push(nodesToMove[nodesToMove.length - 1].nextSibling);
-            }
-            TemplateEngine.#insertAllBefore(referenceNode.parentNode, referenceNode, nodesToMove);
-          }
-          TemplateEngine.#commit(item.result);
-          ids.add(item.id);
-          lastItem = item;
-        } else {
-          throw new Error(`Unexpected ${name} value "${reference}" provided by callback.`);
-        }
-        index++;
-      }
-      for (const [id, item] of state.map.entries()) {
-        if (!ids.has(id)) {
-          TemplateEngine.#removeThrough(item.startNode, item.node);
-          state.map.delete(id);
-        }
-      }
-    }
-  }
-
   static #map(node, startNode, value, identify, callback) {
-    TemplateEngine.#mapInner(node, startNode, identify, callback, value, 'map');
+    TemplateEngine.#mapInputs(node, startNode, identify, callback, value, 'map');
   }
 
   // Deprecated. Will remove in future release.
   static #repeat(node, startNode, value, identify, callback) {
-    TemplateEngine.#mapInner(node, startNode, identify, callback, value, 'repeat');
+    TemplateEngine.#mapInputs(node, startNode, identify, callback, value, 'repeat');
   }
 
   // Walk through each string from our tagged template function “strings” array
@@ -1722,29 +1599,85 @@ class TemplateEngine {
     return targets;
   }
 
-  // Create and prepare a document fragment to be injected into some container.
-  static #ready(result) {
-    if (result.readied) {
-      throw new Error(`Unexpected re-injection of template result.`);
-    }
-    result.readied = true;
-    const { type, strings } = result;
-    const analysis = TemplateEngine.#setIfMissing(TemplateEngine.#stringsToAnalysis, strings, () => ({}));
-    if (!analysis.done) {
-      analysis.done = true;
-      const fragment = TemplateEngine.#createFragment(type, strings);
-      const lookups = TemplateEngine.#findLookups(fragment);
-      Object.assign(analysis, { fragment, lookups });
+  // Loops over given inputs to either create-or-update a list of nodes.
+  static #mapInputs(node, startNode, identify, callback, inputs, name) {
+    const state = TemplateEngine.#setIfMissing(TemplateEngine.#nodeToArrayState, startNode, () => ({}));
+    if (!state.map) {
+      // There is no mapping in our state — we have a clean slate to work with.
+      TemplateEngine.#clearObject(state);
+      state.map = new Map();
+      const ids = new Set();
+      let index = 0;
+      for (const input of inputs) {
+        const reference = callback ? callback(input, index) : input;
+        const result = TemplateEngine.#symbolToResult.get(reference);
+        if (result) {
+          const id = identify ? identify(input, index) : String(index);
+          if (ids.has(id)) {
+            throw new Error(`Unexpected duplicate value returned from identify callback "${id}".`);
+          }
+          ids.add(id);
+          const cursors = TemplateEngine.#createCursors(node);
+          TemplateEngine.#inject(result, cursors.node, true);
+          state.map.set(id, { id, result, ...cursors });
+        } else {
+          throw new Error(`Unexpected ${name} value "${reference}" provided by callback.`);
+        }
+        index++;
+      }
+    } else {
+      // A mapping has already been created — we need to update the items.
+      let lastItem;
+      const ids = new Set();
+      let index = 0;
+      for (const input of inputs) {
+        const reference = callback ? callback(input, index) : input;
+        const result = TemplateEngine.#symbolToResult.get(reference);
+        if (result) {
+          const id = identify ? identify(input, index) : String(index);
+          if (ids.has(id)) {
+            throw new Error(`Unexpected duplicate value returned from identify callback "${id}".`);
+          }
+          ids.add(id);
+          if (state.map.has(id)) {
+            const item = state.map.get(id);
+            if (TemplateEngine.#cannotReuseResult(item.result, result)) {
+              // Add new comment cursors before removing old comment cursors.
+              const cursors = TemplateEngine.#createCursors(item.startNode);
+              TemplateEngine.#removeThrough(item.startNode, item.node);
+              TemplateEngine.#inject(result, cursors.node, true);
+              Object.assign(item, { result, ...cursors });
+            } else {
+              TemplateEngine.#update(item.result, result);
+            }
+          } else {
+            const cursors = TemplateEngine.#createCursors(node);
+            TemplateEngine.#inject(result, cursors.node, true);
+            const item = { id, result, ...cursors };
+            state.map.set(id, item);
+          }
+          const item = state.map.get(id);
+          const referenceNode = lastItem ? lastItem.node.nextSibling : startNode.nextSibling;
+          if (referenceNode !== item.startNode) {
+            const nodesToMove = [item.startNode];
+            while (nodesToMove[nodesToMove.length - 1] !== item.node) {
+              nodesToMove.push(nodesToMove[nodesToMove.length - 1].nextSibling);
+            }
+            TemplateEngine.#insertAllBefore(referenceNode.parentNode, referenceNode, nodesToMove);
+          }
+          lastItem = item;
+        } else {
+          throw new Error(`Unexpected ${name} value "${reference}" provided by callback.`);
+        }
+        index++;
+      }
+      for (const [id, item] of state.map.entries()) {
+        if (!ids.has(id)) {
+          TemplateEngine.#removeThrough(item.startNode, item.node);
+          state.map.delete(id);
+        }
+      }
     }
-    const fragment = analysis.fragment.cloneNode(true);
-    const targets = TemplateEngine.#findTargets(fragment, analysis.lookups);
-    const entries = Object.entries(targets);
-    Object.assign(result, { fragment, entries });
-  }
-
-  static #assign(result, newResult) {
-    result.lastValues = result.values;
-    result.values = newResult.values;
   }
 
   static #commitAttribute(node, name, value, lastValue) {
@@ -1812,21 +1745,24 @@ class TemplateEngine {
   }
 
   static #commitContent(node, startNode, value, lastValue) {
-    const update = TemplateEngine.#symbolToUpdate.get(value);
-    const lastUpdate = TemplateEngine.#symbolToUpdate.get(lastValue);
+    const introspection = TemplateEngine.#getValueIntrospection(value);
+    const lastIntrospection = TemplateEngine.#getValueIntrospection(lastValue);
     if (
       lastValue !== TemplateEngine.#UNSET && (
-        !!Array.isArray(value) !== !!Array.isArray(lastValue) ||
-        !!update !== !!lastUpdate ||
-        update?.updater !== lastUpdate?.updater
+        introspection?.category !== lastIntrospection?.category ||
+        introspection?.update?.updater !== lastIntrospection?.update?.updater
       )
     ) {
       // Reset content under certain conditions. E.g., `map(…)` >> `null`.
+      const state = TemplateEngine.#setIfMissing(TemplateEngine.#nodeToState, node, () => ({}));
+      const arrayState = TemplateEngine.#setIfMissing(TemplateEngine.#nodeToArrayState, startNode, () => ({}));
       TemplateEngine.#removeBetween(startNode, node);
-      const state = TemplateEngine.#setIfMissing(TemplateEngine.#nodeToArrayState, startNode, () => ({}));
       TemplateEngine.#clearObject(state);
+      TemplateEngine.#clearObject(arrayState);
     }
-    if (update) {
+    if (introspection?.category === 'update') {
+      const { update } = introspection;
+      const lastUpdate = lastIntrospection?.update;
       switch (update.updater) {
         case TemplateEngine.#map:
           TemplateEngine.#map(node, startNode, update.value, update.identify, update.callback);
@@ -1834,9 +1770,6 @@ class TemplateEngine {
         case TemplateEngine.#repeat:
           TemplateEngine.#repeat(node, startNode, update.value, update.identify, update.callback);
           break;
-        case TemplateEngine.#unsafe:
-          TemplateEngine.#unsafe(node, startNode, update.value, lastUpdate?.value, update.language);
-          break;
         case TemplateEngine.#unsafeHTML:
           TemplateEngine.#unsafeHTML(node, startNode, update.value, lastUpdate?.value);
           break;
@@ -1849,28 +1782,29 @@ class TemplateEngine {
       }
     } else {
       if (value !== lastValue) {
-        if (TemplateEngine.#symbolToResult.has(value)) {
-          const state = TemplateEngine.#setIfMissing(TemplateEngine.#nodeToArrayState, startNode, () => ({}));
-          const result = TemplateEngine.#symbolToResult.get(value);
+        if (introspection?.category === 'result') {
+          const state = TemplateEngine.#setIfMissing(TemplateEngine.#nodeToState, node, () => ({}));
+          const { result } = introspection;
           if (TemplateEngine.#cannotReuseResult(state.result, result)) {
             TemplateEngine.#removeBetween(startNode, node);
             TemplateEngine.#clearObject(state);
-            TemplateEngine.#ready(result);
-            TemplateEngine.#commit(result);
-            TemplateEngine.#inject(result, node, { before: true });
+            TemplateEngine.#inject(result, node, true);
             state.result = result;
           } else {
-            TemplateEngine.#assign(state.result, result);
-            TemplateEngine.#commit(state.result);
+            TemplateEngine.#update(state.result, result);
           }
-        } else if (Array.isArray(value)) {
-          TemplateEngine.#mapInner(node, startNode, null, null, value, 'array');
-        } else {
-          const state = TemplateEngine.#setIfMissing(TemplateEngine.#nodeToArrayState, startNode, () => ({}));
-          if (state.result) {
+        } else if (introspection?.category === 'array') {
+          TemplateEngine.#mapInputs(node, startNode, null, null, value, 'array');
+        } else if (introspection?.category === 'fragment') {
+          if (value.childElementCount === 0) {
+            throw new Error(`Unexpected child element count of zero for given DocumentFragment.`);
+          }
+          const previousSibling = node.previousSibling;
+          if (previousSibling !== startNode) {
             TemplateEngine.#removeBetween(startNode, node);
-            TemplateEngine.#clearObject(state);
           }
+          node.parentNode.insertBefore(value, node);
+        } else {
           const previousSibling = node.previousSibling;
           if (previousSibling === startNode) {
             // The `?? ''` is a shortcut for creating a text node and then
@@ -1918,28 +1852,80 @@ class TemplateEngine {
     }
   }
 
-  // Attach a document fragment into some container. Note that all the DOM in
-  //  the fragment will already have values correctly bound.
-  static #inject(result, node, options) {
+  // Inject a given result into a node for the first time. If we’ve never seen
+  //  the template “strings” before, we also have to generate html, parse it,
+  //  and find out binding targets. Then, we commit the values by iterating over
+  //  our targets. Finally, we actually attach our new DOM into our node.
+  static #inject(result, node, before) {
+    // If we see the _exact_ same result again… that’s an error. We don’t allow
+    //  integrators to reuse template results.
+    if (result.readied) {
+      throw new Error(`Unexpected re-injection of template result.`);
+    }
+
+    // Create and prepare a document fragment to be injected.
+    result.readied = true;
+    const { type, strings } = result;
+    const analysis = TemplateEngine.#setIfMissing(TemplateEngine.#stringsToAnalysis, strings, () => ({}));
+    if (!analysis.done) {
+      analysis.done = true;
+      const fragment = TemplateEngine.#createFragment(type, strings);
+      const lookups = TemplateEngine.#findLookups(fragment);
+      Object.assign(analysis, { fragment, lookups });
+    }
+    const fragment = analysis.fragment.cloneNode(true);
+    const targets = TemplateEngine.#findTargets(fragment, analysis.lookups);
+    const entries = Object.entries(targets);
+    Object.assign(result, { fragment, entries });
+
+    // Bind values via our live targets into our disconnected DOM.
+    TemplateEngine.#commit(result);
+
+    // Attach a document fragment into the node. Note that all the DOM in the
+    //  fragment will already have values correctly committed on the line above.
     const nodes = result.type === 'svg'
       ? result.fragment.firstChild.childNodes
       : result.fragment.childNodes;
-    options?.before
+    before
       ? TemplateEngine.#insertAllBefore(node.parentNode, node, nodes)
       : TemplateEngine.#insertAllBefore(node, null, nodes);
     result.fragment = null;
   }
 
+  static #update(result, newResult) {
+    Object.assign(result, { lastValues: result.values, values: newResult.values });
+    TemplateEngine.#commit(result);
+  }
+
+  // TODO: Revisit this concept when we delete deprecated interfaces. Once that
+  //  happens, the _only_ updater available for content is `map`, and we may be
+  //  able to make this more performant.
+  static #getValueIntrospection(value) {
+    if (Array.isArray(value)) {
+      return { category: 'array' };
+    } else if (value instanceof DocumentFragment) {
+      return { category: 'fragment' };
+    } else if (value !== null && typeof value === 'object') {
+      const result = TemplateEngine.#symbolToResult.get(value);
+      if (result) {
+        return { category: 'result', result };
+      } else {
+        const update = TemplateEngine.#symbolToUpdate.get(value);
+        if (update) {
+          return { category: 'update', update };
+        }
+      }
+    }
+  }
+
   static #throwUpdaterError(updater, type) {
     switch (updater) {
-      case TemplateEngine.#live:
-        throw new Error(`The live update must be used on ${TemplateEngine.#getTypeText('property')}, not on ${TemplateEngine.#getTypeText(type)}.`);
       case TemplateEngine.#map:
         throw new Error(`The map update must be used on ${TemplateEngine.#getTypeText('content')}, not on ${TemplateEngine.#getTypeText(type)}.`);
-      case TemplateEngine.#unsafe:
-        throw new Error(`The unsafe update must be used on ${TemplateEngine.#getTypeText('content')}, not on ${TemplateEngine.#getTypeText(type)}.`);
 
       // We’ll delete these updaters later.
+      case TemplateEngine.#live:
+        throw new Error(`The live update must be used on ${TemplateEngine.#getTypeText('property')}, not on ${TemplateEngine.#getTypeText(type)}.`);
       case TemplateEngine.#unsafeHTML:
         throw new Error(`The unsafeHTML update must be used on ${TemplateEngine.#getTypeText('content')}, not on ${TemplateEngine.#getTypeText(type)}.`);
       case TemplateEngine.#unsafeSVG:
@@ -2023,6 +2009,19 @@ class TemplateEngine {
     }
   }
 
+  static #interfaceDeprecatedStacks = new Set();
+  static #interfaceDeprecated(name, callback) {
+    return (...args) => {
+      const error = new Error(`Deprecated "${name}" from default templating engine interface.`);
+      const stack = error.stack;
+      if (!this.#interfaceDeprecatedStacks.has(stack)) {
+        this.#interfaceDeprecatedStacks.add(stack);
+        console.warn(error); // eslint-disable-line no-console
+      }
+      return callback(...args);
+    };
+  }
+
   static #interfaceRemoved(name) {
     return () => {
       throw new Error(`Removed "${name}" from default templating engine interface. Import and plug-in "lit-html" as your element's templating engine if you want this functionality.`);