diff --git a/CHANGELOG.md b/CHANGELOG.md
index c568bdff2..34c004447 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,8 +6,23 @@ All notable changes to **bUnit** will be documented in this file. The project ad
 
 ## [Unreleased]
 
+### Added
+
+- `INode.GetOwningComponent()` and its generic overload, which return the rendered component that rendered a DOM node. Reported by [@egil](https://github.com/egil) in #153.
+- `Parent()`, `Root()`, `GetAncestors()`, `GetChildren()` and its generic overload on `IRenderedComponent`, for navigating the component tree. Reported by [@egil](https://github.com/egil) in #1180.
+
+### Changed
+
+- **Breaking:** all rendered components in a render tree now share a single DOM. Previously each rendered component parsed its own markup into its own document, so an element found through a child component had no ancestors outside that child. Consequences:
+  - Events raised on an element found through a child component now bubble into the markup rendered by its ancestor components, as they do in a browser. Reported by [@JelleHissink](https://github.com/JelleHissink) in #983.
+  - `Find` and `FindAll` on a child component evaluate positional and combinator selectors (`:first-child`, `+`, `~`, ...) against the whole tree rather than the component's markup in isolation.
+  - An `option` element rendered by a child component, inside a `select` element rendered by an ancestor with a matching `value` attribute, now renders as `selected`, matching what the ancestor's markup shows.
+
+  A component whose markup starts or ends with text, or that the HTML parser relocates, still falls back to its own document, since its nodes cannot be identified in the shared one.
+
 ### Fixed
 
+- Events raised on an element obtained through `FindComponent` no longer stop at the child component's own markup, so a submit button in a child component triggers the `@onsubmit` handler on the `form` element rendered by its parent. Reported by [@JelleHissink](https://github.com/JelleHissink) in #983.
 - `BunitHtmlParser.Dispose()` no longer throws `InvalidOperationException: Collection was modified` when a parse is in flight on another thread during test teardown. Reported by [@thimobuchheister](https://github.com/thimobuchheister) in #1892. Fixed by [@linkdotnet](https://github.com/linkdotnet).
 
 ## [2.9.0] - 2026-08-03
diff --git a/docs/site/docs/interaction/trigger-event-handlers.md b/docs/site/docs/interaction/trigger-event-handlers.md
index d8eb3ff8c..cd9497303 100644
--- a/docs/site/docs/interaction/trigger-event-handlers.md
+++ b/docs/site/docs/interaction/trigger-event-handlers.md
@@ -105,4 +105,26 @@ Example:
 
 ```csharp
 await cut.Find("button").ClickAsync();
-```
\ No newline at end of file
+```
+## Events bubble across component boundaries
+
+Every component in a render tree shares one DOM, so an element found through a child
+component still has its ancestors from the parent components around it. Events therefore
+bubble the same way whether the element was found from the component under test or from
+one of its children:
+
+```csharp
+var cut = Render<OuterSubmitForm>();
+
+// Both of these trigger the @onsubmit handler on the <form>
+// rendered by <OuterSubmitForm>.
+cut.Find("button").Click();
+cut.FindComponent<InnerSubmitForm>().Find("button").Click();
+```
+
+Use `GetOwningComponent()` on any element to get the component that rendered it, which is
+covered in <xref:find-owning-component>:
+
+```csharp
+IRenderedComponent<InnerSubmitForm> inner = cut.Find("button").GetOwningComponent<InnerSubmitForm>();
+```
diff --git a/docs/site/docs/toc.md b/docs/site/docs/toc.md
index 53fe7e811..3fafcef19 100644
--- a/docs/site/docs/toc.md
+++ b/docs/site/docs/toc.md
@@ -20,6 +20,7 @@
 # [Verifying output](xref:verification)
 ## [Verify markup](xref:verify-markup)
 ## [Verify component state](xref:verify-component-state)
+## [Find the component that rendered an element](xref:find-owning-component)
 ## [Customizing semantic comparison](xref:semantic-html-comparison)
 ## [Assertion of asynchronous changes](xref:async-assertion)
 
diff --git a/docs/site/docs/verification/find-owning-component.md b/docs/site/docs/verification/find-owning-component.md
new file mode 100644
index 000000000..0e33a483d
--- /dev/null
+++ b/docs/site/docs/verification/find-owning-component.md
@@ -0,0 +1,78 @@
+---
+uid: find-owning-component
+title: Finding the component that rendered an element
+---
+
+# Finding the component that rendered an element
+
+The DOM query API is often the quickest way to reach an interesting part of the rendered
+output. <xref:Bunit.ElementOwningComponentExtensions.GetOwningComponent(AngleSharp.Dom.INode)>
+takes you from a node found that way back to the component that rendered it, so you can
+assert on that component's state:
+
+```csharp
+var cut = Render<TodoList>();
+
+IRenderedComponent<IComponent> owner = cut.Find("li.done").GetOwningComponent();
+
+owner.Instance.ShouldBeOfType<TodoItem>();
+```
+
+Use the generic overload,
+<xref:Bunit.ElementOwningComponentExtensions.GetOwningComponent``1(AngleSharp.Dom.INode)>,
+when you know which component type you are after. It returns a strongly typed
+<xref:Bunit.IRenderedComponent`1>, so the component instance and all the usual verification
+methods are available:
+
+```csharp
+var cut = Render<TodoList>();
+
+IRenderedComponent<TodoItem> item = cut.Find("li.done").GetOwningComponent<TodoItem>();
+
+item.Instance.IsDone.ShouldBeTrue();
+item.MarkupMatches("<li class=\"done\">Buy milk</li>");
+```
+
+## Which component is returned
+
+The **innermost** component that rendered the node. Given a `<TodoList>` that renders a
+`<ul>` and a `<TodoItem>` per entry, `cut.Find("ul").GetOwningComponent()` returns the
+`<TodoList>` and `cut.Find("li").GetOwningComponent()` returns the `<TodoItem>`.
+
+A few details worth knowing:
+
+- **Nodes that are not elements resolve through their closest element.** Calling it on a text
+  node returns the component that rendered the element containing that text.
+- **Content passed as a `RenderFragment` belongs to the receiving component.** A
+  `ChildContent` written in the parent is rendered into the child's render tree, so
+  `GetOwningComponent()` names the child. This matches what the child's
+  <xref:Bunit.IRenderedComponent`1.Markup> already showed.
+- **bUnit's own root component is never returned.** Wrapper components with no markup of their
+  own, such as `CascadingValue<T>`, lose to the component inside them.
+
+The generic overload widens the search outwards: if the innermost component is not a
+`TComponent`, it walks up the component tree until it finds one, and throws
+<xref:Bunit.Rendering.ComponentNotFoundException> if there is none. That makes it a concise
+way to reach a specific ancestor:
+
+```csharp
+// The <button> is rendered by <TodoItem>, but the assertion is about the list around it.
+IRenderedComponent<TodoList> list = cut.Find("li button").GetOwningComponent<TodoList>();
+```
+
+## Nodes that cannot be traced
+
+Both methods throw an `InvalidOperationException` for a node that bUnit did not render, for
+example one parsed from a markup string in a test. Only nodes from a rendered component tree
+carry the information needed to name their component.
+
+## How it works
+
+All components in a render tree share one markup string and one parsed document. While
+generating that markup, bUnit records the character range each component occupies in it, and
+AngleSharp records the position each element was parsed from. Looking up an element's position
+in those ranges identifies the innermost component that produced it - no markers are added to
+the markup, so nothing about the rendered output changes.
+
+The same shared document is what lets events bubble across component boundaries; see
+<xref:trigger-event-handlers>.
diff --git a/docs/site/docs/verification/index.md b/docs/site/docs/verification/index.md
index 728ea3ea9..4b2418a23 100644
--- a/docs/site/docs/verification/index.md
+++ b/docs/site/docs/verification/index.md
@@ -9,5 +9,6 @@ This section covers the different ways to verify the result of a test scenario:
 
 - **<xref:verify-markup>:** This covers the different ways bUnit enables verification and assertions against the rendered markup from a component.
 - **<xref:verify-component-state>:** This covers how to inspect an instance of the component under test.
+- **<xref:find-owning-component>:** This covers how to go from a DOM node found with `Find`/`FindAll` back to the component that rendered it.
 - **<xref:semantic-html-comparison>:** This covers how to customize the semantic HTML/markup comparer included in bUnit for more stable tests.
 - **<xref:async-assertion>:** This covers how to create stable tests in an asynchronous world.
diff --git a/src/bunit/Extensions/ElementOwningComponentExtensions.cs b/src/bunit/Extensions/ElementOwningComponentExtensions.cs
new file mode 100644
index 000000000..52b3030c1
--- /dev/null
+++ b/src/bunit/Extensions/ElementOwningComponentExtensions.cs
@@ -0,0 +1,126 @@
+using AngleSharp.Dom;
+using Bunit.Rendering;
+using Bunit.Web.AngleSharp;
+
+namespace Bunit;
+
+/// <summary>
+/// Extension methods for getting the component that rendered a DOM node.
+/// </summary>
+public static class ElementOwningComponentExtensions
+{
+	/// <summary>
+	/// Gets the component that rendered the <paramref name="node"/>.
+	/// </summary>
+	/// <param name="node">The node to find the rendering component for.</param>
+	/// <exception cref="InvalidOperationException">
+	/// Thrown when the <paramref name="node"/> cannot be traced back to a component,
+	/// e.g. because it was not rendered by a <see cref="BunitRenderer"/>.
+	/// </exception>
+	public static IRenderedComponent<IComponent> GetOwningComponent(this INode node)
+	{
+		ArgumentNullException.ThrowIfNull(node);
+
+		var renderer = node.GetBunitContext()?.Renderer
+			?? throw new InvalidOperationException(
+				$"The node was not rendered by bUnit's '{nameof(BunitRenderer)}', so the component that rendered it is unknown.");
+
+		var element = FindElementWithSourceReference(node)
+			?? throw new InvalidOperationException(
+				"The node cannot be traced back to a component, because neither it nor any of its ancestors was parsed from the markup of a component.");
+
+		var (root, sourceIndexOffset) = FindRenderTreeRootFor(renderer, element.Owner);
+
+		var snapshot = root.MarkupSnapshot
+			?? throw new InvalidOperationException("The render tree the node belongs to has no markup.");
+
+		var sourceIndex = RootMarkupSnapshot.GetSourceIndex(element) + sourceIndexOffset;
+
+		foreach (var range in snapshot.Ranges)
+		{
+			if (!range.Contains(sourceIndex))
+			{
+				continue;
+			}
+
+			var candidate = renderer.GetRenderedComponent(range.ComponentId);
+
+			// Ranges are in post-order, so the first match is the innermost component.
+			if (candidate.Instance is not BunitRootComponent)
+			{
+				return candidate;
+			}
+		}
+
+		throw new InvalidOperationException("The node cannot be traced back to a component.");
+	}
+
+	/// <summary>
+	/// Gets the closest <typeparamref name="TComponent"/> that the <paramref name="node"/>
+	/// was rendered inside of.
+	/// </summary>
+	/// <typeparam name="TComponent">The type of component to find.</typeparam>
+	/// <param name="node">The node to find the rendering component for.</param>
+	/// <exception cref="ComponentNotFoundException">
+	/// Thrown when the <paramref name="node"/> was not rendered inside a <typeparamref name="TComponent"/>.
+	/// </exception>
+	public static IRenderedComponent<TComponent> GetOwningComponent<TComponent>(this INode node)
+		where TComponent : IComponent
+	{
+		var owner = node.GetOwningComponent();
+
+		for (var candidate = owner; candidate is not null; candidate = candidate.Parent())
+		{
+			if (candidate.Instance is TComponent)
+			{
+				return (IRenderedComponent<TComponent>)candidate;
+			}
+		}
+
+		throw new ComponentNotFoundException(typeof(TComponent));
+	}
+
+	/// <summary>
+	/// Gets the root of the render tree the <paramref name="document"/> was parsed for, and the
+	/// offset that rebases a source index in it onto the root's markup.
+	/// </summary>
+	/// <remarks>
+	/// A private document holds one component's markup, so its indices start at zero rather
+	/// than at that component's position in the root's markup.
+	/// </remarks>
+	private static (IRenderedComponentRoot Root, int SourceIndexOffset) FindRenderTreeRootFor(BunitRenderer renderer, IDocument? document)
+	{
+		if (renderer.FindRenderTreeRoot(document) is { } sharedRoot)
+		{
+			return (sharedRoot, 0);
+		}
+
+		if (renderer.FindPrivateDocumentOwner(document) is { } owner
+			&& owner.Root.MarkupSnapshot?.TryGetRange(owner.ComponentId, out var range) == true)
+		{
+			return (owner.Root, range.Start);
+		}
+
+		throw new InvalidOperationException(
+			"The node cannot be traced back to a component, because it does not belong to the document of a rendered component tree.");
+	}
+
+	private static IElement? FindElementWithSourceReference(INode node)
+	{
+		var candidate = node is IElement element
+			? element.Unwrap()
+			: node.ParentElement;
+
+		while (candidate is not null)
+		{
+			if (RootMarkupSnapshot.GetSourceIndex(candidate) >= 0)
+			{
+				return candidate;
+			}
+
+			candidate = candidate.ParentElement;
+		}
+
+		return null;
+	}
+}
diff --git a/src/bunit/Extensions/RenderedComponentTreeExtensions.cs b/src/bunit/Extensions/RenderedComponentTreeExtensions.cs
new file mode 100644
index 000000000..b6284925f
--- /dev/null
+++ b/src/bunit/Extensions/RenderedComponentTreeExtensions.cs
@@ -0,0 +1,121 @@
+using Bunit.Rendering;
+
+namespace Bunit;
+
+/// <summary>
+/// Extension methods for navigating the component tree an
+/// <see cref="IRenderedComponent{TComponent}"/> is part of.
+/// </summary>
+public static class RenderedComponentTreeExtensions
+{
+	/// <summary>
+	/// Gets the component that rendered the <paramref name="renderedComponent"/>,
+	/// or <see langword="null"/> if it is the outermost component in its render tree.
+	/// </summary>
+	public static IRenderedComponent<IComponent>? Parent(this IRenderedComponent<IComponent> renderedComponent)
+	{
+		ArgumentNullException.ThrowIfNull(renderedComponent);
+
+		var parent = ToComponentState(renderedComponent).ParentComponentState;
+
+		return parent is null || IsBunitInfrastructure(parent)
+			? null
+			: (IRenderedComponent<IComponent>)parent;
+	}
+
+	/// <summary>
+	/// Gets the outermost component in the render tree the
+	/// <paramref name="renderedComponent"/> is part of.
+	/// </summary>
+	public static IRenderedComponent<IComponent> Root(this IRenderedComponent<IComponent> renderedComponent)
+	{
+		ArgumentNullException.ThrowIfNull(renderedComponent);
+
+		var result = renderedComponent;
+		while (result.Parent() is { } parent)
+		{
+			result = parent;
+		}
+
+		return result;
+	}
+
+	/// <summary>
+	/// Gets the components the <paramref name="renderedComponent"/> was rendered inside of,
+	/// from its closest parent to the outermost component in the render tree.
+	/// </summary>
+	public static IEnumerable<IRenderedComponent<IComponent>> GetAncestors(this IRenderedComponent<IComponent> renderedComponent)
+	{
+		ArgumentNullException.ThrowIfNull(renderedComponent);
+
+		return Iterate(renderedComponent);
+
+		static IEnumerable<IRenderedComponent<IComponent>> Iterate(IRenderedComponent<IComponent> renderedComponent)
+		{
+			for (var parent = renderedComponent.Parent(); parent is not null; parent = parent.Parent())
+			{
+				yield return parent;
+			}
+		}
+	}
+
+	/// <summary>
+	/// Gets the components rendered directly by the <paramref name="renderedComponent"/>,
+	/// in render order. Components rendered by those children are not included.
+	/// </summary>
+	public static IReadOnlyList<IRenderedComponent<IComponent>> GetChildren(this IRenderedComponent<IComponent> renderedComponent)
+	{
+		ArgumentNullException.ThrowIfNull(renderedComponent);
+
+		var renderer = renderedComponent.Services.GetRequiredService<BunitContext>().Renderer;
+
+		return renderer.GetChildComponents(renderedComponent.ComponentId);
+	}
+
+	/// <summary>
+	/// Gets the <typeparamref name="TComponent"/> components rendered directly by the
+	/// <paramref name="renderedComponent"/>, in render order.
+	/// </summary>
+	/// <typeparam name="TComponent">Type of child components to get.</typeparam>
+	public static IReadOnlyList<IRenderedComponent<TComponent>> GetChildren<TComponent>(this IRenderedComponent<IComponent> renderedComponent)
+		where TComponent : IComponent
+	{
+		var result = new List<IRenderedComponent<TComponent>>();
+
+		foreach (var child in renderedComponent.GetChildren())
+		{
+			if (child.Instance is TComponent)
+			{
+				result.Add((IRenderedComponent<TComponent>)child);
+			}
+		}
+
+		return result;
+	}
+
+	internal static ComponentState ToComponentState(IRenderedComponent<IComponent> renderedComponent)
+		=> (ComponentState)renderedComponent;
+
+	/// <summary>
+	/// Components bUnit wraps the component under test in are not part of the tree a test sees.
+	/// </summary>
+	/// <remarks>
+	/// A <see cref="CascadingValue{TValue}"/> counts as infrastructure only when everything above
+	/// it does too; one written by the user inside their own component is a regular part of the tree.
+	/// </remarks>
+	internal static bool IsBunitInfrastructure(ComponentState componentState)
+	{
+		if (componentState.Component is BunitRootComponent or ContainerFragment)
+		{
+			return true;
+		}
+
+		var componentType = componentState.Component.GetType();
+		if (componentType.IsGenericType && componentType.GetGenericTypeDefinition() == typeof(CascadingValue<>))
+		{
+			return componentState.ParentComponentState is { } parent && IsBunitInfrastructure(parent);
+		}
+
+		return false;
+	}
+}
diff --git a/src/bunit/Rendering/BunitRenderer.cs b/src/bunit/Rendering/BunitRenderer.cs
index 88740fcbc..60025d66f 100644
--- a/src/bunit/Rendering/BunitRenderer.cs
+++ b/src/bunit/Rendering/BunitRenderer.cs
@@ -1,3 +1,4 @@
+using AngleSharp.Dom;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
 using System.Diagnostics;
@@ -25,8 +26,14 @@ public sealed class BunitRenderer : Renderer
 
 	private readonly object renderTreeUpdateLock = new();
 
-	private readonly HashSet<int> returnedRenderedComponentIds = new();
+	private readonly Dictionary<int, IRenderedComponent> returnedRenderedComponents = new();
 	private readonly List<BunitRootComponent> rootComponents = new();
+
+	// Unlike rootComponents this is never cleared, so a node from a document created
+	// before DisposeComponents can still be traced back to its component.
+	private readonly List<IRenderedComponentRoot> renderTreeRoots = new();
+	private readonly ConditionalWeakTable<IDocument, IRenderedComponent> privateDocuments = new();
+	private readonly HashSet<IRenderedComponentRoot> rootsDirtiedByDisposal = new();
 	private readonly ILogger<BunitRenderer> logger;
 	private bool disposed;
 	private TaskCompletionSource<Exception> unhandledExceptionTsc = new(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -309,6 +316,11 @@ protected override ComponentState CreateComponentState(int componentId, ICompone
 	{
 		ArgumentNullException.ThrowIfNull(component);
 
+		if (component is BunitRootComponent)
+		{
+			return new RootRenderedComponent(this, componentId, component, services);
+		}
+
 		var TComponent = component.GetType();
 		var renderedComponentType = typeof(RenderedComponent<>).MakeGenericType(TComponent);
 		var renderedComponent = CreateComponentInstance();
@@ -515,9 +527,18 @@ protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
 		{
 			var id = renderBatch.DisposedComponentIDs.Array[i];
 			disposedComponentIds.Add(id);
-			returnedRenderedComponentIds.Remove(id);
+			returnedRenderedComponents.Remove(id);
+		}
+
+		var dirtyRoots = CollectDirtyRoots(in renderBatch, disposedComponentIds);
+
+		foreach (var root in dirtyRoots)
+		{
+			root.RegenerateMarkup();
 		}
 
+		RaiseMarkupUpdatedForComponentsIn(dirtyRoots);
+
 		for (var i = 0; i < renderBatch.UpdatedComponents.Count; i++)
 		{
 			var diff = renderBatch.UpdatedComponents.Array[i];
@@ -528,23 +549,14 @@ protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
 			}
 
 			var componentState = GetComponentState(diff.ComponentId);
-			var renderedComponent = (IRenderedComponent)componentState;
+			((IRenderedComponent)componentState).UpdateState(hasRendered: true);
 
-			if (returnedRenderedComponentIds.Contains(diff.ComponentId))
-			{
-				renderedComponent.UpdateState(hasRendered: true, isMarkupGenerationRequired: diff.Edits.Count > 0);
-			}
-			else
-			{
-				renderedComponent.UpdateState(hasRendered: true, false);
-			}
-
-			UpdateParents(diff.Edits.Count > 0, componentState, in renderBatch);
+			UpdateParents(componentState, in renderBatch);
 		}
 
 		return Task.CompletedTask;
 
-		void UpdateParents(bool hasChanges, ComponentState componentState, in RenderBatch renderBatch)
+		void UpdateParents(ComponentState componentState, in RenderBatch renderBatch)
 		{
 			var parent = componentState.ParentComponentState;
 			if (parent is null)
@@ -554,16 +566,9 @@ void UpdateParents(bool hasChanges, ComponentState componentState, in RenderBatc
 
 			if (!IsParentComponentAlreadyUpdated(parent.ComponentId, in renderBatch))
 			{
-				if (returnedRenderedComponentIds.Contains(parent.ComponentId))
-				{
-					((IRenderedComponent)parent).UpdateState(hasRendered: true, isMarkupGenerationRequired: hasChanges);
-				}
-				else
-				{
-					((IRenderedComponent)parent).UpdateState(hasRendered: true, false);
-				}
+				((IRenderedComponent)parent).UpdateState(hasRendered: true);
 
-				UpdateParents(hasChanges, parent, in renderBatch);
+				UpdateParents(parent, in renderBatch);
 			}
 		}
 
@@ -582,10 +587,138 @@ static bool IsParentComponentAlreadyUpdated(int componentId, in RenderBatch rend
 		}
 	}
 
+	private HashSet<IRenderedComponentRoot> CollectDirtyRoots(in RenderBatch renderBatch, HashSet<int> disposedComponentIds)
+	{
+		var dirtyRoots = new HashSet<IRenderedComponentRoot>(rootsDirtiedByDisposal);
+		rootsDirtiedByDisposal.Clear();
+
+		for (var i = 0; i < renderBatch.UpdatedComponents.Count; i++)
+		{
+			var diff = renderBatch.UpdatedComponents.Array[i];
+
+			if (diff.Edits.Count == 0 || disposedComponentIds.Contains(diff.ComponentId))
+			{
+				continue;
+			}
+
+			dirtyRoots.Add(((IRenderedComponent)GetComponentState(diff.ComponentId)).Root);
+		}
+
+		return dirtyRoots;
+	}
+
+	/// <summary>
+	/// Regenerating a root replaces the document all components in its render tree
+	/// read from, which invalidates every element previously handed out from it -
+	/// including elements of components whose own markup did not change.
+	/// </summary>
+	private void RaiseMarkupUpdatedForComponentsIn(HashSet<IRenderedComponentRoot> dirtyRoots)
+	{
+		if (dirtyRoots.Count == 0)
+		{
+			return;
+		}
+
+		// Handlers are user code that can call FindComponent, which adds to the dictionary.
+		foreach (var renderedComponent in returnedRenderedComponents.Values.ToArray())
+		{
+			if (renderedComponent.IsDisposed)
+			{
+				continue;
+			}
+
+			if (dirtyRoots.Contains(renderedComponent.Root))
+			{
+				renderedComponent.RaiseMarkupUpdated();
+			}
+		}
+	}
+
+	internal void OnRenderedComponentDisposed(IRenderedComponent renderedComponent)
+	{
+		lock (renderTreeUpdateLock)
+		{
+			returnedRenderedComponents.Remove(renderedComponent.ComponentId);
+
+			if (!renderedComponent.Root.IsDisposed)
+			{
+				rootsDirtiedByDisposal.Add(renderedComponent.Root);
+			}
+		}
+	}
+
 	/// <inheritdoc/>
 	internal new ArrayRange<RenderTreeFrame> GetCurrentRenderTreeFrames(int componentId)
 		=> base.GetCurrentRenderTreeFrames(componentId);
 
+	internal IRenderedComponent<IComponent> GetRenderedComponent(int componentId)
+		=> (IRenderedComponent<IComponent>)GetComponentState(componentId);
+
+	internal IRenderedComponentRoot? FindRenderTreeRoot(IDocument? document)
+	{
+		if (document is null)
+		{
+			return null;
+		}
+
+		IRenderedComponentRoot[] roots;
+		lock (renderTreeUpdateLock)
+		{
+			roots = renderTreeRoots.ToArray();
+		}
+
+		foreach (var root in roots)
+		{
+			if (!root.IsDisposed && ReferenceEquals(root.MarkupSnapshot?.Document, document))
+			{
+				return root;
+			}
+		}
+
+		return null;
+	}
+
+	/// <summary>
+	/// Records a document holding the markup of a single component, parsed because
+	/// that markup could not be located in its render tree's shared document.
+	/// </summary>
+	internal void RegisterPrivateDocument(IDocument document, IRenderedComponent renderedComponent)
+		=> privateDocuments.AddOrUpdate(document, renderedComponent);
+
+	internal IRenderedComponent? FindPrivateDocumentOwner(IDocument? document)
+		=> document is not null && privateDocuments.TryGetValue(document, out var owner) && !owner.IsDisposed
+			? owner
+			: null;
+
+	/// <summary>
+	/// Gets the directly rendered child components, in render order. Unlike
+	/// <see cref="FindComponents{TComponent}(IRenderedComponent{IComponent})"/> this does
+	/// not descend into the children's own render trees.
+	/// </summary>
+	internal IReadOnlyList<IRenderedComponent<IComponent>> GetChildComponents(int componentId)
+	{
+		ObjectDisposedException.ThrowIf(disposed, this);
+
+		var result = new List<IRenderedComponent<IComponent>>();
+
+		lock (renderTreeUpdateLock)
+		{
+			ObjectDisposedException.ThrowIf(disposed, this);
+
+			var frames = GetCurrentRenderTreeFrames(componentId);
+			for (var i = 0; i < frames.Count; i++)
+			{
+				ref var frame = ref frames.Array[i];
+				if (frame.FrameType == RenderTreeFrameType.Component)
+				{
+					result.Add(GetRenderedComponent(frame.ComponentId));
+				}
+			}
+		}
+
+		return result;
+	}
+
 	/// <inheritdoc/>
 	protected override void Dispose(bool disposing)
 	{
@@ -601,7 +734,9 @@ protected override void Dispose(bool disposing)
 
 			if (disposing)
 			{
-				returnedRenderedComponentIds.Clear();
+				returnedRenderedComponents.Clear();
+				renderTreeRoots.Clear();
+				rootsDirtiedByDisposal.Clear();
 				disposalTasks.Clear();
 				unhandledExceptionTsc.TrySetCanceled();
 			}
@@ -620,7 +755,6 @@ private IRenderedComponent<BunitRootComponent> Render(RenderFragment renderFragm
 
 			var root = new BunitRootComponent(renderFragment);
 			var rootComponentId = AssignRootComponentId(root);
-			returnedRenderedComponentIds.Add(rootComponentId);
 			rootComponents.Add(root);
 			root.Render();
 			return rootComponentId;
@@ -663,10 +797,6 @@ private List<IRenderedComponent<TComponent>> FindComponents<TComponent>(IRendere
 		{
 			ObjectDisposedException.ThrowIf(disposed, this);
 			FindComponentsInRenderTree(parentComponent.ComponentId);
-			foreach (var rc in result)
-			{
-				((IRenderedComponent)rc).UpdateState(hasRendered: false, isMarkupGenerationRequired: true);
-			}
 		}
 
 		return result;
@@ -700,8 +830,18 @@ void FindComponentsInRenderTree(int componentId)
 	private IRenderedComponent<TComponent> GetRenderedComponent<TComponent>(int componentId)
 		where TComponent : IComponent
 	{
-		var result = GetComponentState(componentId);
-		returnedRenderedComponentIds.Add(result.ComponentId);
+		var result = (IRenderedComponent)GetComponentState(componentId);
+
+		lock (renderTreeUpdateLock)
+		{
+			returnedRenderedComponents[result.ComponentId] = result;
+
+			if (result is IRenderedComponentRoot root && !renderTreeRoots.Contains(root))
+			{
+				renderTreeRoots.Add(root);
+			}
+		}
+
 		return (IRenderedComponent<TComponent>)result;
 	}
 
diff --git a/src/bunit/Rendering/IRenderedComponent.cs b/src/bunit/Rendering/IRenderedComponent.cs
index dc7e0e7ee..ad8f9b8bd 100644
--- a/src/bunit/Rendering/IRenderedComponent.cs
+++ b/src/bunit/Rendering/IRenderedComponent.cs
@@ -9,8 +9,35 @@ internal interface IRenderedComponent : IDisposable
 	/// </summary>
 	int ComponentId { get; }
 
+	bool IsDisposed { get; }
+
+	/// <summary>
+	/// Gets the root of this component's render tree. A root returns itself.
+	/// </summary>
+	IRenderedComponentRoot Root { get; }
+
+	/// <summary>
+	/// Notifies subscribers that the document behind <see cref="IRenderedComponent{TComponent}.Nodes"/>
+	/// was replaced, which invalidates every element previously handed out from it.
+	/// </summary>
+	void RaiseMarkupUpdated();
+
 	/// <summary>
 	/// Called by the owning <see cref="BunitRenderer"/> when it finishes a render.
 	/// </summary>
-	void UpdateState(bool hasRendered, bool isMarkupGenerationRequired);
+	void UpdateState(bool hasRendered);
+}
+
+/// <summary>
+/// The rendered component at the root of a render tree, which owns the markup and the
+/// AngleSharp document every component in that tree reads from.
+/// </summary>
+internal interface IRenderedComponentRoot : IRenderedComponent
+{
+	RootMarkupSnapshot? MarkupSnapshot { get; }
+
+	/// <summary>
+	/// Regenerates the markup of the entire render tree.
+	/// </summary>
+	void RegenerateMarkup();
 }
diff --git a/src/bunit/Rendering/Internal/ComponentMarkupRange.cs b/src/bunit/Rendering/Internal/ComponentMarkupRange.cs
new file mode 100644
index 000000000..07d61902a
--- /dev/null
+++ b/src/bunit/Rendering/Internal/ComponentMarkupRange.cs
@@ -0,0 +1,15 @@
+namespace Bunit.Rendering;
+
+/// <summary>
+/// The half-open range <c>[Start, End)</c> a component occupies in the
+/// markup generated for the root component of its render tree.
+/// </summary>
+internal readonly record struct ComponentMarkupRange(int ComponentId, int Start, int End)
+{
+	public bool Contains(int index) => index >= Start && index < End;
+}
+
+/// <summary>
+/// The markup generated by the <see cref="Htmlizer"/> and the range of it each component rendered.
+/// </summary>
+internal sealed record HtmlizerResult(string Markup, IReadOnlyList<ComponentMarkupRange> Ranges);
diff --git a/src/bunit/Rendering/Internal/Htmlizer.cs b/src/bunit/Rendering/Internal/Htmlizer.cs
index 9f31c4bd0..00687b6ca 100644
--- a/src/bunit/Rendering/Internal/Htmlizer.cs
+++ b/src/bunit/Rendering/Internal/Htmlizer.cs
@@ -52,13 +52,17 @@ public static string ToBlazorAttribute(string attributeName)
 		return $"{BlazorAttrPrefix}{attributeName}";
 	}
 
-	public static string GetHtml(int componentId, BunitRenderer renderer)
+	public static HtmlizerResult GetHtml(int componentId, BunitRenderer renderer)
 	{
 		var context = new HtmlRenderingContext(renderer);
 		var frames = context.GetRenderTreeFrames(componentId);
 		var newPosition = RenderFrames(context, frames, 0, frames.Count);
 		Debug.Assert(newPosition == frames.Count);
-		return context.Result.ToString();
+
+		// Added after the child components, which keeps the list in post-order.
+		context.Ranges.Add(new ComponentMarkupRange(componentId, 0, context.Result.Length));
+
+		return new HtmlizerResult(context.Result.ToString(), context.Ranges);
 	}
 
 	private static int RenderFrames(
@@ -131,8 +135,10 @@ int position
 	)
 	{
 		var frame = frames.Array[position];
+		var startIndex = context.Result.Length;
 		var childFrames = context.GetRenderTreeFrames(frame.ComponentId);
 		RenderFrames(context, childFrames, 0, childFrames.Count);
+		context.Ranges.Add(new ComponentMarkupRange(frame.ComponentId, startIndex, context.Result.Length));
 		return position + frame.ComponentSubtreeLength;
 	}
 
@@ -401,6 +407,8 @@ public ArrayRange<RenderTreeFrame> GetRenderTreeFrames(int componentId)
 
 		public StringBuilder Result { get; } = new();
 
+		public List<ComponentMarkupRange> Ranges { get; } = new();
+
 		public string? ClosestSelectValueAsString { get; set; }
 	}
 }
diff --git a/src/bunit/Rendering/Internal/NodeRangeList.cs b/src/bunit/Rendering/Internal/NodeRangeList.cs
new file mode 100644
index 000000000..483836a28
--- /dev/null
+++ b/src/bunit/Rendering/Internal/NodeRangeList.cs
@@ -0,0 +1,35 @@
+using System.Collections;
+using AngleSharp;
+using AngleSharp.Dom;
+
+namespace Bunit.Rendering;
+
+/// <summary>
+/// A read-only <see cref="INodeList"/> over a range of sibling nodes.
+/// </summary>
+internal sealed class NodeRangeList : INodeList, IReadOnlyList<INode>
+{
+	public static readonly NodeRangeList Empty = new([]);
+
+	private readonly IReadOnlyList<INode> nodes;
+
+	public NodeRangeList(IReadOnlyList<INode> nodes) => this.nodes = nodes;
+
+	public INode this[int index] => nodes[index];
+
+	public int Length => nodes.Count;
+
+	public int Count => nodes.Count;
+
+	public IEnumerator<INode> GetEnumerator() => nodes.GetEnumerator();
+
+	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+	public void ToHtml(TextWriter writer, IMarkupFormatter formatter)
+	{
+		for (var i = 0; i < nodes.Count; i++)
+		{
+			nodes[i].ToHtml(writer, formatter);
+		}
+	}
+}
diff --git a/src/bunit/Rendering/Internal/RootMarkupSnapshot.cs b/src/bunit/Rendering/Internal/RootMarkupSnapshot.cs
new file mode 100644
index 000000000..6a2ef2759
--- /dev/null
+++ b/src/bunit/Rendering/Internal/RootMarkupSnapshot.cs
@@ -0,0 +1,240 @@
+using AngleSharp.Dom;
+
+namespace Bunit.Rendering;
+
+/// <summary>
+/// The markup produced for one root render tree, and the range of it each component rendered.
+/// </summary>
+/// <remarks>
+/// Shared by every component under the root, so they all read from one AngleSharp document.
+/// Replaced rather than mutated, which makes its reference identity the version stamp.
+/// </remarks>
+internal sealed class RootMarkupSnapshot
+{
+	private readonly BunitHtmlParser htmlParser;
+	private readonly Dictionary<int, ComponentMarkupRange> rangesById;
+	private readonly object gate = new();
+	private INodeList? nodes;
+	private int[]? sourceIndices;
+	private IElement[]? elements;
+
+	public string Markup { get; }
+
+	/// <summary>
+	/// Gets the component ranges in post-order, i.e. a component always precedes its ancestors.
+	/// </summary>
+	public IReadOnlyList<ComponentMarkupRange> Ranges { get; }
+
+	public int RootComponentId { get; }
+
+	public RootMarkupSnapshot(int rootComponentId, HtmlizerResult result, BunitHtmlParser htmlParser)
+	{
+		RootComponentId = rootComponentId;
+		Markup = result.Markup;
+		Ranges = result.Ranges;
+		this.htmlParser = htmlParser;
+
+		rangesById = new Dictionary<int, ComponentMarkupRange>(result.Ranges.Count);
+		foreach (var range in result.Ranges)
+		{
+			rangesById[range.ComponentId] = range;
+		}
+	}
+
+	public INodeList Nodes
+	{
+		get
+		{
+			lock (gate)
+			{
+				return nodes ??= htmlParser.Parse(Markup);
+			}
+		}
+	}
+
+	public IDocument? Document => Nodes.Length > 0 ? Nodes[0].Owner : null;
+
+	public string GetMarkup(int componentId)
+		=> rangesById.TryGetValue(componentId, out var range)
+			? Markup[range.Start..range.End]
+			: string.Empty;
+
+	public bool TryGetRange(int componentId, out ComponentMarkupRange range)
+		=> rangesById.TryGetValue(componentId, out range);
+
+	/// <summary>
+	/// Gets the nodes the component rendered, as a view into <see cref="Nodes"/>. Returns
+	/// <see langword="false"/> when they cannot be identified there and the component needs
+	/// a document of its own.
+	/// </summary>
+	public bool TryGetNodeView(int componentId, out INodeList view)
+	{
+		if (!rangesById.TryGetValue(componentId, out var range))
+		{
+			view = NodeRangeList.Empty;
+			return false;
+		}
+
+		if (componentId == RootComponentId)
+		{
+			view = Nodes;
+			return true;
+		}
+
+		if (range.Start == range.End)
+		{
+			view = NodeRangeList.Empty;
+			return true;
+		}
+
+		var slice = Markup.AsSpan(range.Start, range.End - range.Start);
+		var firstNonWhitespace = IndexOfFirstNonWhitespace(slice);
+		var lastNonWhitespace = IndexOfLastNonWhitespace(slice);
+
+		// AngleSharp merges adjacent text nodes, so leading or trailing text is fused
+		// into the parent's text node and no range of nodes can represent this component.
+		if (firstNonWhitespace < 0 || slice[firstNonWhitespace] != '<' || slice[lastNonWhitespace] != '>')
+		{
+			view = NodeRangeList.Empty;
+			return false;
+		}
+
+		if (!TryGetElementAt(range.Start + firstNonWhitespace, out var first))
+		{
+			view = NodeRangeList.Empty;
+			return false;
+		}
+
+		view = CollectSiblingRun(first, range);
+		return true;
+	}
+
+	private static NodeRangeList CollectSiblingRun(IElement first, ComponentMarkupRange range)
+	{
+		var result = new List<INode>();
+		var lastElementIndex = -1;
+
+		for (INode? node = first; node is not null; node = node.NextSibling)
+		{
+			// An element without a source position - synthesized from a stray end tag, or in a
+			// foreign namespace such as SVG - cannot be placed, but it is inside this markup.
+			if (node is IElement element && GetSourceIndex(element) is var index and >= 0 && !range.Contains(index))
+			{
+				break;
+			}
+
+			if (node is IElement)
+			{
+				lastElementIndex = result.Count;
+			}
+
+			result.Add(node);
+		}
+
+		// The markup is known to end with a tag, so anything after the last element is the parent's.
+		if (lastElementIndex + 1 < result.Count)
+		{
+			result.RemoveRange(lastElementIndex + 1, result.Count - lastElementIndex - 1);
+		}
+
+		return new NodeRangeList(result);
+	}
+
+	private bool TryGetElementAt(int sourceIndex, [NotNullWhen(true)] out IElement? element)
+	{
+		EnsureElementIndex();
+
+		var position = Array.BinarySearch(sourceIndices!, sourceIndex);
+		if (position < 0)
+		{
+			element = null;
+			return false;
+		}
+
+		// The parser clones formatting elements, so several can share one source index.
+		while (position > 0 && sourceIndices![position - 1] == sourceIndex)
+		{
+			position--;
+		}
+
+		element = elements![position];
+		return true;
+	}
+
+	private void EnsureElementIndex()
+	{
+		lock (gate)
+		{
+			if (sourceIndices is not null)
+			{
+				return;
+			}
+
+			var found = new List<IElement>();
+			foreach (var node in Nodes)
+			{
+				CollectElements(node, found);
+			}
+
+			found.Sort(static (x, y) => GetSourceIndex(x).CompareTo(GetSourceIndex(y)));
+
+			sourceIndices = new int[found.Count];
+			for (var i = 0; i < found.Count; i++)
+			{
+				sourceIndices[i] = GetSourceIndex(found[i]);
+			}
+
+			elements = found.ToArray();
+		}
+
+		static void CollectElements(INode node, List<IElement> found)
+		{
+			if (node is IElement element && GetSourceIndex(element) >= 0)
+			{
+				found.Add(element);
+			}
+
+			foreach (var child in node.ChildNodes)
+			{
+				CollectElements(child, found);
+			}
+		}
+	}
+
+	/// <summary>
+	/// Gets the index in <see cref="Markup"/> the element was parsed from, or -1 when the
+	/// parser synthesized it, e.g. an implicit &lt;tbody&gt;.
+	/// </summary>
+	internal static int GetSourceIndex(IElement element)
+		=> element.SourceReference?.Position.Index ?? -1;
+
+#if !NET11_0_OR_GREATER
+	private static int IndexOfLastNonWhitespace(ReadOnlySpan<char> value)
+	{
+		for (var i = value.Length - 1; i >= 0; i--)
+		{
+			if (!char.IsWhiteSpace(value[i]))
+				return i;
+		}
+
+		return -1;
+	}
+
+		private static int IndexOfFirstNonWhitespace(ReadOnlySpan<char> value)
+	{
+		for (var i = 0; i < value.Length; i++)
+		{
+			if (!char.IsWhiteSpace(value[i]))
+				return i;
+		}
+
+		return -1;
+	}
+#else
+	private static int IndexOfFirstNonWhitespace(ReadOnlySpan<char> value)
+		=> value.IndexOfAnyExceptWhiteSpace();
+		
+	private static int IndexOfLastNonWhitespace(ReadOnlySpan<char> value)
+		=> value.LastIndexOfAnyExceptWhiteSpace();
+#endif	
+}
diff --git a/src/bunit/Rendering/RenderedComponent.cs b/src/bunit/Rendering/RenderedComponent.cs
index afd868453..ab98ab22c 100644
--- a/src/bunit/Rendering/RenderedComponent.cs
+++ b/src/bunit/Rendering/RenderedComponent.cs
@@ -7,18 +7,24 @@ namespace Bunit;
 /// <summary>
 /// Represents a rendered component.
 /// </summary>
+/// <remarks>
+/// The markup and the AngleSharp document belong to the root of the render tree and are
+/// shared by every component in it; this type exposes the slice of both that this
+/// component rendered. See <see cref="RootMarkupSnapshot"/>.
+/// </remarks>
 [DebuggerDisplay("Component={typeof(TComponent).Name,nq},RenderCount={RenderCount}")]
-internal sealed class RenderedComponent<TComponent> : ComponentState, IRenderedComponent<TComponent>, IRenderedComponent
+internal class RenderedComponent<TComponent> : ComponentState, IRenderedComponent<TComponent>, IRenderedComponent
 	where TComponent : IComponent
 {
-	private readonly BunitRenderer renderer;
 	private readonly TComponent instance;
+	private readonly object sliceGate = new();
+	private readonly IRenderedComponentRoot? renderTreeRoot;
+	private Slice? slice;
 
-	[SuppressMessage("Usage", "CA2213:Disposable fields should be disposed", Justification = "Owned by BunitServiceProvider, disposed by it.")]
-	private readonly BunitHtmlParser htmlParser;
+	private protected BunitRenderer OwningRenderer { get; }
 
-	private string markup = string.Empty;
-	private INodeList? latestRenderNodes;
+	[SuppressMessage("Usage", "CA2213:Disposable fields should be disposed", Justification = "Owned by BunitServiceProvider, disposed by it.")]
+	private protected BunitHtmlParser HtmlParser { get; }
 
 	/// <summary>
 	/// Gets the component under test.
@@ -37,6 +43,10 @@ public TComponent Instance
 	/// </summary>
 	public bool IsDisposed { get; private set; }
 
+	/// <inheritdoc/>
+	public virtual IRenderedComponentRoot Root => renderTreeRoot
+		?? throw new InvalidOperationException("A rendered component that is not a render tree root always has a parent.");
+
 	/// <summary>
 	/// Gets the HTML markup from the rendered fragment/component.
 	/// </summary>
@@ -45,11 +55,7 @@ public string Markup
 		get
 		{
 			EnsureComponentNotDisposed();
-			// Volatile read is necessary to ensure the updated markup
-			// is available across CPU cores. Without it, the pointer to the
-			// markup string can be stored in a CPUs register and not
-			// get updated when another CPU changes the string.
-			return Volatile.Read(ref markup);
+			return GetSlice()?.Markup ?? string.Empty;
 		}
 	}
 
@@ -68,7 +74,7 @@ public INodeList Nodes
 		get
 		{
 			EnsureComponentNotDisposed();
-			return latestRenderNodes ??= htmlParser.Parse(Markup);
+			return GetSlice()?.GetNodes(HtmlParser) ?? NodeRangeList.Empty;
 		}
 	}
 
@@ -86,9 +92,10 @@ public RenderedComponent(
 		: base(renderer, componentId, instance, parentComponentState)
 	{
 		Services = services;
-		this.renderer = renderer;
+		OwningRenderer = renderer;
+		HtmlParser = services.GetRequiredService<BunitHtmlParser>();
 		this.instance = (TComponent)instance;
-		htmlParser = Services.GetRequiredService<BunitHtmlParser>();
+		renderTreeRoot = (parentComponentState as IRenderedComponent)?.Root;
 	}
 
 	/// <summary>
@@ -101,45 +108,48 @@ public RenderedComponent(
 	/// </summary>
 	public event EventHandler? OnMarkupUpdated;
 
-	/// <summary>
-	/// Called by the owning <see cref="BunitRenderer"/> when it finishes a render.
-	/// </summary>
-	public void UpdateState(bool hasRendered, bool isMarkupGenerationRequired)
+	/// <inheritdoc/>
+	public void RaiseMarkupUpdated()
 	{
 		if (IsDisposed)
 			return;
 
-		if (hasRendered)
-		{
-			RenderCount++;
-		}
+		OnMarkupUpdated?.Invoke(this, EventArgs.Empty);
+	}
 
-		if (isMarkupGenerationRequired)
-		{
-			UpdateMarkup();
-			OnMarkupUpdated?.Invoke(this, EventArgs.Empty);
-		}
+	/// <inheritdoc/>
+	public void UpdateState(bool hasRendered)
+	{
+		if (IsDisposed)
+			return;
 
-		// The order here is important, since consumers of the events
-		// expect that markup has indeed changed when OnAfterRender is invoked
-		// (assuming there are markup changes)
 		if (hasRendered)
+		{
+			RenderCount++;
 			OnAfterRender?.Invoke(this, EventArgs.Empty);
+		}
 	}
 
 	/// <summary>
-	/// Updates the markup of the rendered fragment.
+	/// Gets this component's slice of the current snapshot, recomputing it when
+	/// the snapshot has been replaced.
 	/// </summary>
-	private void UpdateMarkup()
+	private Slice? GetSlice()
 	{
-		latestRenderNodes = null;
-		var newMarkup = Htmlizer.GetHtml(ComponentId, renderer);
-
-		// Volatile write is necessary to ensure the updated markup
-		// is available across CPU cores. Without it, the pointer to the
-		// markup string can be stored in a CPUs register and not
-		// get updated when another CPU changes the string.
-		Volatile.Write(ref markup, newMarkup);
+		lock (sliceGate)
+		{
+			var current = Root.MarkupSnapshot;
+
+			if (current is null)
+				return null;
+
+			if (slice is null || !ReferenceEquals(slice.Snapshot, current))
+			{
+				slice = new Slice(current, this, OwningRenderer);
+			}
+
+			return slice;
+		}
 	}
 
 	/// <summary>
@@ -155,13 +165,20 @@ private void EnsureComponentNotDisposed()
 	/// <inheritdoc/>
 	public void Dispose()
 	{
-		if (IsDisposed)
+		Dispose(disposing: true);
+		GC.SuppressFinalize(this);
+	}
+
+	protected virtual void Dispose(bool disposing)
+	{
+		if (!disposing || IsDisposed)
 			return;
 
 		IsDisposed = true;
-		markup = string.Empty;
+		slice = null;
 		OnAfterRender = null;
 		OnMarkupUpdated = null;
+		OwningRenderer.OnRenderedComponentDisposed(this);
 	}
 
 	public override ValueTask DisposeAsync()
@@ -169,4 +186,53 @@ public override ValueTask DisposeAsync()
 		Dispose();
 		return base.DisposeAsync();
 	}
+
+	/// <summary>
+	/// One component's view of a <see cref="RootMarkupSnapshot"/>.
+	/// </summary>
+	private sealed class Slice
+	{
+		private readonly RootMarkupSnapshot snapshot;
+		private readonly IRenderedComponent owner;
+		private readonly BunitRenderer renderer;
+		private readonly object gate = new();
+		private INodeList? nodes;
+
+		public RootMarkupSnapshot Snapshot => snapshot;
+
+		public string Markup { get; }
+
+		public Slice(RootMarkupSnapshot snapshot, IRenderedComponent owner, BunitRenderer renderer)
+		{
+			this.snapshot = snapshot;
+			this.owner = owner;
+			this.renderer = renderer;
+			Markup = snapshot.GetMarkup(owner.ComponentId);
+		}
+
+		public INodeList GetNodes(BunitHtmlParser htmlParser)
+		{
+			lock (gate)
+			{
+				if (nodes is not null)
+					return nodes;
+
+				if (snapshot.TryGetNodeView(owner.ComponentId, out var view))
+				{
+					nodes = view;
+					return nodes;
+				}
+
+				// Registered so nodes from this private document can still be traced
+				// back to a component by GetOwningComponent.
+				nodes = htmlParser.Parse(Markup);
+				if (nodes.Length > 0 && nodes[0].Owner is { } document)
+				{
+					renderer.RegisterPrivateDocument(document, owner);
+				}
+
+				return nodes;
+			}
+		}
+	}
 }
diff --git a/src/bunit/Rendering/RootRenderedComponent.cs b/src/bunit/Rendering/RootRenderedComponent.cs
new file mode 100644
index 000000000..810a77b35
--- /dev/null
+++ b/src/bunit/Rendering/RootRenderedComponent.cs
@@ -0,0 +1,44 @@
+using Bunit.Rendering;
+
+namespace Bunit;
+
+/// <summary>
+/// The rendered component of a render tree's root. It owns the markup snapshot that
+/// every <see cref="RenderedComponent{TComponent}"/> in the same tree reads its slice from.
+/// </summary>
+internal sealed class RootRenderedComponent : RenderedComponent<BunitRootComponent>, IRenderedComponentRoot
+{
+	private RootMarkupSnapshot? snapshot;
+
+	public RootRenderedComponent(
+		BunitRenderer renderer,
+		int componentId,
+		IComponent instance,
+		IServiceProvider services)
+		: base(renderer, componentId, instance, services, parentComponentState: null)
+	{
+	}
+
+	/// <inheritdoc/>
+	public override IRenderedComponentRoot Root => this;
+
+	/// <inheritdoc/>
+	public RootMarkupSnapshot? MarkupSnapshot => Volatile.Read(ref snapshot);
+
+	/// <inheritdoc/>
+	public void RegenerateMarkup()
+	{
+		if (IsDisposed)
+			return;
+
+		var html = Htmlizer.GetHtml(ComponentId, OwningRenderer);
+		Volatile.Write(ref snapshot, new RootMarkupSnapshot(ComponentId, html, HtmlParser));
+	}
+
+	/// <inheritdoc/>
+	protected override void Dispose(bool disposing)
+	{
+		snapshot = null;
+		base.Dispose(disposing);
+	}
+}
diff --git a/tests/bunit.testassets/SampleComponents/ChildOption.razor b/tests/bunit.testassets/SampleComponents/ChildOption.razor
new file mode 100644
index 000000000..9f244b2fd
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/ChildOption.razor
@@ -0,0 +1,5 @@
+<option value="@Value">@Value</option>
+
+@code {
+	[Parameter] public string Value { get; set; } = string.Empty;
+}
diff --git a/tests/bunit.testassets/SampleComponents/ChildTableRow.razor b/tests/bunit.testassets/SampleComponents/ChildTableRow.razor
new file mode 100644
index 000000000..e2ec30bbb
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/ChildTableRow.razor
@@ -0,0 +1,5 @@
+<tr id="child-row"><td>@Cell</td></tr>
+
+@code {
+	[Parameter] public string Cell { get; set; } = "cell";
+}
diff --git a/tests/bunit.testassets/SampleComponents/ChildWithButton.razor b/tests/bunit.testassets/SampleComponents/ChildWithButton.razor
new file mode 100644
index 000000000..77c9d8e09
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/ChildWithButton.razor
@@ -0,0 +1,7 @@
+<button id="child-button" type="@ButtonType" @onclick="() => ClickCount++">Child</button>
+
+@code {
+	[Parameter] public string ButtonType { get; set; } = "button";
+
+	public int ClickCount { get; set; }
+}
diff --git a/tests/bunit.testassets/SampleComponents/CounterChild.razor b/tests/bunit.testassets/SampleComponents/CounterChild.razor
new file mode 100644
index 000000000..9ceb74bc7
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/CounterChild.razor
@@ -0,0 +1,5 @@
+<button id="counter-button" @onclick="() => Count++">@Count</button>
+
+@code {
+	public int Count { get; set; }
+}
diff --git a/tests/bunit.testassets/SampleComponents/EmptyChild.razor b/tests/bunit.testassets/SampleComponents/EmptyChild.razor
new file mode 100644
index 000000000..bcf78df4a
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/EmptyChild.razor
@@ -0,0 +1 @@
+@code { }
diff --git a/tests/bunit.testassets/SampleComponents/GrandParentDivWithChildButton.razor b/tests/bunit.testassets/SampleComponents/GrandParentDivWithChildButton.razor
new file mode 100644
index 000000000..14ffb0b01
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/GrandParentDivWithChildButton.razor
@@ -0,0 +1,9 @@
+<div id="grand-parent-div" @onclick="() => ClickCount++">
+	<ParentDivWithChildButton StopPropagation="StopPropagation" />
+</div>
+
+@code {
+	[Parameter] public bool StopPropagation { get; set; }
+
+	public int ClickCount { get; set; }
+}
diff --git a/tests/bunit.testassets/SampleComponents/LeadingTextChild.razor b/tests/bunit.testassets/SampleComponents/LeadingTextChild.razor
new file mode 100644
index 000000000..f13c43287
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/LeadingTextChild.razor
@@ -0,0 +1 @@
+Hello <b id="child-b">world</b>
diff --git a/tests/bunit.testassets/SampleComponents/ParentDivWithChildButton.razor b/tests/bunit.testassets/SampleComponents/ParentDivWithChildButton.razor
new file mode 100644
index 000000000..f825322e5
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/ParentDivWithChildButton.razor
@@ -0,0 +1,9 @@
+<div id="parent-div" @onclick="() => ClickCount++" @onclick:stopPropagation="StopPropagation">
+	<ChildWithButton />
+</div>
+
+@code {
+	[Parameter] public bool StopPropagation { get; set; }
+
+	public int ClickCount { get; set; }
+}
diff --git a/tests/bunit.testassets/SampleComponents/ParentFormWithChildButton.razor b/tests/bunit.testassets/SampleComponents/ParentFormWithChildButton.razor
new file mode 100644
index 000000000..32cd65176
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/ParentFormWithChildButton.razor
@@ -0,0 +1,7 @@
+<form id="parent-form" @onsubmit="() => SubmitCount++">
+	<ChildWithButton ButtonType="submit" />
+</form>
+
+@code {
+	public int SubmitCount { get; set; }
+}
diff --git a/tests/bunit.testassets/SampleComponents/ParentWithEmptyChild.razor b/tests/bunit.testassets/SampleComponents/ParentWithEmptyChild.razor
new file mode 100644
index 000000000..14d74d9a5
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/ParentWithEmptyChild.razor
@@ -0,0 +1 @@
+<div id="parent-div"><EmptyChild /></div>
diff --git a/tests/bunit.testassets/SampleComponents/ParentWithLeadingTextChild.razor b/tests/bunit.testassets/SampleComponents/ParentWithLeadingTextChild.razor
new file mode 100644
index 000000000..33630436a
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/ParentWithLeadingTextChild.razor
@@ -0,0 +1 @@
+<div id="parent-div"><LeadingTextChild /></div>
diff --git a/tests/bunit.testassets/SampleComponents/ParentWithTextOnlyChild.razor b/tests/bunit.testassets/SampleComponents/ParentWithTextOnlyChild.razor
new file mode 100644
index 000000000..a34baa18a
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/ParentWithTextOnlyChild.razor
@@ -0,0 +1 @@
+<p id="parent-p">Hello <TextOnlyChild /> world</p>
diff --git a/tests/bunit.testassets/SampleComponents/SelectWithChildOptions.razor b/tests/bunit.testassets/SampleComponents/SelectWithChildOptions.razor
new file mode 100644
index 000000000..ce2089b65
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/SelectWithChildOptions.razor
@@ -0,0 +1,4 @@
+<select id="parent-select" value="b">
+	<ChildOption Value="a" />
+	<ChildOption Value="b" />
+</select>
diff --git a/tests/bunit.testassets/SampleComponents/SiblingChildren.razor b/tests/bunit.testassets/SampleComponents/SiblingChildren.razor
new file mode 100644
index 000000000..4f2cace32
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/SiblingChildren.razor
@@ -0,0 +1,4 @@
+<div id="parent-div">
+	<ChildWithButton />
+	<CounterChild />
+</div>
diff --git a/tests/bunit.testassets/SampleComponents/TableWithChildRows.razor b/tests/bunit.testassets/SampleComponents/TableWithChildRows.razor
new file mode 100644
index 000000000..78193fd34
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/TableWithChildRows.razor
@@ -0,0 +1,6 @@
+<table id="parent-table">
+	<tbody>
+		<ChildTableRow Cell="one" />
+		<ChildTableRow Cell="two" />
+	</tbody>
+</table>
diff --git a/tests/bunit.testassets/SampleComponents/TextOnlyChild.razor b/tests/bunit.testassets/SampleComponents/TextOnlyChild.razor
new file mode 100644
index 000000000..c3e9594dc
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/TextOnlyChild.razor
@@ -0,0 +1,5 @@
+@ChildText
+
+@code {
+	[Parameter] public string ChildText { get; set; } = "child-text";
+}
diff --git a/tests/bunit.tests/EventDispatchExtensions/ChildComponentEventBubblingTest.cs b/tests/bunit.tests/EventDispatchExtensions/ChildComponentEventBubblingTest.cs
new file mode 100644
index 000000000..e81e42be7
--- /dev/null
+++ b/tests/bunit.tests/EventDispatchExtensions/ChildComponentEventBubblingTest.cs
@@ -0,0 +1,67 @@
+namespace Bunit;
+
+/// <summary>
+/// Verifies that events raised on an element found through a child components
+/// <see cref="IRenderedComponent{TComponent}"/> bubble through the DOM rendered
+/// by the child's ancestor components. See issue #983.
+/// </summary>
+public class ChildComponentEventBubblingTest : BunitContext
+{
+	[Fact(DisplayName = "Clicking a child component's element bubbles to the parent component's element")]
+	public void Test001()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		cut.FindComponent<ChildWithButton>().Find("button").Click();
+
+		cut.Instance.ClickCount.ShouldBe(1);
+	}
+
+	[Fact(DisplayName = "Clicking a child component's submit button triggers the parent component's form")]
+	public void Test002()
+	{
+		var cut = Render<ParentFormWithChildButton>();
+
+		cut.FindComponent<ChildWithButton>().Find("button").Click();
+
+		cut.Instance.SubmitCount.ShouldBe(1);
+	}
+
+	[Fact(DisplayName = "Bubbling from a child component's element is identical to bubbling from the parent's view of it")]
+	public void Test003()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+		var child = cut.FindComponent<ChildWithButton>();
+
+		cut.Find("button").Click();
+		var (parentAfterFirst, childAfterFirst) = (cut.Instance.ClickCount, child.Instance.ClickCount);
+
+		child.Find("button").Click();
+
+		cut.Instance.ClickCount.ShouldBe(parentAfterFirst + 1);
+		child.Instance.ClickCount.ShouldBe(childAfterFirst + 1);
+	}
+
+	[Fact(DisplayName = "stopPropagation on a parent component's element stops bubbling from a child component's element")]
+	public void Test004()
+	{
+		var cut = Render<GrandParentDivWithChildButton>(ps => ps.Add(p => p.StopPropagation, true));
+
+		cut.FindComponent<ChildWithButton>().Find("button").Click();
+
+		cut.FindComponent<ParentDivWithChildButton>().Instance.ClickCount.ShouldBe(1);
+		cut.Instance.ClickCount.ShouldBe(0);
+	}
+
+	[Fact(DisplayName = "Events bubble through three levels of components")]
+	public void Test005()
+	{
+		var cut = Render<GrandParentDivWithChildButton>();
+
+		cut.FindComponent<ChildWithButton>().Find("button").Click();
+
+		cut.FindComponent<ChildWithButton>().Instance.ClickCount.ShouldBe(1);
+		cut.FindComponent<ParentDivWithChildButton>().Instance.ClickCount.ShouldBe(1);
+		cut.Instance.ClickCount.ShouldBe(1);
+	}
+}
diff --git a/tests/bunit.tests/Extensions/ElementOwningComponentTest.cs b/tests/bunit.tests/Extensions/ElementOwningComponentTest.cs
new file mode 100644
index 000000000..cab114097
--- /dev/null
+++ b/tests/bunit.tests/Extensions/ElementOwningComponentTest.cs
@@ -0,0 +1,116 @@
+using AngleSharp.Dom;
+using Bunit.Rendering;
+
+namespace Bunit.Extensions;
+
+/// <summary>
+/// Verifies that a DOM node can be traced back to the component that
+/// rendered it. See issue #153.
+/// </summary>
+public class ElementOwningComponentTest : BunitContext
+{
+	[Fact(DisplayName = "GetOwningComponent returns the component that rendered the element")]
+	public void Test001()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		var owner = cut.Find("button").GetOwningComponent();
+
+		owner.Instance.ShouldBeOfType<ChildWithButton>();
+	}
+
+	[Fact(DisplayName = "GetOwningComponent returns the same rendered component as FindComponent")]
+	public void Test002()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+		var child = cut.FindComponent<ChildWithButton>();
+
+		var owner = cut.Find("button").GetOwningComponent();
+
+		owner.ShouldBeSameAs(child);
+	}
+
+	[Fact(DisplayName = "GetOwningComponent returns the parent component for an element it rendered")]
+	public void Test003()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		var owner = cut.Find("#parent-div").GetOwningComponent();
+
+		owner.Instance.ShouldBeOfType<ParentDivWithChildButton>();
+	}
+
+	[Fact(DisplayName = "GetOwningComponent<T> walks outwards to the nearest component of that type")]
+	public void Test004()
+	{
+		var cut = Render<GrandParentDivWithChildButton>();
+
+		var owner = cut.Find("button").GetOwningComponent<ParentDivWithChildButton>();
+
+		owner.ShouldBeSameAs(cut.FindComponent<ParentDivWithChildButton>());
+	}
+
+	[Fact(DisplayName = "GetOwningComponent<T> throws when no ancestor of that type rendered the element")]
+	public void Test005()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		Should.Throw<ComponentNotFoundException>(
+			() => cut.Find("button").GetOwningComponent<CounterChild>());
+	}
+
+	[Fact(DisplayName = "GetOwningComponent resolves a descendant node to the component that rendered its element")]
+	public void Test006()
+	{
+		var cut = Render<TableWithChildRows>();
+
+		var owner = cut.Find("#child-row td").GetOwningComponent();
+
+		owner.Instance.ShouldBeOfType<ChildTableRow>();
+	}
+
+	[Fact(DisplayName = "GetOwningComponent never returns a bUnit infrastructure component")]
+	public void Test007()
+	{
+		var cut = Render<Simple1>();
+
+		var owner = cut.Find("h1").GetOwningComponent();
+
+		owner.Instance.ShouldBeOfType<Simple1>();
+	}
+
+	[Fact(DisplayName = "GetOwningComponent throws for a node that was not rendered by bUnit")]
+	public void Test008()
+	{
+		using var parser = new Bunit.Rendering.BunitHtmlParser();
+		var nodes = parser.Parse("<p>foo</p>");
+
+		Should.Throw<InvalidOperationException>(() => nodes[0].GetOwningComponent());
+	}
+
+	[Fact(DisplayName = "GetOwningComponent resolves an element of a component that has its own document")]
+	public void Test010()
+	{
+		// Markup starting with text cannot be located in the shared document, so the
+		// component is parsed into one of its own - both routes must still resolve.
+		var cut = Render<ParentWithLeadingTextChild>();
+		var child = cut.FindComponent<LeadingTextChild>();
+
+		child.Nodes[0].Owner.ShouldNotBeSameAs(cut.Nodes[0].Owner);
+
+		child.Find("b").GetOwningComponent().ShouldBeSameAs(child);
+		cut.Find("b").GetOwningComponent().ShouldBeSameAs(child);
+	}
+
+	[Fact(DisplayName = "GetOwningComponent resolves elements from separate render trees to their own component")]
+	public void Test009()
+	{
+		var first = Render<ParentDivWithChildButton>();
+		var second = Render<GrandParentDivWithChildButton>();
+
+		first.Find("button").GetOwningComponent()
+			.ShouldBeSameAs(first.FindComponent<ChildWithButton>());
+		second.Find("button").GetOwningComponent()
+			.ShouldBeSameAs(second.FindComponent<ChildWithButton>());
+	}
+}
diff --git a/tests/bunit.tests/Rendering/ComponentTreeNavigationTest.cs b/tests/bunit.tests/Rendering/ComponentTreeNavigationTest.cs
new file mode 100644
index 000000000..7cc940f18
--- /dev/null
+++ b/tests/bunit.tests/Rendering/ComponentTreeNavigationTest.cs
@@ -0,0 +1,81 @@
+namespace Bunit.Rendering;
+
+/// <summary>
+/// Verifies navigation of the component tree. See issue #1180.
+/// </summary>
+public class ComponentTreeNavigationTest : BunitContext
+{
+	[Fact(DisplayName = "Parent returns the component that rendered this component")]
+	public void Test001()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		var parent = cut.FindComponent<ChildWithButton>().Parent();
+
+		parent.ShouldNotBeNull().Instance.ShouldBeOfType<ParentDivWithChildButton>();
+	}
+
+	[Fact(DisplayName = "Parent of the outermost rendered component is null")]
+	public void Test002()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		cut.Parent().ShouldBeNull();
+	}
+
+	[Fact(DisplayName = "Root returns the outermost rendered component")]
+	public void Test003()
+	{
+		var cut = Render<GrandParentDivWithChildButton>();
+
+		var root = cut.FindComponent<ChildWithButton>().Root();
+
+		root.ShouldBeSameAs(cut);
+	}
+
+	[Fact(DisplayName = "GetChildren returns direct child components only, in render order")]
+	public void Test004()
+	{
+		var cut = Render<SiblingChildren>();
+
+		var children = cut.GetChildren();
+
+		children.Count.ShouldBe(2);
+		children[0].Instance.ShouldBeOfType<ChildWithButton>();
+		children[1].Instance.ShouldBeOfType<CounterChild>();
+	}
+
+	[Fact(DisplayName = "GetChildren does not return grandchildren")]
+	public void Test005()
+	{
+		var cut = Render<GrandParentDivWithChildButton>();
+
+		var children = cut.GetChildren();
+
+		children.Count.ShouldBe(1);
+		children[0].Instance.ShouldBeOfType<ParentDivWithChildButton>();
+	}
+
+	[Fact(DisplayName = "GetChildren<T> returns only direct children of that type")]
+	public void Test006()
+	{
+		var cut = Render<SiblingChildren>();
+
+		var children = cut.GetChildren<CounterChild>();
+
+		children.Count.ShouldBe(1);
+		children[0].ShouldBeSameAs(cut.FindComponent<CounterChild>());
+	}
+
+	[Fact(DisplayName = "GetAncestors returns components from the closest parent to the root")]
+	public void Test007()
+	{
+		var cut = Render<GrandParentDivWithChildButton>();
+
+		var ancestors = cut.FindComponent<ChildWithButton>().GetAncestors().ToArray();
+
+		ancestors.Length.ShouldBe(2);
+		ancestors[0].Instance.ShouldBeOfType<ParentDivWithChildButton>();
+		ancestors[1].Instance.ShouldBeOfType<GrandParentDivWithChildButton>();
+	}
+}
diff --git a/tests/bunit.tests/Rendering/SharedDocumentTest.cs b/tests/bunit.tests/Rendering/SharedDocumentTest.cs
new file mode 100644
index 000000000..8529c767c
--- /dev/null
+++ b/tests/bunit.tests/Rendering/SharedDocumentTest.cs
@@ -0,0 +1,142 @@
+using AngleSharp.Dom;
+using Bunit.Web.AngleSharp;
+
+namespace Bunit.Rendering;
+
+/// <summary>
+/// Verifies that all rendered components under the same root share one
+/// AngleSharp document, and that components whose markup cannot be located
+/// in it fall back to their own document.
+/// </summary>
+public class SharedDocumentTest : BunitContext
+{
+	[Fact(DisplayName = "A child component's element is the same instance as the parent component's view of it")]
+	public void Test001()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		var fromParent = cut.Find("button").Unwrap();
+		var fromChild = cut.FindComponent<ChildWithButton>().Find("button").Unwrap();
+
+		fromChild.ShouldBeSameAs(fromParent);
+	}
+
+	[Fact(DisplayName = "A child component's element has the parent component's element as its parent")]
+	public void Test002()
+	{
+		var cut = Render<ParentFormWithChildButton>();
+
+		var button = cut.FindComponent<ChildWithButton>().Find("button");
+
+		button.ParentElement.ShouldNotBeNull().Id.ShouldBe("parent-form");
+	}
+
+	[Fact(DisplayName = "Nodes of parent and child components come from the same document")]
+	public void Test003()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		var child = cut.FindComponent<ChildWithButton>();
+
+		child.Nodes[0].Owner.ShouldBeSameAs(cut.Nodes[0].Owner);
+	}
+
+	[Fact(DisplayName = "Find on a child component only matches elements rendered by that component")]
+	public void Test004()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		var child = cut.FindComponent<ChildWithButton>();
+
+		Should.Throw<ElementNotFoundException>(() => child.Find("#parent-div"));
+	}
+
+	[Fact(DisplayName = "Markup of a child component is unaffected by the shared document")]
+	public void Test005()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+
+		var child = cut.FindComponent<ChildWithButton>();
+
+		child.Markup.ShouldStartWith("<button");
+		child.Markup.ShouldContain("id=\"child-button\"");
+		child.Markup.ShouldNotContain("parent-div");
+	}
+
+	[Fact(DisplayName = "Nodes is the same instance when a render does not change the DOM")]
+	public void Test006()
+	{
+		var cut = Render<ParentDivWithChildButton>();
+		var child = cut.FindComponent<ChildWithButton>();
+		var initialNodes = child.Nodes;
+
+		child.Nodes.ShouldBeSameAs(initialNodes);
+	}
+
+	[Fact(DisplayName = "A component whose sibling re-renders gets its element wrapper refreshed")]
+	public void Test007()
+	{
+		var cut = Render<SiblingChildren>();
+		var button = cut.FindComponent<ChildWithButton>().Find("button");
+
+		cut.Find("#counter-button").Click();
+
+		// The wrapper must re-resolve into the new document instead of
+		// exposing a node detached from the previous parse.
+		button.Unwrap().Owner.ShouldBeSameAs(cut.Nodes[0].Owner);
+	}
+
+	[Fact(DisplayName = "A child component rendering a <tr> inside the parent's <table> is found")]
+	public void Test010()
+	{
+		var cut = Render<TableWithChildRows>();
+
+		var rows = cut.FindComponents<ChildTableRow>();
+
+		rows.Count.ShouldBe(2);
+		rows[0].Find("td").TextContent.ShouldBe("one");
+		rows[1].Find("td").TextContent.ShouldBe("two");
+	}
+
+	[Fact(DisplayName = "A child component rendering an <option> inherits the parent's <select> value")]
+	public void Test011()
+	{
+		var cut = Render<SelectWithChildOptions>();
+
+		var options = cut.FindComponents<ChildOption>();
+
+		options[0].Markup.ShouldNotContain("selected");
+		options[1].Markup.ShouldContain("selected");
+	}
+
+	[Fact(DisplayName = "A child component rendering only text still exposes its markup")]
+	public void Test020()
+	{
+		var cut = Render<ParentWithTextOnlyChild>();
+
+		var child = cut.FindComponent<TextOnlyChild>();
+
+		child.Markup.ShouldBe("child-text");
+		cut.Find("#parent-p").TextContent.ShouldBe("Hello child-text world");
+	}
+
+	[Fact(DisplayName = "A child component rendering nothing has empty markup and no nodes")]
+	public void Test021()
+	{
+		var cut = Render<ParentWithEmptyChild>();
+
+		var child = cut.FindComponent<EmptyChild>();
+
+		child.Markup.ShouldBe(string.Empty);
+		child.Nodes.Length.ShouldBe(0);
+	}
+
+	[Fact(DisplayName = "Components rendered from separate Render calls do not share a document")]
+	public void Test030()
+	{
+		var first = Render<ParentDivWithChildButton>();
+		var second = Render<ParentDivWithChildButton>();
+
+		first.Nodes[0].Owner.ShouldNotBeSameAs(second.Nodes[0].Owner);
+	}
+}