diff --git a/CHANGELOG.md b/CHANGELOG.md
index f484d37..ea439b5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+### Breaking changes
+
+- `Vize.vapor_split/1` is replaced by `Vize.split_template/2`, which works from Vize's L2 semantic IR, the representation Vize's SSR compiler builds on, instead of scanning Vapor's template HTML. The split no longer has to locate elements in generated HTML, so whole classes of bugs are gone: slots dropped after text nodes, components placed before their siblings, a root `v-if` rendered twice, and implicit default slot content lost beside a named slot. The slots have a new shape, documented in [Splitting templates](guides/features/templates-and-ssr.md#splitting-templates):
+  - Expressions are source strings, and every slot has a `:position`.
+  - An `:attr` slot is a whole attribute, so a renderer can leave it out, as Vue does for `null` and false boolean attributes; a static attribute of the same name comes with it.
+  - Components carry their props, events, and the content of each slot; `<slot>` outlets are slots too.
+  - `v-show`, `v-model` on `<input>` and `<textarea>`, `v-html`, `v-text`, `v-bind` objects and dynamic attribute names are slots.
+  - Events and `v-model`s are `:on` and `:model` bindings.
+- Errors from `split_template/2` are `Vize.Error`s with a `Vize.Diagnostic` and position for each problem, such as an expression that doesn't parse; it used to return a list of strings.
+
+### Added
+
+- `split_template/2` takes `root_attrs: true` for a component's template: the attributes of a single root element come back as one `:root_attrs` slot, so a caller can merge the [fallthrough attributes](https://vuejs.org/guide/components/attrs.html) a parent passes.
+- Warnings, such as a custom directive that doesn't run on the server, come back in the split's `:diagnostics`.
+- `Vize.Diagnostic` has a `:severity`, and `Vize.Diagnostic.to_code_diagnostic/2` converts one to Elixir's `t:Code.diagnostic/1` shape, positioned in the file a template came from.
+- `Vize.Error` messages list their diagnostics with positions.
+
 ## 0.16.1 - 2026-10-03
 
 ### Fixed
diff --git a/Cargo.lock b/Cargo.lock
index f48bd16..f4db94e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2699,6 +2699,10 @@ dependencies = [
  "vize_atelier_vapor",
  "vize_carton",
  "vize_croquis",
+ "vize_davinci",
+ "vize_l1",
+ "vize_l1_to_l2",
+ "vize_l2",
  "vize_patina",
  "vize_relief",
 ]
diff --git a/codegen/vize/codegen/native_types.ex b/codegen/vize/codegen/native_types.ex
index 9eaf3ce..9618bb2 100644
--- a/codegen/vize/codegen/native_types.ex
+++ b/codegen/vize/codegen/native_types.ex
@@ -122,71 +122,167 @@ defmodule Vize.Codegen.NativeTypes do
           required(:element_template_map) => [{R.usize(), R.usize()}]
         }
 
-  @type encoded_vapor_split :: %{
+  ## split_template
+  #
+  # A template split into static HTML and the dynamic slots between them, the
+  # shape of `%Phoenix.LiveView.Rendered{}`. Expressions are JavaScript source
+  # strings. Every slot has a `position`, `{line, column}` in the template.
+
+  @type split_template_opts :: %{required(:root_attrs) => boolean()}
+
+  @type encoded_template_split :: %{
           required(:statics) => [String.t()],
           required(:slots) => [R.term()],
           required(:bindings) => [encoded_split_binding()],
-          required(:templates) => [String.t()],
-          required(:element_template_map) => [{R.usize(), R.usize()}]
+          required(:diagnostics) => [encoded_split_diagnostic()]
         }
 
-  ## vapor_split slots
-  #
-  # Each slot fills the hole between two statics. Expressions (`R.term()`) are
-  # a string, or `{:static, string}` for static values.
-
   @type encoded_split_block :: %{
           required(:statics) => [String.t()],
           required(:slots) => [R.term()],
           required(:bindings) => [encoded_split_binding()]
         }
 
-  # An event or v-model on an element, left for the caller to render. `at` is
-  # `{static_index, byte_offset}`: where that element's start tag ends.
+  # A problem with the template. Positions are 1-based; `end` is exclusive.
+  @type encoded_split_diagnostic :: %{
+          required(:severity) => :error | :warning,
+          required(:message) => String.t(),
+          required(:start) => encoded_position(),
+          required(:end) => encoded_position()
+        }
+
+  # An event or `v-model` on an element, left for the caller to render. `at` is
+  # `{static_index, byte_offset}`: where the element's start tag ends.
   @type encoded_split_binding :: %{
-          required(:kind) => :set_event | :directive,
-          required(:node) => R.term(),
-          required(:at) => {R.usize(), R.usize()}
+          required(:kind) => :on | :model,
+          required(:name) => String.t() | nil,
+          required(:modifiers) => [String.t()],
+          required(:value) => String.t() | nil,
+          required(:at) => {R.usize(), R.usize()},
+          required(:position) => {R.usize(), R.usize()}
         }
 
-  @type encoded_values_slot :: %{
-          required(:kind) => :set_prop | :set_text,
-          required(:values) => [R.term()]
+  # Escaped text from an interpolation.
+  @type encoded_text_slot :: %{
+          required(:kind) => :text,
+          required(:value) => String.t(),
+          required(:position) => {R.usize(), R.usize()}
         }
 
-  @type encoded_value_slot :: %{
-          required(:kind) => :v_show | :v_model | :set_html,
-          required(:value) => R.term()
+  # Unescaped HTML, from `v-html`.
+  @type encoded_html_slot :: %{
+          required(:kind) => :html,
+          required(:value) => String.t(),
+          required(:position) => {R.usize(), R.usize()}
+        }
+
+  # One attribute, rendered whole with its leading space so a caller can leave
+  # it out. `name_value` is the expression of a dynamic `:[name]`. `static` is
+  # a static attribute of the same name, such as `class="a"` beside
+  # `:class="b"`, and `show` the `v-show` expression a `style` combines with.
+  @type encoded_attr_slot :: %{
+          required(:kind) => :attr,
+          required(:name) => String.t() | nil,
+          required(:name_value) => String.t() | nil,
+          required(:static) => String.t() | nil,
+          required(:value) => String.t() | nil,
+          required(:show) => String.t() | nil,
+          required(:position) => {R.usize(), R.usize()}
+        }
+
+  # The attributes of an object, from `v-bind="attrs"`.
+  @type encoded_spread_slot :: %{
+          required(:kind) => :spread,
+          required(:value) => String.t(),
+          required(:position) => {R.usize(), R.usize()}
+        }
+
+  # A `v-model` on a form element: the `value`, `checked` state, or text it
+  # renders. `type` and `static_value` are the element's static `type` and
+  # `value` attributes, which decide that for checkboxes and radios.
+  @type encoded_model_slot :: %{
+          required(:kind) => :model,
+          required(:tag) => String.t(),
+          required(:type) => String.t() | nil,
+          required(:static_value) => String.t() | nil,
+          required(:value) => String.t(),
+          required(:position) => {R.usize(), R.usize()}
         }
 
-  # `negative` is a split block, a nested if slot, or nil.
   @type encoded_if_slot :: %{
-          required(:kind) => :if_node,
-          required(:condition) => R.term(),
-          required(:positive) => encoded_split_block(),
-          required(:negative) => R.term() | nil
+          required(:kind) => :if,
+          required(:branches) => [encoded_if_branch()],
+          required(:position) => {R.usize(), R.usize()}
+        }
+
+  # `condition` is nil for `v-else`.
+  @type encoded_if_branch :: %{
+          required(:condition) => String.t() | nil,
+          required(:block) => encoded_split_block()
         }
 
   @type encoded_for_slot :: %{
-          required(:kind) => :for_node,
-          required(:source) => R.term(),
-          required(:value) => R.term() | nil,
-          required(:key_prop) => R.term() | nil,
-          required(:render) => encoded_split_block()
+          required(:kind) => :for,
+          required(:source) => String.t(),
+          required(:value) => String.t(),
+          required(:key) => String.t() | nil,
+          required(:index) => String.t() | nil,
+          required(:key_prop) => String.t() | nil,
+          required(:block) => encoded_split_block(),
+          required(:position) => {R.usize(), R.usize()}
+        }
+
+  # A prop, attribute or `v-bind` object passed to a component or outlet, or
+  # one of a root element's attributes. A spread has neither name.
+  @type encoded_prop :: %{
+          required(:name) => String.t() | nil,
+          required(:name_value) => String.t() | nil,
+          required(:static) => String.t() | nil,
+          required(:value) => String.t() | nil
+        }
+
+  @type encoded_event :: %{
+          required(:name) => String.t() | nil,
+          required(:modifiers) => [String.t()],
+          required(:value) => String.t() | nil
         }
 
   @type encoded_component_slot :: %{
-          required(:kind) => :create_component,
-          required(:tag) => String.t(),
-          required(:props) => [R.term()],
-          required(:value) =>
-            :regular
-            | :teleport
-            | :keep_alive
-            | :suspense
-            | :transition
-            | :transition_group
-            | :dynamic
+          required(:kind) => :component,
+          required(:name) => String.t(),
+          required(:props) => [encoded_prop()],
+          required(:events) => [encoded_event()],
+          required(:slots) => [encoded_slot_content()],
+          required(:position) => {R.usize(), R.usize()}
+        }
+
+  # Content passed to one of a component's slots. `params` is the slot props
+  # pattern, such as `{ item }`.
+  @type encoded_slot_content :: %{
+          required(:name) => String.t() | nil,
+          required(:name_value) => String.t() | nil,
+          required(:params) => String.t() | nil,
+          required(:block) => encoded_split_block()
+        }
+
+  # A `<slot>` outlet, where the parent's slot content renders.
+  @type encoded_slot_outlet :: %{
+          required(:kind) => :slot,
+          required(:name) => String.t() | nil,
+          required(:name_value) => String.t() | nil,
+          required(:props) => [encoded_prop()],
+          required(:fallback) => encoded_split_block() | nil,
+          required(:position) => {R.usize(), R.usize()}
+        }
+
+  # With `root_attrs: true`, every attribute of the template's single root
+  # element, in authored order, so a caller can merge a component's
+  # fallthrough attributes in.
+  @type encoded_root_attrs_slot :: %{
+          required(:kind) => :root_attrs,
+          required(:props) => [encoded_prop()],
+          required(:show) => String.t() | nil,
+          required(:position) => {R.usize(), R.usize()}
         }
 
   ## SFC
diff --git a/guides/cheatsheets/api.cheatmd b/guides/cheatsheets/api.cheatmd
index c73b1a5..c407828 100644
--- a/guides/cheatsheets/api.cheatmd
+++ b/guides/cheatsheets/api.cheatmd
@@ -86,7 +86,13 @@ Vize.compile_vapor(source,
 
 ```elixir
 Vize.vapor_ir(source)
-Vize.vapor_split(source)
+```
+
+### Split for server rendering
+
+```elixir
+{:ok, %{statics: statics, slots: slots}} = Vize.split_template(source)
+Vize.split_template(source, root_attrs: true)
 ```
 
 ## CSS
diff --git a/guides/features/templates-and-ssr.md b/guides/features/templates-and-ssr.md
index 6ded903..e23308a 100644
--- a/guides/features/templates-and-ssr.md
+++ b/guides/features/templates-and-ssr.md
@@ -32,3 +32,49 @@ result.code
 result.preamble
 # import { ssrInterpolate as _ssrInterpolate, ssrRenderAttrs as _ssrRenderAttrs } from "@vue/server-renderer"
 ```
+
+## Splitting templates
+
+`Vize.split_template/2` turns a template into static HTML and the dynamic slots between them, the shape of `%Phoenix.LiveView.Rendered{}`, so a server can render it without JavaScript. [PhoenixVapor](https://github.com/elixir-volt/phoenix_vapor) uses it to render Vue templates in Phoenix LiveView.
+
+It works from Vize's L2 semantic IR, which Vize's SSR compiler also builds on: elements, static attributes and text become HTML, and everything that depends on data becomes a slot. Expressions are JavaScript source strings, and every slot has a `:position`, `{line, column}` in the template.
+
+```elixir
+{:ok, split} = Vize.split_template(~s(<p :class="kind">Hi {{ name }}</p>))
+
+split.statics  # ["<p", ">Hi ", "</p>"]
+split.slots    # [%{kind: :attr, name: "class", value: "kind", static: nil, ...}, %{kind: :text, value: "name", ...}]
+```
+
+An `:attr` slot stands for the whole attribute with its leading space, so a renderer can leave it out, as Vue does for `null` and a false [boolean attribute](https://vuejs.org/guide/essentials/template-syntax.html#boolean-attributes). A static attribute of the same name, such as `class="a"` beside `:class="b"`, arrives as its `:static`.
+
+`v-if` and `v-for` slots carry a block each: its own `:statics`, `:slots` and `:bindings`. A component slot has its `:props`, `:events`, and the content passed to each of its [slots](https://vuejs.org/guide/components/slots.html); a `<slot>` outlet is a slot of its own:
+
+```elixir
+{:ok, split} = Vize.split_template(~s(<Card title="Hi"><p>Body</p><template #footer="{ ok }">{{ ok }}</template></Card>))
+
+[%{kind: :component, name: "Card", props: [%{name: "title", static: "Hi"}], slots: slots}] = split.slots
+slots  # [%{name: "footer", params: "{ ok }", block: %{statics: ["", ""], ...}}, %{name: "default", block: ...}]
+```
+
+A component's own template can be split with `root_attrs: true`. When it has a single root element, all of that element's attributes, static ones included, come back as one `:root_attrs` slot, so the caller can merge in the [fallthrough attributes](https://vuejs.org/guide/components/attrs.html) the parent passed:
+
+```elixir
+{:ok, split} = Vize.split_template(~s(<button class="btn" type="button"><slot /></button>), root_attrs: true)
+
+split.statics  # ["<button", ">", "</button>"]
+split.slots    # [%{kind: :root_attrs, props: [%{name: "class", static: "btn"}, %{name: "type", static: "button"}]}, %{kind: :slot, ...}]
+```
+
+Events and `v-model`s are not rendered. They are reported as bindings, with the position where their element's start tag ends, so a caller can add whatever attributes its runtime needs:
+
+```elixir
+{:ok, split} = Vize.split_template(~s(<button @click="save">{{ label }}</button>))
+
+split.statics   # ["<button>", "</button>"]
+split.bindings  # [%{kind: :on, name: "click", value: "save", modifiers: [], at: {0, 7}, ...}]
+```
+
+`at: {0, 7}` is byte 7 of the first static, just before the `>`. PhoenixVapor adds `phx-click="save"` there.
+
+A template with errors, such as an expression that doesn't parse, returns `{:error, %Vize.Error{}}` with a `Vize.Diagnostic` for each, and warnings come back in the split's `:diagnostics`. `Vize.Diagnostic.to_code_diagnostic/2` converts one to Elixir's `t:Code.diagnostic/1` shape for a file, offset to where the template starts in it.
diff --git a/guides/features/vapor.md b/guides/features/vapor.md
index ef260d2..759938f 100644
--- a/guides/features/vapor.md
+++ b/guides/features/vapor.md
@@ -55,24 +55,4 @@ Every node has a `:kind`:
 
 Expressions are strings; static values are `{:static_, "value"}` tuples.
 
-## Splitting templates
-
-`Vize.vapor_split/1` turns a template into static HTML strings and the dynamic slots between them, the shape of `%Phoenix.LiveView.Rendered{}`. `v-if` and `v-for` blocks are split recursively.
-
-```elixir
-{:ok, split} = Vize.vapor_split(~s(<div :class="cls"><p>{{ msg }}</p></div>))
-
-split.statics  # ["<div class=\"", "\"><p>", "</p></div>"]
-split.slots    # [%{kind: :set_prop, values: ["cls"]}, %{kind: :set_text, values: ["msg"]}]
-```
-
-Events and `v-model`s are not rendered. They are reported as bindings, with the IR node and the position where their element's start tag ends, so a caller can add whatever attributes its runtime needs:
-
-```elixir
-{:ok, split} = Vize.vapor_split(~s(<button @click="save">{{ label }}</button>))
-
-split.statics   # ["<button>", "</button>"]
-split.bindings  # [%{kind: :set_event, node: %{key: {:static_, "click"}, value: "save", ...}, at: {0, 7}}]
-```
-
-`at: {0, 7}` is byte 7 of the first static, just before the `>`. [PhoenixVapor](https://github.com/elixir-volt/phoenix_vapor) uses it to add `phx-click="save"` there.
+To render a template on a server without JavaScript, see [Splitting templates](templates-and-ssr.md#splitting-templates).
diff --git a/lib/vize.ex b/lib/vize.ex
index 8b6a375..401f722 100644
--- a/lib/vize.ex
+++ b/lib/vize.ex
@@ -371,33 +371,83 @@ defmodule Vize do
   end
 
   @doc """
-  Split a Vue template into static HTML and the dynamic slots between them.
+  Split a Vue template into static HTML and the dynamic slots between them,
+  the shape of `%Phoenix.LiveView.Rendered{}`.
 
-  Returns `{:ok, split}` where `split` has:
+  The template is lowered to Vize's L2 semantic IR, which its SSR compiler
+  also uses, and printed: elements, static attributes, and text become HTML,
+  and everything that depends on data becomes a slot. Returns `{:ok, split}`:
 
     * `:statics` — static HTML strings, one more than there are slots
-    * `:slots` — slot descriptors in document order, each with a `:kind`.
-      `v-if` and `v-for` slots carry their own split.
-    * `:bindings` — events and `v-model`s, which the split leaves for the caller
-      to render. Each has a `:kind` (`:set_event` or `:directive`), the IR
-      `:node` as `vapor_ir/1` encodes it, and `:at`, a `{static_index, offset}`
-      pair: the byte offset in that static where the element's start tag ends,
-      so attributes can be inserted there.
-    * `:templates` — raw template strings (for sub-block rendering)
-    * `:element_template_map` — element ID → template index mapping
-
-  The statics and slots map directly onto a `%Phoenix.LiveView.Rendered{}`.
+    * `:slots` — slots in document order. Each has a `:kind` and a
+      `:position`, `{line, column}` in the template. Expressions are
+      JavaScript source strings.
+      * `:text` — an escaped interpolation (`:value`)
+      * `:html` — unescaped HTML from `v-html` (`:value`)
+      * `:attr` — one attribute, rendered whole with its leading space, so a
+        renderer can leave it out, as Vue does for `null` and a false boolean
+        attribute. Has `:name` (or `:name_value` for `:[name]`), `:value`,
+        `:static` for a static attribute of the same name such as `class="a"`
+        beside `:class="b"`, and `:show` for the `v-show` a `style` combines with
+      * `:spread` — the attributes of an object, from `v-bind="attrs"` (`:value`)
+      * `:model` — what a `v-model` renders on an `<input>` or `<textarea>`:
+        `:value`, the element's `:tag`, and its static `:type` and `:static_value`
+      * `:if` — `:branches`, each a `:condition` (nil for `v-else`) and a `:block`
+      * `:for` — `:source`, `:value`, `:key`, `:index`, the repeated element's
+        `:key_prop`, and its `:block`
+      * `:component` — `:name`, `:props`, `:events`, and `:slots`: the content
+        passed to each of its slots, with its `:name`, `:params` pattern such
+        as `{ item }`, and `:block`
+      * `:slot` — a `<slot>` outlet: `:name`, `:props`, and a `:fallback` block
+      * `:root_attrs` — with `root_attrs: true`, see below
+    * `:bindings` — events and `v-model`s, left for the caller to render: each
+      has a `:kind` (`:on` or `:model`), `:name`, `:modifiers`, `:value`, and
+      `:at`, a `{static_index, offset}` pair where the element's start tag
+      ends, so attributes can be inserted there
+    * `:diagnostics` — warnings, as `Vize.Diagnostic` structs
+
+  A block, such as a `v-if` branch, has its own `:statics`, `:slots`, and
+  `:bindings`. A prop or attribute in `:props` has `:name` (or `:name_value`),
+  and `:static` or `:value`; one with neither name is a `v-bind` object.
+
+  Returns `{:error, %Vize.Error{}}` when the template has errors, such as an
+  expression that doesn't parse.
+
+  ## Options
+
+    * `:root_attrs` — for a component's template: when it has a single root
+      element, return all of that element's attributes, static ones included,
+      as one `:root_attrs` slot, so a caller can merge the
+      [fallthrough attributes](https://vuejs.org/guide/components/attrs.html)
+      a parent passes (default: `false`)
+
+  ## Examples
+
+      iex> {:ok, split} = Vize.split_template(~s(<p :class="kind">Hi {{ name }}</p>))
+      iex> split.statics
+      ["<p", ">Hi ", "</p>"]
+      iex> Enum.map(split.slots, & &1.kind)
+      [:attr, :text]
   """
-  @spec vapor_split(String.t()) :: {:ok, map()} | {:error, [String.t()]}
-  def vapor_split(source) do
-    Vize.Native.vapor_split_nif(source)
+  @spec split_template(String.t(), keyword()) :: {:ok, map()} | {:error, Vize.Error.t()}
+  def split_template(source, opts \\ []) do
+    nif_opts = %{root_attrs: Keyword.get(opts, :root_attrs, false)}
+
+    case Vize.Native.split_template_nif(source, nif_opts) do
+      {:ok, split} ->
+        {:ok, %{split | diagnostics: Enum.map(split.diagnostics, &Vize.Diagnostic.new/1)}}
+
+      {:error, diagnostics} ->
+        {:error, error("Vue template has errors", diagnostics)}
+    end
   end
 
-  @spec vapor_split!(String.t()) :: map()
-  def vapor_split!(source) do
-    case vapor_split(source) do
+  @doc "Like `split_template/2` but raises `Vize.Error` on errors."
+  @spec split_template!(String.t(), keyword()) :: map()
+  def split_template!(source, opts \\ []) do
+    case split_template(source, opts) do
       {:ok, split} -> split
-      {:error, errors} -> raise "Vize vapor split error: #{inspect(errors)}"
+      {:error, error} -> raise error
     end
   end
 
diff --git a/lib/vize/diagnostic.ex b/lib/vize/diagnostic.ex
index a32c07f..1a3ffe3 100644
--- a/lib/vize/diagnostic.ex
+++ b/lib/vize/diagnostic.ex
@@ -1,12 +1,18 @@
 defmodule Vize.Diagnostic do
-  @moduledoc "Structured diagnostic emitted by Vize."
+  @moduledoc """
+  Structured diagnostic emitted by Vize.
 
-  defstruct [:code, :message, :location, recoverable?: false]
+  `to_code_diagnostic/2` converts one to Elixir's `t:Code.diagnostic/1` shape,
+  which editors, `Mix.Task.Compiler`, and tools such as OXC and Volt share.
+  """
+
+  defstruct [:code, :message, :location, severity: :error, recoverable?: false]
 
   @type t :: %__MODULE__{
           code: atom() | String.t() | nil,
           message: String.t(),
           location: Vize.SourceRange.t() | nil,
+          severity: :error | :warning,
           recoverable?: boolean()
         }
 
@@ -15,6 +21,9 @@ defmodule Vize.Diagnostic do
           required(:message) => String.t(),
           optional(:location) => Vize.SourceRange.input() | Vize.SourceRange.t() | nil,
           optional(:loc) => Vize.SourceRange.input() | Vize.SourceRange.t() | nil,
+          optional(:start) => Vize.SourceLocation.input() | nil,
+          optional(:end) => Vize.SourceLocation.input() | nil,
+          optional(:severity) => :error | :warning,
           optional(:recoverable?) => boolean(),
           optional(:recoverable) => boolean()
         }
@@ -24,11 +33,60 @@ defmodule Vize.Diagnostic do
   def new(message) when is_binary(message), do: %__MODULE__{message: message}
 
   def new(%{} = attrs) do
+    location =
+      Map.get(attrs, :location) || Map.get(attrs, :loc) ||
+        if Map.has_key?(attrs, :start), do: %{start: attrs.start, end: Map.get(attrs, :end)}
+
     %__MODULE__{
       code: Map.get(attrs, :code),
       message: Map.fetch!(attrs, :message),
-      location: Vize.SourceRange.new(Map.get(attrs, :location) || Map.get(attrs, :loc)),
+      location: Vize.SourceRange.new(location),
+      severity: Map.get(attrs, :severity, :error),
       recoverable?: Map.get(attrs, :recoverable?, Map.get(attrs, :recoverable, false))
     }
   end
+
+  @doc """
+  Converts a diagnostic to Elixir's `t:Code.diagnostic/1` shape.
+
+  ## Options
+
+    * `:file` — the file the diagnostic belongs to
+    * `:origin` — `{line, column}` where the source Vize was given starts in
+      that file, such as a `<template>` block's content in an SFC, so
+      positions point into the file (default: `{1, 1}`)
+  """
+  @spec to_code_diagnostic(t(), keyword()) :: Code.diagnostic(:error | :warning)
+  def to_code_diagnostic(%__MODULE__{} = diagnostic, opts \\ []) do
+    origin = Keyword.get(opts, :origin, {1, 1})
+    location = diagnostic.location
+
+    %{
+      file: Keyword.get(opts, :file),
+      severity: diagnostic.severity,
+      message: diagnostic.message,
+      position: position(location && location.start, origin) || 0,
+      span: position(location && location.end, origin),
+      source: Keyword.get(opts, :file),
+      stacktrace: [],
+      details: nil
+    }
+  end
+
+  @doc """
+  Shifts a `{line, column}` position in a source Vize was given to the file it
+  came from, whose content starts at `origin`.
+  """
+  @spec shift({pos_integer(), pos_integer()}, {pos_integer(), pos_integer()}) ::
+          {pos_integer(), pos_integer()}
+  def shift({1, column}, {origin_line, origin_column}),
+    do: {origin_line, origin_column + column - 1}
+
+  def shift({line, column}, {origin_line, _origin_column}), do: {origin_line + line - 1, column}
+
+  defp position(%Vize.SourceLocation{line: line, column: column}, origin)
+       when is_integer(line) and is_integer(column),
+       do: shift({line, column}, origin)
+
+  defp position(_location, _origin), do: nil
 end
diff --git a/lib/vize/error.ex b/lib/vize/error.ex
index 7dd80a6..196b52f 100644
--- a/lib/vize/error.ex
+++ b/lib/vize/error.ex
@@ -14,4 +14,20 @@ defmodule Vize.Error do
     diagnostics = Enum.map(List.wrap(errors), &Vize.Diagnostic.new/1)
     %__MODULE__{message: message, diagnostics: diagnostics, errors: errors}
   end
+
+  @impl true
+  def message(%__MODULE__{message: message, diagnostics: []}), do: message
+
+  def message(%__MODULE__{message: message, diagnostics: diagnostics}) do
+    Enum.map_join([message | Enum.map(diagnostics, &line/1)], "\n", & &1)
+  end
+
+  defp line(%Vize.Diagnostic{
+         message: message,
+         location: %Vize.SourceRange{start: %Vize.SourceLocation{line: line, column: column}}
+       })
+       when is_integer(line),
+       do: "  #{line}:#{column}: #{message}"
+
+  defp line(%Vize.Diagnostic{message: message}), do: "  " <> message
 end
diff --git a/lib/vize/generated_nif_stubs.ex b/lib/vize/generated_nif_stubs.ex
index d63c5df..ada9528 100644
--- a/lib/vize/generated_nif_stubs.ex
+++ b/lib/vize/generated_nif_stubs.ex
@@ -70,7 +70,7 @@ defmodule Vize.GeneratedNifStubs do
         :erlang.nif_error(:nif_not_loaded)
       end
 
-      def vapor_split_nif(_source) do
+      def split_template_nif(_source, _opts) do
         :erlang.nif_error(:nif_not_loaded)
       end
 
diff --git a/lib/vize/native.ex b/lib/vize/native.ex
index 394bbd7..6415d55 100644
--- a/lib/vize/native.ex
+++ b/lib/vize/native.ex
@@ -36,7 +36,7 @@ defmodule Vize.Native do
 
   @spec vapor_ir_nif(String.t()) :: {:ok, map()} | {:error, list()}
 
-  @spec vapor_split_nif(String.t()) :: {:ok, map()} | {:error, list()}
+  @spec split_template_nif(String.t(), map()) :: {:ok, map()} | {:error, list()}
 
   @spec lint_nif(String.t(), String.t()) :: {:ok, list()}
 
diff --git a/native/vize_ex_nif/Cargo.toml b/native/vize_ex_nif/Cargo.toml
index 46e0f1a..3c35739 100644
--- a/native/vize_ex_nif/Cargo.toml
+++ b/native/vize_ex_nif/Cargo.toml
@@ -28,6 +28,10 @@ vize_atelier_ssr = "=0.429.1"
 vize_atelier_sfc = { version = "=0.429.1", features = ["native"] }
 vize_patina = "=0.429.1"
 vize_croquis = "=0.429.1"
+vize_davinci = "=0.429.1"
+vize_l1 = "=0.429.1"
+vize_l1_to_l2 = "=0.429.1"
+vize_l2 = "=0.429.1"
 
 [dev-dependencies]
 proptest = "1.6"
diff --git a/native/vize_ex_nif/src/generated_atoms.rs b/native/vize_ex_nif/src/generated_atoms.rs
index 97d89cd..ee45afb 100644
--- a/native/vize_ex_nif/src/generated_atoms.rs
+++ b/native/vize_ex_nif/src/generated_atoms.rs
@@ -2,24 +2,24 @@
 
 mod atoms {
     rustler::atoms! {
-        r#for = "for", r#if = "if", anchor, asset, ast, attrs, block, block_type,
+        r#for = "for", r#if = "if", anchor, asset, ast, attr, attrs, block, block_type,
         builtin, camel, capture, child_id, child_ref, children, code, component,
         condition, content, control, create_component, css, css_import, css_url,
         css_vars, custom_blocks, delegate, directive, dynamic, dynamic_slots, effect,
         effects, element, end, end_ = "end", end_column, end_line, error, errors,
         exports, expression, fallback, flags, fn_exp, for_node, get_text_child, group,
-        has_scoped, helpers, id, if_node, index, input_type, insert_node, is_component,
-        is_element, is_event, is_expr, keep_alive, key, key_prop, keys, kind, lang, loc,
-        macro_artifacts, match_scope, media, message, model_modifiers, model_update,
-        modifiers, module, name, negative, next_ref, non_keys, object, offset, ok, once,
-        only_child, operations, options, parent, parent_id, passive, positive, preamble,
-        prepend_node, prop_modifier, props, ref_for, regular, render, returns, scoped,
-        script, script_hash, script_setup, set_dynamic_props, set_event, set_html,
-        set_merged_props, set_prop, set_template_ref, set_text, setup,
-        should_force_reload, slot_outlet, slots, slotted, source, source_map, sources,
-        src, start, start_column, start_line, static_, style_hash, styles, supports,
-        suspense, tag, tag_end, tag_start, teleport, temp_id, template, template_hash,
-        transition, transition_group, url, v_model, v_show, value, value_kind, values,
-        warnings
+        has_scoped, helpers, html, id, if_node, index, input_type, insert_node,
+        is_component, is_element, is_event, is_expr, keep_alive, key, key_prop, keys,
+        kind, lang, loc, macro_artifacts, match_scope, media, message, model,
+        model_modifiers, model_update, modifiers, module, name, negative, next_ref,
+        non_keys, object, offset, ok, on, once, only_child, operations, options, parent,
+        parent_id, passive, positive, preamble, prepend_node, prop_modifier, props,
+        ref_for, regular, render, returns, root_attrs, scoped, script, script_hash,
+        script_setup, set_dynamic_props, set_event, set_html, set_merged_props, set_prop,
+        set_template_ref, set_text, setup, should_force_reload, slot, slot_outlet, slots,
+        slotted, source, source_map, sources, spread, src, start, start_column,
+        start_line, static_, style_hash, styles, supports, suspense, tag, tag_end,
+        tag_start, teleport, temp_id, template, template_hash, text, transition,
+        transition_group, url, v_show, value, value_kind, values, warning, warnings
     }
 }
diff --git a/native/vize_ex_nif/src/generated_nifs.rs b/native/vize_ex_nif/src/generated_nifs.rs
index 4d83bde..c0b99de 100644
--- a/native/vize_ex_nif/src/generated_nifs.rs
+++ b/native/vize_ex_nif/src/generated_nifs.rs
@@ -120,8 +120,12 @@ fn bundle_css_nif<'a>(
     bundle_css_nif_impl(env, entry_path, opts)
 }
 #[rustler::nif(schedule = "DirtyCpu")]
-fn vapor_split_nif<'a>(env: Env<'a>, source: &str) -> NifResult<Term<'a>> {
-    vapor_split_nif_impl(env, source)
+fn split_template_nif<'a>(
+    env: Env<'a>,
+    source: &str,
+    opts: SplitTemplateOpts,
+) -> NifResult<Term<'a>> {
+    split_template_nif_impl(env, source, opts)
 }
 #[rustler::nif(schedule = "DirtyCpu")]
 fn generate_dts_nif<'a>(
diff --git a/native/vize_ex_nif/src/generated_types.rs b/native/vize_ex_nif/src/generated_types.rs
index 653ec42..13b48ea 100644
--- a/native/vize_ex_nif/src/generated_types.rs
+++ b/native/vize_ex_nif/src/generated_types.rs
@@ -50,6 +50,16 @@ pub struct CompileVaporOpts {
     pub template_syntax: String,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedAttrSlot {
+    pub kind: Atom,
+    pub name: Option<String>,
+    pub name_value: Option<String>,
+    pub r#static: Option<String>,
+    pub value: Option<String>,
+    pub show: Option<String>,
+    pub position: (usize, usize),
+}
+#[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedBinding {
     pub name: String,
     pub kind: String,
@@ -57,9 +67,11 @@ pub struct EncodedBinding {
 #[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedComponentSlot<'a> {
     pub kind: Atom,
-    pub tag: String,
-    pub props: Vec<Term<'a>>,
-    pub value: Atom,
+    pub name: String,
+    pub props: Vec<EncodedProp>,
+    pub events: Vec<EncodedEvent>,
+    pub slots: Vec<EncodedSlotContent<'a>>,
+    pub position: (usize, usize),
 }
 #[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedComponentUsage {
@@ -80,6 +92,12 @@ pub struct EncodedDts {
     pub dts: String,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedEvent {
+    pub name: Option<String>,
+    pub modifiers: Vec<String>,
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedEventListener {
     pub name: String,
     pub handler: Option<String>,
@@ -87,17 +105,39 @@ pub struct EncodedEventListener {
 #[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedForSlot<'a> {
     pub kind: Atom,
-    pub source: Term<'a>,
-    pub value: Option<Term<'a>>,
-    pub key_prop: Option<Term<'a>>,
-    pub render: EncodedSplitBlock<'a>,
+    pub source: String,
+    pub value: String,
+    pub key: Option<String>,
+    pub index: Option<String>,
+    pub key_prop: Option<String>,
+    pub block: EncodedSplitBlock<'a>,
+    pub position: (usize, usize),
+}
+#[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedHtmlSlot {
+    pub kind: Atom,
+    pub value: String,
+    pub position: (usize, usize),
+}
+#[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedIfBranch<'a> {
+    pub condition: Option<String>,
+    pub block: EncodedSplitBlock<'a>,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedIfSlot<'a> {
     pub kind: Atom,
-    pub condition: Term<'a>,
-    pub positive: EncodedSplitBlock<'a>,
-    pub negative: Option<Term<'a>>,
+    pub branches: Vec<EncodedIfBranch<'a>>,
+    pub position: (usize, usize),
+}
+#[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedModelSlot {
+    pub kind: Atom,
+    pub tag: String,
+    pub r#type: Option<String>,
+    pub static_value: Option<String>,
+    pub value: String,
+    pub position: (usize, usize),
 }
 #[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedPassedProp {
@@ -112,6 +152,13 @@ pub struct EncodedPosition {
     pub column: u32,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedProp {
+    pub name: Option<String>,
+    pub name_value: Option<String>,
+    pub r#static: Option<String>,
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedPropDeclaration {
     pub name: String,
     pub required: bool,
@@ -122,6 +169,13 @@ pub struct EncodedRange {
     pub end: u32,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedRootAttrsSlot {
+    pub kind: Atom,
+    pub props: Vec<EncodedProp>,
+    pub show: Option<String>,
+    pub position: (usize, usize),
+}
+#[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedSass {
     pub code: String,
 }
@@ -149,22 +203,54 @@ pub struct EncodedSfcStats {
     pub undefined_refs: usize,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedSlotContent<'a> {
+    pub name: Option<String>,
+    pub name_value: Option<String>,
+    pub params: Option<String>,
+    pub block: EncodedSplitBlock<'a>,
+}
+#[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedSlotOutlet<'a> {
+    pub kind: Atom,
+    pub name: Option<String>,
+    pub name_value: Option<String>,
+    pub props: Vec<EncodedProp>,
+    pub fallback: Option<EncodedSplitBlock<'a>>,
+    pub position: (usize, usize),
+}
+#[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedSourceLocation {
     pub start: EncodedPosition,
     pub end: EncodedPosition,
     pub source: String,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
-pub struct EncodedSplitBinding<'a> {
+pub struct EncodedSplitBinding {
     pub kind: Atom,
-    pub node: Term<'a>,
+    pub name: Option<String>,
+    pub modifiers: Vec<String>,
+    pub value: Option<String>,
     pub at: (usize, usize),
+    pub position: (usize, usize),
 }
 #[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedSplitBlock<'a> {
     pub statics: Vec<String>,
     pub slots: Vec<Term<'a>>,
-    pub bindings: Vec<EncodedSplitBinding<'a>>,
+    pub bindings: Vec<EncodedSplitBinding>,
+}
+#[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedSplitDiagnostic {
+    pub severity: Atom,
+    pub message: String,
+    pub start: EncodedPosition,
+    pub end: EncodedPosition,
+}
+#[derive(Clone, Debug, rustler::NifMap)]
+pub struct EncodedSpreadSlot {
+    pub kind: Atom,
+    pub value: String,
+    pub position: (usize, usize),
 }
 #[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedTemplateAsset {
@@ -178,20 +264,23 @@ pub struct EncodedTemplateExpression {
     pub range: EncodedRange,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
-pub struct EncodedUndefinedRef {
-    pub name: String,
-    pub offset: u32,
-    pub context: String,
+pub struct EncodedTemplateSplit<'a> {
+    pub statics: Vec<String>,
+    pub slots: Vec<Term<'a>>,
+    pub bindings: Vec<EncodedSplitBinding>,
+    pub diagnostics: Vec<EncodedSplitDiagnostic>,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
-pub struct EncodedValueSlot<'a> {
+pub struct EncodedTextSlot {
     pub kind: Atom,
-    pub value: Term<'a>,
+    pub value: String,
+    pub position: (usize, usize),
 }
 #[derive(Clone, Debug, rustler::NifMap)]
-pub struct EncodedValuesSlot<'a> {
-    pub kind: Atom,
-    pub values: Vec<Term<'a>>,
+pub struct EncodedUndefinedRef {
+    pub name: String,
+    pub offset: u32,
+    pub context: String,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
 pub struct EncodedVaporDiagnosticsOutput {
@@ -213,14 +302,6 @@ pub struct EncodedVaporOutput {
     pub templates: Vec<String>,
 }
 #[derive(Clone, Debug, rustler::NifMap)]
-pub struct EncodedVaporSplit<'a> {
-    pub statics: Vec<String>,
-    pub slots: Vec<Term<'a>>,
-    pub bindings: Vec<EncodedSplitBinding<'a>>,
-    pub templates: Vec<String>,
-    pub element_template_map: Vec<(usize, usize)>,
-}
-#[derive(Clone, Debug, rustler::NifMap)]
 pub struct ParseCssOpts {
     pub filename: String,
     pub custom_media: bool,
@@ -237,3 +318,7 @@ pub struct ScopeIdOpts {
     pub production: bool,
     pub source: String,
 }
+#[derive(Clone, Debug, rustler::NifMap)]
+pub struct SplitTemplateOpts {
+    pub root_attrs: bool,
+}
diff --git a/native/vize_ex_nif/src/html_inject.rs b/native/vize_ex_nif/src/html_inject.rs
deleted file mode 100644
index 007a80c..0000000
--- a/native/vize_ex_nif/src/html_inject.rs
+++ /dev/null
@@ -1,512 +0,0 @@
-#[derive(Debug, Clone)]
-pub(crate) struct TagEntry {
-    pub(crate) tag: String,
-    pub(crate) pos: usize,
-    pub(crate) parent: Option<usize>,
-    /// Position among the parent's child nodes, counting text runs and anchors
-    /// as the DOM does. Vapor's `child`/`next` offsets count the same way.
-    pub(crate) node_index: usize,
-    pub(crate) open_start: usize,
-    pub(crate) open_end: usize,
-    pub(crate) close_start: Option<usize>,
-}
-
-/// Empty comment Vapor templates use as the anchor for a structural node.
-pub(crate) const VAPOR_ANCHOR: &str = "<!---->";
-const VAPOR_ANCHOR_TAG: &str = "!--";
-
-impl TagEntry {
-    pub(crate) fn is_anchor(&self) -> bool {
-        self.tag == VAPOR_ANCHOR_TAG
-    }
-}
-
-fn is_void_element(tag: &str) -> bool {
-    matches!(
-        tag,
-        "area"
-            | "base"
-            | "br"
-            | "col"
-            | "embed"
-            | "hr"
-            | "img"
-            | "input"
-            | "link"
-            | "meta"
-            | "param"
-            | "source"
-            | "track"
-            | "wbr"
-    )
-}
-
-fn skip_comment(bytes: &[u8], i: &mut usize) {
-    *i += 4;
-    while *i + 2 < bytes.len() {
-        if bytes[*i] == b'-' && bytes[*i + 1] == b'-' && bytes[*i + 2] == b'>' {
-            *i += 3;
-            return;
-        }
-        *i += 1;
-    }
-    *i = bytes.len();
-}
-
-fn skip_declaration(bytes: &[u8], i: &mut usize) {
-    *i += 2;
-    while *i < bytes.len() && bytes[*i] != b'>' {
-        *i += 1;
-    }
-    if *i < bytes.len() {
-        *i += 1;
-    }
-}
-
-fn next_node_index(
-    node_counts: &mut std::collections::HashMap<Option<usize>, usize>,
-    parent: Option<usize>,
-) -> usize {
-    let count = node_counts.entry(parent).or_default();
-    let index = *count;
-    *count += 1;
-    index
-}
-
-pub(crate) fn parse_tag_tree(html: &str) -> Vec<TagEntry> {
-    let bytes = html.as_bytes();
-    let len = bytes.len();
-    let mut entries: Vec<TagEntry> = Vec::new();
-    let mut stack: Vec<usize> = Vec::new();
-    let mut node_counts: std::collections::HashMap<Option<usize>, usize> =
-        std::collections::HashMap::new();
-    let mut in_text = false;
-    let mut i = 0;
-
-    while i < len {
-        if bytes[i] != b'<' {
-            if !in_text {
-                *node_counts.entry(stack.last().copied()).or_default() += 1;
-                in_text = true;
-            }
-            i += 1;
-            continue;
-        }
-        in_text = false;
-
-        if html[i..].starts_with(VAPOR_ANCHOR) {
-            // Anchors are DOM nodes at runtime, so child/next offsets count them.
-            let parent = stack.last().copied();
-            let node_index = next_node_index(&mut node_counts, parent);
-            let pos = entries.len();
-            entries.push(TagEntry {
-                tag: VAPOR_ANCHOR_TAG.to_string(),
-                pos,
-                parent,
-                node_index,
-                open_start: i,
-                open_end: i + VAPOR_ANCHOR.len(),
-                close_start: None,
-            });
-            i += VAPOR_ANCHOR.len();
-            continue;
-        }
-
-        if i + 3 < len && &bytes[i..i + 4] == b"<!--" {
-            skip_comment(bytes, &mut i);
-            continue;
-        }
-
-        if i + 1 < len && (bytes[i + 1] == b'!' || bytes[i + 1] == b'?') {
-            skip_declaration(bytes, &mut i);
-            continue;
-        }
-
-        if i + 1 < len && bytes[i + 1] == b'/' {
-            let start = i;
-            i += 2;
-            while i < len && bytes[i] != b'>' {
-                i += 1;
-            }
-            if i < len {
-                i += 1;
-            }
-            if let Some(top) = stack.pop() {
-                entries[top].close_start = Some(start);
-            }
-            continue;
-        }
-
-        let open_start = i;
-        i += 1;
-        let name_start = i;
-        while i < len && bytes[i] != b' ' && bytes[i] != b'>' && bytes[i] != b'/' {
-            i += 1;
-        }
-        let tag_name = String::from_utf8_lossy(&bytes[name_start..i]).to_string();
-
-        let mut self_closing = false;
-        let mut quote = None;
-        while i < len {
-            match quote {
-                Some(current_quote) if bytes[i] == current_quote => {
-                    quote = None;
-                }
-                Some(_) => {}
-                None if bytes[i] == b'"' || bytes[i] == b'\'' => {
-                    quote = Some(bytes[i]);
-                }
-                None if bytes[i] == b'/' && i + 1 < len && bytes[i + 1] == b'>' => {
-                    self_closing = true;
-                }
-                None if bytes[i] == b'>' => {
-                    break;
-                }
-                None => {}
-            }
-            i += 1;
-        }
-        if i < len {
-            i += 1;
-        }
-        let open_end = i;
-
-        let parent = stack.last().copied();
-        let node_index = next_node_index(&mut node_counts, parent);
-
-        let pos = entries.len();
-        entries.push(TagEntry {
-            tag: tag_name.clone(),
-            pos,
-            parent,
-            node_index,
-            open_start,
-            open_end,
-            close_start: None,
-        });
-
-        if !self_closing && !is_void_element(&tag_name) {
-            stack.push(pos);
-        }
-    }
-
-    entries
-}
-
-pub(crate) fn build_elem_to_tag(
-    returns: &[usize],
-    operations: &[vize_atelier_vapor::ir::OperationNode],
-    tags: &[TagEntry],
-) -> std::collections::HashMap<usize, usize> {
-    let mut map = std::collections::HashMap::new();
-
-    for (idx, &elem_id) in returns.iter().enumerate() {
-        let root_tags: Vec<_> = tags.iter().filter(|tag| tag.parent.is_none()).collect();
-        if let Some(tag) = root_tags.get(idx) {
-            map.insert(elem_id, tag.pos);
-        }
-    }
-
-    loop {
-        let prev_size = map.len();
-        for op in operations {
-            match op {
-                vize_atelier_vapor::ir::OperationNode::ChildRef(node) => {
-                    if let Some(&parent_tag_pos) = map.get(&node.parent_id) {
-                        if let Some(child) = tags.iter().find(|tag| {
-                            tag.parent == Some(parent_tag_pos) && tag.node_index == node.offset
-                        }) {
-                            map.insert(node.child_id, child.pos);
-                        }
-                    }
-                }
-                vize_atelier_vapor::ir::OperationNode::NextRef(node) => {
-                    if let Some(&prev_tag_pos) = map.get(&node.prev_id) {
-                        if let Some(prev_entry) = tags.get(prev_tag_pos) {
-                            let target = prev_entry.node_index + node.offset;
-                            if let Some(sibling) = tags.iter().find(|tag| {
-                                tag.parent == prev_entry.parent && tag.node_index == target
-                            }) {
-                                map.insert(node.child_id, sibling.pos);
-                            }
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-        if map.len() == prev_size {
-            break;
-        }
-    }
-
-    map
-}
-
-fn attr_insert_at(html: &str, entry: &TagEntry) -> usize {
-    let bytes = html.as_bytes();
-    if entry.open_end >= 2 && bytes[entry.open_end - 2] == b'/' {
-        let slash_at = entry.open_end - 2;
-        if slash_at > 0 && bytes[slash_at - 1] == b' ' {
-            slash_at - 1
-        } else {
-            slash_at
-        }
-    } else {
-        entry.open_end - 1
-    }
-}
-
-fn shift_offset(offset: &mut usize, replaced_end: usize, delta: isize) {
-    if *offset >= replaced_end {
-        *offset = (*offset as isize + delta) as usize;
-    }
-}
-
-pub(crate) fn replace_range(
-    html: &mut String,
-    tags: &mut [TagEntry],
-    start: usize,
-    old_len: usize,
-    replacement: &str,
-) {
-    let replaced_end = start + old_len;
-    let delta = replacement.len() as isize - old_len as isize;
-    html.replace_range(start..replaced_end, replacement);
-
-    if delta == 0 {
-        return;
-    }
-
-    for entry in tags.iter_mut() {
-        shift_offset(&mut entry.open_start, replaced_end, delta);
-        shift_offset(&mut entry.open_end, replaced_end, delta);
-        if let Some(close_start) = &mut entry.close_start {
-            shift_offset(close_start, replaced_end, delta);
-        }
-    }
-}
-
-/// End offset of a node, past its closing tag when it has one.
-fn node_end(html: &str, entry: &TagEntry) -> usize {
-    entry
-        .close_start
-        .and_then(|close| html[close..].find('>').map(|gt| close + gt + 1))
-        .unwrap_or(entry.open_end)
-}
-
-/// Replaces the direct text node of an element whose decoded content equals
-/// `text`. Text nodes are the runs between the element's child nodes.
-pub(crate) fn replace_text_node(
-    html: &mut String,
-    tags: &mut [TagEntry],
-    tag_pos: usize,
-    text: &str,
-    replacement: &str,
-) -> bool {
-    let Some(entry) = tags.get(tag_pos) else {
-        return false;
-    };
-    let content_end = entry.close_start.unwrap_or(entry.open_end);
-
-    let mut run_start = entry.open_end;
-    let mut boundaries: Vec<(usize, usize)> = tags
-        .iter()
-        .filter(|child| child.parent == Some(tag_pos))
-        .map(|child| (child.open_start, node_end(html, child)))
-        .collect();
-    boundaries.push((content_end, content_end));
-
-    let target = boundaries.into_iter().find_map(|(child_start, child_end)| {
-        let run = (run_start, child_start);
-        run_start = child_end;
-        let content = &html[run.0..run.1];
-        (!content.is_empty() && html_escape::decode_html_entities(content) == text).then_some(run)
-    });
-
-    let Some((start, end)) = target else {
-        return false;
-    };
-    replace_range(html, tags, start, end - start, replacement);
-    true
-}
-
-pub(crate) fn replace_first_space_in_content(
-    html: &mut String,
-    tags: &mut [TagEntry],
-    tag_pos: usize,
-    replacement: &str,
-) -> bool {
-    let Some(entry) = tags.get(tag_pos) else {
-        return false;
-    };
-
-    let content_start = entry.open_end;
-    let content_end = entry.close_start.unwrap_or(content_start);
-    let Some(relative_pos) = html[content_start..content_end].find(' ') else {
-        return false;
-    };
-
-    replace_range(html, tags, content_start + relative_pos, 1, replacement);
-    true
-}
-
-pub(crate) fn inject_attr(html: &mut String, tags: &mut [TagEntry], tag_pos: usize, attr: &str) {
-    if let Some(entry) = tags.get(tag_pos) {
-        let insert_at = attr_insert_at(html, entry);
-        replace_range(html, tags, insert_at, 0, attr);
-    }
-}
-
-pub(crate) fn inject_before_close(
-    html: &mut String,
-    tags: &mut [TagEntry],
-    tag_pos: usize,
-    content: &str,
-) {
-    if let Some(entry) = tags.get(tag_pos) {
-        let insert_at = entry.close_start.unwrap_or(entry.open_end);
-        replace_range(html, tags, insert_at, 0, content);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{inject_attr, inject_before_close, parse_tag_tree, replace_first_space_in_content};
-    use proptest::prelude::*;
-
-    #[test]
-    fn parse_tag_tree_tracks_nested_and_void_elements() {
-        let html = "<div><img src=\"x\"><input /><span></span></div>";
-        let tags = parse_tag_tree(html);
-
-        assert_eq!(tags.len(), 4);
-        assert_eq!(tags[0].parent, None);
-        assert_eq!(tags[1].parent, Some(0));
-        assert_eq!(tags[2].parent, Some(0));
-        assert_eq!(tags[3].parent, Some(0));
-        assert_eq!(tags[1].close_start, None);
-        assert_eq!(tags[2].close_start, None);
-        assert_eq!(tags[3].close_start, Some(html.find("</span>").unwrap()));
-        assert_eq!(tags[1].node_index, 0);
-        assert_eq!(tags[2].node_index, 1);
-        assert_eq!(tags[3].node_index, 2);
-    }
-
-    #[test]
-    fn parse_tag_tree_counts_text_runs_in_node_indices() {
-        let tags = parse_tag_tree("<p>a<b></b>c<!----><i></i></p>");
-
-        assert_eq!(tags[1].node_index, 1);
-        assert_eq!(tags[2].node_index, 3);
-        assert_eq!(tags[3].node_index, 4);
-    }
-
-    #[test]
-    fn parse_tag_tree_ignores_angle_brackets_inside_quoted_attributes() {
-        let html = r#"<div data-text=\"1 > 0\"><span data-note='a > b'></span></div>"#;
-        let tags = parse_tag_tree(html);
-
-        assert_eq!(tags.len(), 2);
-        assert_eq!(tags[0].parent, None);
-        assert_eq!(tags[1].parent, Some(0));
-        assert_eq!(tags[1].close_start, Some(html.find("</span>").unwrap()));
-    }
-
-    #[test]
-    fn parse_tag_tree_skips_comments_and_preserves_sibling_roots() {
-        let html = "<div>one</div><!-- ignored --><span>two</span>";
-        let tags = parse_tag_tree(html);
-
-        assert_eq!(tags.len(), 2);
-        assert_eq!(tags[0].parent, None);
-        assert_eq!(tags[1].parent, None);
-        assert_eq!(tags[0].node_index, 0);
-        assert_eq!(tags[1].node_index, 1);
-    }
-
-    #[test]
-    fn inject_helpers_keep_offsets_in_sync() {
-        let mut html = String::from("<div><span></span></div>");
-        let mut tags = parse_tag_tree(&html);
-
-        inject_attr(&mut html, &mut tags, 1, " class=\"pill\"");
-        inject_before_close(&mut html, &mut tags, 0, "!");
-
-        assert_eq!(html, "<div><span class=\"pill\"></span>!</div>");
-        assert_eq!(tags[0].close_start, Some(html.find("</div>").unwrap()));
-        assert_eq!(tags[1].close_start, Some(html.find("</span>").unwrap()));
-    }
-
-    #[test]
-    fn inject_attr_preserves_self_closing_syntax() {
-        let mut html = String::from("<div><input /></div>");
-        let mut tags = parse_tag_tree(&html);
-
-        inject_attr(&mut html, &mut tags, 1, " class=\"field\"");
-
-        assert_eq!(html, "<div><input class=\"field\" /></div>");
-        assert_eq!(tags[1].close_start, None);
-    }
-
-    #[test]
-    fn replace_first_space_in_content_updates_offsets_without_reparse() {
-        let mut html = String::from("<div> <span>ok</span></div>");
-        let mut tags = parse_tag_tree(&html);
-
-        assert!(replace_first_space_in_content(
-            &mut html, &mut tags, 0, "__TEXT__"
-        ));
-
-        assert_eq!(html, "<div>__TEXT__<span>ok</span></div>");
-        assert_eq!(tags[0].close_start, Some(html.find("</div>").unwrap()));
-        assert_eq!(tags[1].open_start, html.find("<span>").unwrap());
-        assert_eq!(tags[1].close_start, Some(html.find("</span>").unwrap()));
-    }
-
-    proptest! {
-        #[test]
-        fn parse_tag_tree_handles_random_quoted_angle_brackets(
-            text in "[A-Za-z0-9 ><_=/-]{0,24}",
-            note in "[A-Za-z0-9 ><_=/-]{0,24}"
-        ) {
-            let html = format!(r#"<div data-text=\"{}\"><span data-note='{}'></span></div>"#, text, note);
-            let tags = parse_tag_tree(&html);
-
-            prop_assert_eq!(tags.len(), 2);
-            prop_assert_eq!(tags[0].parent, None);
-            prop_assert_eq!(tags[1].parent, Some(0));
-            prop_assert_eq!(tags[1].close_start, html.find("</span>"));
-        }
-
-        #[test]
-        fn inject_attr_keeps_self_closing_tags_well_formed(name in "[a-z]{1,8}") {
-            let mut html = String::from("<div><input /></div>");
-            let mut tags = parse_tag_tree(&html);
-            let attr = format!(" {}=\"x\"", name);
-
-            inject_attr(&mut html, &mut tags, 1, &attr);
-
-            let misplaced_attr = format!("/ {}=", name);
-
-            prop_assert!(html.contains("<input "));
-            prop_assert!(html.contains(" />"));
-            prop_assert!(!html.contains(&misplaced_attr));
-            prop_assert_eq!(tags[1].close_start, None);
-        }
-
-        #[test]
-        fn replace_first_space_preserves_tag_boundaries(prefix in "[A-Za-z0-9]{0,8}") {
-            let mut html = format!("<div>{} <span>ok</span></div>", prefix);
-            let mut tags = parse_tag_tree(&html);
-
-            let replaced = replace_first_space_in_content(&mut html, &mut tags, 0, "__MARK__");
-
-            prop_assert!(replaced);
-            prop_assert_eq!(tags.len(), 2);
-            prop_assert_eq!(tags[1].open_start, html.find("<span>").unwrap());
-            prop_assert_eq!(tags[1].close_start, html.find("</span>"));
-            prop_assert_eq!(tags[0].close_start, html.find("</div>"));
-        }
-    }
-}
diff --git a/native/vize_ex_nif/src/lib.rs b/native/vize_ex_nif/src/lib.rs
index a6190f0..ea5ba7a 100644
--- a/native/vize_ex_nif/src/lib.rs
+++ b/native/vize_ex_nif/src/lib.rs
@@ -26,7 +26,6 @@ use vize_atelier_vapor::{
 };
 use vize_carton::{line_index::LineIndex, Allocator};
 
-mod html_inject;
 mod ir_encoding;
 
 mod ir_encoders {
@@ -48,8 +47,8 @@ mod sfc_encoders {
 
     include!("generated_sfc_encoders.rs");
 }
+mod template_split;
 mod term_encoding;
-mod vapor_split;
 
 use crate::term_encoding::{
     decode_json_value, error_term, ok_term, EncodedBinding, EncodedBundleCssResult,
@@ -59,13 +58,13 @@ use crate::term_encoding::{
     EncodedRange, EncodedSass, EncodedSfcAnalysis, EncodedSfcStats, EncodedSourceLocation,
     EncodedSsrCompileResult, EncodedTemplateAsset, EncodedTemplateCompileResult,
     EncodedTemplateExpression, EncodedUndefinedRef, EncodedVaporDiagnosticsOutput, EncodedVaporIr,
-    EncodedVaporOutput, EncodedVaporSplit,
+    EncodedVaporOutput,
 };
 use crate::term_encoding::{
     BrowserTargets, BundleCssOpts, CompileCssOpts, CompileSassOpts, CompileSfcOpts,
     CompileTemplateOpts, CompileVaporOpts, ParseCssOpts, PrintCssOpts, ScopeIdOpts,
+    SplitTemplateOpts,
 };
-use crate::vapor_split::process_block;
 
 include!("generated_atoms.rs");
 include!("generated_nifs.rs");
@@ -994,42 +993,15 @@ fn bundle_css_nif_impl<'a>(
     Ok(ok_term(env, EncodedBundleCssResult { result: &result }))
 }
 
-fn vapor_split_nif_impl<'a>(env: Env<'a>, source: &str) -> NifResult<Term<'a>> {
-    let allocator = Allocator::new();
-    let parser_opts = ParserOptions::default();
-    let (mut root, errors) = parse_with_options(&allocator, source, parser_opts);
-
-    if !errors.is_empty() {
-        let msgs: std::vec::Vec<std::string::String> =
-            errors.iter().map(|e| e.message.to_string()).collect();
-        return Ok(error_term(env, msgs));
+fn split_template_nif_impl<'a>(
+    env: Env<'a>,
+    source: &str,
+    opts: SplitTemplateOpts,
+) -> NifResult<Term<'a>> {
+    match template_split::split_template(env, source, opts.root_attrs) {
+        Ok(split) => Ok(ok_term(env, split)),
+        Err(diagnostics) => Ok(error_term(env, diagnostics)),
     }
-
-    let transform_opts = TransformOptions {
-        vapor: true,
-        ..Default::default()
-    };
-    transform(&allocator, &mut root, transform_opts, None);
-
-    let ir = transform_to_ir(&allocator, &root, source);
-
-    let (statics, slots, bindings) = match process_block(env, &ir.block, &ir, source) {
-        Ok(split) => split,
-        Err(message) => return Ok(error_term(env, vec![message])),
-    };
-
-    let split = EncodedVaporSplit {
-        statics,
-        slots,
-        bindings,
-        templates: ir.templates.iter().map(ToString::to_string).collect(),
-        element_template_map: ir
-            .element_template_map
-            .iter()
-            .map(|(&element, &template)| (element, template))
-            .collect(),
-    };
-    Ok(ok_term(env, split))
 }
 
 // ── Declaration .d.ts Generation ──
diff --git a/native/vize_ex_nif/src/template_split.rs b/native/vize_ex_nif/src/template_split.rs
new file mode 100644
index 0000000..380d6eb
--- /dev/null
+++ b/native/vize_ex_nif/src/template_split.rs
@@ -0,0 +1,875 @@
+//! Splits a Vue template into static HTML and the dynamic slots between them.
+//!
+//! The template is lowered to Vize's L2 semantic IR, the op family Vize's own
+//! SSR string plan is built from, and printed: static elements, attributes and
+//! text become HTML, and each expression, structural directive, component and
+//! slot outlet becomes a slot for the caller to render.
+
+use std::collections::HashMap;
+
+use rustler::{Encoder, Env, Term};
+use vize_carton::line_index::LineIndex;
+use vize_carton::{is_void_tag, Allocator};
+use vize_davinci::diagnostic::{Diagnostic, Severity};
+use vize_l1_to_l2::decode_ssr_static_text;
+use vize_l1_to_l2::emit::decode_html_attribute_entities;
+use vize_l1_to_l2::lower::TextPart;
+use vize_l2::expr::{ExprRef, OpaqueReason};
+use vize_l2::op::{
+    Attribute, BindOp, BindingOp, ComponentOp, DynamicName, ElementOp, ForOp, IfOp, ModelOp, Op,
+    Region, SlotOp,
+};
+
+use crate::atoms;
+use crate::term_encoding::{
+    EncodedAttrSlot, EncodedComponentSlot, EncodedEvent, EncodedForSlot, EncodedHtmlSlot,
+    EncodedIfBranch, EncodedIfSlot, EncodedModelSlot, EncodedPosition, EncodedProp,
+    EncodedRootAttrsSlot, EncodedSlotContent, EncodedSlotOutlet, EncodedSplitBinding,
+    EncodedSplitBlock, EncodedSplitDiagnostic, EncodedSpreadSlot, EncodedTemplateSplit,
+    EncodedTextSlot,
+};
+
+type Position = (usize, usize);
+
+/// Splits `source`, a template's content. With `root_attrs`, the attributes of
+/// a single root element come back as one `:root_attrs` slot. Errors are the
+/// diagnostics that make the template unrenderable.
+pub(crate) fn split_template<'a>(
+    env: Env<'a>,
+    source: &str,
+    root_attrs: bool,
+) -> Result<EncodedTemplateSplit<'a>, Vec<EncodedSplitDiagnostic>> {
+    let allocator = Allocator::new();
+    let (tree, errors) = vize_l1::parse(&allocator, source);
+    let lowered = vize_l1_to_l2::lower(&allocator, &tree, &errors);
+
+    let mut splitter = Splitter {
+        env,
+        lines: LineIndex::new(source),
+        texts: lowered
+            .texts
+            .iter()
+            .filter_map(|(_id, parts)| {
+                Some((parts.parts.first()?.span.start, parts.parts.as_slice()))
+            })
+            .collect(),
+        diagnostics: lowered
+            .diagnostics
+            .iter()
+            .filter_map(|diagnostic| lowering_diagnostic(diagnostic, source))
+            .collect(),
+    };
+
+    let mut block = Block::default();
+    let root = if root_attrs {
+        single_root(&lowered.root)
+    } else {
+        None
+    };
+
+    for op in lowered.root.ops.iter() {
+        match (op, root) {
+            (Op::Element(element), Some(root)) if std::ptr::eq(&**element, root) => {
+                splitter.element(&mut block, element, true)
+            }
+            _ => splitter.op(&mut block, op),
+        }
+    }
+
+    let errors: Vec<_> = splitter
+        .diagnostics
+        .iter()
+        .filter(|diagnostic| diagnostic.severity == atoms::error())
+        .cloned()
+        .collect();
+
+    if !errors.is_empty() {
+        return Err(errors);
+    }
+
+    let EncodedSplitBlock {
+        statics,
+        slots,
+        bindings,
+    } = block.finish();
+
+    Ok(EncodedTemplateSplit {
+        statics,
+        slots,
+        bindings,
+        diagnostics: splitter.diagnostics,
+    })
+}
+
+/// The template's only element, ignoring whitespace and comments around it.
+fn single_root<'r, 'a>(root: &'r Region<'a>) -> Option<&'r ElementOp<'a>> {
+    let mut elements = root.ops.iter().filter(|op| match op {
+        Op::Text(text) => !text.content.trim().is_empty(),
+        Op::Comment(_) => false,
+        _ => true,
+    });
+
+    match (elements.next(), elements.next()) {
+        (Some(Op::Element(element)), None) => Some(element),
+        _ => None,
+    }
+}
+
+/// Static HTML and the slots between its pieces, built in document order.
+#[derive(Default)]
+struct Block<'a> {
+    statics: Vec<String>,
+    current: String,
+    slots: Vec<Term<'a>>,
+    bindings: Vec<EncodedSplitBinding>,
+}
+
+impl<'a> Block<'a> {
+    fn push(&mut self, html: &str) {
+        self.current.push_str(html);
+    }
+
+    fn slot(&mut self, slot: Term<'a>) {
+        self.statics.push(std::mem::take(&mut self.current));
+        self.slots.push(slot);
+    }
+
+    /// Where the next byte goes: `{static_index, byte_offset}`.
+    fn at(&self) -> (usize, usize) {
+        (self.statics.len(), self.current.len())
+    }
+
+    fn finish(mut self) -> EncodedSplitBlock<'a> {
+        self.statics.push(self.current);
+        EncodedSplitBlock {
+            statics: self.statics,
+            slots: self.slots,
+            bindings: self.bindings,
+        }
+    }
+}
+
+struct Splitter<'s, 'a> {
+    env: Env<'a>,
+    lines: LineIndex<'s>,
+    /// Merged text runs such as `Hello {{ name }}!`, by where they start.
+    texts: HashMap<u32, &'s [TextPart]>,
+    diagnostics: Vec<EncodedSplitDiagnostic>,
+}
+
+impl<'s, 'a> Splitter<'s, 'a> {
+    fn region(&mut self, region: &Region<'_>) -> EncodedSplitBlock<'a> {
+        let mut block = Block::default();
+        for op in region.ops.iter() {
+            self.op(&mut block, op);
+        }
+        block.finish()
+    }
+
+    fn op(&mut self, block: &mut Block<'a>, op: &Op<'_>) {
+        match op {
+            Op::Element(element) => self.element(block, element, false),
+            Op::Component(component) => {
+                let slot = self.component(component);
+                block.slot(slot);
+            }
+            Op::Text(text) => block.push(&escape_text(text.content)),
+            Op::Interpolation(interpolation) => match interpolation.expression {
+                ExprRef::Opaque(opaque) if opaque.reason == OpaqueReason::Compound => {
+                    self.compound_text(block, interpolation.span.start, opaque.source)
+                }
+                expression => {
+                    let slot = self.text_slot(expression);
+                    block.slot(slot);
+                }
+            },
+            Op::Comment(_) => {}
+            Op::If(if_op) => {
+                let slot = self.if_slot(if_op);
+                block.slot(slot);
+            }
+            Op::For(for_op) => {
+                let slot = self.for_slot(for_op);
+                block.slot(slot);
+            }
+            Op::Slot(outlet) => {
+                let slot = self.slot_outlet(outlet);
+                block.slot(slot);
+            }
+        }
+    }
+
+    fn compound_text(&mut self, block: &mut Block<'a>, start: u32, source: &str) {
+        let Some(parts) = self.texts.get(&start).copied() else {
+            self.error(start, start + source.len() as u32, "can't split this text");
+            return;
+        };
+
+        for part in parts {
+            if part.dynamic {
+                let slot = EncodedTextSlot {
+                    kind: atoms::text(),
+                    value: part.text.to_string(),
+                    position: self.position(part.span.start),
+                }
+                .encode(self.env);
+                block.slot(slot);
+            } else {
+                block.push(&escape_text(&part.text));
+            }
+        }
+    }
+
+    fn text_slot(&mut self, expression: ExprRef<'_>) -> Term<'a> {
+        EncodedTextSlot {
+            kind: atoms::text(),
+            value: self.expression(expression),
+            position: self.position(expression.span().start),
+        }
+        .encode(self.env)
+    }
+
+    fn element(&mut self, block: &mut Block<'a>, element: &ElementOp<'_>, root: bool) {
+        block.push("<");
+        block.push(element.tag);
+
+        let bound = bound_names(&element.bindings);
+        let show = element.bindings.iter().find_map(|binding| match binding {
+            BindingOp::VueShow(show) => Some(show.value),
+            _ => None,
+        });
+
+        if root {
+            let slot = self.root_attrs(element, show);
+            block.slot(slot);
+        } else {
+            self.attributes(block, element, &bound, show);
+        }
+
+        let mut content = None;
+
+        for binding in element.bindings.iter() {
+            match binding {
+                BindingOp::On(on) => {
+                    let binding = EncodedSplitBinding {
+                        kind: atoms::on(),
+                        name: on.name.and_then(static_name),
+                        modifiers: on.modifiers.iter().map(ToString::to_string).collect(),
+                        value: on.handler.map(|handler| self.expression(handler)),
+                        at: block.at(),
+                        position: self.position(on.span.start),
+                    };
+                    block.bindings.push(binding);
+                }
+                BindingOp::Model(model) => {
+                    let value = self.expression(model.contract.read);
+                    block.bindings.push(EncodedSplitBinding {
+                        kind: atoms::model(),
+                        name: model.argument.and_then(static_name),
+                        modifiers: Vec::new(),
+                        value: Some(value),
+                        at: block.at(),
+                        position: self.position(model.span.start),
+                    });
+
+                    let slot = self.model_slot(element, model);
+                    if element.tag.eq_ignore_ascii_case("textarea") {
+                        content = Some(slot);
+                    } else if element.tag.eq_ignore_ascii_case("input") {
+                        block.slot(slot);
+                    } else {
+                        self.warning(model.span.start, model.span.end, "v-model only renders its value on <input> and <textarea> on the server");
+                    }
+                }
+                BindingOp::VueHtml(html) => {
+                    content = html.value.map(|value| {
+                        EncodedHtmlSlot {
+                            kind: atoms::html(),
+                            value: self.expression(value),
+                            position: self.position(html.span.start),
+                        }
+                        .encode(self.env)
+                    });
+                }
+                BindingOp::VueText(text) => {
+                    content = text.value.map(|value| self.text_slot(value));
+                }
+                BindingOp::VueDirective(directive) => {
+                    let message = format!(
+                        "the custom directive v-{} doesn't run on the server",
+                        directive.name
+                    );
+                    self.warning(directive.span.start, directive.span.end, &message);
+                }
+                BindingOp::SlotContent(slot) => {
+                    self.error(
+                        slot.span.start,
+                        slot.span.end,
+                        "slot content must be passed to a component",
+                    );
+                }
+                BindingOp::VueSync(sync) => {
+                    self.error(sync.span.start, sync.span.end, ".sync is Vue 2 syntax");
+                }
+                BindingOp::VueSlotScope(scope) => {
+                    self.error(
+                        scope.span.start,
+                        scope.span.end,
+                        "slot-scope is Vue 2 syntax",
+                    );
+                }
+                BindingOp::Bind(_)
+                | BindingOp::VueShow(_)
+                | BindingOp::VueCssBind(_)
+                | BindingOp::VueOnce(_)
+                | BindingOp::VueMemo(_)
+                | BindingOp::VueCloak(_) => {}
+            }
+        }
+
+        block.push(">");
+
+        if is_void_tag(element.tag) {
+            return;
+        }
+
+        match content {
+            Some(slot) => block.slot(slot),
+            None => {
+                for op in element.children.ops.iter() {
+                    self.op(block, op);
+                }
+            }
+        }
+
+        block.push("</");
+        block.push(element.tag);
+        block.push(">");
+    }
+
+    /// Static attributes print as HTML. Each binding is an `:attr` slot, which
+    /// takes in a static attribute of the same name, so `class="a"` and
+    /// `:class="b"` render as one attribute.
+    fn attributes(
+        &mut self,
+        block: &mut Block<'a>,
+        element: &ElementOp<'_>,
+        bound: &[&str],
+        show: Option<ExprRef<'_>>,
+    ) {
+        let has_style = bound.contains(&"style");
+
+        for attribute in element.attributes.iter() {
+            let merged =
+                bound.contains(&attribute.name) || (attribute.name == "style" && show.is_some());
+            if !merged {
+                block.push(&static_attribute(attribute));
+            }
+        }
+
+        for binding in element.bindings.iter() {
+            let BindingOp::Bind(bind) = binding else {
+                continue;
+            };
+
+            let slot = match bind.name {
+                Some(DynamicName::Static("key")) => continue,
+                Some(DynamicName::Static(name)) => self.attr_slot(
+                    Some(name),
+                    None,
+                    static_value(&element.attributes, name),
+                    bind,
+                    if name == "style" { show } else { None },
+                ),
+                Some(DynamicName::Dynamic(name)) => {
+                    self.attr_slot(None, Some(name), None, bind, None)
+                }
+                None => match bind.value {
+                    Some(value) => EncodedSpreadSlot {
+                        kind: atoms::spread(),
+                        value: self.expression(value),
+                        position: self.position(bind.span.start),
+                    }
+                    .encode(self.env),
+                    None => continue,
+                },
+            };
+            block.slot(slot);
+        }
+
+        if let (Some(show), false) = (show, has_style) {
+            let slot = EncodedAttrSlot {
+                kind: atoms::attr(),
+                name: Some("style".to_string()),
+                name_value: None,
+                r#static: static_value(&element.attributes, "style"),
+                value: None,
+                show: Some(self.expression(show)),
+                position: self.position(show.span().start),
+            }
+            .encode(self.env);
+            block.slot(slot);
+        }
+    }
+
+    fn attr_slot(
+        &mut self,
+        name: Option<&str>,
+        name_value: Option<ExprRef<'_>>,
+        static_value: Option<String>,
+        bind: &BindOp<'_>,
+        show: Option<ExprRef<'_>>,
+    ) -> Term<'a> {
+        EncodedAttrSlot {
+            kind: atoms::attr(),
+            name: name.map(ToString::to_string),
+            name_value: name_value.map(|name| self.expression(name)),
+            r#static: static_value,
+            value: bind.value.map(|value| self.expression(value)),
+            show: show.map(|show| self.expression(show)),
+            position: self.position(bind.span.start),
+        }
+        .encode(self.env)
+    }
+
+    fn root_attrs(&mut self, element: &ElementOp<'_>, show: Option<ExprRef<'_>>) -> Term<'a> {
+        let props = self.props(&element.attributes, &element.bindings);
+        EncodedRootAttrsSlot {
+            kind: atoms::root_attrs(),
+            props,
+            show: show.map(|show| self.expression(show)),
+            position: self.position(element.span.start),
+        }
+        .encode(self.env)
+    }
+
+    /// Static attributes and bindings as props, in authored order. A static
+    /// attribute that a binding of the same name also sets is folded into it.
+    fn props(
+        &mut self,
+        attributes: &[Attribute<'_>],
+        bindings: &[BindingOp<'_>],
+    ) -> Vec<EncodedProp> {
+        let bound = bound_names(bindings);
+
+        let statics = attributes
+            .iter()
+            .filter(|attribute| !bound.contains(&attribute.name))
+            .map(|attribute| (attribute.span.start, static_prop(attribute)));
+
+        let binds: Vec<_> = bindings
+            .iter()
+            .filter_map(|binding| match binding {
+                BindingOp::Bind(bind) if !matches!(bind.name, Some(DynamicName::Static("key"))) => {
+                    Some(bind)
+                }
+                _ => None,
+            })
+            .map(|bind| (bind.span.start, self.bind_prop(attributes, bind)))
+            .collect();
+
+        let mut props: Vec<_> = statics.chain(binds).collect();
+        props.sort_by_key(|(start, _prop)| *start);
+        props.into_iter().map(|(_start, prop)| prop).collect()
+    }
+
+    fn bind_prop(&mut self, attributes: &[Attribute<'_>], bind: &BindOp<'_>) -> EncodedProp {
+        let (name, name_value) = match bind.name {
+            Some(DynamicName::Static(name)) => (Some(name.to_string()), None),
+            Some(DynamicName::Dynamic(name)) => (None, Some(self.expression(name))),
+            None => (None, None),
+        };
+
+        EncodedProp {
+            r#static: name
+                .as_deref()
+                .and_then(|name| static_value(attributes, name)),
+            name,
+            name_value,
+            value: bind.value.map(|value| self.expression(value)),
+        }
+    }
+
+    fn model_slot(&mut self, element: &ElementOp<'_>, model: &ModelOp<'_>) -> Term<'a> {
+        EncodedModelSlot {
+            kind: atoms::model(),
+            tag: element.tag.to_string(),
+            r#type: static_value(&element.attributes, "type"),
+            static_value: static_value(&element.attributes, "value"),
+            value: self.expression(model.contract.read),
+            position: self.position(model.span.start),
+        }
+        .encode(self.env)
+    }
+
+    fn component(&mut self, component: &ComponentOp<'_>) -> Term<'a> {
+        let mut props = self.props(&component.attributes, &component.bindings);
+        let mut events = Vec::new();
+        let mut own_slot = None;
+
+        for binding in component.bindings.iter() {
+            match binding {
+                BindingOp::On(on) => events.push(EncodedEvent {
+                    name: on.name.and_then(static_name),
+                    modifiers: on.modifiers.iter().map(ToString::to_string).collect(),
+                    value: on.handler.map(|handler| self.expression(handler)),
+                }),
+                // `v-model` on a component is a prop and its update event.
+                BindingOp::Model(model) => {
+                    let name = model
+                        .argument
+                        .and_then(static_name)
+                        .unwrap_or_else(|| "modelValue".to_string());
+                    props.push(EncodedProp {
+                        name: Some(name.clone()),
+                        name_value: None,
+                        r#static: None,
+                        value: Some(self.expression(model.contract.read)),
+                    });
+                    events.push(EncodedEvent {
+                        name: Some(format!("update:{name}")),
+                        modifiers: Vec::new(),
+                        value: Some(self.expression(model.contract.write)),
+                    });
+                }
+                BindingOp::SlotContent(slot) => own_slot = Some(slot),
+                BindingOp::Bind(_) => {}
+                other => {
+                    let span = binding_span(other);
+                    self.warning(
+                        span.0,
+                        span.1,
+                        "this directive isn't applied to a component on the server",
+                    );
+                }
+            }
+        }
+
+        let slots = match own_slot {
+            // `<List v-slot="{ item }">`: the children are the default slot.
+            Some(slot) => vec![EncodedSlotContent {
+                name: slot
+                    .name
+                    .and_then(static_name)
+                    .or_else(|| Some("default".to_string())),
+                name_value: None,
+                params: slot.params.map(|params| self.expression(params)),
+                block: self.region(&component.children),
+            }],
+            None => self.slot_contents(&component.children),
+        };
+
+        EncodedComponentSlot {
+            kind: atoms::component(),
+            name: component.name.to_string(),
+            props,
+            events,
+            slots,
+            position: self.position(component.span.start),
+        }
+        .encode(self.env)
+    }
+
+    /// A component's children: `<template #name>` elements are named slots, and
+    /// everything else is the default slot.
+    fn slot_contents(&mut self, children: &Region<'_>) -> Vec<EncodedSlotContent<'a>> {
+        let mut named = Vec::new();
+        let mut default = Block::default();
+        let mut has_default = false;
+
+        for op in children.ops.iter() {
+            match op {
+                Op::Element(element) if element.tag == "template" => {
+                    match element.bindings.iter().find_map(|binding| match binding {
+                        BindingOp::SlotContent(slot) => Some(slot),
+                        _ => None,
+                    }) {
+                        Some(slot) => {
+                            let (name, name_value) = match slot.name {
+                                Some(DynamicName::Static(name)) => (Some(name.to_string()), None),
+                                Some(DynamicName::Dynamic(name)) => {
+                                    (None, Some(self.expression(name)))
+                                }
+                                None => (Some("default".to_string()), None),
+                            };
+                            named.push(EncodedSlotContent {
+                                name,
+                                name_value,
+                                params: slot.params.map(|params| self.expression(params)),
+                                block: self.region(&element.children),
+                            });
+                        }
+                        None => {
+                            has_default = true;
+                            self.op(&mut default, op);
+                        }
+                    }
+                }
+                Op::If(if_op)
+                    if if_op
+                        .branches
+                        .iter()
+                        .any(|branch| has_slot_template(&branch.region)) =>
+                {
+                    self.error(
+                        if_op.span.start,
+                        if_op.span.end,
+                        "conditional slots aren't supported on the server yet",
+                    );
+                }
+                Op::For(for_op) if has_slot_template(&for_op.region) => {
+                    self.error(
+                        for_op.span.start,
+                        for_op.span.end,
+                        "slots from v-for aren't supported on the server yet",
+                    );
+                }
+                Op::Text(text) if text.content.trim().is_empty() => {
+                    default.push(&escape_text(text.content))
+                }
+                Op::Comment(_) => {}
+                _ => {
+                    has_default = true;
+                    self.op(&mut default, op);
+                }
+            }
+        }
+
+        if has_default {
+            named.push(EncodedSlotContent {
+                name: Some("default".to_string()),
+                name_value: None,
+                params: None,
+                block: default.finish(),
+            });
+        }
+
+        named
+    }
+
+    fn slot_outlet(&mut self, outlet: &SlotOp<'_>) -> Term<'a> {
+        let (name, name_value) = match outlet.name {
+            DynamicName::Static(name) => (Some(name.to_string()), None),
+            DynamicName::Dynamic(name) => (None, Some(self.expression(name))),
+        };
+
+        let fallback = if outlet.fallback.ops.is_empty() {
+            None
+        } else {
+            Some(self.region(&outlet.fallback))
+        };
+
+        EncodedSlotOutlet {
+            kind: atoms::slot(),
+            name,
+            name_value,
+            props: self.props(&outlet.attributes, &outlet.bindings),
+            fallback,
+            position: self.position(outlet.span.start),
+        }
+        .encode(self.env)
+    }
+
+    fn if_slot(&mut self, if_op: &IfOp<'_>) -> Term<'a> {
+        let branches = if_op
+            .branches
+            .iter()
+            .map(|branch| EncodedIfBranch {
+                condition: branch.condition.map(|condition| self.expression(condition)),
+                block: self.region(&branch.region),
+            })
+            .collect();
+
+        EncodedIfSlot {
+            kind: atoms::r#if(),
+            branches,
+            position: self.position(if_op.span.start),
+        }
+        .encode(self.env)
+    }
+
+    fn for_slot(&mut self, for_op: &ForOp<'_>) -> Term<'a> {
+        let binding = for_op.binding;
+        let key_prop = loop_key(&for_op.region).map(|key| self.expression(key));
+
+        EncodedForSlot {
+            kind: atoms::r#for(),
+            source: self.expression(binding.source),
+            value: self.expression(binding.value),
+            key: binding.key.map(|key| self.expression(key)),
+            index: binding.index.map(|index| self.expression(index)),
+            key_prop,
+            block: self.region(&for_op.region),
+            position: self.position(for_op.span.start),
+        }
+        .encode(self.env)
+    }
+
+    /// The expression's source. One Vize couldn't parse is reported, and its
+    /// source is returned anyway so splitting can go on to find more problems.
+    fn expression(&mut self, expression: ExprRef<'_>) -> String {
+        if let ExprRef::Opaque(opaque) = expression {
+            let message = format!("can't parse the expression `{}`", opaque.source.trim());
+            self.error(opaque.span.start, opaque.span.end, &message);
+        }
+        expression.source().trim().to_string()
+    }
+
+    fn position(&self, offset: u32) -> Position {
+        let (line, column) = self.lines.line_col(offset as usize);
+        (line as usize + 1, column as usize + 1)
+    }
+
+    fn encoded_position(&self, offset: u32) -> EncodedPosition {
+        let (line, column) = self.position(offset);
+        EncodedPosition {
+            offset,
+            line: line as u32,
+            column: column as u32,
+        }
+    }
+
+    fn error(&mut self, start: u32, end: u32, message: &str) {
+        self.diagnose(atoms::error(), start, end, message);
+    }
+
+    fn warning(&mut self, start: u32, end: u32, message: &str) {
+        self.diagnose(atoms::warning(), start, end, message);
+    }
+
+    fn diagnose(&mut self, severity: rustler::Atom, start: u32, end: u32, message: &str) {
+        let diagnostic = EncodedSplitDiagnostic {
+            severity,
+            message: message.to_string(),
+            start: self.encoded_position(start),
+            end: self.encoded_position(end),
+        };
+        self.diagnostics.push(diagnostic);
+    }
+}
+
+fn lowering_diagnostic(diagnostic: &Diagnostic, source: &str) -> Option<EncodedSplitDiagnostic> {
+    let severity = match diagnostic.severity() {
+        Severity::Error => atoms::error(),
+        Severity::Warning => atoms::warning(),
+        Severity::Info | Severity::Hint => return None,
+    };
+
+    let lines = LineIndex::new(source);
+    let position = |offset: u32| {
+        let (line, column) = lines.line_col(offset as usize);
+        EncodedPosition {
+            offset,
+            line: line + 1,
+            column: column + 1,
+        }
+    };
+
+    Some(EncodedSplitDiagnostic {
+        severity,
+        message: diagnostic.message.to_string(),
+        start: position(diagnostic.span.start),
+        end: position(diagnostic.span.end),
+    })
+}
+
+/// The names bindings set statically, such as `class` for `:class`.
+fn bound_names<'b>(bindings: &'b [BindingOp<'_>]) -> Vec<&'b str> {
+    bindings
+        .iter()
+        .filter_map(|binding| match binding {
+            BindingOp::Bind(bind) => match bind.name {
+                Some(DynamicName::Static(name)) => Some(name),
+                _ => None,
+            },
+            _ => None,
+        })
+        .collect()
+}
+
+fn static_name(name: DynamicName<'_>) -> Option<String> {
+    match name {
+        DynamicName::Static(name) => Some(name.to_string()),
+        DynamicName::Dynamic(_) => None,
+    }
+}
+
+fn static_value(attributes: &[Attribute<'_>], name: &str) -> Option<String> {
+    attributes
+        .iter()
+        .find(|attribute| attribute.name == name)
+        .map(|attribute| decode_html_attribute_entities(attribute.value.unwrap_or("")).to_string())
+}
+
+fn static_prop(attribute: &Attribute<'_>) -> EncodedProp {
+    EncodedProp {
+        name: Some(attribute.name.to_string()),
+        name_value: None,
+        r#static: Some(decode_html_attribute_entities(attribute.value.unwrap_or("")).to_string()),
+        value: None,
+    }
+}
+
+fn static_attribute(attribute: &Attribute<'_>) -> String {
+    match attribute.value {
+        Some(value) => {
+            let value = decode_html_attribute_entities(value);
+            format!(
+                " {}=\"{}\"",
+                attribute.name,
+                html_escape::encode_double_quoted_attribute(&value)
+            )
+        }
+        None => format!(" {}", attribute.name),
+    }
+}
+
+fn escape_text(raw: &str) -> String {
+    html_escape::encode_text(&decode_ssr_static_text(raw)).into_owned()
+}
+
+/// The `:key` of a `v-for`'s repeated element.
+fn loop_key<'r>(region: &'r Region<'r>) -> Option<ExprRef<'r>> {
+    let bindings = match region.ops.as_slice() {
+        [Op::Element(element)] => &element.bindings,
+        [Op::Component(component)] => &component.bindings,
+        _ => return None,
+    };
+
+    bindings.iter().find_map(|binding| match binding {
+        BindingOp::Bind(bind) if matches!(bind.name, Some(DynamicName::Static("key"))) => {
+            bind.value
+        }
+        _ => None,
+    })
+}
+
+fn has_slot_template(region: &Region<'_>) -> bool {
+    region.ops.iter().any(|op| match op {
+        Op::Element(element) => element
+            .bindings
+            .iter()
+            .any(|binding| matches!(binding, BindingOp::SlotContent(_))),
+        _ => false,
+    })
+}
+
+fn binding_span(binding: &BindingOp<'_>) -> (u32, u32) {
+    let span = match binding {
+        BindingOp::Bind(op) => op.span,
+        BindingOp::On(op) => op.span,
+        BindingOp::Model(op) => op.span,
+        BindingOp::SlotContent(op) => op.span,
+        BindingOp::VueDirective(op) => op.span,
+        BindingOp::VueCssBind(op) => op.span,
+        BindingOp::VueSync(op) => op.span,
+        BindingOp::VueSlotScope(op) => op.span,
+        BindingOp::VueOnce(op) => op.span,
+        BindingOp::VueMemo(op) => op.span,
+        BindingOp::VueShow(op) => op.span,
+        BindingOp::VueHtml(op) => op.span,
+        BindingOp::VueText(op) => op.span,
+        BindingOp::VueCloak(op) => op.span,
+    };
+    (span.start, span.end)
+}
diff --git a/native/vize_ex_nif/src/vapor_split.rs b/native/vize_ex_nif/src/vapor_split.rs
deleted file mode 100644
index 2ad9ad7..0000000
--- a/native/vize_ex_nif/src/vapor_split.rs
+++ /dev/null
@@ -1,634 +0,0 @@
-use rustler::{Atom, Encoder, Env, Term};
-use vize_atelier_vapor::ir::*;
-
-use crate::atoms;
-use crate::html_inject::{
-    build_elem_to_tag, inject_attr, inject_before_close, parse_tag_tree,
-    replace_first_space_in_content, replace_range, replace_text_node, TagEntry,
-};
-use crate::ir_encoders::{encode_directive_ir_node, encode_ir_prop, encode_set_event_ir_node};
-use crate::ir_encoding::encode_simple_expr;
-use crate::term_encoding::{
-    EncodedComponentSlot, EncodedForSlot, EncodedIfSlot, EncodedSplitBinding, EncodedSplitBlock,
-    EncodedValueSlot, EncodedValuesSlot,
-};
-
-fn encode_slot_values<'a>(env: Env<'a>, kind: Atom, values: Vec<Term<'a>>) -> Term<'a> {
-    EncodedValuesSlot { kind, values }.encode(env)
-}
-
-fn encode_slot_value<'a>(
-    env: Env<'a>,
-    kind: Atom,
-    expr: &vize_atelier_core::SimpleExpressionNode,
-) -> Term<'a> {
-    EncodedValueSlot {
-        kind,
-        value: encode_simple_expr(env, expr),
-    }
-    .encode(env)
-}
-
-fn split_block<'a, 'b>(
-    env: Env<'a>,
-    block: &'b BlockIRNode<'b>,
-    ir: &'b RootIRNode<'b>,
-    source: &str,
-) -> Result<EncodedSplitBlock<'a>, String> {
-    let (statics, slots, bindings) = process_block(env, block, ir, source)?;
-    Ok(EncodedSplitBlock {
-        statics,
-        slots,
-        bindings,
-    })
-}
-
-fn encode_slot_if_split<'a, 'b>(
-    env: Env<'a>,
-    if_node: &'b IfIRNode<'b>,
-    ir: &'b RootIRNode<'b>,
-    source: &str,
-) -> Result<Term<'a>, String> {
-    let negative = match &if_node.negative {
-        Some(NegativeBranch::Block(block)) => {
-            Some(split_block(env, block, ir, source)?.encode(env))
-        }
-        Some(NegativeBranch::If(nested)) => Some(encode_slot_if_split(env, nested, ir, source)?),
-        None => None,
-    };
-
-    Ok(EncodedIfSlot {
-        kind: atoms::if_node(),
-        condition: encode_simple_expr(env, &if_node.condition),
-        positive: split_block(env, &if_node.positive, ir, source)?,
-        negative,
-    }
-    .encode(env))
-}
-
-fn encode_slot_for_split<'a, 'b>(
-    env: Env<'a>,
-    for_node: &'b ForIRNode<'b>,
-    ir: &'b RootIRNode<'b>,
-    source: &str,
-) -> Result<Term<'a>, String> {
-    Ok(EncodedForSlot {
-        kind: atoms::for_node(),
-        source: encode_simple_expr(env, &for_node.source),
-        value: for_node
-            .value
-            .as_ref()
-            .map(|value| encode_simple_expr(env, value)),
-        key_prop: for_node
-            .key_prop
-            .as_ref()
-            .map(|key_prop| encode_simple_expr(env, key_prop)),
-        render: split_block(env, &for_node.render, ir, source)?,
-    }
-    .encode(env))
-}
-
-fn encode_slot_component<'a>(env: Env<'a>, node: &CreateComponentIRNode) -> Term<'a> {
-    let kind = match node.kind {
-        ComponentKind::Regular => atoms::regular(),
-        ComponentKind::Teleport => atoms::teleport(),
-        ComponentKind::KeepAlive => atoms::keep_alive(),
-        ComponentKind::Suspense => atoms::suspense(),
-        ComponentKind::Transition => atoms::transition(),
-        ComponentKind::TransitionGroup => atoms::transition_group(),
-        ComponentKind::Dynamic => atoms::dynamic(),
-    };
-
-    EncodedComponentSlot {
-        kind: atoms::create_component(),
-        tag: node.tag.to_string(),
-        props: node
-            .props
-            .iter()
-            .map(|prop| encode_ir_prop(env, prop))
-            .collect(),
-        value: kind,
-    }
-    .encode(env)
-}
-
-const SLOT_MARKER_PREFIX: &str = "\0VIZE_SLOT_";
-const BINDING_MARKER_PREFIX: &str = "\0VIZE_BINDING_";
-const SLOT_MARKER_SUFFIX: char = '\0';
-
-struct SlotMarker<'a> {
-    term: Option<Term<'a>>,
-    source_offset: u32,
-}
-
-/// The text node Vapor bakes into its template for a `setText` target: static
-/// parts verbatim and a single space in place of each dynamic value.
-fn text_node_template<'b>(
-    values: impl IntoIterator<Item = &'b vize_atelier_core::SimpleExpressionNode<'b>>,
-) -> String {
-    values
-        .into_iter()
-        .map(|value| if value.is_static { value.content } else { " " })
-        .collect()
-}
-
-/// Only a `Node` anchor points at a `<!---->` placeholder; `Index` appends.
-fn placeholder_anchor(anchor: Option<InsertionAnchor>) -> Option<usize> {
-    match anchor {
-        Some(InsertionAnchor::Node(id)) => Some(id),
-        Some(InsertionAnchor::Index(_)) | None => None,
-    }
-}
-
-fn slot_marker(index: usize) -> String {
-    format!("{SLOT_MARKER_PREFIX}{index}{SLOT_MARKER_SUFFIX}")
-}
-
-// Marks where an element's start tag ends, for an event or v-model the split
-// reports as a binding instead of rendering.
-fn push_binding_marker<'a>(
-    bindings: &mut Vec<(Atom, Term<'a>)>,
-    kind: Atom,
-    node: Term<'a>,
-) -> String {
-    let index = bindings.len();
-    bindings.push((kind, node));
-    format!("{BINDING_MARKER_PREFIX}{index}{SLOT_MARKER_SUFFIX}")
-}
-
-fn push_slot_marker<'a>(
-    slots: &mut Vec<SlotMarker<'a>>,
-    slot: Term<'a>,
-    source_offset: u32,
-) -> String {
-    let index = slots.len();
-    slots.push(SlotMarker {
-        term: Some(slot),
-        source_offset,
-    });
-    slot_marker(index)
-}
-
-fn source_tag_at_offset(tags: &[TagEntry], offset: u32) -> Option<usize> {
-    let offset = offset as usize;
-    tags.iter()
-        .filter(|tag| tag.open_start <= offset && offset < tag.open_end)
-        .max_by_key(|tag| tag.open_start)
-        .map(|tag| tag.pos)
-}
-
-fn structural_source_tags(
-    block: &BlockIRNode<'_>,
-    source_tags: &[TagEntry],
-) -> std::collections::HashSet<usize> {
-    let roots: std::collections::HashSet<usize> = block
-        .operation
-        .iter()
-        .filter_map(|operation| match operation {
-            OperationNode::If(node) => {
-                source_tag_at_offset(source_tags, node.condition.loc.span.start)
-            }
-            OperationNode::For(node) => {
-                source_tag_at_offset(source_tags, node.source.loc.span.start)
-            }
-            _ => None,
-        })
-        .collect();
-
-    source_tags
-        .iter()
-        .filter(|tag| {
-            let mut current = Some(tag.pos);
-            while let Some(pos) = current {
-                if roots.contains(&pos) {
-                    return true;
-                }
-                current = source_tags.get(pos).and_then(|entry| entry.parent);
-            }
-            false
-        })
-        .map(|tag| tag.pos)
-        .collect()
-}
-
-fn align_tag_source_offsets(
-    rendered_tags: &[TagEntry],
-    source: &str,
-    block: &BlockIRNode<'_>,
-) -> Vec<Option<u32>> {
-    let source_tags = parse_tag_tree(source);
-    let excluded = structural_source_tags(block, &source_tags);
-    let mut cursor = 0usize;
-
-    rendered_tags
-        .iter()
-        .map(|rendered| {
-            if rendered.is_anchor() {
-                return None;
-            }
-            let match_pos = source_tags[cursor..]
-                .iter()
-                .position(|source_tag| {
-                    !excluded.contains(&source_tag.pos)
-                        && !source_tag.is_anchor()
-                        && source_tag.tag.eq_ignore_ascii_case(&rendered.tag)
-                })
-                .map(|relative| cursor + relative);
-
-            match_pos.map(|pos| {
-                cursor = pos + 1;
-                source_tags[pos].open_start as u32
-            })
-        })
-        .collect()
-}
-
-fn inject_structural_marker(
-    html: &mut String,
-    tags: &mut [TagEntry],
-    elem_to_tag: &std::collections::HashMap<usize, usize>,
-    insertion: (Option<usize>, Option<usize>),
-    marker: &str,
-    source_position: (&[Option<u32>], u32),
-    slots: &[SlotMarker<'_>],
-) {
-    let (parent, anchor) = insertion;
-    let (tag_source_offsets, source_offset) = source_position;
-    if let Some(anchor_pos) = anchor.and_then(|id| elem_to_tag.get(&id)).copied() {
-        if let Some(entry) = tags.get(anchor_pos) {
-            // The marker takes the place of Vapor's own anchor comment.
-            let anchor_len = if entry.is_anchor() {
-                entry.open_end - entry.open_start
-            } else {
-                0
-            };
-            replace_range(html, tags, entry.open_start, anchor_len, marker);
-            return;
-        }
-    }
-
-    let bounds = parent
-        .and_then(|id| elem_to_tag.get(&id))
-        .and_then(|&tag_pos| tags.get(tag_pos))
-        .map(|entry| (entry.open_end, entry.close_start.unwrap_or(entry.open_end)));
-
-    let next_tag_position = tags
-        .iter()
-        .zip(tag_source_offsets)
-        .filter(|(tag, offset)| {
-            offset.is_some_and(|offset| offset > source_offset)
-                && bounds
-                    .map(|(start, end)| tag.open_start >= start && tag.open_start <= end)
-                    .unwrap_or(true)
-        })
-        .map(|(tag, _)| tag.open_start)
-        .min();
-
-    let next_marker_position = slots
-        .iter()
-        .enumerate()
-        .filter(|(_, slot)| slot.source_offset > source_offset)
-        .filter_map(|(index, _)| html.find(&slot_marker(index)))
-        .filter(|position| {
-            bounds
-                .map(|(start, end)| *position >= start && *position <= end)
-                .unwrap_or(true)
-        })
-        .min();
-
-    if let Some(position) = [next_tag_position, next_marker_position]
-        .into_iter()
-        .flatten()
-        .min()
-    {
-        replace_range(html, tags, position, 0, marker);
-    } else if let Some(parent_id) = parent {
-        if let Some(&tag_pos) = elem_to_tag.get(&parent_id) {
-            inject_before_close(html, tags, tag_pos, marker);
-        }
-    } else {
-        html.push_str(marker);
-    }
-}
-
-// Splits the HTML at slot markers into statics, and turns binding markers into
-// `{static_index, byte_offset}` positions in those statics.
-fn split_on_markers<'a>(
-    html: &str,
-    mut slots: Vec<SlotMarker<'a>>,
-    binding_nodes: Vec<(Atom, Term<'a>)>,
-) -> (Vec<String>, Vec<Term<'a>>, Vec<EncodedSplitBinding<'a>>) {
-    let unsplit = || (vec![html.to_string()], Vec::new(), Vec::new());
-    let mut statics = Vec::new();
-    let mut ordered_slots = Vec::new();
-    let mut bindings: Vec<(usize, (usize, usize))> = Vec::new();
-    let mut current = String::new();
-    let mut rest = html;
-
-    loop {
-        let next_slot = rest
-            .find(SLOT_MARKER_PREFIX)
-            .map(|p| (p, SLOT_MARKER_PREFIX));
-        let next_binding = rest
-            .find(BINDING_MARKER_PREFIX)
-            .map(|p| (p, BINDING_MARKER_PREFIX));
-
-        let Some((position, prefix)) = [next_slot, next_binding]
-            .into_iter()
-            .flatten()
-            .min_by_key(|(position, _)| *position)
-        else {
-            break;
-        };
-
-        current.push_str(&rest[..position]);
-
-        let marker_body = &rest[position + prefix.len()..];
-        let Some(suffix_position) = marker_body.find(SLOT_MARKER_SUFFIX) else {
-            return unsplit();
-        };
-        let Ok(index) = marker_body[..suffix_position].parse::<usize>() else {
-            return unsplit();
-        };
-
-        if prefix == SLOT_MARKER_PREFIX {
-            let Some(slot) = slots.get_mut(index).and_then(|slot| slot.term.take()) else {
-                return unsplit();
-            };
-            ordered_slots.push(slot);
-            statics.push(std::mem::take(&mut current));
-        } else {
-            bindings.push((index, (statics.len(), current.len())));
-        }
-
-        rest = &marker_body[suffix_position + SLOT_MARKER_SUFFIX.len_utf8()..];
-    }
-
-    current.push_str(rest);
-    statics.push(current);
-
-    let bindings = bindings
-        .into_iter()
-        .map(|(index, at)| {
-            let (kind, node) = binding_nodes[index];
-            EncodedSplitBinding { kind, node, at }
-        })
-        .collect();
-
-    (statics, ordered_slots, bindings)
-}
-
-type SplitResult<'a> = Result<(Vec<String>, Vec<Term<'a>>, Vec<EncodedSplitBinding<'a>>), String>;
-
-pub(crate) fn process_block<'a, 'b>(
-    env: Env<'a>,
-    block: &'b BlockIRNode<'b>,
-    ir: &'b RootIRNode<'b>,
-    source: &str,
-) -> SplitResult<'a> {
-    let template_html: String = block
-        .returns
-        .iter()
-        .map(|&elem_id| {
-            let template_idx = ir
-                .element_template_map
-                .get(&elem_id)
-                .copied()
-                .unwrap_or(elem_id);
-            ir.templates.get(template_idx).copied().unwrap_or("")
-        })
-        .collect();
-
-    let mut html = template_html;
-    let mut tags = parse_tag_tree(&html);
-    let tag_source_offsets = align_tag_source_offsets(&tags, source, block);
-    let mut elem_to_tag = build_elem_to_tag(&block.returns, &block.operation, &tags);
-    let mut slots: Vec<SlotMarker<'a>> = Vec::new();
-
-    let mut binding_nodes: Vec<(Atom, Term<'a>)> = Vec::new();
-
-    for op in &block.operation {
-        if let OperationNode::SetEvent(event) = op {
-            if let Some(&tag_pos) = elem_to_tag.get(&event.element) {
-                let marker = push_binding_marker(
-                    &mut binding_nodes,
-                    atoms::set_event(),
-                    encode_set_event_ir_node(env, event),
-                );
-                inject_attr(&mut html, &mut tags, tag_pos, &marker);
-            }
-        }
-    }
-
-    let all_effects: Vec<_> = block
-        .effect
-        .iter()
-        .flat_map(|effect| effect.operations.iter())
-        .collect();
-
-    let mut prop_effects = Vec::new();
-    let mut text_effects = Vec::new();
-    let mut html_effects = Vec::new();
-
-    for operation in &all_effects {
-        match operation {
-            OperationNode::SetProp(prop) => prop_effects.push(prop),
-            OperationNode::SetText(text) => text_effects.push(text),
-            OperationNode::SetHtml(html_node) => html_effects.push(html_node),
-            _ => {}
-        }
-    }
-
-    for element in text_effects
-        .iter()
-        .map(|text| text.element)
-        .chain(html_effects.iter().map(|html| html.element))
-    {
-        if elem_to_tag.contains_key(&element) {
-            continue;
-        }
-        if let Some(parent_tag) = block
-            .operation
-            .iter()
-            .find_map(|operation| match operation {
-                OperationNode::ChildRef(child) if child.child_id == element => {
-                    elem_to_tag.get(&child.parent_id).copied()
-                }
-                _ => None,
-            })
-        {
-            elem_to_tag.insert(element, parent_tag);
-        }
-    }
-
-    // A slot whose element can't be located would silently disappear from the
-    // output, so fail instead.
-    let bound_elements = block
-        .operation
-        .iter()
-        .filter_map(|operation| match operation {
-            OperationNode::SetEvent(event) => Some(event.element),
-            OperationNode::Directive(dir) if matches!(dir.name, "model" | "show") => {
-                Some(dir.element)
-            }
-            _ => None,
-        });
-    if let Some(element) = text_effects
-        .iter()
-        .map(|text| text.element)
-        .chain(html_effects.iter().map(|html| html.element))
-        .chain(prop_effects.iter().map(|prop| prop.element))
-        .chain(bound_elements)
-        .find(|element| !elem_to_tag.contains_key(element))
-    {
-        return Err(format!(
-            "vapor_split could not locate element {element} in the template"
-        ));
-    }
-
-    for prop in &prop_effects {
-        if let Some(&tag_pos) = elem_to_tag.get(&prop.element) {
-            let values: Vec<Term<'a>> = prop
-                .prop
-                .values
-                .iter()
-                .map(|value| encode_simple_expr(env, value))
-                .collect();
-            let slot = encode_slot_values(env, atoms::set_prop(), values);
-            let source_offset = prop
-                .prop
-                .values
-                .first()
-                .map(|value| value.loc.span.start)
-                .unwrap_or(prop.prop.key.loc.span.start);
-            let marker = push_slot_marker(&mut slots, slot, source_offset);
-            let attr_name = prop.prop.key.content;
-            let attr = format!(" {attr_name}=\"{marker}\"");
-            inject_attr(&mut html, &mut tags, tag_pos, &attr);
-        }
-    }
-
-    for op in &block.operation {
-        if let OperationNode::Directive(dir) = op {
-            if let Some(&tag_pos) = elem_to_tag.get(&dir.element) {
-                match dir.name {
-                    "vShow" => {
-                        if let Some(vize_atelier_core::ExpressionNode::Simple(simple)) =
-                            &dir.dir.exp
-                        {
-                            let slot = encode_slot_value(env, atoms::v_show(), simple);
-                            let marker = push_slot_marker(&mut slots, slot, dir.dir.loc.span.start);
-                            let attr = format!(" style=\"{marker}\"");
-                            inject_attr(&mut html, &mut tags, tag_pos, &attr);
-                        }
-                    }
-                    "model" => {
-                        if let Some(vize_atelier_core::ExpressionNode::Simple(simple)) =
-                            &dir.dir.exp
-                        {
-                            let slot = encode_slot_value(env, atoms::v_model(), simple);
-                            let marker = push_slot_marker(&mut slots, slot, dir.dir.loc.span.start);
-                            let attr = format!(" value=\"{marker}\"");
-                            inject_attr(&mut html, &mut tags, tag_pos, &attr);
-                            let marker = push_binding_marker(
-                                &mut binding_nodes,
-                                atoms::directive(),
-                                encode_directive_ir_node(env, dir),
-                            );
-                            inject_attr(&mut html, &mut tags, tag_pos, &marker);
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    for text in &text_effects {
-        if let Some(&tag_pos) = elem_to_tag.get(&text.element) {
-            let values: Vec<Term<'a>> = text
-                .values
-                .iter()
-                .map(|value| encode_simple_expr(env, value))
-                .collect();
-            let slot = encode_slot_values(env, atoms::set_text(), values);
-            let source_offset = text
-                .values
-                .first()
-                .map(|value| value.loc.span.start)
-                .unwrap_or(u32::MAX);
-            let marker = push_slot_marker(&mut slots, slot, source_offset);
-            let template_text = text_node_template(text.values.iter().map(|value| &**value));
-            if !replace_text_node(&mut html, &mut tags, tag_pos, &template_text, &marker) {
-                replace_first_space_in_content(&mut html, &mut tags, tag_pos, &marker);
-            }
-        }
-    }
-
-    for html_effect in &html_effects {
-        if let Some(&tag_pos) = elem_to_tag.get(&html_effect.element) {
-            let slot = encode_slot_value(env, atoms::set_html(), &html_effect.value);
-            let marker = push_slot_marker(&mut slots, slot, html_effect.value.loc.span.start);
-            // `v-html` owns the element's content, which the template leaves empty.
-            if !replace_first_space_in_content(&mut html, &mut tags, tag_pos, &marker) {
-                inject_before_close(&mut html, &mut tags, tag_pos, &marker);
-            }
-        }
-    }
-
-    for operation in &block.operation {
-        match operation {
-            OperationNode::If(if_node) => {
-                let source_offset = if_node.condition.loc.span.start;
-                let slot = encode_slot_if_split(env, if_node, ir, source)?;
-                let marker = push_slot_marker(&mut slots, slot, source_offset);
-                inject_structural_marker(
-                    &mut html,
-                    &mut tags,
-                    &elem_to_tag,
-                    (if_node.parent, placeholder_anchor(if_node.anchor)),
-                    &marker,
-                    (&tag_source_offsets, source_offset),
-                    &slots,
-                );
-            }
-            OperationNode::For(for_node) => {
-                let source_offset = for_node.source.loc.span.start;
-                let slot = encode_slot_for_split(env, for_node, ir, source)?;
-                let marker = push_slot_marker(&mut slots, slot, source_offset);
-                inject_structural_marker(
-                    &mut html,
-                    &mut tags,
-                    &elem_to_tag,
-                    (for_node.parent, placeholder_anchor(for_node.anchor)),
-                    &marker,
-                    (&tag_source_offsets, source_offset),
-                    &slots,
-                );
-            }
-            OperationNode::CreateComponent(component) => {
-                let source_offset = component
-                    .props
-                    .iter()
-                    .flat_map(|prop| prop.values.iter())
-                    .map(|value| value.loc.span.start)
-                    .min()
-                    .unwrap_or(u32::MAX);
-                let slot = encode_slot_component(env, component);
-                let marker = push_slot_marker(&mut slots, slot, source_offset);
-                inject_structural_marker(
-                    &mut html,
-                    &mut tags,
-                    &elem_to_tag,
-                    (component.parent, placeholder_anchor(component.anchor)),
-                    &marker,
-                    (&tag_source_offsets, source_offset),
-                    &slots,
-                );
-            }
-            _ => {}
-        }
-    }
-
-    Ok(split_on_markers(&html, slots, binding_nodes))
-}
diff --git a/rustq.exs b/rustq.exs
index 80aaffa..ddb81ad 100644
--- a/rustq.exs
+++ b/rustq.exs
@@ -144,7 +144,7 @@ nifs = [
   compile_sass_nif: [],
   compile_css_nif: [attrs: [A.attr(:allow, [A.path([:clippy, :too_many_arguments])])]],
   bundle_css_nif: [],
-  vapor_split_nif: [],
+  split_template_nif: [],
   generate_dts_nif: []
 ]
 
@@ -161,7 +161,16 @@ source_atoms =
 
 atoms =
   (source_atoms ++ encoder_atoms ++ Vize.Codegen.Sfc.atoms() ++ Vize.Codegen.VaporIR.atoms())
-  |> Enum.uniq()
+  # A raw identifier such as `atoms::r#for()` names the atom `for`, which
+  # other sources declare as `{:for, "for"}`.
+  |> Enum.map(fn
+    "r#" <> name -> {"r#" <> name, name}
+    atom -> atom
+  end)
+  |> Enum.uniq_by(fn
+    {_ident, name} -> to_string(name)
+    name -> name
+  end)
   |> Enum.sort()
   |> Enum.map(fn
     "end_" -> {"end_", "end"}
diff --git a/test/vize/split_template_test.exs b/test/vize/split_template_test.exs
new file mode 100644
index 0000000..389cbeb
--- /dev/null
+++ b/test/vize/split_template_test.exs
@@ -0,0 +1,247 @@
+defmodule Vize.SplitTemplateTest do
+  use ExUnit.Case, async: true
+
+  defp split(template, opts \\ []), do: Vize.split_template!(template, opts)
+  defp kinds(%{slots: slots}), do: Enum.map(slots, & &1.kind)
+
+  describe "static content" do
+    test "is one static" do
+      assert split(~S|<div class="a"><p>Hello</p><br></div>|).statics ==
+               [~S|<div class="a"><p>Hello</p><br></div>|]
+    end
+
+    test "decodes entities once and escapes them again" do
+      assert split(~S|<p title="a &amp; b &lt;c&gt;">x &lt; y &amp;&amp; z</p>|).statics ==
+               [~S|<p title="a &amp; b &lt;c&gt;">x &lt; y &amp;&amp; z</p>|]
+    end
+
+    test "closes self-closing elements that aren't void" do
+      assert split(~S|<div><span /><input /></div>|).statics == [
+               "<div><span></span><input></div>"
+             ]
+    end
+  end
+
+  describe "text" do
+    test "an interpolation is a text slot" do
+      result = split(~S|<p>{{ name }}</p>|)
+
+      assert result.statics == ["<p>", "</p>"]
+      assert [%{kind: :text, value: "name", position: {1, 7}}] = result.slots
+    end
+
+    test "static text around interpolations stays in the statics" do
+      result = split(~S|<p>Hi {{ first }} {{ last }}!</p>|)
+
+      assert result.statics == ["<p>Hi ", " ", "!</p>"]
+      assert Enum.map(result.slots, & &1.value) == ["first", "last"]
+    end
+
+    test "v-html and v-text replace the element's content" do
+      result = split(~S|<div v-html="raw"></div><p v-text="msg"></p>|)
+
+      assert result.statics == ["<div>", "</div><p>", "</p>"]
+      assert kinds(result) == [:html, :text]
+    end
+  end
+
+  describe "attributes" do
+    test "a binding is an attribute slot, rendered whole" do
+      result = split(~S|<a :href="url" title="t">x</a>|)
+
+      assert result.statics == [~S|<a title="t"|, ">x</a>"]
+      assert [%{kind: :attr, name: "href", value: "url", static: nil}] = result.slots
+    end
+
+    test "takes in a static attribute of the same name" do
+      result = split(~S|<p class="a" :class="{ on: active }">x</p>|)
+
+      assert result.statics == ["<p", ">x</p>"]
+      assert [%{name: "class", static: "a", value: "{ on: active }"}] = result.slots
+    end
+
+    test "v-show combines with the style" do
+      assert [%{name: "style", static: "color: red", value: nil, show: "visible"}] =
+               split(~S|<p style="color: red" v-show="visible">x</p>|).slots
+    end
+
+    test "dynamic names and v-bind objects" do
+      result = split(~S|<p :[name]="v" v-bind="attrs">x</p>|)
+
+      assert [
+               %{kind: :attr, name: nil, name_value: "name", value: "v"},
+               %{kind: :spread, value: "attrs"}
+             ] =
+               result.slots
+    end
+
+    test ":key isn't rendered" do
+      assert split(~S|<p :key="id">x</p>|).slots == []
+    end
+  end
+
+  describe "bindings" do
+    test "events are reported where the element's start tag ends" do
+      result = split(~S|<button class="b" @click.prevent="save">Save</button>|)
+
+      assert [%{kind: :on, name: "click", modifiers: ["prevent"], value: "save", at: {0, offset}}] =
+               result.bindings
+
+      assert binary_part(hd(result.statics), 0, offset) == ~S|<button class="b"|
+    end
+
+    test "v-model on an input is a binding and a slot for its value" do
+      result = split(~S|<input type="checkbox" value="a" v-model="picked">|)
+
+      assert [%{kind: :model, value: "picked"}] = result.bindings
+
+      assert [%{kind: :model, tag: "input", type: "checkbox", static_value: "a", value: "picked"}] =
+               result.slots
+    end
+
+    test "v-model on a textarea renders its content" do
+      result = split(~S|<textarea v-model="body"></textarea>|)
+
+      assert result.statics == ["<textarea>", "</textarea>"]
+      assert [%{kind: :model, tag: "textarea"}] = result.slots
+    end
+  end
+
+  describe "structure" do
+    test "v-if branches are blocks" do
+      result =
+        split(~S|<div><p v-if="a">A {{ x }}</p><p v-else-if="b">B</p><p v-else>C</p></div>|)
+
+      assert [%{kind: :if, branches: [first, second, third]}] = result.slots
+      assert %{condition: "a", block: %{statics: ["<p>A ", "</p>"]}} = first
+      assert %{condition: "b", block: %{statics: ["<p>B</p>"]}} = second
+      assert %{condition: nil, block: %{statics: ["<p>C</p>"]}} = third
+    end
+
+    test "v-for has its source, aliases, key, and block" do
+      result =
+        split(~S|<ul><li v-for="(item, i) in items" :key="item.id">{{ item.name }}</li></ul>|)
+
+      assert [
+               %{
+                 kind: :for,
+                 source: "items",
+                 value: "item",
+                 key: "i",
+                 key_prop: "item.id",
+                 block: %{statics: ["<li>", "</li>"]}
+               }
+             ] = result.slots
+    end
+
+    test "template wrappers render only their content" do
+      result = split(~S|<template v-if="a"><b>1</b>2</template>|)
+
+      assert [%{branches: [%{block: %{statics: ["<b>1</b>2"]}}]}] = result.slots
+    end
+
+    test "slots keep their place among static siblings" do
+      result = split(~S|<div><b>x</b><Card /><i>{{ y }}</i><Card /></div>|)
+
+      assert result.statics == ["<div><b>x</b>", "<i>", "</i>", "</div>"]
+      assert kinds(result) == [:component, :text, :component]
+    end
+  end
+
+  describe "components" do
+    test "have props, events, and slot content" do
+      result =
+        split(
+          ~S|<Card title="T" :count="n" @close="shut"><p>{{ x }}</p><template #footer="{ ok }">F {{ ok }}</template></Card>|
+        )
+
+      assert [%{kind: :component, name: "Card", props: props, events: events, slots: slots}] =
+               result.slots
+
+      assert [%{name: "title", static: "T"}, %{name: "count", value: "n"}] = props
+      assert [%{name: "close", value: "shut"}] = events
+
+      assert [
+               %{name: "footer", params: "{ ok }", block: %{statics: ["F ", ""]}},
+               %{name: "default", params: nil, block: %{statics: ["<p>", "</p>"]}}
+             ] = slots
+    end
+
+    test "v-slot on the component makes its children the default slot" do
+      assert [%{slots: [%{name: "default", params: "{ item }"}]}] =
+               split(~S|<List v-slot="{ item }">{{ item }}</List>|).slots
+    end
+
+    test "v-model is a prop and an update event" do
+      assert [
+               %{
+                 props: [%{name: "modelValue", value: "q"}],
+                 events: [%{name: "update:modelValue", value: "q"}]
+               }
+             ] =
+               split(~S|<Search v-model="q" />|).slots
+    end
+
+    test "a <slot> outlet has its name, props, and fallback" do
+      result = split(~S|<footer><slot name="end" :count="n">none</slot></footer>|)
+
+      assert [
+               %{
+                 kind: :slot,
+                 name: "end",
+                 props: [%{name: "count", value: "n"}],
+                 fallback: %{statics: ["none"]}
+               }
+             ] = result.slots
+    end
+  end
+
+  describe "root_attrs" do
+    test "gathers the root element's attributes into one slot" do
+      result =
+        split(~S|<button type="button" class="btn" :class="c" disabled><slot /></button>|,
+          root_attrs: true
+        )
+
+      assert result.statics == ["<button", ">", "</button>"]
+      assert [%{kind: :root_attrs, props: props}, %{kind: :slot}] = result.slots
+
+      assert Enum.map(props, &{&1.name, &1.static, &1.value}) == [
+               {"type", "button", nil},
+               {"class", "btn", "c"},
+               {"disabled", "", nil}
+             ]
+    end
+
+    test "leaves templates with several roots alone" do
+      assert split(~S|<p class="a">x</p><p>y</p>|, root_attrs: true).statics ==
+               [~S|<p class="a">x</p><p>y</p>|]
+    end
+  end
+
+  describe "diagnostics" do
+    test "an expression that doesn't parse is an error with its position" do
+      assert {:error, %Vize.Error{diagnostics: [diagnostic]} = error} =
+               Vize.split_template(~S|<p>{{ a + }}</p>|)
+
+      assert %Vize.Diagnostic{severity: :error, location: %{start: %{line: 1, column: 7}}} =
+               diagnostic
+
+      assert Exception.message(error) =~ "1:7: can't parse the expression `a +`"
+    end
+
+    test "a custom directive is a warning" do
+      assert %{diagnostics: [%Vize.Diagnostic{severity: :warning, message: message}]} =
+               split(~S|<input v-focus>|)
+
+      assert message =~ "v-focus"
+    end
+
+    test "convert to Elixir's diagnostic shape relative to a file" do
+      {:error, %Vize.Error{diagnostics: [diagnostic]}} = Vize.split_template("<p>\n{{ a + }}</p>")
+
+      assert %{file: "Page.vue", severity: :error, position: {11, 4}} =
+               Vize.Diagnostic.to_code_diagnostic(diagnostic, file: "Page.vue", origin: {10, 5})
+    end
+  end
+end
diff --git a/test/vize/vapor_split_test.exs b/test/vize/vapor_split_test.exs
deleted file mode 100644
index 6190468..0000000
--- a/test/vize/vapor_split_test.exs
+++ /dev/null
@@ -1,239 +0,0 @@
-defmodule Vize.VaporSplitTest do
-  use ExUnit.Case, async: true
-
-  test "preserves self-closing tag syntax when injecting attrs" do
-    {:ok, split} = Vize.vapor_split("<div><input v-model=\"name\" /></div>")
-
-    statics = Enum.join(split.statics)
-
-    assert statics =~ "<input"
-    assert statics =~ "value=\"\""
-    refute statics =~ "/ value"
-    assert Enum.any?(split.slots, &(&1.kind == :v_model))
-  end
-
-  test "handles sibling roots" do
-    {:ok, split} = Vize.vapor_split("<div>{{ one }}</div><span>{{ two }}</span>")
-
-    assert length(split.statics) >= 3
-    assert Enum.count(split.slots, &(&1.kind == :set_text)) == 2
-  end
-
-  test "keeps slot ordering aligned with static markers" do
-    {:ok, split} =
-      Vize.vapor_split("<div :class=\"cls\">{{ msg }}</div><div v-if=\"show\">ok</div>")
-
-    assert Enum.map(split.slots, & &1.kind) == [:set_prop, :set_text, :if_node]
-    assert length(split.statics) == length(split.slots) + 1
-  end
-
-  test "orders nested property slots by document position" do
-    {:ok, split} =
-      Vize.vapor_split("<div :class=\"outer\"><i :class=\"inner\"></i></div>")
-
-    assert [
-             %{kind: :set_prop, values: ["outer"]},
-             %{kind: :set_prop, values: ["inner"]}
-           ] = split.slots
-
-    assert split.statics == ["<div class=\"", "\"><i class=\"", "\"></i></div>"]
-  end
-
-  test "orders structural and text slots by document position" do
-    {:ok, leading_if} =
-      Vize.vapor_split("<div><p v-if=\"show\">visible</p>{{ message }}</div>")
-
-    assert Enum.map(leading_if.slots, & &1.kind) == [:if_node, :set_text]
-    assert length(leading_if.statics) == length(leading_if.slots) + 1
-
-    {:ok, trailing_if} =
-      Vize.vapor_split("<div>{{ message }}<p v-if=\"show\">visible</p></div>")
-
-    assert Enum.map(trailing_if.slots, & &1.kind) == [:set_text, :if_node]
-    assert length(trailing_if.statics) == length(trailing_if.slots) + 1
-  end
-
-  test "positions structural slots between static siblings" do
-    {:ok, split} =
-      Vize.vapor_split("<div><span>before</span><p v-if=\"show\">visible</p><b>after</b></div>")
-
-    assert Enum.map(split.slots, & &1.kind) == [:if_node]
-    assert split.statics == ["<div><span>before</span>", "<b>after</b></div>"]
-  end
-
-  test "distinguishes removed and retained tags with the same name" do
-    {:ok, split} =
-      Vize.vapor_split("<div><p v-if=\"show\">conditional</p><p>static</p></div>")
-
-    assert Enum.map(split.slots, & &1.kind) == [:if_node]
-    assert split.statics == ["<div>", "<p>static</p></div>"]
-  end
-
-  test "preserves static content between structural and text slots" do
-    {:ok, split} =
-      Vize.vapor_split("<div><p v-if=\"show\">visible</p><span>static</span>{{ message }}</div>")
-
-    assert Enum.map(split.slots, & &1.kind) == [:if_node, :set_text]
-    assert split.statics == ["<div>", "<span>static</span>", "</div>"]
-  end
-
-  test "positions v-for slots between static siblings" do
-    {:ok, split} =
-      Vize.vapor_split(
-        "<ul><li>before</li><li v-for=\"item in items\">{{ item }}</li><li>after</li></ul>"
-      )
-
-    assert Enum.map(split.slots, & &1.kind) == [:for_node]
-    assert split.statics == ["<ul><li>before</li>", "<li>after</li></ul>"]
-  end
-
-  test "replaces the whole text node for mixed static and dynamic text" do
-    {:ok, split} = Vize.vapor_split("<span>Hello {{ a }}, you have {{ n }} items</span>")
-
-    assert split.statics == ["<span>", "</span>"]
-
-    assert [
-             %{
-               kind: :set_text,
-               values: [
-                 {:static_, "Hello "},
-                 "a",
-                 {:static_, ", you have "},
-                 "n",
-                 {:static_, " items"}
-               ]
-             }
-           ] =
-             split.slots
-  end
-
-  test "matches HTML-escaped static text" do
-    {:ok, split} = Vize.vapor_split("<p>\"Tom\" & {{ x }} <3</p>")
-
-    assert split.statics == ["<p>", "</p>"]
-  end
-
-  test "places text slots after sibling elements" do
-    {:ok, split} = Vize.vapor_split("<div><b>bold</b> hi {{ x }}</div>")
-
-    assert split.statics == ["<div><b>bold</b>", "</div>"]
-  end
-
-  test "replaces Vapor anchor comments with structural slots" do
-    {:ok, split} =
-      Vize.vapor_split(
-        "<div><p v-if=\"a\">A</p><p v-if=\"b\">B</p><i :id=\"k\">{{ x }}</i></div>"
-      )
-
-    assert Enum.map(split.slots, & &1.kind) == [:if_node, :if_node, :set_prop, :set_text]
-    assert split.statics == ["<div>", "", "<i id=\"", "\">", "</i></div>"]
-  end
-
-  test "matches text nodes by decoded content, not by a substring" do
-    {:ok, split} = Vize.vapor_split("<div>static <b>x</b> hi {{ a }}</div>")
-    assert split.statics == ["<div>static <b>x</b>", "</div>"]
-
-    {:ok, split} = Vize.vapor_split("<div>x {{ a }}<b>x </b>x {{ c }}</div>")
-    assert split.statics == ["<div>", "<b>x </b>", "</div>"]
-  end
-
-  # https://github.com/elixir-volt/vize_ex/issues/3
-  test "orders slots by document position across nesting and structural nodes" do
-    {:ok, split} = Vize.vapor_split(~s(<a :class="l1"><b :class="l2"><c :class="l3"></c></b></a>))
-    assert Enum.map(split.slots, & &1.values) == [["l1"], ["l2"], ["l3"]]
-
-    {:ok, split} = Vize.vapor_split(~s(<div><b v-if="on">Y</b><span>{{ label }}</span></div>))
-    assert Enum.map(split.slots, & &1.kind) == [:if_node, :set_text]
-    assert split.statics == ["<div>", "<span>", "</span></div>"]
-
-    {:ok, split} =
-      Vize.vapor_split(
-        ~s(<div><section><b v-if="on">Y</b></section><span>{{ label }}</span></div>)
-      )
-
-    assert Enum.map(split.slots, & &1.kind) == [:if_node, :set_text]
-    assert split.statics == ["<div><section>", "</section><span>", "</span></div>"]
-  end
-
-  test "places v-html slots inside their element" do
-    {:ok, split} = Vize.vapor_split(~s(<div v-html="raw"></div>))
-    assert split.statics == ["<div>", "</div>"]
-    assert [%{kind: :set_html, value: "raw"}] = split.slots
-
-    {:ok, split} = Vize.vapor_split(~s(<section><p v-html="raw"></p><b>{{ x }}</b></section>))
-    assert split.statics == ["<section><p>", "</p><b>", "</b></section>"]
-    assert Enum.map(split.slots, & &1.kind) == [:set_html, :set_text]
-  end
-
-  describe "bindings" do
-    test "events are reported with where their element's start tag ends" do
-      {:ok, split} =
-        Vize.vapor_split(~S|<div><button @click.prevent='say("hi")'>{{ label }}</button></div>|)
-
-      assert split.statics == ["<div><button>", "</button></div>"]
-
-      assert [%{kind: :set_event, node: node, at: {0, 12}}] = split.bindings
-      assert node.key == {:static_, "click"}
-      assert node.value == ~s|say("hi")|
-      assert node.modifiers.non_keys == ["prevent"]
-
-      assert binary_part(hd(split.statics), 0, 12) == "<div><button"
-    end
-
-    test "v-model is reported as its directive" do
-      {:ok, split} = Vize.vapor_split(~S|<input v-model="name">|)
-
-      assert split.statics == [~s(<input value="), ~s(">)]
-
-      assert [%{kind: :directive, node: %{name: "model", value: "name"}, at: {1, 1}}] =
-               split.bindings
-
-      assert [%{kind: :v_model}] = split.slots
-    end
-
-    test "positions count from the static they fall in" do
-      {:ok, split} =
-        Vize.vapor_split(~S|<p :class="cls">{{ a }}</p><button @click="go">x</button>|)
-
-      assert [%{at: {index, offset}}] = split.bindings
-      assert binary_part(Enum.at(split.statics, index), 0, offset) =~ ~r/<button\z/
-    end
-
-    test "bindings inside v-if and v-for belong to their block" do
-      {:ok, split} =
-        Vize.vapor_split(
-          ~S|<ul><li v-for="item in items" @click="pick(item)">{{ item }}</li></ul><b v-if="on" @click="off">x</b>|
-        )
-
-      assert split.bindings == []
-
-      [for_slot, if_slot] = split.slots
-      assert [%{kind: :set_event, node: %{value: "pick(item)"}}] = for_slot.render.bindings
-      assert [%{kind: :set_event, node: %{value: "off"}}] = if_slot.positive.bindings
-    end
-  end
-
-  describe "text nodes before elements" do
-    test "an element after a text node in a nested list keeps its slot" do
-      {:ok, split} =
-        Vize.vapor_split(~S|<ul><li>a<ul><li>{{ b }}</li></ul></li><li>c</li></ul>|)
-
-      assert split.statics == ["<ul><li>a<ul><li>", "</li></ul></li><li>c</li></ul>"]
-      assert [%{kind: :set_text, values: ["b"]}] = split.slots
-    end
-
-    test "slots after mixed text and elements" do
-      {:ok, split} = Vize.vapor_split(~S|<p>a<b>{{ x }}</b>c<i :title="t">{{ y }}</i></p>|)
-
-      assert split.statics == ["<p>a<b>", "</b>c<i title=\"", "\">", "</i></p>"]
-      assert Enum.map(split.slots, & &1.kind) == [:set_text, :set_prop, :set_text]
-    end
-
-    test "an event after a text node is bound to its element" do
-      {:ok, split} = Vize.vapor_split(~S|<div>hi<button @click="go">x</button></div>|)
-
-      assert [%{at: {0, offset}}] = split.bindings
-      assert binary_part(hd(split.statics), 0, offset) == "<div>hi<button"
-    end
-  end
-end